lib/cutego
1
0
Fork 0
mirror of https://github.com/bluszcz/cutego.git synced 2024-09-28 21:25:16 +03:00
Code Issues Projects Releases Packages Wiki Activity
cutego/core/core.cpp
therecipe aa8a227277 even more changes related to the js binding + fixes for Qt 5.14 
* support for static darwin docker deployments
2019-12-21 17:42:05 +01:00

27751 lines
1.3 MiB
Raw Blame History

// +build !minimal
#define protected public
#define private public
#include "core.h"
#include "_cgo_export.h"
#ifndef QT_CORE_LIB
#error ------------------------------------------------------------------
#error please run: '$(go env GOPATH)/bin/qtsetup'
#error more info here: https://github.com/therecipe/qt/wiki/Installation
#error ------------------------------------------------------------------
#endif
#include <QAbstractAnimation>
#include <QAbstractEventDispatcher>
#include <QAbstractItemModel>
#include <QAbstractListModel>
#include <QAbstractNativeEventFilter>
#include <QAbstractProxyModel>
#include <QAbstractState>
#include <QAbstractTableModel>
#include <QAbstractTransition>
#include <QAnimationGroup>
#include <QAssociativeIterable>
#include <QAudioSystemPlugin>
#include <QBasicMutex>
#include <QBasicTimer>
#include <QBitArray>
#include <QBrush>
#include <QBuffer>
#include <QByteArray>
#include <QByteArrayList>
#include <QByteArrayMatcher>
#include <QCameraImageCapture>
#include <QCborArray>
#include <QCborError>
#include <QCborMap>
#include <QCborParserError>
#include <QCborValue>
#include <QChar>
#include <QChildEvent>
#include <QCollator>
#include <QCollatorSortKey>
#include <QColor>
#include <QCommandLineOption>
#include <QCommandLineParser>
#include <QConcatenateTablesProxyModel>
#include <QCoreApplication>
#include <QCryptographicHash>
#include <QDBusPendingCallWatcher>
#include <QDataStream>
#include <QDate>
#include <QDateTime>
#include <QDeadlineTimer>
#include <QDebug>
#include <QDebugStateSaver>
#include <QDeferredDeleteEvent>
#include <QDir>
#include <QDynamicPropertyChangeEvent>
#include <QEasingCurve>
#include <QElapsedTimer>
#include <QEvent>
#include <QEventLoop>
#include <QEventLoopLocker>
#include <QEventTransition>
#include <QExtensionFactory>
#include <QExtensionManager>
#include <QFile>
#include <QFileDevice>
#include <QFileInfo>
#include <QFileSelector>
#include <QFileSystemWatcher>
#include <QFinalState>
#include <QFlag>
#include <QFont>
#include <QFutureInterface>
#include <QFutureWatcherBase>
#include <QGenericArgument>
#include <QGenericReturnArgument>
#include <QGraphicsObject>
#include <QGraphicsWidget>
#include <QHash>
#include <QHistoryState>
#include <QIODevice>
#include <QIcon>
#include <QIdentityProxyModel>
#include <QImage>
#include <QItemSelection>
#include <QItemSelectionModel>
#include <QItemSelectionRange>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonParseError>
#include <QJsonValue>
#include <QLatin1Char>
#include <QLatin1String>
#include <QLayout>
#include <QLibrary>
#include <QLibraryInfo>
#include <QLine>
#include <QLineF>
#include <QLocale>
#include <QLockFile>
#include <QLoggingCategory>
#include <QMap>
#include <QMargins>
#include <QMarginsF>
#include <QMediaPlaylist>
#include <QMediaRecorder>
#include <QMediaServiceProviderPlugin>
#include <QMessageAuthenticationCode>
#include <QMessageLogger>
#include <QMetaClassInfo>
#include <QMetaEnum>
#include <QMetaMethod>
#include <QMetaObject>
#include <QMetaProperty>
#include <QMetaType>
#include <QMimeData>
#include <QMimeDatabase>
#include <QMimeType>
#include <QModelIndex>
#include <QMutex>
#include <QMutexLocker>
#include <QObject>
#include <QObjectCleanupHandler>
#include <QObjectData>
#include <QOffscreenSurface>
#include <QOperatingSystemVersion>
#include <QPaintDeviceWindow>
#include <QParallelAnimationGroup>
#include <QPauseAnimation>
#include <QPdfWriter>
#include <QPersistentModelIndex>
#include <QPluginLoader>
#include <QPoint>
#include <QPointF>
#include <QProcess>
#include <QProcessEnvironment>
#include <QPropertyAnimation>
#include <QQuickItem>
#include <QRadioData>
#include <QRandomGenerator>
#include <QRandomGenerator64>
#include <QReadLocker>
#include <QReadWriteLock>
#include <QRect>
#include <QRectF>
#include <QRegExp>
#include <QRegularExpression>
#include <QRegularExpressionMatch>
#include <QRegularExpressionMatchIterator>
#include <QRemoteObjectPendingCallWatcher>
#include <QResource>
#include <QRunnable>
#include <QSaveFile>
#include <QScriptExtensionPlugin>
#include <QSemaphore>
#include <QSemaphoreReleaser>
#include <QSequentialAnimationGroup>
#include <QSequentialIterable>
#include <QSettings>
#include <QSharedData>
#include <QSharedMemory>
#include <QSignalBlocker>
#include <QSignalTransition>
#include <QSize>
#include <QSizeF>
#include <QSocketNotifier>
#include <QSortFilterProxyModel>
#include <QStandardPaths>
#include <QState>
#include <QStateMachine>
#include <QStaticPlugin>
#include <QStorageInfo>
#include <QString>
#include <QStringListModel>
#include <QStringMatcher>
#include <QStringRef>
#include <QSysInfo>
#include <QSystemSemaphore>
#include <QTemporaryDir>
#include <QTemporaryFile>
#include <QTextBoundaryFinder>
#include <QTextCodec>
#include <QTextDecoder>
#include <QTextEncoder>
#include <QTextStream>
#include <QThread>
#include <QThreadPool>
#include <QTime>
#include <QTimeLine>
#include <QTimeZone>
#include <QTimer>
#include <QTimerEvent>
#include <QTranslator>
#include <QTransposeProxyModel>
#include <QUnhandledException>
#include <QUrl>
#include <QUrlQuery>
#include <QUuid>
#include <QVariant>
#include <QVariantAnimation>
#include <QVector>
#include <QVersionNumber>
#include <QWaitCondition>
#include <QWidget>
#include <QWinEventNotifier>
#include <QWindow>
#include <QWriteLocker>
#include <QXmlStreamAttribute>
#include <QXmlStreamAttributes>
#include <QXmlStreamEntityDeclaration>
#include <QXmlStreamEntityResolver>
#include <QXmlStreamNamespaceDeclaration>
#include <QXmlStreamNotationDeclaration>
#include <QXmlStreamReader>
#include <QXmlStreamWriter>
#include <QtGlobal>
#include <QTextDocument>
class MyQAbstractAnimation: public QAbstractAnimation
{
public:
MyQAbstractAnimation(QObject *parent = Q_NULLPTR) : QAbstractAnimation(parent) {QAbstractAnimation_QAbstractAnimation_QRegisterMetaType();};
void Signal_CurrentLoopChanged(int currentLoop) { callbackQAbstractAnimation_CurrentLoopChanged(this, currentLoop); };
void Signal_DirectionChanged(QAbstractAnimation::Direction newDirection) { callbackQAbstractAnimation_DirectionChanged(this, newDirection); };
int duration() const { return callbackQAbstractAnimation_Duration(const_cast<void*>(static_cast<const void*>(this))); };
bool event(QEvent * event) { return callbackQObject_Event(this, event) != 0; };
void Signal_Finished() { callbackQAbstractAnimation_Finished(this); };
void pause() { callbackQAbstractAnimation_Pause(this); };
void resume() { callbackQAbstractAnimation_Resume(this); };
void setCurrentTime(int msecs) { callbackQAbstractAnimation_SetCurrentTime(this, msecs); };
void setPaused(bool paused) { callbackQAbstractAnimation_SetPaused(this, paused); };
void start(QAbstractAnimation::DeletionPolicy policy) { callbackQAbstractAnimation_Start(this, policy); };
void Signal_StateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { callbackQAbstractAnimation_StateChanged(this, newState, oldState); };
void stop() { callbackQAbstractAnimation_Stop(this); };
void updateCurrentTime(int currentTime) { callbackQAbstractAnimation_UpdateCurrentTime(this, currentTime); };
void updateDirection(QAbstractAnimation::Direction direction) { callbackQAbstractAnimation_UpdateDirection(this, direction); };
void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { callbackQAbstractAnimation_UpdateState(this, newState, oldState); };
~MyQAbstractAnimation() { callbackQAbstractAnimation_DestroyQAbstractAnimation(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QAbstractAnimation*)
Q_DECLARE_METATYPE(MyQAbstractAnimation*)
int QAbstractAnimation_QAbstractAnimation_QRegisterMetaType(){qRegisterMetaType<QAbstractAnimation*>(); return qRegisterMetaType<MyQAbstractAnimation*>();}
void* QAbstractAnimation_NewQAbstractAnimation(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQAbstractAnimation(static_cast<QWindow*>(parent));
} else {
return new MyQAbstractAnimation(static_cast<QObject*>(parent));
}
}
int QAbstractAnimation_CurrentLoop(void* ptr)
{
return static_cast<QAbstractAnimation*>(ptr)->currentLoop();
}
void QAbstractAnimation_ConnectCurrentLoopChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractAnimation*>(ptr), static_cast<void (QAbstractAnimation::*)(int)>(&QAbstractAnimation::currentLoopChanged), static_cast<MyQAbstractAnimation*>(ptr), static_cast<void (MyQAbstractAnimation::*)(int)>(&MyQAbstractAnimation::Signal_CurrentLoopChanged), static_cast<Qt::ConnectionType>(t));
}
void QAbstractAnimation_DisconnectCurrentLoopChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstractAnimation*>(ptr), static_cast<void (QAbstractAnimation::*)(int)>(&QAbstractAnimation::currentLoopChanged), static_cast<MyQAbstractAnimation*>(ptr), static_cast<void (MyQAbstractAnimation::*)(int)>(&MyQAbstractAnimation::Signal_CurrentLoopChanged));
}
void QAbstractAnimation_CurrentLoopChanged(void* ptr, int currentLoop)
{
static_cast<QAbstractAnimation*>(ptr)->currentLoopChanged(currentLoop);
}
int QAbstractAnimation_CurrentLoopTime(void* ptr)
{
return static_cast<QAbstractAnimation*>(ptr)->currentLoopTime();
}
int QAbstractAnimation_CurrentTime(void* ptr)
{
return static_cast<QAbstractAnimation*>(ptr)->currentTime();
}
long long QAbstractAnimation_Direction(void* ptr)
{
return static_cast<QAbstractAnimation*>(ptr)->direction();
}
void QAbstractAnimation_ConnectDirectionChanged(void* ptr, long long t)
{
qRegisterMetaType<QAbstractAnimation::Direction>();
QObject::connect(static_cast<QAbstractAnimation*>(ptr), static_cast<void (QAbstractAnimation::*)(QAbstractAnimation::Direction)>(&QAbstractAnimation::directionChanged), static_cast<MyQAbstractAnimation*>(ptr), static_cast<void (MyQAbstractAnimation::*)(QAbstractAnimation::Direction)>(&MyQAbstractAnimation::Signal_DirectionChanged), static_cast<Qt::ConnectionType>(t));
}
void QAbstractAnimation_DisconnectDirectionChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstractAnimation*>(ptr), static_cast<void (QAbstractAnimation::*)(QAbstractAnimation::Direction)>(&QAbstractAnimation::directionChanged), static_cast<MyQAbstractAnimation*>(ptr), static_cast<void (MyQAbstractAnimation::*)(QAbstractAnimation::Direction)>(&MyQAbstractAnimation::Signal_DirectionChanged));
}
void QAbstractAnimation_DirectionChanged(void* ptr, long long newDirection)
{
static_cast<QAbstractAnimation*>(ptr)->directionChanged(static_cast<QAbstractAnimation::Direction>(newDirection));
}
int QAbstractAnimation_Duration(void* ptr)
{
return static_cast<QAbstractAnimation*>(ptr)->duration();
}
void QAbstractAnimation_ConnectFinished(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractAnimation*>(ptr), static_cast<void (QAbstractAnimation::*)()>(&QAbstractAnimation::finished), static_cast<MyQAbstractAnimation*>(ptr), static_cast<void (MyQAbstractAnimation::*)()>(&MyQAbstractAnimation::Signal_Finished), static_cast<Qt::ConnectionType>(t));
}
void QAbstractAnimation_DisconnectFinished(void* ptr)
{
QObject::disconnect(static_cast<QAbstractAnimation*>(ptr), static_cast<void (QAbstractAnimation::*)()>(&QAbstractAnimation::finished), static_cast<MyQAbstractAnimation*>(ptr), static_cast<void (MyQAbstractAnimation::*)()>(&MyQAbstractAnimation::Signal_Finished));
}
void QAbstractAnimation_Finished(void* ptr)
{
static_cast<QAbstractAnimation*>(ptr)->finished();
}
void* QAbstractAnimation_Group(void* ptr)
{
return static_cast<QAbstractAnimation*>(ptr)->group();
}
int QAbstractAnimation_LoopCount(void* ptr)
{
return static_cast<QAbstractAnimation*>(ptr)->loopCount();
}
void QAbstractAnimation_Pause(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QAbstractAnimation*>(ptr), "pause");
}
void QAbstractAnimation_PauseDefault(void* ptr)
{
if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::pause();
} else if (dynamic_cast<QVariantAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::pause();
} else if (dynamic_cast<QPauseAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::pause();
} else if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::pause();
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::pause();
} else if (dynamic_cast<QAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QAnimationGroup*>(ptr)->QAnimationGroup::pause();
} else {
static_cast<QAbstractAnimation*>(ptr)->QAbstractAnimation::pause();
}
}
void QAbstractAnimation_Resume(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QAbstractAnimation*>(ptr), "resume");
}
void QAbstractAnimation_ResumeDefault(void* ptr)
{
if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::resume();
} else if (dynamic_cast<QVariantAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::resume();
} else if (dynamic_cast<QPauseAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::resume();
} else if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::resume();
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::resume();
} else if (dynamic_cast<QAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QAnimationGroup*>(ptr)->QAnimationGroup::resume();
} else {
static_cast<QAbstractAnimation*>(ptr)->QAbstractAnimation::resume();
}
}
void QAbstractAnimation_SetCurrentTime(void* ptr, int msecs)
{
QMetaObject::invokeMethod(static_cast<QAbstractAnimation*>(ptr), "setCurrentTime", Q_ARG(int, msecs));
}
void QAbstractAnimation_SetCurrentTimeDefault(void* ptr, int msecs)
{
if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::setCurrentTime(msecs);
} else if (dynamic_cast<QVariantAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::setCurrentTime(msecs);
} else if (dynamic_cast<QPauseAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::setCurrentTime(msecs);
} else if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::setCurrentTime(msecs);
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::setCurrentTime(msecs);
} else if (dynamic_cast<QAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QAnimationGroup*>(ptr)->QAnimationGroup::setCurrentTime(msecs);
} else {
static_cast<QAbstractAnimation*>(ptr)->QAbstractAnimation::setCurrentTime(msecs);
}
}
void QAbstractAnimation_SetDirection(void* ptr, long long direction)
{
static_cast<QAbstractAnimation*>(ptr)->setDirection(static_cast<QAbstractAnimation::Direction>(direction));
}
void QAbstractAnimation_SetLoopCount(void* ptr, int loopCount)
{
static_cast<QAbstractAnimation*>(ptr)->setLoopCount(loopCount);
}
void QAbstractAnimation_SetPaused(void* ptr, char paused)
{
QMetaObject::invokeMethod(static_cast<QAbstractAnimation*>(ptr), "setPaused", Q_ARG(bool, paused != 0));
}
void QAbstractAnimation_SetPausedDefault(void* ptr, char paused)
{
if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::setPaused(paused != 0);
} else if (dynamic_cast<QVariantAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::setPaused(paused != 0);
} else if (dynamic_cast<QPauseAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::setPaused(paused != 0);
} else if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::setPaused(paused != 0);
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::setPaused(paused != 0);
} else if (dynamic_cast<QAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QAnimationGroup*>(ptr)->QAnimationGroup::setPaused(paused != 0);
} else {
static_cast<QAbstractAnimation*>(ptr)->QAbstractAnimation::setPaused(paused != 0);
}
}
void QAbstractAnimation_Start(void* ptr, long long policy)
{
QMetaObject::invokeMethod(static_cast<QAbstractAnimation*>(ptr), "start", Q_ARG(QAbstractAnimation::DeletionPolicy, static_cast<QAbstractAnimation::DeletionPolicy>(policy)));
}
void QAbstractAnimation_StartDefault(void* ptr, long long policy)
{
if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::start(static_cast<QAbstractAnimation::DeletionPolicy>(policy));
} else if (dynamic_cast<QVariantAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::start(static_cast<QAbstractAnimation::DeletionPolicy>(policy));
} else if (dynamic_cast<QPauseAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::start(static_cast<QAbstractAnimation::DeletionPolicy>(policy));
} else if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::start(static_cast<QAbstractAnimation::DeletionPolicy>(policy));
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::start(static_cast<QAbstractAnimation::DeletionPolicy>(policy));
} else if (dynamic_cast<QAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QAnimationGroup*>(ptr)->QAnimationGroup::start(static_cast<QAbstractAnimation::DeletionPolicy>(policy));
} else {
static_cast<QAbstractAnimation*>(ptr)->QAbstractAnimation::start(static_cast<QAbstractAnimation::DeletionPolicy>(policy));
}
}
long long QAbstractAnimation_State(void* ptr)
{
return static_cast<QAbstractAnimation*>(ptr)->state();
}
void QAbstractAnimation_ConnectStateChanged(void* ptr, long long t)
{
qRegisterMetaType<QAbstractAnimation::State>();
qRegisterMetaType<QAbstractAnimation::State>();
QObject::connect(static_cast<QAbstractAnimation*>(ptr), static_cast<void (QAbstractAnimation::*)(QAbstractAnimation::State, QAbstractAnimation::State)>(&QAbstractAnimation::stateChanged), static_cast<MyQAbstractAnimation*>(ptr), static_cast<void (MyQAbstractAnimation::*)(QAbstractAnimation::State, QAbstractAnimation::State)>(&MyQAbstractAnimation::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}
void QAbstractAnimation_DisconnectStateChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstractAnimation*>(ptr), static_cast<void (QAbstractAnimation::*)(QAbstractAnimation::State, QAbstractAnimation::State)>(&QAbstractAnimation::stateChanged), static_cast<MyQAbstractAnimation*>(ptr), static_cast<void (MyQAbstractAnimation::*)(QAbstractAnimation::State, QAbstractAnimation::State)>(&MyQAbstractAnimation::Signal_StateChanged));
}
void QAbstractAnimation_StateChanged(void* ptr, long long newState, long long oldState)
{
static_cast<QAbstractAnimation*>(ptr)->stateChanged(static_cast<QAbstractAnimation::State>(newState), static_cast<QAbstractAnimation::State>(oldState));
}
void QAbstractAnimation_Stop(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QAbstractAnimation*>(ptr), "stop");
}
void QAbstractAnimation_StopDefault(void* ptr)
{
if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::stop();
} else if (dynamic_cast<QVariantAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::stop();
} else if (dynamic_cast<QPauseAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::stop();
} else if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::stop();
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::stop();
} else if (dynamic_cast<QAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QAnimationGroup*>(ptr)->QAnimationGroup::stop();
} else {
static_cast<QAbstractAnimation*>(ptr)->QAbstractAnimation::stop();
}
}
int QAbstractAnimation_TotalDuration(void* ptr)
{
return static_cast<QAbstractAnimation*>(ptr)->totalDuration();
}
void QAbstractAnimation_UpdateCurrentTime(void* ptr, int currentTime)
{
static_cast<QAbstractAnimation*>(ptr)->updateCurrentTime(currentTime);
}
void QAbstractAnimation_UpdateDirection(void* ptr, long long direction)
{
static_cast<QAbstractAnimation*>(ptr)->updateDirection(static_cast<QAbstractAnimation::Direction>(direction));
}
void QAbstractAnimation_UpdateDirectionDefault(void* ptr, long long direction)
{
if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::updateDirection(static_cast<QAbstractAnimation::Direction>(direction));
} else if (dynamic_cast<QVariantAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::updateDirection(static_cast<QAbstractAnimation::Direction>(direction));
} else if (dynamic_cast<QPauseAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::updateDirection(static_cast<QAbstractAnimation::Direction>(direction));
} else if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::updateDirection(static_cast<QAbstractAnimation::Direction>(direction));
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::updateDirection(static_cast<QAbstractAnimation::Direction>(direction));
} else if (dynamic_cast<QAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QAnimationGroup*>(ptr)->QAnimationGroup::updateDirection(static_cast<QAbstractAnimation::Direction>(direction));
} else {
static_cast<QAbstractAnimation*>(ptr)->QAbstractAnimation::updateDirection(static_cast<QAbstractAnimation::Direction>(direction));
}
}
void QAbstractAnimation_UpdateState(void* ptr, long long newState, long long oldState)
{
static_cast<QAbstractAnimation*>(ptr)->updateState(static_cast<QAbstractAnimation::State>(newState), static_cast<QAbstractAnimation::State>(oldState));
}
void QAbstractAnimation_UpdateStateDefault(void* ptr, long long newState, long long oldState)
{
if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::updateState(static_cast<QAbstractAnimation::State>(newState), static_cast<QAbstractAnimation::State>(oldState));
} else if (dynamic_cast<QVariantAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::updateState(static_cast<QAbstractAnimation::State>(newState), static_cast<QAbstractAnimation::State>(oldState));
} else if (dynamic_cast<QPauseAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::updateState(static_cast<QAbstractAnimation::State>(newState), static_cast<QAbstractAnimation::State>(oldState));
} else if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::updateState(static_cast<QAbstractAnimation::State>(newState), static_cast<QAbstractAnimation::State>(oldState));
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::updateState(static_cast<QAbstractAnimation::State>(newState), static_cast<QAbstractAnimation::State>(oldState));
} else if (dynamic_cast<QAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QAnimationGroup*>(ptr)->QAnimationGroup::updateState(static_cast<QAbstractAnimation::State>(newState), static_cast<QAbstractAnimation::State>(oldState));
} else {
static_cast<QAbstractAnimation*>(ptr)->QAbstractAnimation::updateState(static_cast<QAbstractAnimation::State>(newState), static_cast<QAbstractAnimation::State>(oldState));
}
}
void QAbstractAnimation_DestroyQAbstractAnimation(void* ptr)
{
static_cast<QAbstractAnimation*>(ptr)->~QAbstractAnimation();
}
void QAbstractAnimation_DestroyQAbstractAnimationDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQAbstractEventDispatcher: public QAbstractEventDispatcher
{
public:
void Signal_AboutToBlock() { callbackQAbstractEventDispatcher_AboutToBlock(this); };
void Signal_Awake() { callbackQAbstractEventDispatcher_Awake(this); };
void interrupt() { callbackQAbstractEventDispatcher_Interrupt(this); };
bool processEvents(QEventLoop::ProcessEventsFlags flags) { return callbackQAbstractEventDispatcher_ProcessEvents(this, flags) != 0; };
#ifdef Q_OS_WIN
bool registerEventNotifier(QWinEventNotifier * notifier) { return callbackQAbstractEventDispatcher_RegisterEventNotifier(this, notifier) != 0; };
#endif
void registerSocketNotifier(QSocketNotifier * notifier) { callbackQAbstractEventDispatcher_RegisterSocketNotifier(this, notifier); };
void registerTimer(int timerId, int interval, Qt::TimerType timerType, QObject * object) { callbackQAbstractEventDispatcher_RegisterTimer4(this, timerId, interval, timerType, object); };
int remainingTime(int timerId) { return callbackQAbstractEventDispatcher_RemainingTime(this, timerId); };
#ifdef Q_OS_WIN
void unregisterEventNotifier(QWinEventNotifier * notifier) { callbackQAbstractEventDispatcher_UnregisterEventNotifier(this, notifier); };
#endif
void unregisterSocketNotifier(QSocketNotifier * notifier) { callbackQAbstractEventDispatcher_UnregisterSocketNotifier(this, notifier); };
bool unregisterTimer(int timerId) { return callbackQAbstractEventDispatcher_UnregisterTimer(this, timerId) != 0; };
bool unregisterTimers(QObject * object) { return callbackQAbstractEventDispatcher_UnregisterTimers(this, object) != 0; };
void wakeUp() { callbackQAbstractEventDispatcher_WakeUp(this); };
~MyQAbstractEventDispatcher() { callbackQAbstractEventDispatcher_DestroyQAbstractEventDispatcher(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QAbstractEventDispatcher*)
Q_DECLARE_METATYPE(MyQAbstractEventDispatcher*)
int QAbstractEventDispatcher_QAbstractEventDispatcher_QRegisterMetaType(){qRegisterMetaType<QAbstractEventDispatcher*>(); return qRegisterMetaType<MyQAbstractEventDispatcher*>();}
void QAbstractEventDispatcher_ConnectAboutToBlock(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractEventDispatcher*>(ptr), static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::aboutToBlock), static_cast<MyQAbstractEventDispatcher*>(ptr), static_cast<void (MyQAbstractEventDispatcher::*)()>(&MyQAbstractEventDispatcher::Signal_AboutToBlock), static_cast<Qt::ConnectionType>(t));
}
void QAbstractEventDispatcher_DisconnectAboutToBlock(void* ptr)
{
QObject::disconnect(static_cast<QAbstractEventDispatcher*>(ptr), static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::aboutToBlock), static_cast<MyQAbstractEventDispatcher*>(ptr), static_cast<void (MyQAbstractEventDispatcher::*)()>(&MyQAbstractEventDispatcher::Signal_AboutToBlock));
}
void QAbstractEventDispatcher_AboutToBlock(void* ptr)
{
static_cast<QAbstractEventDispatcher*>(ptr)->aboutToBlock();
}
void QAbstractEventDispatcher_ConnectAwake(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractEventDispatcher*>(ptr), static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::awake), static_cast<MyQAbstractEventDispatcher*>(ptr), static_cast<void (MyQAbstractEventDispatcher::*)()>(&MyQAbstractEventDispatcher::Signal_Awake), static_cast<Qt::ConnectionType>(t));
}
void QAbstractEventDispatcher_DisconnectAwake(void* ptr)
{
QObject::disconnect(static_cast<QAbstractEventDispatcher*>(ptr), static_cast<void (QAbstractEventDispatcher::*)()>(&QAbstractEventDispatcher::awake), static_cast<MyQAbstractEventDispatcher*>(ptr), static_cast<void (MyQAbstractEventDispatcher::*)()>(&MyQAbstractEventDispatcher::Signal_Awake));
}
void QAbstractEventDispatcher_Awake(void* ptr)
{
static_cast<QAbstractEventDispatcher*>(ptr)->awake();
}
char QAbstractEventDispatcher_FilterNativeEvent(void* ptr, void* eventType, void* message, long* result)
{
return static_cast<QAbstractEventDispatcher*>(ptr)->filterNativeEvent(*static_cast<QByteArray*>(eventType), message, result);
}
void QAbstractEventDispatcher_InstallNativeEventFilter(void* ptr, void* filterObj)
{
static_cast<QAbstractEventDispatcher*>(ptr)->installNativeEventFilter(static_cast<QAbstractNativeEventFilter*>(filterObj));
}
void* QAbstractEventDispatcher_QAbstractEventDispatcher_Instance(void* thread)
{
return QAbstractEventDispatcher::instance(static_cast<QThread*>(thread));
}
void QAbstractEventDispatcher_Interrupt(void* ptr)
{
static_cast<QAbstractEventDispatcher*>(ptr)->interrupt();
}
char QAbstractEventDispatcher_ProcessEvents(void* ptr, long long flags)
{
return static_cast<QAbstractEventDispatcher*>(ptr)->processEvents(static_cast<QEventLoop::ProcessEventsFlag>(flags));
}
char QAbstractEventDispatcher_RegisterEventNotifier(void* ptr, void* notifier)
{
#ifdef Q_OS_WIN
return static_cast<QAbstractEventDispatcher*>(ptr)->registerEventNotifier(static_cast<QWinEventNotifier*>(notifier));
#else
return false;
#endif
}
void QAbstractEventDispatcher_RegisterSocketNotifier(void* ptr, void* notifier)
{
static_cast<QAbstractEventDispatcher*>(ptr)->registerSocketNotifier(static_cast<QSocketNotifier*>(notifier));
}
int QAbstractEventDispatcher_RegisterTimer3(void* ptr, int interval, long long timerType, void* object)
{
return static_cast<QAbstractEventDispatcher*>(ptr)->registerTimer(interval, static_cast<Qt::TimerType>(timerType), static_cast<QObject*>(object));
}
void QAbstractEventDispatcher_RegisterTimer4(void* ptr, int timerId, int interval, long long timerType, void* object)
{
static_cast<QAbstractEventDispatcher*>(ptr)->registerTimer(timerId, interval, static_cast<Qt::TimerType>(timerType), static_cast<QObject*>(object));
}
int QAbstractEventDispatcher_RemainingTime(void* ptr, int timerId)
{
return static_cast<QAbstractEventDispatcher*>(ptr)->remainingTime(timerId);
}
void QAbstractEventDispatcher_RemoveNativeEventFilter(void* ptr, void* filter)
{
static_cast<QAbstractEventDispatcher*>(ptr)->removeNativeEventFilter(static_cast<QAbstractNativeEventFilter*>(filter));
}
void QAbstractEventDispatcher_UnregisterEventNotifier(void* ptr, void* notifier)
{
#ifdef Q_OS_WIN
static_cast<QAbstractEventDispatcher*>(ptr)->unregisterEventNotifier(static_cast<QWinEventNotifier*>(notifier));
#endif
}
void QAbstractEventDispatcher_UnregisterSocketNotifier(void* ptr, void* notifier)
{
static_cast<QAbstractEventDispatcher*>(ptr)->unregisterSocketNotifier(static_cast<QSocketNotifier*>(notifier));
}
char QAbstractEventDispatcher_UnregisterTimer(void* ptr, int timerId)
{
return static_cast<QAbstractEventDispatcher*>(ptr)->unregisterTimer(timerId);
}
char QAbstractEventDispatcher_UnregisterTimers(void* ptr, void* object)
{
return static_cast<QAbstractEventDispatcher*>(ptr)->unregisterTimers(static_cast<QObject*>(object));
}
void QAbstractEventDispatcher_WakeUp(void* ptr)
{
static_cast<QAbstractEventDispatcher*>(ptr)->wakeUp();
}
void QAbstractEventDispatcher_DestroyQAbstractEventDispatcher(void* ptr)
{
static_cast<QAbstractEventDispatcher*>(ptr)->~QAbstractEventDispatcher();
}
void QAbstractEventDispatcher_DestroyQAbstractEventDispatcherDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQAbstractItemModel: public QAbstractItemModel
{
public:
MyQAbstractItemModel(QObject *parent = Q_NULLPTR) : QAbstractItemModel(parent) {QAbstractItemModel_QAbstractItemModel_QRegisterMetaType();};
QModelIndex buddy(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Buddy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool canDropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) const { return callbackQAbstractItemModel_CanDropMimeData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
bool canFetchMore(const QModelIndex & parent) const { return callbackQAbstractItemModel_CanFetchMore(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
int columnCount(const QModelIndex & parent) const { return callbackQAbstractItemModel_ColumnCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
void Signal_ColumnsAboutToBeInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationColumn) { callbackQAbstractItemModel_ColumnsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationColumn); };
void Signal_ColumnsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int column) { callbackQAbstractItemModel_ColumnsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), column); };
void Signal_ColumnsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
QVariant data(const QModelIndex & index, int role) const { return *static_cast<QVariant*>(callbackQAbstractItemModel_Data(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), role)); };
void Signal_DataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQAbstractItemModel_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtCore_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQAbstractItemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
void fetchMore(const QModelIndex & parent) { callbackQAbstractItemModel_FetchMore(this, const_cast<QModelIndex*>(&parent)); };
Qt::ItemFlags flags(const QModelIndex & index) const { return static_cast<Qt::ItemFlag>(callbackQAbstractItemModel_Flags(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool hasChildren(const QModelIndex & parent) const { return callbackQAbstractItemModel_HasChildren(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
QVariant headerData(int section, Qt::Orientation orientation, int role) const { return *static_cast<QVariant*>(callbackQAbstractItemModel_HeaderData(const_cast<void*>(static_cast<const void*>(this)), section, orientation, role)); };
void Signal_HeaderDataChanged(Qt::Orientation orientation, int first, int last) { callbackQAbstractItemModel_HeaderDataChanged(this, orientation, first, last); };
QModelIndex index(int row, int column, const QModelIndex & parent) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Index(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&parent))); };
bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
QMap<int, QVariant> itemData(const QModelIndex & index) const { return ({ QMap<int, QVariant>* tmpP = static_cast<QMap<int, QVariant>*>(callbackQAbstractItemModel_ItemData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); QMap<int, QVariant> tmpV = *tmpP; tmpP->~QMap(); free(tmpP); tmpV; }); };
void Signal_LayoutAboutToBeChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQAbstractItemModel_LayoutAboutToBeChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtCore_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
void Signal_LayoutChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQAbstractItemModel_LayoutChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtCore_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
QList<QModelIndex> match(const QModelIndex & start, int role, const QVariant & value, int hits, Qt::MatchFlags flags) const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemModel_Match(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&start), role, const_cast<QVariant*>(&value), hits, flags)); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
QMimeData * mimeData(const QModelIndexList & indexes) const { return static_cast<QMimeData*>(callbackQAbstractItemModel_MimeData(const_cast<void*>(static_cast<const void*>(this)), ({ QList<QModelIndex>* tmpValuee0adf2 = new QList<QModelIndex>(indexes); QtCore_PackedList { tmpValuee0adf2, tmpValuee0adf2->size() }; }))); };
QStringList mimeTypes() const { return ({ QtCore_PackedString tempVal = callbackQAbstractItemModel_MimeTypes(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
void Signal_ModelAboutToBeReset() { callbackQAbstractItemModel_ModelAboutToBeReset(this); };
void Signal_ModelReset() { callbackQAbstractItemModel_ModelReset(this); };
bool moveColumns(const QModelIndex & sourceParent, int sourceColumn, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQAbstractItemModel_MoveColumns(this, const_cast<QModelIndex*>(&sourceParent), sourceColumn, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
bool moveRows(const QModelIndex & sourceParent, int sourceRow, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQAbstractItemModel_MoveRows(this, const_cast<QModelIndex*>(&sourceParent), sourceRow, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
QModelIndex parent(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Parent(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool removeColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool removeRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
void resetInternalData() { callbackQAbstractItemModel_ResetInternalData(this); };
void revert() { callbackQAbstractItemModel_Revert(this); };
QHash<int, QByteArray> roleNames() const { return ({ QHash<int, QByteArray>* tmpP = static_cast<QHash<int, QByteArray>*>(callbackQAbstractItemModel_RoleNames(const_cast<void*>(static_cast<const void*>(this)))); QHash<int, QByteArray> tmpV = *tmpP; tmpP->~QHash(); free(tmpP); tmpV; }); };
int rowCount(const QModelIndex & parent) const { return callbackQAbstractItemModel_RowCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
void Signal_RowsAboutToBeInserted(const QModelIndex & parent, int start, int end) { callbackQAbstractItemModel_RowsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
void Signal_RowsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationRow) { callbackQAbstractItemModel_RowsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationRow); };
void Signal_RowsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int row) { callbackQAbstractItemModel_RowsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), row); };
void Signal_RowsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
bool setData(const QModelIndex & index, const QVariant & value, int role) { return callbackQAbstractItemModel_SetData(this, const_cast<QModelIndex*>(&index), const_cast<QVariant*>(&value), role) != 0; };
bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQAbstractItemModel_SetHeaderData(this, section, orientation, const_cast<QVariant*>(&value), role) != 0; };
bool setItemData(const QModelIndex & index, const QMap<int, QVariant> & roles) { return callbackQAbstractItemModel_SetItemData(this, const_cast<QModelIndex*>(&index), ({ QMap<int, QVariant>* tmpValue037c88 = new QMap<int, QVariant>(roles); QtCore_PackedList { tmpValue037c88, tmpValue037c88->size() }; })) != 0; };
QModelIndex sibling(int row, int column, const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Sibling(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&index))); };
void sort(int column, Qt::SortOrder order) { callbackQAbstractItemModel_Sort(this, column, order); };
QSize span(const QModelIndex & index) const { return *static_cast<QSize*>(callbackQAbstractItemModel_Span(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool submit() { return callbackQAbstractItemModel_Submit(this) != 0; };
Qt::DropActions supportedDragActions() const { return static_cast<Qt::DropAction>(callbackQAbstractItemModel_SupportedDragActions(const_cast<void*>(static_cast<const void*>(this)))); };
Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQAbstractItemModel_SupportedDropActions(const_cast<void*>(static_cast<const void*>(this)))); };
~MyQAbstractItemModel() { callbackQAbstractItemModel_DestroyQAbstractItemModel(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QAbstractItemModel*)
Q_DECLARE_METATYPE(MyQAbstractItemModel*)
int QAbstractItemModel_QAbstractItemModel_QRegisterMetaType(){qRegisterMetaType<QAbstractItemModel*>(); return qRegisterMetaType<MyQAbstractItemModel*>();}
void* QAbstractItemModel_NewQAbstractItemModel(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQAbstractItemModel(static_cast<QWindow*>(parent));
} else {
return new MyQAbstractItemModel(static_cast<QObject*>(parent));
}
}
void QAbstractItemModel_BeginInsertColumns(void* ptr, void* parent, int first, int last)
{
static_cast<QAbstractItemModel*>(ptr)->beginInsertColumns(*static_cast<QModelIndex*>(parent), first, last);
}
void QAbstractItemModel_BeginInsertRows(void* ptr, void* parent, int first, int last)
{
static_cast<QAbstractItemModel*>(ptr)->beginInsertRows(*static_cast<QModelIndex*>(parent), first, last);
}
char QAbstractItemModel_BeginMoveColumns(void* ptr, void* sourceParent, int sourceFirst, int sourceLast, void* destinationParent, int destinationChild)
{
return static_cast<QAbstractItemModel*>(ptr)->beginMoveColumns(*static_cast<QModelIndex*>(sourceParent), sourceFirst, sourceLast, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}
char QAbstractItemModel_BeginMoveRows(void* ptr, void* sourceParent, int sourceFirst, int sourceLast, void* destinationParent, int destinationChild)
{
return static_cast<QAbstractItemModel*>(ptr)->beginMoveRows(*static_cast<QModelIndex*>(sourceParent), sourceFirst, sourceLast, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}
void QAbstractItemModel_BeginRemoveColumns(void* ptr, void* parent, int first, int last)
{
static_cast<QAbstractItemModel*>(ptr)->beginRemoveColumns(*static_cast<QModelIndex*>(parent), first, last);
}
void QAbstractItemModel_BeginRemoveRows(void* ptr, void* parent, int first, int last)
{
static_cast<QAbstractItemModel*>(ptr)->beginRemoveRows(*static_cast<QModelIndex*>(parent), first, last);
}
void QAbstractItemModel_BeginResetModel(void* ptr)
{
static_cast<QAbstractItemModel*>(ptr)->beginResetModel();
}
void* QAbstractItemModel_Buddy(void* ptr, void* index)
{
return new QModelIndex(static_cast<QAbstractItemModel*>(ptr)->buddy(*static_cast<QModelIndex*>(index)));
}
void* QAbstractItemModel_BuddyDefault(void* ptr, void* index)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::buddy(*static_cast<QModelIndex*>(index)));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::buddy(*static_cast<QModelIndex*>(index)));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::buddy(*static_cast<QModelIndex*>(index)));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::buddy(*static_cast<QModelIndex*>(index)));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::buddy(*static_cast<QModelIndex*>(index)));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QStringListModel*>(ptr)->QStringListModel::buddy(*static_cast<QModelIndex*>(index)));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::buddy(*static_cast<QModelIndex*>(index)));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::buddy(*static_cast<QModelIndex*>(index)));
} else {
return new QModelIndex(static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::buddy(*static_cast<QModelIndex*>(index)));
}
}
char QAbstractItemModel_CanDropMimeData(void* ptr, void* data, long long action, int row, int column, void* parent)
{
return static_cast<QAbstractItemModel*>(ptr)->canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}
char QAbstractItemModel_CanDropMimeDataDefault(void* ptr, void* data, long long action, int row, int column, void* parent)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
} else {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}
}
char QAbstractItemModel_CanFetchMore(void* ptr, void* parent)
{
return static_cast<QAbstractItemModel*>(ptr)->canFetchMore(*static_cast<QModelIndex*>(parent));
}
char QAbstractItemModel_CanFetchMoreDefault(void* ptr, void* parent)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::canFetchMore(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::canFetchMore(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::canFetchMore(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::canFetchMore(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::canFetchMore(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::canFetchMore(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::canFetchMore(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::canFetchMore(*static_cast<QModelIndex*>(parent));
} else {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::canFetchMore(*static_cast<QModelIndex*>(parent));
}
}
void QAbstractItemModel_ChangePersistentIndex(void* ptr, void* from, void* to)
{
static_cast<QAbstractItemModel*>(ptr)->changePersistentIndex(*static_cast<QModelIndex*>(from), *static_cast<QModelIndex*>(to));
}
void QAbstractItemModel_ChangePersistentIndexList(void* ptr, void* from, void* to)
{
static_cast<QAbstractItemModel*>(ptr)->changePersistentIndexList(({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(from); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }), ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(to); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
}
char QAbstractItemModel_CheckIndex(void* ptr, void* index, long long options)
{
return static_cast<QAbstractItemModel*>(ptr)->checkIndex(*static_cast<QModelIndex*>(index), static_cast<QAbstractItemModel::CheckIndexOption>(options));
}
int QAbstractItemModel_ColumnCount(void* ptr, void* parent)
{
return static_cast<QAbstractItemModel*>(ptr)->columnCount(*static_cast<QModelIndex*>(parent));
}
void QAbstractItemModel_ConnectColumnsAboutToBeInserted(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsAboutToBeInserted, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_ColumnsAboutToBeInserted), static_cast<Qt::ConnectionType>(t));
}
void QAbstractItemModel_DisconnectColumnsAboutToBeInserted(void* ptr)
{
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsAboutToBeInserted, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_ColumnsAboutToBeInserted));
}
void QAbstractItemModel_ConnectColumnsAboutToBeMoved(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsAboutToBeMoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int, const QModelIndex &, int)>(&MyQAbstractItemModel::Signal_ColumnsAboutToBeMoved), static_cast<Qt::ConnectionType>(t));
}
void QAbstractItemModel_DisconnectColumnsAboutToBeMoved(void* ptr)
{
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsAboutToBeMoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int, const QModelIndex &, int)>(&MyQAbstractItemModel::Signal_ColumnsAboutToBeMoved));
}
void QAbstractItemModel_ConnectColumnsAboutToBeRemoved(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsAboutToBeRemoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_ColumnsAboutToBeRemoved), static_cast<Qt::ConnectionType>(t));
}
void QAbstractItemModel_DisconnectColumnsAboutToBeRemoved(void* ptr)
{
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsAboutToBeRemoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_ColumnsAboutToBeRemoved));
}
void QAbstractItemModel_ConnectColumnsInserted(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsInserted, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_ColumnsInserted), static_cast<Qt::ConnectionType>(t));
}
void QAbstractItemModel_DisconnectColumnsInserted(void* ptr)
{
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsInserted, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_ColumnsInserted));
}
void QAbstractItemModel_ConnectColumnsMoved(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsMoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int, const QModelIndex &, int)>(&MyQAbstractItemModel::Signal_ColumnsMoved), static_cast<Qt::ConnectionType>(t));
}
void QAbstractItemModel_DisconnectColumnsMoved(void* ptr)
{
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsMoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int, const QModelIndex &, int)>(&MyQAbstractItemModel::Signal_ColumnsMoved));
}
void QAbstractItemModel_ConnectColumnsRemoved(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsRemoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_ColumnsRemoved), static_cast<Qt::ConnectionType>(t));
}
void QAbstractItemModel_DisconnectColumnsRemoved(void* ptr)
{
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::columnsRemoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_ColumnsRemoved));
}
void* QAbstractItemModel_CreateIndex(void* ptr, int row, int column, void* p)
{
return new QModelIndex(static_cast<QAbstractItemModel*>(ptr)->createIndex(row, column, p));
}
void* QAbstractItemModel_CreateIndex2(void* ptr, int row, int column, uintptr_t id)
{
return new QModelIndex(static_cast<QAbstractItemModel*>(ptr)->createIndex(row, column, id));
}
void* QAbstractItemModel_Data(void* ptr, void* index, int role)
{
return new QVariant(static_cast<QAbstractItemModel*>(ptr)->data(*static_cast<QModelIndex*>(index), role));
}
void QAbstractItemModel_ConnectDataChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractItemModel*>(ptr), static_cast<void (QAbstractItemModel::*)(const QModelIndex &, const QModelIndex &, const QVector<int> &)>(&QAbstractItemModel::dataChanged), static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, const QModelIndex &, const QVector<int> &)>(&MyQAbstractItemModel::Signal_DataChanged), static_cast<Qt::ConnectionType>(t));
}
void QAbstractItemModel_DisconnectDataChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), static_cast<void (QAbstractItemModel::*)(const QModelIndex &, const QModelIndex &, const QVector<int> &)>(&QAbstractItemModel::dataChanged), static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, const QModelIndex &, const QVector<int> &)>(&MyQAbstractItemModel::Signal_DataChanged));
}
void QAbstractItemModel_DataChanged(void* ptr, void* topLeft, void* bottomRight, void* roles)
{
static_cast<QAbstractItemModel*>(ptr)->dataChanged(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight), *static_cast<QVector<int>*>(roles));
}
char QAbstractItemModel_DropMimeData(void* ptr, void* data, long long action, int row, int column, void* parent)
{
return static_cast<QAbstractItemModel*>(ptr)->dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}
char QAbstractItemModel_DropMimeDataDefault(void* ptr, void* data, long long action, int row, int column, void* parent)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
} else {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}
}
void QAbstractItemModel_EndInsertColumns(void* ptr)
{
static_cast<QAbstractItemModel*>(ptr)->endInsertColumns();
}
void QAbstractItemModel_EndInsertRows(void* ptr)
{
static_cast<QAbstractItemModel*>(ptr)->endInsertRows();
}
void QAbstractItemModel_EndMoveColumns(void* ptr)
{
static_cast<QAbstractItemModel*>(ptr)->endMoveColumns();
}
void QAbstractItemModel_EndMoveRows(void* ptr)
{
static_cast<QAbstractItemModel*>(ptr)->endMoveRows();
}
void QAbstractItemModel_EndRemoveColumns(void* ptr)
{
static_cast<QAbstractItemModel*>(ptr)->endRemoveColumns();
}
void QAbstractItemModel_EndRemoveRows(void* ptr)
{
static_cast<QAbstractItemModel*>(ptr)->endRemoveRows();
}
void QAbstractItemModel_EndResetModel(void* ptr)
{
static_cast<QAbstractItemModel*>(ptr)->endResetModel();
}
void QAbstractItemModel_FetchMore(void* ptr, void* parent)
{
static_cast<QAbstractItemModel*>(ptr)->fetchMore(*static_cast<QModelIndex*>(parent));
}
void QAbstractItemModel_FetchMoreDefault(void* ptr, void* parent)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::fetchMore(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::fetchMore(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::fetchMore(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::fetchMore(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::fetchMore(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QStringListModel*>(ptr)->QStringListModel::fetchMore(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::fetchMore(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::fetchMore(*static_cast<QModelIndex*>(parent));
} else {
static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::fetchMore(*static_cast<QModelIndex*>(parent));
}
}
long long QAbstractItemModel_Flags(void* ptr, void* index)
{
return static_cast<QAbstractItemModel*>(ptr)->flags(*static_cast<QModelIndex*>(index));
}
long long QAbstractItemModel_FlagsDefault(void* ptr, void* index)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::flags(*static_cast<QModelIndex*>(index));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::flags(*static_cast<QModelIndex*>(index));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::flags(*static_cast<QModelIndex*>(index));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::flags(*static_cast<QModelIndex*>(index));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::flags(*static_cast<QModelIndex*>(index));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::flags(*static_cast<QModelIndex*>(index));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::flags(*static_cast<QModelIndex*>(index));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::flags(*static_cast<QModelIndex*>(index));
} else {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::flags(*static_cast<QModelIndex*>(index));
}
}
char QAbstractItemModel_HasChildren(void* ptr, void* parent)
{
return static_cast<QAbstractItemModel*>(ptr)->hasChildren(*static_cast<QModelIndex*>(parent));
}
char QAbstractItemModel_HasChildrenDefault(void* ptr, void* parent)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::hasChildren(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::hasChildren(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::hasChildren(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::hasChildren(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::hasChildren(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::hasChildren(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::hasChildren(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::hasChildren(*static_cast<QModelIndex*>(parent));
} else {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::hasChildren(*static_cast<QModelIndex*>(parent));
}
}
char QAbstractItemModel_HasIndex(void* ptr, int row, int column, void* parent)
{
return static_cast<QAbstractItemModel*>(ptr)->hasIndex(row, column, *static_cast<QModelIndex*>(parent));
}
void* QAbstractItemModel_HeaderData(void* ptr, int section, long long orientation, int role)
{
return new QVariant(static_cast<QAbstractItemModel*>(ptr)->headerData(section, static_cast<Qt::Orientation>(orientation), role));
}
void* QAbstractItemModel_HeaderDataDefault(void* ptr, int section, long long orientation, int role)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return new QVariant(static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::headerData(section, static_cast<Qt::Orientation>(orientation), role));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return new QVariant(static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::headerData(section, static_cast<Qt::Orientation>(orientation), role));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return new QVariant(static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::headerData(section, static_cast<Qt::Orientation>(orientation), role));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return new QVariant(static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::headerData(section, static_cast<Qt::Orientation>(orientation), role));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return new QVariant(static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::headerData(section, static_cast<Qt::Orientation>(orientation), role));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return new QVariant(static_cast<QStringListModel*>(ptr)->QStringListModel::headerData(section, static_cast<Qt::Orientation>(orientation), role));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return new QVariant(static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::headerData(section, static_cast<Qt::Orientation>(orientation), role));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return new QVariant(static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::headerData(section, static_cast<Qt::Orientation>(orientation), role));
} else {
return new QVariant(static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::headerData(section, static_cast<Qt::Orientation>(orientation), role));
}
}
void QAbstractItemModel_ConnectHeaderDataChanged(void* ptr, long long t)
{
qRegisterMetaType<Qt::Orientation>();
QObject::connect(static_cast<QAbstractItemModel*>(ptr), static_cast<void (QAbstractItemModel::*)(Qt::Orientation, int, int)>(&QAbstractItemModel::headerDataChanged), static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(Qt::Orientation, int, int)>(&MyQAbstractItemModel::Signal_HeaderDataChanged), static_cast<Qt::ConnectionType>(t));
}
void QAbstractItemModel_DisconnectHeaderDataChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), static_cast<void (QAbstractItemModel::*)(Qt::Orientation, int, int)>(&QAbstractItemModel::headerDataChanged), static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(Qt::Orientation, int, int)>(&MyQAbstractItemModel::Signal_HeaderDataChanged));
}
void QAbstractItemModel_HeaderDataChanged(void* ptr, long long orientation, int first, int last)
{
static_cast<QAbstractItemModel*>(ptr)->headerDataChanged(static_cast<Qt::Orientation>(orientation), first, last);
}
void* QAbstractItemModel_Index(void* ptr, int row, int column, void* parent)
{
return new QModelIndex(static_cast<QAbstractItemModel*>(ptr)->index(row, column, *static_cast<QModelIndex*>(parent)));
}
char QAbstractItemModel_InsertColumn(void* ptr, int column, void* parent)
{
return static_cast<QAbstractItemModel*>(ptr)->insertColumn(column, *static_cast<QModelIndex*>(parent));
}
char QAbstractItemModel_InsertColumns(void* ptr, int column, int count, void* parent)
{
return static_cast<QAbstractItemModel*>(ptr)->insertColumns(column, count, *static_cast<QModelIndex*>(parent));
}
char QAbstractItemModel_InsertColumnsDefault(void* ptr, int column, int count, void* parent)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::insertColumns(column, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::insertColumns(column, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::insertColumns(column, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::insertColumns(column, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::insertColumns(column, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::insertColumns(column, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::insertColumns(column, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::insertColumns(column, count, *static_cast<QModelIndex*>(parent));
} else {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::insertColumns(column, count, *static_cast<QModelIndex*>(parent));
}
}
char QAbstractItemModel_InsertRow(void* ptr, int row, void* parent)
{
return static_cast<QAbstractItemModel*>(ptr)->insertRow(row, *static_cast<QModelIndex*>(parent));
}
char QAbstractItemModel_InsertRows(void* ptr, int row, int count, void* parent)
{
return static_cast<QAbstractItemModel*>(ptr)->insertRows(row, count, *static_cast<QModelIndex*>(parent));
}
char QAbstractItemModel_InsertRowsDefault(void* ptr, int row, int count, void* parent)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::insertRows(row, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::insertRows(row, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::insertRows(row, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::insertRows(row, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::insertRows(row, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::insertRows(row, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::insertRows(row, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::insertRows(row, count, *static_cast<QModelIndex*>(parent));
} else {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::insertRows(row, count, *static_cast<QModelIndex*>(parent));
}
}
struct QtCore_PackedList QAbstractItemModel_ItemData(void* ptr, void* index)
{
return ({ QMap<int, QVariant>* tmpValue2d9f39 = new QMap<int, QVariant>(static_cast<QAbstractItemModel*>(ptr)->itemData(*static_cast<QModelIndex*>(index))); QtCore_PackedList { tmpValue2d9f39, tmpValue2d9f39->size() }; });
}
struct QtCore_PackedList QAbstractItemModel_ItemDataDefault(void* ptr, void* index)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QMap<int, QVariant>* tmpValue46a96f = new QMap<int, QVariant>(static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::itemData(*static_cast<QModelIndex*>(index))); QtCore_PackedList { tmpValue46a96f, tmpValue46a96f->size() }; });
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QMap<int, QVariant>* tmpValue46a96f = new QMap<int, QVariant>(static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::itemData(*static_cast<QModelIndex*>(index))); QtCore_PackedList { tmpValue46a96f, tmpValue46a96f->size() }; });
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QMap<int, QVariant>* tmpValue46a96f = new QMap<int, QVariant>(static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::itemData(*static_cast<QModelIndex*>(index))); QtCore_PackedList { tmpValue46a96f, tmpValue46a96f->size() }; });
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QMap<int, QVariant>* tmpValue46a96f = new QMap<int, QVariant>(static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::itemData(*static_cast<QModelIndex*>(index))); QtCore_PackedList { tmpValue46a96f, tmpValue46a96f->size() }; });
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QMap<int, QVariant>* tmpValue46a96f = new QMap<int, QVariant>(static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::itemData(*static_cast<QModelIndex*>(index))); QtCore_PackedList { tmpValue46a96f, tmpValue46a96f->size() }; });
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return ({ QMap<int, QVariant>* tmpValue46a96f = new QMap<int, QVariant>(static_cast<QStringListModel*>(ptr)->QStringListModel::itemData(*static_cast<QModelIndex*>(index))); QtCore_PackedList { tmpValue46a96f, tmpValue46a96f->size() }; });
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return ({ QMap<int, QVariant>* tmpValue46a96f = new QMap<int, QVariant>(static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::itemData(*static_cast<QModelIndex*>(index))); QtCore_PackedList { tmpValue46a96f, tmpValue46a96f->size() }; });
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return ({ QMap<int, QVariant>* tmpValue46a96f = new QMap<int, QVariant>(static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::itemData(*static_cast<QModelIndex*>(index))); QtCore_PackedList { tmpValue46a96f, tmpValue46a96f->size() }; });
} else {
return ({ QMap<int, QVariant>* tmpValue46a96f = new QMap<int, QVariant>(static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::itemData(*static_cast<QModelIndex*>(index))); QtCore_PackedList { tmpValue46a96f, tmpValue46a96f->size() }; });
}
}
void QAbstractItemModel_ConnectLayoutAboutToBeChanged(void* ptr, long long t)
{
qRegisterMetaType<QAbstractItemModel::LayoutChangeHint>();
QObject::connect(static_cast<QAbstractItemModel*>(ptr), static_cast<void (QAbstractItemModel::*)(const QList<QPersistentModelIndex> &, QAbstractItemModel::LayoutChangeHint)>(&QAbstractItemModel::layoutAboutToBeChanged), static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QList<QPersistentModelIndex> &, QAbstractItemModel::LayoutChangeHint)>(&MyQAbstractItemModel::Signal_LayoutAboutToBeChanged), static_cast<Qt::ConnectionType>(t));
}
void QAbstractItemModel_DisconnectLayoutAboutToBeChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), static_cast<void (QAbstractItemModel::*)(const QList<QPersistentModelIndex> &, QAbstractItemModel::LayoutChangeHint)>(&QAbstractItemModel::layoutAboutToBeChanged), static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QList<QPersistentModelIndex> &, QAbstractItemModel::LayoutChangeHint)>(&MyQAbstractItemModel::Signal_LayoutAboutToBeChanged));
}
void QAbstractItemModel_LayoutAboutToBeChanged(void* ptr, void* parents, long long hint)
{
static_cast<QAbstractItemModel*>(ptr)->layoutAboutToBeChanged(*static_cast<QList<QPersistentModelIndex>*>(parents), static_cast<QAbstractItemModel::LayoutChangeHint>(hint));
}
void QAbstractItemModel_ConnectLayoutChanged(void* ptr, long long t)
{
qRegisterMetaType<QAbstractItemModel::LayoutChangeHint>();
QObject::connect(static_cast<QAbstractItemModel*>(ptr), static_cast<void (QAbstractItemModel::*)(const QList<QPersistentModelIndex> &, QAbstractItemModel::LayoutChangeHint)>(&QAbstractItemModel::layoutChanged), static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QList<QPersistentModelIndex> &, QAbstractItemModel::LayoutChangeHint)>(&MyQAbstractItemModel::Signal_LayoutChanged), static_cast<Qt::ConnectionType>(t));
}
void QAbstractItemModel_DisconnectLayoutChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), static_cast<void (QAbstractItemModel::*)(const QList<QPersistentModelIndex> &, QAbstractItemModel::LayoutChangeHint)>(&QAbstractItemModel::layoutChanged), static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QList<QPersistentModelIndex> &, QAbstractItemModel::LayoutChangeHint)>(&MyQAbstractItemModel::Signal_LayoutChanged));
}
void QAbstractItemModel_LayoutChanged(void* ptr, void* parents, long long hint)
{
static_cast<QAbstractItemModel*>(ptr)->layoutChanged(*static_cast<QList<QPersistentModelIndex>*>(parents), static_cast<QAbstractItemModel::LayoutChangeHint>(hint));
}
struct QtCore_PackedList QAbstractItemModel_Match(void* ptr, void* start, int role, void* value, int hits, long long flags)
{
return ({ QList<QModelIndex>* tmpValuef30906 = new QList<QModelIndex>(static_cast<QAbstractItemModel*>(ptr)->match(*static_cast<QModelIndex*>(start), role, *static_cast<QVariant*>(value), hits, static_cast<Qt::MatchFlag>(flags))); QtCore_PackedList { tmpValuef30906, tmpValuef30906->size() }; });
}
struct QtCore_PackedList QAbstractItemModel_MatchDefault(void* ptr, void* start, int role, void* value, int hits, long long flags)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QList<QModelIndex>* tmpValue4d7ea4 = new QList<QModelIndex>(static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::match(*static_cast<QModelIndex*>(start), role, *static_cast<QVariant*>(value), hits, static_cast<Qt::MatchFlag>(flags))); QtCore_PackedList { tmpValue4d7ea4, tmpValue4d7ea4->size() }; });
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QList<QModelIndex>* tmpValue4d7ea4 = new QList<QModelIndex>(static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::match(*static_cast<QModelIndex*>(start), role, *static_cast<QVariant*>(value), hits, static_cast<Qt::MatchFlag>(flags))); QtCore_PackedList { tmpValue4d7ea4, tmpValue4d7ea4->size() }; });
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QList<QModelIndex>* tmpValue4d7ea4 = new QList<QModelIndex>(static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::match(*static_cast<QModelIndex*>(start), role, *static_cast<QVariant*>(value), hits, static_cast<Qt::MatchFlag>(flags))); QtCore_PackedList { tmpValue4d7ea4, tmpValue4d7ea4->size() }; });
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QList<QModelIndex>* tmpValue4d7ea4 = new QList<QModelIndex>(static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::match(*static_cast<QModelIndex*>(start), role, *static_cast<QVariant*>(value), hits, static_cast<Qt::MatchFlag>(flags))); QtCore_PackedList { tmpValue4d7ea4, tmpValue4d7ea4->size() }; });
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QList<QModelIndex>* tmpValue4d7ea4 = new QList<QModelIndex>(static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::match(*static_cast<QModelIndex*>(start), role, *static_cast<QVariant*>(value), hits, static_cast<Qt::MatchFlag>(flags))); QtCore_PackedList { tmpValue4d7ea4, tmpValue4d7ea4->size() }; });
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return ({ QList<QModelIndex>* tmpValue4d7ea4 = new QList<QModelIndex>(static_cast<QStringListModel*>(ptr)->QStringListModel::match(*static_cast<QModelIndex*>(start), role, *static_cast<QVariant*>(value), hits, static_cast<Qt::MatchFlag>(flags))); QtCore_PackedList { tmpValue4d7ea4, tmpValue4d7ea4->size() }; });
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return ({ QList<QModelIndex>* tmpValue4d7ea4 = new QList<QModelIndex>(static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::match(*static_cast<QModelIndex*>(start), role, *static_cast<QVariant*>(value), hits, static_cast<Qt::MatchFlag>(flags))); QtCore_PackedList { tmpValue4d7ea4, tmpValue4d7ea4->size() }; });
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return ({ QList<QModelIndex>* tmpValue4d7ea4 = new QList<QModelIndex>(static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::match(*static_cast<QModelIndex*>(start), role, *static_cast<QVariant*>(value), hits, static_cast<Qt::MatchFlag>(flags))); QtCore_PackedList { tmpValue4d7ea4, tmpValue4d7ea4->size() }; });
} else {
return ({ QList<QModelIndex>* tmpValue4d7ea4 = new QList<QModelIndex>(static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::match(*static_cast<QModelIndex*>(start), role, *static_cast<QVariant*>(value), hits, static_cast<Qt::MatchFlag>(flags))); QtCore_PackedList { tmpValue4d7ea4, tmpValue4d7ea4->size() }; });
}
}
void* QAbstractItemModel_MimeData(void* ptr, void* indexes)
{
return static_cast<QAbstractItemModel*>(ptr)->mimeData(({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(indexes); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
}
void* QAbstractItemModel_MimeDataDefault(void* ptr, void* indexes)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::mimeData(({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(indexes); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::mimeData(({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(indexes); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::mimeData(({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(indexes); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::mimeData(({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(indexes); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::mimeData(({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(indexes); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::mimeData(({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(indexes); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::mimeData(({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(indexes); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::mimeData(({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(indexes); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
} else {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::mimeData(({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(indexes); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
}
}
struct QtCore_PackedString QAbstractItemModel_MimeTypes(void* ptr)
{
return ({ QByteArray* ta50262 = new QByteArray(static_cast<QAbstractItemModel*>(ptr)->mimeTypes().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(ta50262->prepend("WHITESPACE").constData()+10), ta50262->size()-10, ta50262 }; });
}
struct QtCore_PackedString QAbstractItemModel_MimeTypesDefault(void* ptr)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QByteArray* tf2dad9 = new QByteArray(static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::mimeTypes().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tf2dad9->prepend("WHITESPACE").constData()+10), tf2dad9->size()-10, tf2dad9 }; });
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QByteArray* tf2dad9 = new QByteArray(static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::mimeTypes().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tf2dad9->prepend("WHITESPACE").constData()+10), tf2dad9->size()-10, tf2dad9 }; });
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QByteArray* tf2dad9 = new QByteArray(static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::mimeTypes().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tf2dad9->prepend("WHITESPACE").constData()+10), tf2dad9->size()-10, tf2dad9 }; });
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QByteArray* tf2dad9 = new QByteArray(static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::mimeTypes().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tf2dad9->prepend("WHITESPACE").constData()+10), tf2dad9->size()-10, tf2dad9 }; });
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QByteArray* tf2dad9 = new QByteArray(static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::mimeTypes().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tf2dad9->prepend("WHITESPACE").constData()+10), tf2dad9->size()-10, tf2dad9 }; });
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return ({ QByteArray* tf2dad9 = new QByteArray(static_cast<QStringListModel*>(ptr)->QStringListModel::mimeTypes().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tf2dad9->prepend("WHITESPACE").constData()+10), tf2dad9->size()-10, tf2dad9 }; });
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return ({ QByteArray* tf2dad9 = new QByteArray(static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::mimeTypes().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tf2dad9->prepend("WHITESPACE").constData()+10), tf2dad9->size()-10, tf2dad9 }; });
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return ({ QByteArray* tf2dad9 = new QByteArray(static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::mimeTypes().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tf2dad9->prepend("WHITESPACE").constData()+10), tf2dad9->size()-10, tf2dad9 }; });
} else {
return ({ QByteArray* tf2dad9 = new QByteArray(static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::mimeTypes().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tf2dad9->prepend("WHITESPACE").constData()+10), tf2dad9->size()-10, tf2dad9 }; });
}
}
void QAbstractItemModel_ConnectModelAboutToBeReset(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::modelAboutToBeReset, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)()>(&MyQAbstractItemModel::Signal_ModelAboutToBeReset), static_cast<Qt::ConnectionType>(t));
}
void QAbstractItemModel_DisconnectModelAboutToBeReset(void* ptr)
{
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::modelAboutToBeReset, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)()>(&MyQAbstractItemModel::Signal_ModelAboutToBeReset));
}
void QAbstractItemModel_ConnectModelReset(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::modelReset, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)()>(&MyQAbstractItemModel::Signal_ModelReset), static_cast<Qt::ConnectionType>(t));
}
void QAbstractItemModel_DisconnectModelReset(void* ptr)
{
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::modelReset, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)()>(&MyQAbstractItemModel::Signal_ModelReset));
}
char QAbstractItemModel_MoveColumn(void* ptr, void* sourceParent, int sourceColumn, void* destinationParent, int destinationChild)
{
return static_cast<QAbstractItemModel*>(ptr)->moveColumn(*static_cast<QModelIndex*>(sourceParent), sourceColumn, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}
char QAbstractItemModel_MoveColumns(void* ptr, void* sourceParent, int sourceColumn, int count, void* destinationParent, int destinationChild)
{
return static_cast<QAbstractItemModel*>(ptr)->moveColumns(*static_cast<QModelIndex*>(sourceParent), sourceColumn, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}
char QAbstractItemModel_MoveColumnsDefault(void* ptr, void* sourceParent, int sourceColumn, int count, void* destinationParent, int destinationChild)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::moveColumns(*static_cast<QModelIndex*>(sourceParent), sourceColumn, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::moveColumns(*static_cast<QModelIndex*>(sourceParent), sourceColumn, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::moveColumns(*static_cast<QModelIndex*>(sourceParent), sourceColumn, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::moveColumns(*static_cast<QModelIndex*>(sourceParent), sourceColumn, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::moveColumns(*static_cast<QModelIndex*>(sourceParent), sourceColumn, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::moveColumns(*static_cast<QModelIndex*>(sourceParent), sourceColumn, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::moveColumns(*static_cast<QModelIndex*>(sourceParent), sourceColumn, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::moveColumns(*static_cast<QModelIndex*>(sourceParent), sourceColumn, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
} else {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::moveColumns(*static_cast<QModelIndex*>(sourceParent), sourceColumn, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}
}
char QAbstractItemModel_MoveRow(void* ptr, void* sourceParent, int sourceRow, void* destinationParent, int destinationChild)
{
return static_cast<QAbstractItemModel*>(ptr)->moveRow(*static_cast<QModelIndex*>(sourceParent), sourceRow, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}
char QAbstractItemModel_MoveRows(void* ptr, void* sourceParent, int sourceRow, int count, void* destinationParent, int destinationChild)
{
return static_cast<QAbstractItemModel*>(ptr)->moveRows(*static_cast<QModelIndex*>(sourceParent), sourceRow, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}
char QAbstractItemModel_MoveRowsDefault(void* ptr, void* sourceParent, int sourceRow, int count, void* destinationParent, int destinationChild)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::moveRows(*static_cast<QModelIndex*>(sourceParent), sourceRow, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::moveRows(*static_cast<QModelIndex*>(sourceParent), sourceRow, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::moveRows(*static_cast<QModelIndex*>(sourceParent), sourceRow, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::moveRows(*static_cast<QModelIndex*>(sourceParent), sourceRow, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::moveRows(*static_cast<QModelIndex*>(sourceParent), sourceRow, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::moveRows(*static_cast<QModelIndex*>(sourceParent), sourceRow, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::moveRows(*static_cast<QModelIndex*>(sourceParent), sourceRow, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::moveRows(*static_cast<QModelIndex*>(sourceParent), sourceRow, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
} else {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::moveRows(*static_cast<QModelIndex*>(sourceParent), sourceRow, count, *static_cast<QModelIndex*>(destinationParent), destinationChild);
}
}
void* QAbstractItemModel_Parent(void* ptr, void* index)
{
return new QModelIndex(static_cast<QAbstractItemModel*>(ptr)->parent(*static_cast<QModelIndex*>(index)));
}
struct QtCore_PackedList QAbstractItemModel_PersistentIndexList(void* ptr)
{
return ({ QList<QModelIndex>* tmpValue86ddbc = new QList<QModelIndex>(static_cast<QAbstractItemModel*>(ptr)->persistentIndexList()); QtCore_PackedList { tmpValue86ddbc, tmpValue86ddbc->size() }; });
}
char QAbstractItemModel_RemoveColumn(void* ptr, int column, void* parent)
{
return static_cast<QAbstractItemModel*>(ptr)->removeColumn(column, *static_cast<QModelIndex*>(parent));
}
char QAbstractItemModel_RemoveColumns(void* ptr, int column, int count, void* parent)
{
return static_cast<QAbstractItemModel*>(ptr)->removeColumns(column, count, *static_cast<QModelIndex*>(parent));
}
char QAbstractItemModel_RemoveColumnsDefault(void* ptr, int column, int count, void* parent)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::removeColumns(column, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::removeColumns(column, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::removeColumns(column, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::removeColumns(column, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::removeColumns(column, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::removeColumns(column, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::removeColumns(column, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::removeColumns(column, count, *static_cast<QModelIndex*>(parent));
} else {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::removeColumns(column, count, *static_cast<QModelIndex*>(parent));
}
}
char QAbstractItemModel_RemoveRow(void* ptr, int row, void* parent)
{
return static_cast<QAbstractItemModel*>(ptr)->removeRow(row, *static_cast<QModelIndex*>(parent));
}
char QAbstractItemModel_RemoveRows(void* ptr, int row, int count, void* parent)
{
return static_cast<QAbstractItemModel*>(ptr)->removeRows(row, count, *static_cast<QModelIndex*>(parent));
}
char QAbstractItemModel_RemoveRowsDefault(void* ptr, int row, int count, void* parent)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::removeRows(row, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::removeRows(row, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::removeRows(row, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::removeRows(row, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::removeRows(row, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::removeRows(row, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::removeRows(row, count, *static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::removeRows(row, count, *static_cast<QModelIndex*>(parent));
} else {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::removeRows(row, count, *static_cast<QModelIndex*>(parent));
}
}
void QAbstractItemModel_ResetInternalData(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QAbstractItemModel*>(ptr), "resetInternalData");
}
void QAbstractItemModel_ResetInternalDataDefault(void* ptr)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::resetInternalData();
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::resetInternalData();
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::resetInternalData();
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::resetInternalData();
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::resetInternalData();
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QStringListModel*>(ptr)->QStringListModel::resetInternalData();
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::resetInternalData();
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::resetInternalData();
} else {
static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::resetInternalData();
}
}
void QAbstractItemModel_Revert(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QAbstractItemModel*>(ptr), "revert");
}
void QAbstractItemModel_RevertDefault(void* ptr)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::revert();
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::revert();
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::revert();
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::revert();
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::revert();
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QStringListModel*>(ptr)->QStringListModel::revert();
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::revert();
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::revert();
} else {
static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::revert();
}
}
struct QtCore_PackedList QAbstractItemModel_RoleNames(void* ptr)
{
return ({ QHash<int, QByteArray>* tmpValue40dc1d = new QHash<int, QByteArray>(static_cast<QAbstractItemModel*>(ptr)->roleNames()); QtCore_PackedList { tmpValue40dc1d, tmpValue40dc1d->size() }; });
}
struct QtCore_PackedList QAbstractItemModel_RoleNamesDefault(void* ptr)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QHash<int, QByteArray>* tmpValue42442f = new QHash<int, QByteArray>(static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::roleNames()); QtCore_PackedList { tmpValue42442f, tmpValue42442f->size() }; });
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QHash<int, QByteArray>* tmpValue42442f = new QHash<int, QByteArray>(static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::roleNames()); QtCore_PackedList { tmpValue42442f, tmpValue42442f->size() }; });
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QHash<int, QByteArray>* tmpValue42442f = new QHash<int, QByteArray>(static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::roleNames()); QtCore_PackedList { tmpValue42442f, tmpValue42442f->size() }; });
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QHash<int, QByteArray>* tmpValue42442f = new QHash<int, QByteArray>(static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::roleNames()); QtCore_PackedList { tmpValue42442f, tmpValue42442f->size() }; });
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QHash<int, QByteArray>* tmpValue42442f = new QHash<int, QByteArray>(static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::roleNames()); QtCore_PackedList { tmpValue42442f, tmpValue42442f->size() }; });
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return ({ QHash<int, QByteArray>* tmpValue42442f = new QHash<int, QByteArray>(static_cast<QStringListModel*>(ptr)->QStringListModel::roleNames()); QtCore_PackedList { tmpValue42442f, tmpValue42442f->size() }; });
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return ({ QHash<int, QByteArray>* tmpValue42442f = new QHash<int, QByteArray>(static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::roleNames()); QtCore_PackedList { tmpValue42442f, tmpValue42442f->size() }; });
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return ({ QHash<int, QByteArray>* tmpValue42442f = new QHash<int, QByteArray>(static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::roleNames()); QtCore_PackedList { tmpValue42442f, tmpValue42442f->size() }; });
} else {
return ({ QHash<int, QByteArray>* tmpValue42442f = new QHash<int, QByteArray>(static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::roleNames()); QtCore_PackedList { tmpValue42442f, tmpValue42442f->size() }; });
}
}
int QAbstractItemModel_RowCount(void* ptr, void* parent)
{
return static_cast<QAbstractItemModel*>(ptr)->rowCount(*static_cast<QModelIndex*>(parent));
}
void QAbstractItemModel_ConnectRowsAboutToBeInserted(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsAboutToBeInserted, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_RowsAboutToBeInserted), static_cast<Qt::ConnectionType>(t));
}
void QAbstractItemModel_DisconnectRowsAboutToBeInserted(void* ptr)
{
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsAboutToBeInserted, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_RowsAboutToBeInserted));
}
void QAbstractItemModel_ConnectRowsAboutToBeMoved(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsAboutToBeMoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int, const QModelIndex &, int)>(&MyQAbstractItemModel::Signal_RowsAboutToBeMoved), static_cast<Qt::ConnectionType>(t));
}
void QAbstractItemModel_DisconnectRowsAboutToBeMoved(void* ptr)
{
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsAboutToBeMoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int, const QModelIndex &, int)>(&MyQAbstractItemModel::Signal_RowsAboutToBeMoved));
}
void QAbstractItemModel_ConnectRowsAboutToBeRemoved(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsAboutToBeRemoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_RowsAboutToBeRemoved), static_cast<Qt::ConnectionType>(t));
}
void QAbstractItemModel_DisconnectRowsAboutToBeRemoved(void* ptr)
{
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsAboutToBeRemoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_RowsAboutToBeRemoved));
}
void QAbstractItemModel_ConnectRowsInserted(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsInserted, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_RowsInserted), static_cast<Qt::ConnectionType>(t));
}
void QAbstractItemModel_DisconnectRowsInserted(void* ptr)
{
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsInserted, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_RowsInserted));
}
void QAbstractItemModel_ConnectRowsMoved(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsMoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int, const QModelIndex &, int)>(&MyQAbstractItemModel::Signal_RowsMoved), static_cast<Qt::ConnectionType>(t));
}
void QAbstractItemModel_DisconnectRowsMoved(void* ptr)
{
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsMoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int, const QModelIndex &, int)>(&MyQAbstractItemModel::Signal_RowsMoved));
}
void QAbstractItemModel_ConnectRowsRemoved(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsRemoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_RowsRemoved), static_cast<Qt::ConnectionType>(t));
}
void QAbstractItemModel_DisconnectRowsRemoved(void* ptr)
{
QObject::disconnect(static_cast<QAbstractItemModel*>(ptr), &QAbstractItemModel::rowsRemoved, static_cast<MyQAbstractItemModel*>(ptr), static_cast<void (MyQAbstractItemModel::*)(const QModelIndex &, int, int)>(&MyQAbstractItemModel::Signal_RowsRemoved));
}
char QAbstractItemModel_SetData(void* ptr, void* index, void* value, int role)
{
return static_cast<QAbstractItemModel*>(ptr)->setData(*static_cast<QModelIndex*>(index), *static_cast<QVariant*>(value), role);
}
char QAbstractItemModel_SetDataDefault(void* ptr, void* index, void* value, int role)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::setData(*static_cast<QModelIndex*>(index), *static_cast<QVariant*>(value), role);
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::setData(*static_cast<QModelIndex*>(index), *static_cast<QVariant*>(value), role);
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::setData(*static_cast<QModelIndex*>(index), *static_cast<QVariant*>(value), role);
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::setData(*static_cast<QModelIndex*>(index), *static_cast<QVariant*>(value), role);
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::setData(*static_cast<QModelIndex*>(index), *static_cast<QVariant*>(value), role);
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::setData(*static_cast<QModelIndex*>(index), *static_cast<QVariant*>(value), role);
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::setData(*static_cast<QModelIndex*>(index), *static_cast<QVariant*>(value), role);
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::setData(*static_cast<QModelIndex*>(index), *static_cast<QVariant*>(value), role);
} else {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::setData(*static_cast<QModelIndex*>(index), *static_cast<QVariant*>(value), role);
}
}
char QAbstractItemModel_SetHeaderData(void* ptr, int section, long long orientation, void* value, int role)
{
return static_cast<QAbstractItemModel*>(ptr)->setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
}
char QAbstractItemModel_SetHeaderDataDefault(void* ptr, int section, long long orientation, void* value, int role)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
} else {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
}
}
char QAbstractItemModel_SetItemData(void* ptr, void* index, void* roles)
{
return static_cast<QAbstractItemModel*>(ptr)->setItemData(*static_cast<QModelIndex*>(index), *static_cast<QMap<int, QVariant>*>(roles));
}
char QAbstractItemModel_SetItemDataDefault(void* ptr, void* index, void* roles)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::setItemData(*static_cast<QModelIndex*>(index), *static_cast<QMap<int, QVariant>*>(roles));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::setItemData(*static_cast<QModelIndex*>(index), *static_cast<QMap<int, QVariant>*>(roles));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::setItemData(*static_cast<QModelIndex*>(index), *static_cast<QMap<int, QVariant>*>(roles));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::setItemData(*static_cast<QModelIndex*>(index), *static_cast<QMap<int, QVariant>*>(roles));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::setItemData(*static_cast<QModelIndex*>(index), *static_cast<QMap<int, QVariant>*>(roles));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::setItemData(*static_cast<QModelIndex*>(index), *static_cast<QMap<int, QVariant>*>(roles));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::setItemData(*static_cast<QModelIndex*>(index), *static_cast<QMap<int, QVariant>*>(roles));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::setItemData(*static_cast<QModelIndex*>(index), *static_cast<QMap<int, QVariant>*>(roles));
} else {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::setItemData(*static_cast<QModelIndex*>(index), *static_cast<QMap<int, QVariant>*>(roles));
}
}
void* QAbstractItemModel_Sibling(void* ptr, int row, int column, void* index)
{
return new QModelIndex(static_cast<QAbstractItemModel*>(ptr)->sibling(row, column, *static_cast<QModelIndex*>(index)));
}
void* QAbstractItemModel_SiblingDefault(void* ptr, int row, int column, void* index)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::sibling(row, column, *static_cast<QModelIndex*>(index)));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::sibling(row, column, *static_cast<QModelIndex*>(index)));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::sibling(row, column, *static_cast<QModelIndex*>(index)));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::sibling(row, column, *static_cast<QModelIndex*>(index)));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::sibling(row, column, *static_cast<QModelIndex*>(index)));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QStringListModel*>(ptr)->QStringListModel::sibling(row, column, *static_cast<QModelIndex*>(index)));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::sibling(row, column, *static_cast<QModelIndex*>(index)));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::sibling(row, column, *static_cast<QModelIndex*>(index)));
} else {
return new QModelIndex(static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::sibling(row, column, *static_cast<QModelIndex*>(index)));
}
}
void QAbstractItemModel_Sort(void* ptr, int column, long long order)
{
static_cast<QAbstractItemModel*>(ptr)->sort(column, static_cast<Qt::SortOrder>(order));
}
void QAbstractItemModel_SortDefault(void* ptr, int column, long long order)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::sort(column, static_cast<Qt::SortOrder>(order));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::sort(column, static_cast<Qt::SortOrder>(order));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::sort(column, static_cast<Qt::SortOrder>(order));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::sort(column, static_cast<Qt::SortOrder>(order));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::sort(column, static_cast<Qt::SortOrder>(order));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QStringListModel*>(ptr)->QStringListModel::sort(column, static_cast<Qt::SortOrder>(order));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::sort(column, static_cast<Qt::SortOrder>(order));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::sort(column, static_cast<Qt::SortOrder>(order));
} else {
static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::sort(column, static_cast<Qt::SortOrder>(order));
}
}
void* QAbstractItemModel_Span(void* ptr, void* index)
{
return ({ QSize tmpValue = static_cast<QAbstractItemModel*>(ptr)->span(*static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
}
void* QAbstractItemModel_SpanDefault(void* ptr, void* index)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::span(*static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::span(*static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::span(*static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::span(*static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::span(*static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QStringListModel*>(ptr)->QStringListModel::span(*static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::span(*static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return ({ QSize tmpValue = static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::span(*static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
} else {
return ({ QSize tmpValue = static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::span(*static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
}
}
char QAbstractItemModel_Submit(void* ptr)
{
bool returnArg;
QMetaObject::invokeMethod(static_cast<QAbstractItemModel*>(ptr), "submit", Q_RETURN_ARG(bool, returnArg));
return returnArg;
}
char QAbstractItemModel_SubmitDefault(void* ptr)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::submit();
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::submit();
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::submit();
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::submit();
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::submit();
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::submit();
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::submit();
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::submit();
} else {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::submit();
}
}
long long QAbstractItemModel_SupportedDragActions(void* ptr)
{
return static_cast<QAbstractItemModel*>(ptr)->supportedDragActions();
}
long long QAbstractItemModel_SupportedDragActionsDefault(void* ptr)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::supportedDragActions();
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::supportedDragActions();
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::supportedDragActions();
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::supportedDragActions();
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::supportedDragActions();
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::supportedDragActions();
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::supportedDragActions();
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::supportedDragActions();
} else {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::supportedDragActions();
}
}
long long QAbstractItemModel_SupportedDropActions(void* ptr)
{
return static_cast<QAbstractItemModel*>(ptr)->supportedDropActions();
}
long long QAbstractItemModel_SupportedDropActionsDefault(void* ptr)
{
if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::supportedDropActions();
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::supportedDropActions();
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::supportedDropActions();
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::supportedDropActions();
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::supportedDropActions();
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::supportedDropActions();
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::supportedDropActions();
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::supportedDropActions();
} else {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::supportedDropActions();
}
}
void QAbstractItemModel_DestroyQAbstractItemModel(void* ptr)
{
static_cast<QAbstractItemModel*>(ptr)->~QAbstractItemModel();
}
void QAbstractItemModel_DestroyQAbstractItemModelDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QAbstractItemModel___changePersistentIndexList_from_atList(void* ptr, int i)
{
return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QAbstractItemModel___changePersistentIndexList_from_setList(void* ptr, void* i)
{
static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}
void* QAbstractItemModel___changePersistentIndexList_from_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QModelIndex>();
}
void* QAbstractItemModel___changePersistentIndexList_to_atList(void* ptr, int i)
{
return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QAbstractItemModel___changePersistentIndexList_to_setList(void* ptr, void* i)
{
static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}
void* QAbstractItemModel___changePersistentIndexList_to_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QModelIndex>();
}
int QAbstractItemModel___dataChanged_roles_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QVector<int>*>(ptr)->at(i); if (i == static_cast<QVector<int>*>(ptr)->size()-1) { static_cast<QVector<int>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QAbstractItemModel___dataChanged_roles_setList(void* ptr, int i)
{
static_cast<QVector<int>*>(ptr)->append(i);
}
void* QAbstractItemModel___dataChanged_roles_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<int>();
}
void* QAbstractItemModel___doSetRoleNames_roleNames_atList(void* ptr, int v, int i)
{
return new QByteArray(({ QByteArray tmp = static_cast<QHash<int, QByteArray>*>(ptr)->value(v); if (i == static_cast<QHash<int, QByteArray>*>(ptr)->size()-1) { static_cast<QHash<int, QByteArray>*>(ptr)->~QHash(); free(ptr); }; tmp; }));
}
void QAbstractItemModel___doSetRoleNames_roleNames_setList(void* ptr, int key, void* i)
{
static_cast<QHash<int, QByteArray>*>(ptr)->insert(key, *static_cast<QByteArray*>(i));
}
void* QAbstractItemModel___doSetRoleNames_roleNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QHash<int, QByteArray>();
}
struct QtCore_PackedList QAbstractItemModel___doSetRoleNames_roleNames_keyList(void* ptr)
{
return ({ QList<int>* tmpValue7fc3bb = new QList<int>(static_cast<QHash<int, QByteArray>*>(ptr)->keys()); QtCore_PackedList { tmpValue7fc3bb, tmpValue7fc3bb->size() }; });
}
void* QAbstractItemModel___encodeData_indexes_atList(void* ptr, int i)
{
return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QAbstractItemModel___encodeData_indexes_setList(void* ptr, void* i)
{
static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}
void* QAbstractItemModel___encodeData_indexes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QModelIndex>();
}
void* QAbstractItemModel___itemData_atList(void* ptr, int v, int i)
{
return new QVariant(({ QVariant tmp = static_cast<QMap<int, QVariant>*>(ptr)->value(v); if (i == static_cast<QMap<int, QVariant>*>(ptr)->size()-1) { static_cast<QMap<int, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}
void QAbstractItemModel___itemData_setList(void* ptr, int key, void* i)
{
static_cast<QMap<int, QVariant>*>(ptr)->insert(key, *static_cast<QVariant*>(i));
}
void* QAbstractItemModel___itemData_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QMap<int, QVariant>();
}
struct QtCore_PackedList QAbstractItemModel___itemData_keyList(void* ptr)
{
return ({ QList<int>* tmpValue249128 = new QList<int>(static_cast<QMap<int, QVariant>*>(ptr)->keys()); QtCore_PackedList { tmpValue249128, tmpValue249128->size() }; });
}
void* QAbstractItemModel___layoutAboutToBeChanged_parents_atList(void* ptr, int i)
{
return new QPersistentModelIndex(({QPersistentModelIndex tmp = static_cast<QList<QPersistentModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QPersistentModelIndex>*>(ptr)->size()-1) { static_cast<QList<QPersistentModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QAbstractItemModel___layoutAboutToBeChanged_parents_setList(void* ptr, void* i)
{
static_cast<QList<QPersistentModelIndex>*>(ptr)->append(*static_cast<QPersistentModelIndex*>(i));
}
void* QAbstractItemModel___layoutAboutToBeChanged_parents_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QPersistentModelIndex>();
}
void* QAbstractItemModel___layoutChanged_parents_atList(void* ptr, int i)
{
return new QPersistentModelIndex(({QPersistentModelIndex tmp = static_cast<QList<QPersistentModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QPersistentModelIndex>*>(ptr)->size()-1) { static_cast<QList<QPersistentModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QAbstractItemModel___layoutChanged_parents_setList(void* ptr, void* i)
{
static_cast<QList<QPersistentModelIndex>*>(ptr)->append(*static_cast<QPersistentModelIndex*>(i));
}
void* QAbstractItemModel___layoutChanged_parents_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QPersistentModelIndex>();
}
void* QAbstractItemModel___match_atList(void* ptr, int i)
{
return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QAbstractItemModel___match_setList(void* ptr, void* i)
{
static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}
void* QAbstractItemModel___match_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QModelIndex>();
}
void* QAbstractItemModel___mimeData_indexes_atList(void* ptr, int i)
{
return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QAbstractItemModel___mimeData_indexes_setList(void* ptr, void* i)
{
static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}
void* QAbstractItemModel___mimeData_indexes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QModelIndex>();
}
void* QAbstractItemModel___persistentIndexList_atList(void* ptr, int i)
{
return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QAbstractItemModel___persistentIndexList_setList(void* ptr, void* i)
{
static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}
void* QAbstractItemModel___persistentIndexList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QModelIndex>();
}
void* QAbstractItemModel___roleNames_atList(void* ptr, int v, int i)
{
return new QByteArray(({ QByteArray tmp = static_cast<QHash<int, QByteArray>*>(ptr)->value(v); if (i == static_cast<QHash<int, QByteArray>*>(ptr)->size()-1) { static_cast<QHash<int, QByteArray>*>(ptr)->~QHash(); free(ptr); }; tmp; }));
}
void QAbstractItemModel___roleNames_setList(void* ptr, int key, void* i)
{
static_cast<QHash<int, QByteArray>*>(ptr)->insert(key, *static_cast<QByteArray*>(i));
}
void* QAbstractItemModel___roleNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QHash<int, QByteArray>();
}
struct QtCore_PackedList QAbstractItemModel___roleNames_keyList(void* ptr)
{
return ({ QList<int>* tmpValue7fc3bb = new QList<int>(static_cast<QHash<int, QByteArray>*>(ptr)->keys()); QtCore_PackedList { tmpValue7fc3bb, tmpValue7fc3bb->size() }; });
}
void* QAbstractItemModel___setItemData_roles_atList(void* ptr, int v, int i)
{
return new QVariant(({ QVariant tmp = static_cast<QMap<int, QVariant>*>(ptr)->value(v); if (i == static_cast<QMap<int, QVariant>*>(ptr)->size()-1) { static_cast<QMap<int, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}
void QAbstractItemModel___setItemData_roles_setList(void* ptr, int key, void* i)
{
static_cast<QMap<int, QVariant>*>(ptr)->insert(key, *static_cast<QVariant*>(i));
}
void* QAbstractItemModel___setItemData_roles_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QMap<int, QVariant>();
}
struct QtCore_PackedList QAbstractItemModel___setItemData_roles_keyList(void* ptr)
{
return ({ QList<int>* tmpValue249128 = new QList<int>(static_cast<QMap<int, QVariant>*>(ptr)->keys()); QtCore_PackedList { tmpValue249128, tmpValue249128->size() }; });
}
void* QAbstractItemModel___setRoleNames_roleNames_atList(void* ptr, int v, int i)
{
return new QByteArray(({ QByteArray tmp = static_cast<QHash<int, QByteArray>*>(ptr)->value(v); if (i == static_cast<QHash<int, QByteArray>*>(ptr)->size()-1) { static_cast<QHash<int, QByteArray>*>(ptr)->~QHash(); free(ptr); }; tmp; }));
}
void QAbstractItemModel___setRoleNames_roleNames_setList(void* ptr, int key, void* i)
{
static_cast<QHash<int, QByteArray>*>(ptr)->insert(key, *static_cast<QByteArray*>(i));
}
void* QAbstractItemModel___setRoleNames_roleNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QHash<int, QByteArray>();
}
struct QtCore_PackedList QAbstractItemModel___setRoleNames_roleNames_keyList(void* ptr)
{
return ({ QList<int>* tmpValue7fc3bb = new QList<int>(static_cast<QHash<int, QByteArray>*>(ptr)->keys()); QtCore_PackedList { tmpValue7fc3bb, tmpValue7fc3bb->size() }; });
}
int QAbstractItemModel_____doSetRoleNames_roleNames_keyList_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAbstractItemModel_____doSetRoleNames_roleNames_keyList_setList(void* ptr, int i)
{
static_cast<QList<int>*>(ptr)->append(i);
}
void* QAbstractItemModel_____doSetRoleNames_roleNames_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<int>();
}
int QAbstractItemModel_____itemData_keyList_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAbstractItemModel_____itemData_keyList_setList(void* ptr, int i)
{
static_cast<QList<int>*>(ptr)->append(i);
}
void* QAbstractItemModel_____itemData_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<int>();
}
int QAbstractItemModel_____roleNames_keyList_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAbstractItemModel_____roleNames_keyList_setList(void* ptr, int i)
{
static_cast<QList<int>*>(ptr)->append(i);
}
void* QAbstractItemModel_____roleNames_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<int>();
}
int QAbstractItemModel_____setItemData_roles_keyList_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAbstractItemModel_____setItemData_roles_keyList_setList(void* ptr, int i)
{
static_cast<QList<int>*>(ptr)->append(i);
}
void* QAbstractItemModel_____setItemData_roles_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<int>();
}
int QAbstractItemModel_____setRoleNames_roleNames_keyList_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAbstractItemModel_____setRoleNames_roleNames_keyList_setList(void* ptr, int i)
{
static_cast<QList<int>*>(ptr)->append(i);
}
void* QAbstractItemModel_____setRoleNames_roleNames_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<int>();
}
class MyQAbstractListModel: public QAbstractListModel
{
public:
MyQAbstractListModel(QObject *parent = Q_NULLPTR) : QAbstractListModel(parent) {QAbstractListModel_QAbstractListModel_QRegisterMetaType();};
bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQAbstractItemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
Qt::ItemFlags flags(const QModelIndex & index) const { return static_cast<Qt::ItemFlag>(callbackQAbstractItemModel_Flags(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
QModelIndex index(int row, int column, const QModelIndex & parent) const { return *static_cast<QModelIndex*>(callbackQAbstractListModel_Index(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&parent))); };
QModelIndex sibling(int row, int column, const QModelIndex & idx) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Sibling(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&idx))); };
~MyQAbstractListModel() { callbackQAbstractListModel_DestroyQAbstractListModel(this); };
QModelIndex buddy(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Buddy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool canDropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) const { return callbackQAbstractItemModel_CanDropMimeData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
bool canFetchMore(const QModelIndex & parent) const { return callbackQAbstractItemModel_CanFetchMore(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
int columnCount(const QModelIndex & parent) const { return callbackQAbstractListModel_ColumnCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
void Signal_ColumnsAboutToBeInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationColumn) { callbackQAbstractItemModel_ColumnsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationColumn); };
void Signal_ColumnsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int column) { callbackQAbstractItemModel_ColumnsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), column); };
void Signal_ColumnsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
QVariant data(const QModelIndex & index, int role) const { return *static_cast<QVariant*>(callbackQAbstractListModel_Data(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), role)); };
void Signal_DataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQAbstractItemModel_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtCore_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
void fetchMore(const QModelIndex & parent) { callbackQAbstractItemModel_FetchMore(this, const_cast<QModelIndex*>(&parent)); };
bool hasChildren(const QModelIndex & parent) const { return callbackQAbstractItemModel_HasChildren(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
QVariant headerData(int section, Qt::Orientation orientation, int role) const { return *static_cast<QVariant*>(callbackQAbstractItemModel_HeaderData(const_cast<void*>(static_cast<const void*>(this)), section, orientation, role)); };
void Signal_HeaderDataChanged(Qt::Orientation orientation, int first, int last) { callbackQAbstractItemModel_HeaderDataChanged(this, orientation, first, last); };
bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
QMap<int, QVariant> itemData(const QModelIndex & index) const { return ({ QMap<int, QVariant>* tmpP = static_cast<QMap<int, QVariant>*>(callbackQAbstractItemModel_ItemData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); QMap<int, QVariant> tmpV = *tmpP; tmpP->~QMap(); free(tmpP); tmpV; }); };
void Signal_LayoutAboutToBeChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQAbstractItemModel_LayoutAboutToBeChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtCore_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
void Signal_LayoutChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQAbstractItemModel_LayoutChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtCore_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
QList<QModelIndex> match(const QModelIndex & start, int role, const QVariant & value, int hits, Qt::MatchFlags flags) const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemModel_Match(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&start), role, const_cast<QVariant*>(&value), hits, flags)); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
QMimeData * mimeData(const QModelIndexList & indexes) const { return static_cast<QMimeData*>(callbackQAbstractItemModel_MimeData(const_cast<void*>(static_cast<const void*>(this)), ({ QList<QModelIndex>* tmpValuee0adf2 = new QList<QModelIndex>(indexes); QtCore_PackedList { tmpValuee0adf2, tmpValuee0adf2->size() }; }))); };
QStringList mimeTypes() const { return ({ QtCore_PackedString tempVal = callbackQAbstractItemModel_MimeTypes(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
void Signal_ModelAboutToBeReset() { callbackQAbstractItemModel_ModelAboutToBeReset(this); };
void Signal_ModelReset() { callbackQAbstractItemModel_ModelReset(this); };
bool moveColumns(const QModelIndex & sourceParent, int sourceColumn, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQAbstractItemModel_MoveColumns(this, const_cast<QModelIndex*>(&sourceParent), sourceColumn, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
bool moveRows(const QModelIndex & sourceParent, int sourceRow, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQAbstractItemModel_MoveRows(this, const_cast<QModelIndex*>(&sourceParent), sourceRow, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
QModelIndex parent(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQAbstractListModel_Parent(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool removeColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool removeRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
void resetInternalData() { callbackQAbstractItemModel_ResetInternalData(this); };
void revert() { callbackQAbstractItemModel_Revert(this); };
QHash<int, QByteArray> roleNames() const { return ({ QHash<int, QByteArray>* tmpP = static_cast<QHash<int, QByteArray>*>(callbackQAbstractItemModel_RoleNames(const_cast<void*>(static_cast<const void*>(this)))); QHash<int, QByteArray> tmpV = *tmpP; tmpP->~QHash(); free(tmpP); tmpV; }); };
int rowCount(const QModelIndex & parent) const { return callbackQAbstractListModel_RowCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
void Signal_RowsAboutToBeInserted(const QModelIndex & parent, int start, int end) { callbackQAbstractItemModel_RowsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
void Signal_RowsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationRow) { callbackQAbstractItemModel_RowsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationRow); };
void Signal_RowsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int row) { callbackQAbstractItemModel_RowsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), row); };
void Signal_RowsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
bool setData(const QModelIndex & index, const QVariant & value, int role) { return callbackQAbstractItemModel_SetData(this, const_cast<QModelIndex*>(&index), const_cast<QVariant*>(&value), role) != 0; };
bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQAbstractItemModel_SetHeaderData(this, section, orientation, const_cast<QVariant*>(&value), role) != 0; };
bool setItemData(const QModelIndex & index, const QMap<int, QVariant> & roles) { return callbackQAbstractItemModel_SetItemData(this, const_cast<QModelIndex*>(&index), ({ QMap<int, QVariant>* tmpValue037c88 = new QMap<int, QVariant>(roles); QtCore_PackedList { tmpValue037c88, tmpValue037c88->size() }; })) != 0; };
void sort(int column, Qt::SortOrder order) { callbackQAbstractItemModel_Sort(this, column, order); };
QSize span(const QModelIndex & index) const { return *static_cast<QSize*>(callbackQAbstractItemModel_Span(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool submit() { return callbackQAbstractItemModel_Submit(this) != 0; };
Qt::DropActions supportedDragActions() const { return static_cast<Qt::DropAction>(callbackQAbstractItemModel_SupportedDragActions(const_cast<void*>(static_cast<const void*>(this)))); };
Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQAbstractItemModel_SupportedDropActions(const_cast<void*>(static_cast<const void*>(this)))); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QAbstractListModel*)
Q_DECLARE_METATYPE(MyQAbstractListModel*)
int QAbstractListModel_QAbstractListModel_QRegisterMetaType(){qRegisterMetaType<QAbstractListModel*>(); return qRegisterMetaType<MyQAbstractListModel*>();}
void* QAbstractListModel_NewQAbstractListModel(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQAbstractListModel(static_cast<QWindow*>(parent));
} else {
return new MyQAbstractListModel(static_cast<QObject*>(parent));
}
}
void* QAbstractListModel_Index(void* ptr, int row, int column, void* parent)
{
return new QModelIndex(static_cast<QAbstractListModel*>(ptr)->index(row, column, *static_cast<QModelIndex*>(parent)));
}
void* QAbstractListModel_IndexDefault(void* ptr, int row, int column, void* parent)
{
if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QStringListModel*>(ptr)->QStringListModel::index(row, column, *static_cast<QModelIndex*>(parent)));
} else {
return new QModelIndex(static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::index(row, column, *static_cast<QModelIndex*>(parent)));
}
}
void QAbstractListModel_DestroyQAbstractListModel(void* ptr)
{
static_cast<QAbstractListModel*>(ptr)->~QAbstractListModel();
}
void QAbstractListModel_DestroyQAbstractListModelDefault(void* ptr)
{
Q_UNUSED(ptr);
}
int QAbstractListModel_ColumnCount(void* ptr, void* parent)
{
return static_cast<QAbstractListModel*>(ptr)->columnCount(*static_cast<QModelIndex*>(parent));
}
int QAbstractListModel_ColumnCountDefault(void* ptr, void* parent)
{
if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::columnCount(*static_cast<QModelIndex*>(parent));
} else {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::columnCount(*static_cast<QModelIndex*>(parent));
}
}
void* QAbstractListModel_Data(void* ptr, void* index, int role)
{
return new QVariant(static_cast<QAbstractListModel*>(ptr)->data(*static_cast<QModelIndex*>(index), role));
}
void* QAbstractListModel_DataDefault(void* ptr, void* index, int role)
{
if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return new QVariant(static_cast<QStringListModel*>(ptr)->QStringListModel::data(*static_cast<QModelIndex*>(index), role));
} else {
}
}
void* QAbstractListModel_Parent(void* ptr, void* index)
{
return new QModelIndex(static_cast<QAbstractListModel*>(ptr)->parent(*static_cast<QModelIndex*>(index)));
}
void* QAbstractListModel_ParentDefault(void* ptr, void* index)
{
if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QStringListModel*>(ptr)->QStringListModel::parent(*static_cast<QModelIndex*>(index)));
} else {
return new QModelIndex(static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::parent(*static_cast<QModelIndex*>(index)));
}
}
int QAbstractListModel_RowCount(void* ptr, void* parent)
{
return static_cast<QAbstractListModel*>(ptr)->rowCount(*static_cast<QModelIndex*>(parent));
}
int QAbstractListModel_RowCountDefault(void* ptr, void* parent)
{
if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::rowCount(*static_cast<QModelIndex*>(parent));
} else {
}
}
class MyQAbstractNativeEventFilter: public QAbstractNativeEventFilter
{
public:
MyQAbstractNativeEventFilter() : QAbstractNativeEventFilter() {QAbstractNativeEventFilter_QAbstractNativeEventFilter_QRegisterMetaType();};
bool nativeEventFilter(const QByteArray & eventType, void * message, long * result) { return callbackQAbstractNativeEventFilter_NativeEventFilter(this, const_cast<QByteArray*>(&eventType), message, result) != 0; };
~MyQAbstractNativeEventFilter() { callbackQAbstractNativeEventFilter_DestroyQAbstractNativeEventFilter(this); };
};
Q_DECLARE_METATYPE(QAbstractNativeEventFilter*)
Q_DECLARE_METATYPE(MyQAbstractNativeEventFilter*)
int QAbstractNativeEventFilter_QAbstractNativeEventFilter_QRegisterMetaType(){qRegisterMetaType<QAbstractNativeEventFilter*>(); return qRegisterMetaType<MyQAbstractNativeEventFilter*>();}
void* QAbstractNativeEventFilter_NewQAbstractNativeEventFilter()
{
return new MyQAbstractNativeEventFilter();
}
char QAbstractNativeEventFilter_NativeEventFilter(void* ptr, void* eventType, void* message, long* result)
{
return static_cast<QAbstractNativeEventFilter*>(ptr)->nativeEventFilter(*static_cast<QByteArray*>(eventType), message, result);
}
void QAbstractNativeEventFilter_DestroyQAbstractNativeEventFilter(void* ptr)
{
static_cast<QAbstractNativeEventFilter*>(ptr)->~QAbstractNativeEventFilter();
}
void QAbstractNativeEventFilter_DestroyQAbstractNativeEventFilterDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQAbstractProxyModel: public QAbstractProxyModel
{
public:
MyQAbstractProxyModel(QObject *parent = Q_NULLPTR) : QAbstractProxyModel(parent) {QAbstractProxyModel_QAbstractProxyModel_QRegisterMetaType();};
QModelIndex buddy(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Buddy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool canDropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) const { return callbackQAbstractItemModel_CanDropMimeData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
bool canFetchMore(const QModelIndex & parent) const { return callbackQAbstractItemModel_CanFetchMore(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
QVariant data(const QModelIndex & proxyIndex, int role) const { return *static_cast<QVariant*>(callbackQAbstractProxyModel_Data(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&proxyIndex), role)); };
bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQAbstractItemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
void fetchMore(const QModelIndex & parent) { callbackQAbstractItemModel_FetchMore(this, const_cast<QModelIndex*>(&parent)); };
Qt::ItemFlags flags(const QModelIndex & index) const { return static_cast<Qt::ItemFlag>(callbackQAbstractItemModel_Flags(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool hasChildren(const QModelIndex & parent) const { return callbackQAbstractItemModel_HasChildren(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
QVariant headerData(int section, Qt::Orientation orientation, int role) const { return *static_cast<QVariant*>(callbackQAbstractItemModel_HeaderData(const_cast<void*>(static_cast<const void*>(this)), section, orientation, role)); };
QMap<int, QVariant> itemData(const QModelIndex & proxyIndex) const { return ({ QMap<int, QVariant>* tmpP = static_cast<QMap<int, QVariant>*>(callbackQAbstractItemModel_ItemData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&proxyIndex))); QMap<int, QVariant> tmpV = *tmpP; tmpP->~QMap(); free(tmpP); tmpV; }); };
QModelIndex mapFromSource(const QModelIndex & sourceIndex) const { return *static_cast<QModelIndex*>(callbackQAbstractProxyModel_MapFromSource(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&sourceIndex))); };
QItemSelection mapSelectionFromSource(const QItemSelection & sourceSelection) const { return *static_cast<QItemSelection*>(callbackQAbstractProxyModel_MapSelectionFromSource(const_cast<void*>(static_cast<const void*>(this)), const_cast<QItemSelection*>(&sourceSelection))); };
QItemSelection mapSelectionToSource(const QItemSelection & proxySelection) const { return *static_cast<QItemSelection*>(callbackQAbstractProxyModel_MapSelectionToSource(const_cast<void*>(static_cast<const void*>(this)), const_cast<QItemSelection*>(&proxySelection))); };
QModelIndex mapToSource(const QModelIndex & proxyIndex) const { return *static_cast<QModelIndex*>(callbackQAbstractProxyModel_MapToSource(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&proxyIndex))); };
QMimeData * mimeData(const QModelIndexList & indexes) const { return static_cast<QMimeData*>(callbackQAbstractItemModel_MimeData(const_cast<void*>(static_cast<const void*>(this)), ({ QList<QModelIndex>* tmpValuee0adf2 = new QList<QModelIndex>(indexes); QtCore_PackedList { tmpValuee0adf2, tmpValuee0adf2->size() }; }))); };
QStringList mimeTypes() const { return ({ QtCore_PackedString tempVal = callbackQAbstractItemModel_MimeTypes(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
void resetInternalData() { callbackQAbstractItemModel_ResetInternalData(this); };
void revert() { callbackQAbstractProxyModel_Revert(this); };
bool setData(const QModelIndex & index, const QVariant & value, int role) { return callbackQAbstractItemModel_SetData(this, const_cast<QModelIndex*>(&index), const_cast<QVariant*>(&value), role) != 0; };
bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQAbstractItemModel_SetHeaderData(this, section, orientation, const_cast<QVariant*>(&value), role) != 0; };
bool setItemData(const QModelIndex & index, const QMap<int, QVariant> & roles) { return callbackQAbstractItemModel_SetItemData(this, const_cast<QModelIndex*>(&index), ({ QMap<int, QVariant>* tmpValue037c88 = new QMap<int, QVariant>(roles); QtCore_PackedList { tmpValue037c88, tmpValue037c88->size() }; })) != 0; };
void setSourceModel(QAbstractItemModel * sourceModel) { callbackQAbstractProxyModel_SetSourceModel(this, sourceModel); };
QModelIndex sibling(int row, int column, const QModelIndex & idx) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Sibling(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&idx))); };
void sort(int column, Qt::SortOrder order) { callbackQAbstractItemModel_Sort(this, column, order); };
void Signal_SourceModelChanged() { callbackQAbstractProxyModel_SourceModelChanged(this); };
QSize span(const QModelIndex & index) const { return *static_cast<QSize*>(callbackQAbstractItemModel_Span(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool submit() { return callbackQAbstractProxyModel_Submit(this) != 0; };
Qt::DropActions supportedDragActions() const { return static_cast<Qt::DropAction>(callbackQAbstractItemModel_SupportedDragActions(const_cast<void*>(static_cast<const void*>(this)))); };
Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQAbstractItemModel_SupportedDropActions(const_cast<void*>(static_cast<const void*>(this)))); };
~MyQAbstractProxyModel() { callbackQAbstractProxyModel_DestroyQAbstractProxyModel(this); };
int columnCount(const QModelIndex & parent) const { return callbackQAbstractProxyModel_ColumnCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
void Signal_ColumnsAboutToBeInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationColumn) { callbackQAbstractItemModel_ColumnsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationColumn); };
void Signal_ColumnsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int column) { callbackQAbstractItemModel_ColumnsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), column); };
void Signal_ColumnsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_DataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQAbstractItemModel_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtCore_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
void Signal_HeaderDataChanged(Qt::Orientation orientation, int first, int last) { callbackQAbstractItemModel_HeaderDataChanged(this, orientation, first, last); };
QModelIndex index(int row, int column, const QModelIndex & parent) const { return *static_cast<QModelIndex*>(callbackQAbstractProxyModel_Index(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&parent))); };
bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
void Signal_LayoutAboutToBeChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQAbstractItemModel_LayoutAboutToBeChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtCore_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
void Signal_LayoutChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQAbstractItemModel_LayoutChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtCore_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
QList<QModelIndex> match(const QModelIndex & start, int role, const QVariant & value, int hits, Qt::MatchFlags flags) const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemModel_Match(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&start), role, const_cast<QVariant*>(&value), hits, flags)); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
void Signal_ModelAboutToBeReset() { callbackQAbstractItemModel_ModelAboutToBeReset(this); };
void Signal_ModelReset() { callbackQAbstractItemModel_ModelReset(this); };
bool moveColumns(const QModelIndex & sourceParent, int sourceColumn, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQAbstractItemModel_MoveColumns(this, const_cast<QModelIndex*>(&sourceParent), sourceColumn, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
bool moveRows(const QModelIndex & sourceParent, int sourceRow, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQAbstractItemModel_MoveRows(this, const_cast<QModelIndex*>(&sourceParent), sourceRow, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
QModelIndex parent(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQAbstractProxyModel_Parent(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool removeColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool removeRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
QHash<int, QByteArray> roleNames() const { return ({ QHash<int, QByteArray>* tmpP = static_cast<QHash<int, QByteArray>*>(callbackQAbstractItemModel_RoleNames(const_cast<void*>(static_cast<const void*>(this)))); QHash<int, QByteArray> tmpV = *tmpP; tmpP->~QHash(); free(tmpP); tmpV; }); };
int rowCount(const QModelIndex & parent) const { return callbackQAbstractProxyModel_RowCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
void Signal_RowsAboutToBeInserted(const QModelIndex & parent, int start, int end) { callbackQAbstractItemModel_RowsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
void Signal_RowsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationRow) { callbackQAbstractItemModel_RowsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationRow); };
void Signal_RowsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int row) { callbackQAbstractItemModel_RowsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), row); };
void Signal_RowsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QAbstractProxyModel*)
Q_DECLARE_METATYPE(MyQAbstractProxyModel*)
int QAbstractProxyModel_QAbstractProxyModel_QRegisterMetaType(){qRegisterMetaType<QAbstractProxyModel*>(); return qRegisterMetaType<MyQAbstractProxyModel*>();}
void* QAbstractProxyModel_NewQAbstractProxyModel(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQAbstractProxyModel(static_cast<QWindow*>(parent));
} else {
return new MyQAbstractProxyModel(static_cast<QObject*>(parent));
}
}
void* QAbstractProxyModel_Data(void* ptr, void* proxyIndex, int role)
{
return new QVariant(static_cast<QAbstractProxyModel*>(ptr)->data(*static_cast<QModelIndex*>(proxyIndex), role));
}
void* QAbstractProxyModel_DataDefault(void* ptr, void* proxyIndex, int role)
{
if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return new QVariant(static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::data(*static_cast<QModelIndex*>(proxyIndex), role));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return new QVariant(static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::data(*static_cast<QModelIndex*>(proxyIndex), role));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return new QVariant(static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::data(*static_cast<QModelIndex*>(proxyIndex), role));
} else {
return new QVariant(static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::data(*static_cast<QModelIndex*>(proxyIndex), role));
}
}
void* QAbstractProxyModel_MapFromSource(void* ptr, void* sourceIndex)
{
return new QModelIndex(static_cast<QAbstractProxyModel*>(ptr)->mapFromSource(*static_cast<QModelIndex*>(sourceIndex)));
}
void* QAbstractProxyModel_MapSelectionFromSource(void* ptr, void* sourceSelection)
{
return new QItemSelection(static_cast<QAbstractProxyModel*>(ptr)->mapSelectionFromSource(*static_cast<QItemSelection*>(sourceSelection)));
}
void* QAbstractProxyModel_MapSelectionFromSourceDefault(void* ptr, void* sourceSelection)
{
if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return new QItemSelection(static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::mapSelectionFromSource(*static_cast<QItemSelection*>(sourceSelection)));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return new QItemSelection(static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::mapSelectionFromSource(*static_cast<QItemSelection*>(sourceSelection)));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return new QItemSelection(static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::mapSelectionFromSource(*static_cast<QItemSelection*>(sourceSelection)));
} else {
return new QItemSelection(static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::mapSelectionFromSource(*static_cast<QItemSelection*>(sourceSelection)));
}
}
void* QAbstractProxyModel_MapSelectionToSource(void* ptr, void* proxySelection)
{
return new QItemSelection(static_cast<QAbstractProxyModel*>(ptr)->mapSelectionToSource(*static_cast<QItemSelection*>(proxySelection)));
}
void* QAbstractProxyModel_MapSelectionToSourceDefault(void* ptr, void* proxySelection)
{
if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return new QItemSelection(static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::mapSelectionToSource(*static_cast<QItemSelection*>(proxySelection)));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return new QItemSelection(static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::mapSelectionToSource(*static_cast<QItemSelection*>(proxySelection)));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return new QItemSelection(static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::mapSelectionToSource(*static_cast<QItemSelection*>(proxySelection)));
} else {
return new QItemSelection(static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::mapSelectionToSource(*static_cast<QItemSelection*>(proxySelection)));
}
}
void* QAbstractProxyModel_MapToSource(void* ptr, void* proxyIndex)
{
return new QModelIndex(static_cast<QAbstractProxyModel*>(ptr)->mapToSource(*static_cast<QModelIndex*>(proxyIndex)));
}
void QAbstractProxyModel_Revert(void* ptr)
{
static_cast<QAbstractProxyModel*>(ptr)->revert();
}
void QAbstractProxyModel_RevertDefault(void* ptr)
{
if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::revert();
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::revert();
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::revert();
} else {
static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::revert();
}
}
void QAbstractProxyModel_SetSourceModel(void* ptr, void* sourceModel)
{
static_cast<QAbstractProxyModel*>(ptr)->setSourceModel(static_cast<QAbstractItemModel*>(sourceModel));
}
void QAbstractProxyModel_SetSourceModelDefault(void* ptr, void* sourceModel)
{
if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::setSourceModel(static_cast<QAbstractItemModel*>(sourceModel));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::setSourceModel(static_cast<QAbstractItemModel*>(sourceModel));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::setSourceModel(static_cast<QAbstractItemModel*>(sourceModel));
} else {
static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::setSourceModel(static_cast<QAbstractItemModel*>(sourceModel));
}
}
void* QAbstractProxyModel_SourceModel(void* ptr)
{
return static_cast<QAbstractProxyModel*>(ptr)->sourceModel();
}
void QAbstractProxyModel_ConnectSourceModelChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractProxyModel*>(ptr), &QAbstractProxyModel::sourceModelChanged, static_cast<MyQAbstractProxyModel*>(ptr), static_cast<void (MyQAbstractProxyModel::*)()>(&MyQAbstractProxyModel::Signal_SourceModelChanged), static_cast<Qt::ConnectionType>(t));
}
void QAbstractProxyModel_DisconnectSourceModelChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstractProxyModel*>(ptr), &QAbstractProxyModel::sourceModelChanged, static_cast<MyQAbstractProxyModel*>(ptr), static_cast<void (MyQAbstractProxyModel::*)()>(&MyQAbstractProxyModel::Signal_SourceModelChanged));
}
char QAbstractProxyModel_Submit(void* ptr)
{
return static_cast<QAbstractProxyModel*>(ptr)->submit();
}
char QAbstractProxyModel_SubmitDefault(void* ptr)
{
if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::submit();
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::submit();
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::submit();
} else {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::submit();
}
}
void QAbstractProxyModel_DestroyQAbstractProxyModel(void* ptr)
{
static_cast<QAbstractProxyModel*>(ptr)->~QAbstractProxyModel();
}
void QAbstractProxyModel_DestroyQAbstractProxyModelDefault(void* ptr)
{
Q_UNUSED(ptr);
}
int QAbstractProxyModel_ColumnCount(void* ptr, void* parent)
{
return static_cast<QAbstractProxyModel*>(ptr)->columnCount(*static_cast<QModelIndex*>(parent));
}
int QAbstractProxyModel_ColumnCountDefault(void* ptr, void* parent)
{
if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::columnCount(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::columnCount(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::columnCount(*static_cast<QModelIndex*>(parent));
} else {
}
}
void* QAbstractProxyModel_Index(void* ptr, int row, int column, void* parent)
{
return new QModelIndex(static_cast<QAbstractProxyModel*>(ptr)->index(row, column, *static_cast<QModelIndex*>(parent)));
}
void* QAbstractProxyModel_IndexDefault(void* ptr, int row, int column, void* parent)
{
if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::index(row, column, *static_cast<QModelIndex*>(parent)));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::index(row, column, *static_cast<QModelIndex*>(parent)));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::index(row, column, *static_cast<QModelIndex*>(parent)));
} else {
}
}
void* QAbstractProxyModel_Parent(void* ptr, void* index)
{
return new QModelIndex(static_cast<QAbstractProxyModel*>(ptr)->parent(*static_cast<QModelIndex*>(index)));
}
void* QAbstractProxyModel_ParentDefault(void* ptr, void* index)
{
if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::parent(*static_cast<QModelIndex*>(index)));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::parent(*static_cast<QModelIndex*>(index)));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return new QModelIndex(static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::parent(*static_cast<QModelIndex*>(index)));
} else {
}
}
int QAbstractProxyModel_RowCount(void* ptr, void* parent)
{
return static_cast<QAbstractProxyModel*>(ptr)->rowCount(*static_cast<QModelIndex*>(parent));
}
int QAbstractProxyModel_RowCountDefault(void* ptr, void* parent)
{
if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::rowCount(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::rowCount(*static_cast<QModelIndex*>(parent));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::rowCount(*static_cast<QModelIndex*>(parent));
} else {
}
}
class MyQAbstractState: public QAbstractState
{
public:
MyQAbstractState(QState *parent = Q_NULLPTR) : QAbstractState(parent) {QAbstractState_QAbstractState_QRegisterMetaType();};
void Signal_ActiveChanged(bool active) { callbackQAbstractState_ActiveChanged(this, active); };
void Signal_Entered() { callbackQAbstractState_Entered(this); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
void Signal_Exited() { callbackQAbstractState_Exited(this); };
void onEntry(QEvent * event) { callbackQAbstractState_OnEntry(this, event); };
void onExit(QEvent * event) { callbackQAbstractState_OnExit(this, event); };
~MyQAbstractState() { callbackQAbstractState_DestroyQAbstractState(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QAbstractState*)
Q_DECLARE_METATYPE(MyQAbstractState*)
int QAbstractState_QAbstractState_QRegisterMetaType(){qRegisterMetaType<QAbstractState*>(); return qRegisterMetaType<MyQAbstractState*>();}
void* QAbstractState_NewQAbstractState(void* parent)
{
return new MyQAbstractState(static_cast<QState*>(parent));
}
char QAbstractState_Active(void* ptr)
{
return static_cast<QAbstractState*>(ptr)->active();
}
void QAbstractState_ConnectActiveChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractState*>(ptr), static_cast<void (QAbstractState::*)(bool)>(&QAbstractState::activeChanged), static_cast<MyQAbstractState*>(ptr), static_cast<void (MyQAbstractState::*)(bool)>(&MyQAbstractState::Signal_ActiveChanged), static_cast<Qt::ConnectionType>(t));
}
void QAbstractState_DisconnectActiveChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstractState*>(ptr), static_cast<void (QAbstractState::*)(bool)>(&QAbstractState::activeChanged), static_cast<MyQAbstractState*>(ptr), static_cast<void (MyQAbstractState::*)(bool)>(&MyQAbstractState::Signal_ActiveChanged));
}
void QAbstractState_ActiveChanged(void* ptr, char active)
{
static_cast<QAbstractState*>(ptr)->activeChanged(active != 0);
}
void QAbstractState_ConnectEntered(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractState*>(ptr), &QAbstractState::entered, static_cast<MyQAbstractState*>(ptr), static_cast<void (MyQAbstractState::*)()>(&MyQAbstractState::Signal_Entered), static_cast<Qt::ConnectionType>(t));
}
void QAbstractState_DisconnectEntered(void* ptr)
{
QObject::disconnect(static_cast<QAbstractState*>(ptr), &QAbstractState::entered, static_cast<MyQAbstractState*>(ptr), static_cast<void (MyQAbstractState::*)()>(&MyQAbstractState::Signal_Entered));
}
void QAbstractState_ConnectExited(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractState*>(ptr), &QAbstractState::exited, static_cast<MyQAbstractState*>(ptr), static_cast<void (MyQAbstractState::*)()>(&MyQAbstractState::Signal_Exited), static_cast<Qt::ConnectionType>(t));
}
void QAbstractState_DisconnectExited(void* ptr)
{
QObject::disconnect(static_cast<QAbstractState*>(ptr), &QAbstractState::exited, static_cast<MyQAbstractState*>(ptr), static_cast<void (MyQAbstractState::*)()>(&MyQAbstractState::Signal_Exited));
}
void* QAbstractState_Machine(void* ptr)
{
return static_cast<QAbstractState*>(ptr)->machine();
}
void QAbstractState_OnEntry(void* ptr, void* event)
{
static_cast<QAbstractState*>(ptr)->onEntry(static_cast<QEvent*>(event));
}
void QAbstractState_OnExit(void* ptr, void* event)
{
static_cast<QAbstractState*>(ptr)->onExit(static_cast<QEvent*>(event));
}
void* QAbstractState_ParentState(void* ptr)
{
return static_cast<QAbstractState*>(ptr)->parentState();
}
void QAbstractState_DestroyQAbstractState(void* ptr)
{
static_cast<QAbstractState*>(ptr)->~QAbstractState();
}
void QAbstractState_DestroyQAbstractStateDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQAbstractTableModel: public QAbstractTableModel
{
public:
MyQAbstractTableModel(QObject *parent = Q_NULLPTR) : QAbstractTableModel(parent) {QAbstractTableModel_QAbstractTableModel_QRegisterMetaType();};
bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQAbstractItemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
Qt::ItemFlags flags(const QModelIndex & index) const { return static_cast<Qt::ItemFlag>(callbackQAbstractItemModel_Flags(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
QModelIndex index(int row, int column, const QModelIndex & parent) const { return *static_cast<QModelIndex*>(callbackQAbstractTableModel_Index(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&parent))); };
QModelIndex sibling(int row, int column, const QModelIndex & idx) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Sibling(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&idx))); };
~MyQAbstractTableModel() { callbackQAbstractTableModel_DestroyQAbstractTableModel(this); };
QModelIndex buddy(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Buddy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool canDropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) const { return callbackQAbstractItemModel_CanDropMimeData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
bool canFetchMore(const QModelIndex & parent) const { return callbackQAbstractItemModel_CanFetchMore(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
int columnCount(const QModelIndex & parent) const { return callbackQAbstractTableModel_ColumnCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
void Signal_ColumnsAboutToBeInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationColumn) { callbackQAbstractItemModel_ColumnsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationColumn); };
void Signal_ColumnsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int column) { callbackQAbstractItemModel_ColumnsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), column); };
void Signal_ColumnsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
QVariant data(const QModelIndex & index, int role) const { return *static_cast<QVariant*>(callbackQAbstractTableModel_Data(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), role)); };
void Signal_DataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQAbstractItemModel_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtCore_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
void fetchMore(const QModelIndex & parent) { callbackQAbstractItemModel_FetchMore(this, const_cast<QModelIndex*>(&parent)); };
bool hasChildren(const QModelIndex & parent) const { return callbackQAbstractItemModel_HasChildren(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
QVariant headerData(int section, Qt::Orientation orientation, int role) const { return *static_cast<QVariant*>(callbackQAbstractItemModel_HeaderData(const_cast<void*>(static_cast<const void*>(this)), section, orientation, role)); };
void Signal_HeaderDataChanged(Qt::Orientation orientation, int first, int last) { callbackQAbstractItemModel_HeaderDataChanged(this, orientation, first, last); };
bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
QMap<int, QVariant> itemData(const QModelIndex & index) const { return ({ QMap<int, QVariant>* tmpP = static_cast<QMap<int, QVariant>*>(callbackQAbstractItemModel_ItemData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); QMap<int, QVariant> tmpV = *tmpP; tmpP->~QMap(); free(tmpP); tmpV; }); };
void Signal_LayoutAboutToBeChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQAbstractItemModel_LayoutAboutToBeChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtCore_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
void Signal_LayoutChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQAbstractItemModel_LayoutChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtCore_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
QList<QModelIndex> match(const QModelIndex & start, int role, const QVariant & value, int hits, Qt::MatchFlags flags) const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemModel_Match(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&start), role, const_cast<QVariant*>(&value), hits, flags)); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
QMimeData * mimeData(const QModelIndexList & indexes) const { return static_cast<QMimeData*>(callbackQAbstractItemModel_MimeData(const_cast<void*>(static_cast<const void*>(this)), ({ QList<QModelIndex>* tmpValuee0adf2 = new QList<QModelIndex>(indexes); QtCore_PackedList { tmpValuee0adf2, tmpValuee0adf2->size() }; }))); };
QStringList mimeTypes() const { return ({ QtCore_PackedString tempVal = callbackQAbstractItemModel_MimeTypes(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
void Signal_ModelAboutToBeReset() { callbackQAbstractItemModel_ModelAboutToBeReset(this); };
void Signal_ModelReset() { callbackQAbstractItemModel_ModelReset(this); };
bool moveColumns(const QModelIndex & sourceParent, int sourceColumn, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQAbstractItemModel_MoveColumns(this, const_cast<QModelIndex*>(&sourceParent), sourceColumn, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
bool moveRows(const QModelIndex & sourceParent, int sourceRow, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQAbstractItemModel_MoveRows(this, const_cast<QModelIndex*>(&sourceParent), sourceRow, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
QModelIndex parent(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQAbstractTableModel_Parent(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool removeColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool removeRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
void resetInternalData() { callbackQAbstractItemModel_ResetInternalData(this); };
void revert() { callbackQAbstractItemModel_Revert(this); };
QHash<int, QByteArray> roleNames() const { return ({ QHash<int, QByteArray>* tmpP = static_cast<QHash<int, QByteArray>*>(callbackQAbstractItemModel_RoleNames(const_cast<void*>(static_cast<const void*>(this)))); QHash<int, QByteArray> tmpV = *tmpP; tmpP->~QHash(); free(tmpP); tmpV; }); };
int rowCount(const QModelIndex & parent) const { return callbackQAbstractTableModel_RowCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
void Signal_RowsAboutToBeInserted(const QModelIndex & parent, int start, int end) { callbackQAbstractItemModel_RowsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
void Signal_RowsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationRow) { callbackQAbstractItemModel_RowsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationRow); };
void Signal_RowsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int row) { callbackQAbstractItemModel_RowsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), row); };
void Signal_RowsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
bool setData(const QModelIndex & index, const QVariant & value, int role) { return callbackQAbstractItemModel_SetData(this, const_cast<QModelIndex*>(&index), const_cast<QVariant*>(&value), role) != 0; };
bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQAbstractItemModel_SetHeaderData(this, section, orientation, const_cast<QVariant*>(&value), role) != 0; };
bool setItemData(const QModelIndex & index, const QMap<int, QVariant> & roles) { return callbackQAbstractItemModel_SetItemData(this, const_cast<QModelIndex*>(&index), ({ QMap<int, QVariant>* tmpValue037c88 = new QMap<int, QVariant>(roles); QtCore_PackedList { tmpValue037c88, tmpValue037c88->size() }; })) != 0; };
void sort(int column, Qt::SortOrder order) { callbackQAbstractItemModel_Sort(this, column, order); };
QSize span(const QModelIndex & index) const { return *static_cast<QSize*>(callbackQAbstractItemModel_Span(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool submit() { return callbackQAbstractItemModel_Submit(this) != 0; };
Qt::DropActions supportedDragActions() const { return static_cast<Qt::DropAction>(callbackQAbstractItemModel_SupportedDragActions(const_cast<void*>(static_cast<const void*>(this)))); };
Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQAbstractItemModel_SupportedDropActions(const_cast<void*>(static_cast<const void*>(this)))); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QAbstractTableModel*)
Q_DECLARE_METATYPE(MyQAbstractTableModel*)
int QAbstractTableModel_QAbstractTableModel_QRegisterMetaType(){qRegisterMetaType<QAbstractTableModel*>(); return qRegisterMetaType<MyQAbstractTableModel*>();}
void* QAbstractTableModel_NewQAbstractTableModel(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQAbstractTableModel(static_cast<QWindow*>(parent));
} else {
return new MyQAbstractTableModel(static_cast<QObject*>(parent));
}
}
void* QAbstractTableModel_Index(void* ptr, int row, int column, void* parent)
{
return new QModelIndex(static_cast<QAbstractTableModel*>(ptr)->index(row, column, *static_cast<QModelIndex*>(parent)));
}
void* QAbstractTableModel_IndexDefault(void* ptr, int row, int column, void* parent)
{
return new QModelIndex(static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::index(row, column, *static_cast<QModelIndex*>(parent)));
}
void QAbstractTableModel_DestroyQAbstractTableModel(void* ptr)
{
static_cast<QAbstractTableModel*>(ptr)->~QAbstractTableModel();
}
void QAbstractTableModel_DestroyQAbstractTableModelDefault(void* ptr)
{
Q_UNUSED(ptr);
}
int QAbstractTableModel_ColumnCount(void* ptr, void* parent)
{
return static_cast<QAbstractTableModel*>(ptr)->columnCount(*static_cast<QModelIndex*>(parent));
}
int QAbstractTableModel_ColumnCountDefault(void* ptr, void* parent)
{
Q_UNUSED(ptr);
Q_UNUSED(parent);
}
void* QAbstractTableModel_Data(void* ptr, void* index, int role)
{
return new QVariant(static_cast<QAbstractTableModel*>(ptr)->data(*static_cast<QModelIndex*>(index), role));
}
void* QAbstractTableModel_DataDefault(void* ptr, void* index, int role)
{
Q_UNUSED(ptr);
Q_UNUSED(index);
Q_UNUSED(role);
}
void* QAbstractTableModel_Parent(void* ptr, void* index)
{
return new QModelIndex(static_cast<QAbstractTableModel*>(ptr)->parent(*static_cast<QModelIndex*>(index)));
}
void* QAbstractTableModel_ParentDefault(void* ptr, void* index)
{
return new QModelIndex(static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::parent(*static_cast<QModelIndex*>(index)));
}
int QAbstractTableModel_RowCount(void* ptr, void* parent)
{
return static_cast<QAbstractTableModel*>(ptr)->rowCount(*static_cast<QModelIndex*>(parent));
}
int QAbstractTableModel_RowCountDefault(void* ptr, void* parent)
{
Q_UNUSED(ptr);
Q_UNUSED(parent);
}
class MyQAbstractTransition: public QAbstractTransition
{
public:
MyQAbstractTransition(QState *sourceState = Q_NULLPTR) : QAbstractTransition(sourceState) {QAbstractTransition_QAbstractTransition_QRegisterMetaType();};
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventTest(QEvent * event) { return callbackQAbstractTransition_EventTest(this, event) != 0; };
void onTransition(QEvent * event) { callbackQAbstractTransition_OnTransition(this, event); };
void Signal_TargetStateChanged() { callbackQAbstractTransition_TargetStateChanged(this); };
void Signal_TargetStatesChanged() { callbackQAbstractTransition_TargetStatesChanged(this); };
void Signal_Triggered() { callbackQAbstractTransition_Triggered(this); };
~MyQAbstractTransition() { callbackQAbstractTransition_DestroyQAbstractTransition(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QAbstractTransition*)
Q_DECLARE_METATYPE(MyQAbstractTransition*)
int QAbstractTransition_QAbstractTransition_QRegisterMetaType(){qRegisterMetaType<QAbstractTransition*>(); return qRegisterMetaType<MyQAbstractTransition*>();}
void* QAbstractTransition_NewQAbstractTransition(void* sourceState)
{
return new MyQAbstractTransition(static_cast<QState*>(sourceState));
}
void QAbstractTransition_AddAnimation(void* ptr, void* animation)
{
static_cast<QAbstractTransition*>(ptr)->addAnimation(static_cast<QAbstractAnimation*>(animation));
}
struct QtCore_PackedList QAbstractTransition_Animations(void* ptr)
{
return ({ QList<QAbstractAnimation *>* tmpValueb0afeb = new QList<QAbstractAnimation *>(static_cast<QAbstractTransition*>(ptr)->animations()); QtCore_PackedList { tmpValueb0afeb, tmpValueb0afeb->size() }; });
}
char QAbstractTransition_EventTest(void* ptr, void* event)
{
return static_cast<QAbstractTransition*>(ptr)->eventTest(static_cast<QEvent*>(event));
}
void* QAbstractTransition_Machine(void* ptr)
{
return static_cast<QAbstractTransition*>(ptr)->machine();
}
void QAbstractTransition_OnTransition(void* ptr, void* event)
{
static_cast<QAbstractTransition*>(ptr)->onTransition(static_cast<QEvent*>(event));
}
void QAbstractTransition_RemoveAnimation(void* ptr, void* animation)
{
static_cast<QAbstractTransition*>(ptr)->removeAnimation(static_cast<QAbstractAnimation*>(animation));
}
void QAbstractTransition_SetTargetState(void* ptr, void* target)
{
static_cast<QAbstractTransition*>(ptr)->setTargetState(static_cast<QAbstractState*>(target));
}
void QAbstractTransition_SetTargetStates(void* ptr, void* targets)
{
static_cast<QAbstractTransition*>(ptr)->setTargetStates(*static_cast<QList<QAbstractState *>*>(targets));
}
void QAbstractTransition_SetTransitionType(void* ptr, long long ty)
{
static_cast<QAbstractTransition*>(ptr)->setTransitionType(static_cast<QAbstractTransition::TransitionType>(ty));
}
void* QAbstractTransition_SourceState(void* ptr)
{
return static_cast<QAbstractTransition*>(ptr)->sourceState();
}
void* QAbstractTransition_TargetState(void* ptr)
{
return static_cast<QAbstractTransition*>(ptr)->targetState();
}
void QAbstractTransition_ConnectTargetStateChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractTransition*>(ptr), &QAbstractTransition::targetStateChanged, static_cast<MyQAbstractTransition*>(ptr), static_cast<void (MyQAbstractTransition::*)()>(&MyQAbstractTransition::Signal_TargetStateChanged), static_cast<Qt::ConnectionType>(t));
}
void QAbstractTransition_DisconnectTargetStateChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstractTransition*>(ptr), &QAbstractTransition::targetStateChanged, static_cast<MyQAbstractTransition*>(ptr), static_cast<void (MyQAbstractTransition::*)()>(&MyQAbstractTransition::Signal_TargetStateChanged));
}
struct QtCore_PackedList QAbstractTransition_TargetStates(void* ptr)
{
return ({ QList<QAbstractState *>* tmpValue7ca357 = new QList<QAbstractState *>(static_cast<QAbstractTransition*>(ptr)->targetStates()); QtCore_PackedList { tmpValue7ca357, tmpValue7ca357->size() }; });
}
void QAbstractTransition_ConnectTargetStatesChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractTransition*>(ptr), &QAbstractTransition::targetStatesChanged, static_cast<MyQAbstractTransition*>(ptr), static_cast<void (MyQAbstractTransition::*)()>(&MyQAbstractTransition::Signal_TargetStatesChanged), static_cast<Qt::ConnectionType>(t));
}
void QAbstractTransition_DisconnectTargetStatesChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstractTransition*>(ptr), &QAbstractTransition::targetStatesChanged, static_cast<MyQAbstractTransition*>(ptr), static_cast<void (MyQAbstractTransition::*)()>(&MyQAbstractTransition::Signal_TargetStatesChanged));
}
long long QAbstractTransition_TransitionType(void* ptr)
{
return static_cast<QAbstractTransition*>(ptr)->transitionType();
}
void QAbstractTransition_ConnectTriggered(void* ptr, long long t)
{
QObject::connect(static_cast<QAbstractTransition*>(ptr), &QAbstractTransition::triggered, static_cast<MyQAbstractTransition*>(ptr), static_cast<void (MyQAbstractTransition::*)()>(&MyQAbstractTransition::Signal_Triggered), static_cast<Qt::ConnectionType>(t));
}
void QAbstractTransition_DisconnectTriggered(void* ptr)
{
QObject::disconnect(static_cast<QAbstractTransition*>(ptr), &QAbstractTransition::triggered, static_cast<MyQAbstractTransition*>(ptr), static_cast<void (MyQAbstractTransition::*)()>(&MyQAbstractTransition::Signal_Triggered));
}
void QAbstractTransition_DestroyQAbstractTransition(void* ptr)
{
static_cast<QAbstractTransition*>(ptr)->~QAbstractTransition();
}
void QAbstractTransition_DestroyQAbstractTransitionDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QAbstractTransition___animations_atList(void* ptr, int i)
{
return ({QAbstractAnimation * tmp = static_cast<QList<QAbstractAnimation *>*>(ptr)->at(i); if (i == static_cast<QList<QAbstractAnimation *>*>(ptr)->size()-1) { static_cast<QList<QAbstractAnimation *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAbstractTransition___animations_setList(void* ptr, void* i)
{
static_cast<QList<QAbstractAnimation *>*>(ptr)->append(static_cast<QAbstractAnimation*>(i));
}
void* QAbstractTransition___animations_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QAbstractAnimation *>();
}
void* QAbstractTransition___setTargetStates_targets_atList(void* ptr, int i)
{
return ({QAbstractState * tmp = static_cast<QList<QAbstractState *>*>(ptr)->at(i); if (i == static_cast<QList<QAbstractState *>*>(ptr)->size()-1) { static_cast<QList<QAbstractState *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAbstractTransition___setTargetStates_targets_setList(void* ptr, void* i)
{
static_cast<QList<QAbstractState *>*>(ptr)->append(static_cast<QAbstractState*>(i));
}
void* QAbstractTransition___setTargetStates_targets_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QAbstractState *>();
}
void* QAbstractTransition___targetStates_atList(void* ptr, int i)
{
return ({QAbstractState * tmp = static_cast<QList<QAbstractState *>*>(ptr)->at(i); if (i == static_cast<QList<QAbstractState *>*>(ptr)->size()-1) { static_cast<QList<QAbstractState *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAbstractTransition___targetStates_setList(void* ptr, void* i)
{
static_cast<QList<QAbstractState *>*>(ptr)->append(static_cast<QAbstractState*>(i));
}
void* QAbstractTransition___targetStates_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QAbstractState *>();
}
class MyQAnimationGroup: public QAnimationGroup
{
public:
MyQAnimationGroup(QObject *parent = Q_NULLPTR) : QAnimationGroup(parent) {QAnimationGroup_QAnimationGroup_QRegisterMetaType();};
bool event(QEvent * event) { return callbackQObject_Event(this, event) != 0; };
~MyQAnimationGroup() { callbackQAnimationGroup_DestroyQAnimationGroup(this); };
void Signal_CurrentLoopChanged(int currentLoop) { callbackQAbstractAnimation_CurrentLoopChanged(this, currentLoop); };
void Signal_DirectionChanged(QAbstractAnimation::Direction newDirection) { callbackQAbstractAnimation_DirectionChanged(this, newDirection); };
int duration() const { return callbackQAnimationGroup_Duration(const_cast<void*>(static_cast<const void*>(this))); };
void Signal_Finished() { callbackQAbstractAnimation_Finished(this); };
void pause() { callbackQAbstractAnimation_Pause(this); };
void resume() { callbackQAbstractAnimation_Resume(this); };
void setCurrentTime(int msecs) { callbackQAbstractAnimation_SetCurrentTime(this, msecs); };
void setPaused(bool paused) { callbackQAbstractAnimation_SetPaused(this, paused); };
void start(QAbstractAnimation::DeletionPolicy policy) { callbackQAbstractAnimation_Start(this, policy); };
void Signal_StateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { callbackQAbstractAnimation_StateChanged(this, newState, oldState); };
void stop() { callbackQAbstractAnimation_Stop(this); };
void updateCurrentTime(int currentTime) { callbackQAnimationGroup_UpdateCurrentTime(this, currentTime); };
void updateDirection(QAbstractAnimation::Direction direction) { callbackQAbstractAnimation_UpdateDirection(this, direction); };
void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { callbackQAbstractAnimation_UpdateState(this, newState, oldState); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QAnimationGroup*)
Q_DECLARE_METATYPE(MyQAnimationGroup*)
int QAnimationGroup_QAnimationGroup_QRegisterMetaType(){qRegisterMetaType<QAnimationGroup*>(); return qRegisterMetaType<MyQAnimationGroup*>();}
void* QAnimationGroup_NewQAnimationGroup(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQAnimationGroup(static_cast<QWindow*>(parent));
} else {
return new MyQAnimationGroup(static_cast<QObject*>(parent));
}
}
void QAnimationGroup_AddAnimation(void* ptr, void* animation)
{
static_cast<QAnimationGroup*>(ptr)->addAnimation(static_cast<QAbstractAnimation*>(animation));
}
void* QAnimationGroup_AnimationAt(void* ptr, int index)
{
return static_cast<QAnimationGroup*>(ptr)->animationAt(index);
}
int QAnimationGroup_AnimationCount(void* ptr)
{
return static_cast<QAnimationGroup*>(ptr)->animationCount();
}
void QAnimationGroup_Clear(void* ptr)
{
static_cast<QAnimationGroup*>(ptr)->clear();
}
int QAnimationGroup_IndexOfAnimation(void* ptr, void* animation)
{
return static_cast<QAnimationGroup*>(ptr)->indexOfAnimation(static_cast<QAbstractAnimation*>(animation));
}
void QAnimationGroup_InsertAnimation(void* ptr, int index, void* animation)
{
static_cast<QAnimationGroup*>(ptr)->insertAnimation(index, static_cast<QAbstractAnimation*>(animation));
}
void QAnimationGroup_RemoveAnimation(void* ptr, void* animation)
{
static_cast<QAnimationGroup*>(ptr)->removeAnimation(static_cast<QAbstractAnimation*>(animation));
}
void* QAnimationGroup_TakeAnimation(void* ptr, int index)
{
return static_cast<QAnimationGroup*>(ptr)->takeAnimation(index);
}
void QAnimationGroup_DestroyQAnimationGroup(void* ptr)
{
static_cast<QAnimationGroup*>(ptr)->~QAnimationGroup();
}
void QAnimationGroup_DestroyQAnimationGroupDefault(void* ptr)
{
Q_UNUSED(ptr);
}
int QAnimationGroup_Duration(void* ptr)
{
return static_cast<QAnimationGroup*>(ptr)->duration();
}
int QAnimationGroup_DurationDefault(void* ptr)
{
if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
return static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::duration();
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
return static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::duration();
} else {
}
}
void QAnimationGroup_UpdateCurrentTime(void* ptr, int currentTime)
{
static_cast<QAnimationGroup*>(ptr)->updateCurrentTime(currentTime);
}
void QAnimationGroup_UpdateCurrentTimeDefault(void* ptr, int currentTime)
{
if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::updateCurrentTime(currentTime);
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::updateCurrentTime(currentTime);
} else {
}
}
int QAssociativeIterable_Size(void* ptr)
{
return static_cast<QAssociativeIterable*>(ptr)->size();
}
void* QAssociativeIterable_Value(void* ptr, void* key)
{
return new QVariant(static_cast<QAssociativeIterable*>(ptr)->value(*static_cast<QVariant*>(key)));
}
char QBasicMutex_IsRecursive2(void* ptr)
{
return static_cast<QBasicMutex*>(ptr)->isRecursive();
}
Q_DECLARE_METATYPE(QBasicTimer)
Q_DECLARE_METATYPE(QBasicTimer*)
void* QBasicTimer_NewQBasicTimer()
{
return new QBasicTimer();
}
char QBasicTimer_IsActive(void* ptr)
{
return static_cast<QBasicTimer*>(ptr)->isActive();
}
void QBasicTimer_Start(void* ptr, int msec, void* object)
{
static_cast<QBasicTimer*>(ptr)->start(msec, static_cast<QObject*>(object));
}
void QBasicTimer_Start2(void* ptr, int msec, long long timerType, void* obj)
{
static_cast<QBasicTimer*>(ptr)->start(msec, static_cast<Qt::TimerType>(timerType), static_cast<QObject*>(obj));
}
void QBasicTimer_Stop(void* ptr)
{
static_cast<QBasicTimer*>(ptr)->stop();
}
int QBasicTimer_TimerId(void* ptr)
{
return static_cast<QBasicTimer*>(ptr)->timerId();
}
void QBasicTimer_DestroyQBasicTimer(void* ptr)
{
static_cast<QBasicTimer*>(ptr)->~QBasicTimer();
}
Q_DECLARE_METATYPE(QBitArray)
Q_DECLARE_METATYPE(QBitArray*)
void* QBitArray_NewQBitArray()
{
return new QBitArray();
}
void* QBitArray_NewQBitArray2(int size, char value)
{
return new QBitArray(size, value != 0);
}
void* QBitArray_NewQBitArray3(void* other)
{
return new QBitArray(*static_cast<QBitArray*>(other));
}
void* QBitArray_NewQBitArray4(void* other)
{
return new QBitArray(*static_cast<QBitArray*>(other));
}
char QBitArray_At(void* ptr, int i)
{
return static_cast<QBitArray*>(ptr)->at(i);
}
struct QtCore_PackedString QBitArray_Bits(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QBitArray*>(ptr)->bits()), -1, NULL };
}
void QBitArray_Clear(void* ptr)
{
static_cast<QBitArray*>(ptr)->clear();
}
void QBitArray_ClearBit(void* ptr, int i)
{
static_cast<QBitArray*>(ptr)->clearBit(i);
}
int QBitArray_Count(void* ptr)
{
return static_cast<QBitArray*>(ptr)->count();
}
int QBitArray_Count2(void* ptr, char on)
{
return static_cast<QBitArray*>(ptr)->count(on != 0);
}
char QBitArray_Fill(void* ptr, char value, int size)
{
return static_cast<QBitArray*>(ptr)->fill(value != 0, size);
}
void QBitArray_Fill2(void* ptr, char value, int begin, int end)
{
static_cast<QBitArray*>(ptr)->fill(value != 0, begin, end);
}
char QBitArray_IsEmpty(void* ptr)
{
return static_cast<QBitArray*>(ptr)->isEmpty();
}
char QBitArray_IsNull(void* ptr)
{
return static_cast<QBitArray*>(ptr)->isNull();
}
void QBitArray_Resize(void* ptr, int size)
{
static_cast<QBitArray*>(ptr)->resize(size);
}
void QBitArray_SetBit(void* ptr, int i)
{
static_cast<QBitArray*>(ptr)->setBit(i);
}
void QBitArray_SetBit2(void* ptr, int i, char value)
{
static_cast<QBitArray*>(ptr)->setBit(i, value != 0);
}
int QBitArray_Size(void* ptr)
{
return static_cast<QBitArray*>(ptr)->size();
}
void QBitArray_Swap(void* ptr, void* other)
{
static_cast<QBitArray*>(ptr)->swap(*static_cast<QBitArray*>(other));
}
char QBitArray_TestBit(void* ptr, int i)
{
return static_cast<QBitArray*>(ptr)->testBit(i);
}
char QBitArray_ToggleBit(void* ptr, int i)
{
return static_cast<QBitArray*>(ptr)->toggleBit(i);
}
void QBitArray_Truncate(void* ptr, int pos)
{
static_cast<QBitArray*>(ptr)->truncate(pos);
}
class MyQBuffer: public QBuffer
{
public:
MyQBuffer(QObject *parent = Q_NULLPTR) : QBuffer(parent) {QBuffer_QBuffer_QRegisterMetaType();};
MyQBuffer(QByteArray *byteArray, QObject *parent = Q_NULLPTR) : QBuffer(byteArray, parent) {QBuffer_QBuffer_QRegisterMetaType();};
bool atEnd() const { return callbackQIODevice_AtEnd(const_cast<void*>(static_cast<const void*>(this))) != 0; };
bool canReadLine() const { return callbackQIODevice_CanReadLine(const_cast<void*>(static_cast<const void*>(this))) != 0; };
void close() { callbackQIODevice_Close(this); };
bool open(QIODevice::OpenMode flags) { return callbackQIODevice_Open(this, flags) != 0; };
qint64 pos() const { return callbackQIODevice_Pos(const_cast<void*>(static_cast<const void*>(this))); };
qint64 readData(char * data, qint64 l) { QtCore_PackedString dataPacked = { data, l, NULL };return callbackQBuffer_ReadData(this, dataPacked, l); };
bool seek(qint64 pos) { return callbackQIODevice_Seek(this, pos) != 0; };
qint64 size() const { return callbackQIODevice_Size(const_cast<void*>(static_cast<const void*>(this))); };
qint64 writeData(const char * data, qint64 l) { QtCore_PackedString dataPacked = { const_cast<char*>(data), l, NULL };return callbackQBuffer_WriteData(this, dataPacked, l); };
~MyQBuffer() { callbackQBuffer_DestroyQBuffer(this); };
void Signal_AboutToClose() { callbackQIODevice_AboutToClose(this); };
qint64 bytesAvailable() const { return callbackQIODevice_BytesAvailable(const_cast<void*>(static_cast<const void*>(this))); };
qint64 bytesToWrite() const { return callbackQIODevice_BytesToWrite(const_cast<void*>(static_cast<const void*>(this))); };
void Signal_BytesWritten(qint64 bytes) { callbackQIODevice_BytesWritten(this, bytes); };
void Signal_ChannelBytesWritten(int channel, qint64 bytes) { callbackQIODevice_ChannelBytesWritten(this, channel, bytes); };
void Signal_ChannelReadyRead(int channel) { callbackQIODevice_ChannelReadyRead(this, channel); };
bool isSequential() const { return callbackQIODevice_IsSequential(const_cast<void*>(static_cast<const void*>(this))) != 0; };
void Signal_ReadChannelFinished() { callbackQIODevice_ReadChannelFinished(this); };
qint64 readLineData(char * data, qint64 maxSize) { QtCore_PackedString dataPacked = { data, maxSize, NULL };return callbackQIODevice_ReadLineData(this, dataPacked, maxSize); };
void Signal_ReadyRead() { callbackQIODevice_ReadyRead(this); };
bool reset() { return callbackQIODevice_Reset(this) != 0; };
bool waitForBytesWritten(int msecs) { return callbackQIODevice_WaitForBytesWritten(this, msecs) != 0; };
bool waitForReadyRead(int msecs) { return callbackQIODevice_WaitForReadyRead(this, msecs) != 0; };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QBuffer*)
Q_DECLARE_METATYPE(MyQBuffer*)
int QBuffer_QBuffer_QRegisterMetaType(){qRegisterMetaType<QBuffer*>(); return qRegisterMetaType<MyQBuffer*>();}
void* QBuffer_NewQBuffer(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QWindow*>(parent));
} else {
return new MyQBuffer(static_cast<QObject*>(parent));
}
}
void* QBuffer_NewQBuffer2(void* byteArray, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QWindow*>(parent));
} else {
return new MyQBuffer(static_cast<QByteArray*>(byteArray), static_cast<QObject*>(parent));
}
}
void* QBuffer_Buffer(void* ptr)
{
return new QByteArray(static_cast<QBuffer*>(ptr)->buffer());
}
void* QBuffer_Buffer2(void* ptr)
{
return const_cast<QByteArray*>(&static_cast<QBuffer*>(ptr)->buffer());
}
void* QBuffer_Data(void* ptr)
{
return const_cast<QByteArray*>(&static_cast<QBuffer*>(ptr)->data());
}
long long QBuffer_ReadData(void* ptr, char* data, long long l)
{
return static_cast<QBuffer*>(ptr)->readData(data, l);
}
long long QBuffer_ReadDataDefault(void* ptr, char* data, long long l)
{
return static_cast<QBuffer*>(ptr)->QBuffer::readData(data, l);
}
void QBuffer_SetBuffer(void* ptr, void* byteArray)
{
static_cast<QBuffer*>(ptr)->setBuffer(static_cast<QByteArray*>(byteArray));
}
void QBuffer_SetData(void* ptr, void* data)
{
static_cast<QBuffer*>(ptr)->setData(*static_cast<QByteArray*>(data));
}
void QBuffer_SetData2(void* ptr, char* data, int size)
{
static_cast<QBuffer*>(ptr)->setData(const_cast<const char*>(data), size);
}
long long QBuffer_WriteData(void* ptr, char* data, long long l)
{
return static_cast<QBuffer*>(ptr)->writeData(const_cast<const char*>(data), l);
}
long long QBuffer_WriteDataDefault(void* ptr, char* data, long long l)
{
return static_cast<QBuffer*>(ptr)->QBuffer::writeData(const_cast<const char*>(data), l);
}
void QBuffer_DestroyQBuffer(void* ptr)
{
static_cast<QBuffer*>(ptr)->~QBuffer();
}
void QBuffer_DestroyQBufferDefault(void* ptr)
{
Q_UNUSED(ptr);
}
Q_DECLARE_METATYPE(QByteArray)
Q_DECLARE_METATYPE(QByteArray*)
void* QByteArray_NewQByteArray()
{
return new QByteArray();
}
void* QByteArray_NewQByteArray2(char* data, int size)
{
return new QByteArray(const_cast<const char*>(data), size);
}
void* QByteArray_NewQByteArray3(int size, char* ch)
{
return new QByteArray(size, *ch);
}
void* QByteArray_NewQByteArray4(void* other)
{
return new QByteArray(*static_cast<QByteArray*>(other));
}
void* QByteArray_Append(void* ptr, void* ba)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->append(*static_cast<QByteArray*>(ba)));
}
void* QByteArray_Append2(void* ptr, char* ch)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->append(*ch));
}
void* QByteArray_Append3(void* ptr, int count, char* ch)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->append(count, *ch));
}
void* QByteArray_Append4(void* ptr, char* str)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->append(const_cast<const char*>(str)));
}
void* QByteArray_Append5(void* ptr, char* str, int l)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->append(const_cast<const char*>(str), l));
}
void* QByteArray_Append6(void* ptr, struct QtCore_PackedString str)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->append(QString::fromUtf8(str.data, str.len)));
}
struct QtCore_PackedString QByteArray_At(void* ptr, int i)
{
return ({ char t8d8fc5 = static_cast<QByteArray*>(ptr)->at(i); QtCore_PackedString { &t8d8fc5, -1, NULL }; });
}
struct QtCore_PackedString QByteArray_Back(void* ptr)
{
return ({ char te8eea8 = static_cast<QByteArray*>(ptr)->back(); QtCore_PackedString { &te8eea8, -1, NULL }; });
}
int QByteArray_Capacity(void* ptr)
{
return static_cast<QByteArray*>(ptr)->capacity();
}
void QByteArray_Chop(void* ptr, int n)
{
static_cast<QByteArray*>(ptr)->chop(n);
}
void* QByteArray_Chopped(void* ptr, int l)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->chopped(l));
}
void QByteArray_Clear(void* ptr)
{
static_cast<QByteArray*>(ptr)->clear();
}
int QByteArray_Compare(void* ptr, char* c, long long cs)
{
return static_cast<QByteArray*>(ptr)->compare(const_cast<const char*>(c), static_cast<Qt::CaseSensitivity>(cs));
}
int QByteArray_Compare2(void* ptr, void* a, long long cs)
{
return static_cast<QByteArray*>(ptr)->compare(*static_cast<QByteArray*>(a), static_cast<Qt::CaseSensitivity>(cs));
}
struct QtCore_PackedString QByteArray_ConstData(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QByteArray*>(ptr)->constData()), static_cast<QByteArray*>(ptr)->size(), NULL };
}
char QByteArray_Contains(void* ptr, void* ba)
{
return static_cast<QByteArray*>(ptr)->contains(*static_cast<QByteArray*>(ba));
}
char QByteArray_Contains2(void* ptr, char* ch)
{
return static_cast<QByteArray*>(ptr)->contains(*ch);
}
char QByteArray_Contains3(void* ptr, char* str)
{
return static_cast<QByteArray*>(ptr)->contains(const_cast<const char*>(str));
}
int QByteArray_Count(void* ptr, void* ba)
{
return static_cast<QByteArray*>(ptr)->count(*static_cast<QByteArray*>(ba));
}
int QByteArray_Count2(void* ptr, char* ch)
{
return static_cast<QByteArray*>(ptr)->count(*ch);
}
int QByteArray_Count3(void* ptr, char* str)
{
return static_cast<QByteArray*>(ptr)->count(const_cast<const char*>(str));
}
int QByteArray_Count4(void* ptr)
{
return static_cast<QByteArray*>(ptr)->count();
}
struct QtCore_PackedString QByteArray_Data(void* ptr)
{
return QtCore_PackedString { static_cast<QByteArray*>(ptr)->data(), static_cast<QByteArray*>(ptr)->size(), NULL };
}
struct QtCore_PackedString QByteArray_Data2(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QByteArray*>(ptr)->data()), static_cast<QByteArray*>(ptr)->size(), NULL };
}
char QByteArray_EndsWith(void* ptr, void* ba)
{
return static_cast<QByteArray*>(ptr)->endsWith(*static_cast<QByteArray*>(ba));
}
char QByteArray_EndsWith2(void* ptr, char* ch)
{
return static_cast<QByteArray*>(ptr)->endsWith(*ch);
}
char QByteArray_EndsWith3(void* ptr, char* str)
{
return static_cast<QByteArray*>(ptr)->endsWith(const_cast<const char*>(str));
}
void* QByteArray_Fill(void* ptr, char* ch, int size)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->fill(*ch, size));
}
void* QByteArray_QByteArray_FromBase64(void* base64)
{
return new QByteArray(QByteArray::fromBase64(*static_cast<QByteArray*>(base64)));
}
void* QByteArray_QByteArray_FromBase642(void* base64, long long options)
{
return new QByteArray(QByteArray::fromBase64(*static_cast<QByteArray*>(base64), static_cast<QByteArray::Base64Option>(options)));
}
void* QByteArray_QByteArray_FromHex(void* hexEncoded)
{
return new QByteArray(QByteArray::fromHex(*static_cast<QByteArray*>(hexEncoded)));
}
void* QByteArray_QByteArray_FromPercentEncoding(void* input, char* percent)
{
return new QByteArray(QByteArray::fromPercentEncoding(*static_cast<QByteArray*>(input), *percent));
}
void* QByteArray_QByteArray_FromRawData(char* data, int size)
{
return new QByteArray(QByteArray::fromRawData(const_cast<const char*>(data), size));
}
struct QtCore_PackedString QByteArray_Front(void* ptr)
{
return ({ char td65117 = static_cast<QByteArray*>(ptr)->front(); QtCore_PackedString { &td65117, -1, NULL }; });
}
int QByteArray_IndexOf(void* ptr, void* ba, int from)
{
return static_cast<QByteArray*>(ptr)->indexOf(*static_cast<QByteArray*>(ba), from);
}
int QByteArray_IndexOf2(void* ptr, char* ch, int from)
{
return static_cast<QByteArray*>(ptr)->indexOf(*ch, from);
}
int QByteArray_IndexOf3(void* ptr, char* str, int from)
{
return static_cast<QByteArray*>(ptr)->indexOf(const_cast<const char*>(str), from);
}
int QByteArray_IndexOf4(void* ptr, struct QtCore_PackedString str, int from)
{
return static_cast<QByteArray*>(ptr)->indexOf(QString::fromUtf8(str.data, str.len), from);
}
void* QByteArray_Insert(void* ptr, int i, void* ba)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->insert(i, *static_cast<QByteArray*>(ba)));
}
void* QByteArray_Insert2(void* ptr, int i, char* ch)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->insert(i, *ch));
}
void* QByteArray_Insert3(void* ptr, int i, int count, char* ch)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->insert(i, count, *ch));
}
void* QByteArray_Insert4(void* ptr, int i, char* str)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->insert(i, const_cast<const char*>(str)));
}
void* QByteArray_Insert5(void* ptr, int i, char* str, int l)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->insert(i, const_cast<const char*>(str), l));
}
void* QByteArray_Insert6(void* ptr, int i, struct QtCore_PackedString str)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->insert(i, QString::fromUtf8(str.data, str.len)));
}
char QByteArray_IsEmpty(void* ptr)
{
return static_cast<QByteArray*>(ptr)->isEmpty();
}
char QByteArray_IsLower(void* ptr)
{
return static_cast<QByteArray*>(ptr)->isLower();
}
char QByteArray_IsNull(void* ptr)
{
return static_cast<QByteArray*>(ptr)->isNull();
}
char QByteArray_IsUpper(void* ptr)
{
return static_cast<QByteArray*>(ptr)->isUpper();
}
int QByteArray_LastIndexOf(void* ptr, void* ba, int from)
{
return static_cast<QByteArray*>(ptr)->lastIndexOf(*static_cast<QByteArray*>(ba), from);
}
int QByteArray_LastIndexOf2(void* ptr, char* ch, int from)
{
return static_cast<QByteArray*>(ptr)->lastIndexOf(*ch, from);
}
int QByteArray_LastIndexOf3(void* ptr, char* str, int from)
{
return static_cast<QByteArray*>(ptr)->lastIndexOf(const_cast<const char*>(str), from);
}
int QByteArray_LastIndexOf4(void* ptr, struct QtCore_PackedString str, int from)
{
return static_cast<QByteArray*>(ptr)->lastIndexOf(QString::fromUtf8(str.data, str.len), from);
}
void* QByteArray_Left(void* ptr, int l)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->left(l));
}
void* QByteArray_LeftJustified(void* ptr, int width, char* fill, char truncate)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->leftJustified(width, *fill, truncate != 0));
}
int QByteArray_Length(void* ptr)
{
return static_cast<QByteArray*>(ptr)->length();
}
void* QByteArray_Mid(void* ptr, int pos, int l)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->mid(pos, l));
}
void* QByteArray_QByteArray_Number(int n, int base)
{
return new QByteArray(QByteArray::number(n, base));
}
void* QByteArray_QByteArray_Number2(unsigned int n, int base)
{
return new QByteArray(QByteArray::number(n, base));
}
void* QByteArray_QByteArray_Number3(long long n, int base)
{
return new QByteArray(QByteArray::number(n, base));
}
void* QByteArray_QByteArray_Number4(unsigned long long n, int base)
{
return new QByteArray(QByteArray::number(n, base));
}
void* QByteArray_QByteArray_Number5(double n, char* ff, int prec)
{
return new QByteArray(QByteArray::number(n, *ff, prec));
}
void* QByteArray_Prepend(void* ptr, void* ba)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->prepend(*static_cast<QByteArray*>(ba)));
}
void* QByteArray_Prepend2(void* ptr, char* ch)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->prepend(*ch));
}
void* QByteArray_Prepend3(void* ptr, int count, char* ch)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->prepend(count, *ch));
}
void* QByteArray_Prepend4(void* ptr, char* str)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->prepend(const_cast<const char*>(str)));
}
void* QByteArray_Prepend5(void* ptr, char* str, int l)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->prepend(const_cast<const char*>(str), l));
}
void QByteArray_Push_back(void* ptr, void* other)
{
static_cast<QByteArray*>(ptr)->push_back(*static_cast<QByteArray*>(other));
}
void QByteArray_Push_back2(void* ptr, char* ch)
{
static_cast<QByteArray*>(ptr)->push_back(*ch);
}
void QByteArray_Push_back3(void* ptr, char* str)
{
static_cast<QByteArray*>(ptr)->push_back(const_cast<const char*>(str));
}
void QByteArray_Push_front(void* ptr, void* other)
{
static_cast<QByteArray*>(ptr)->push_front(*static_cast<QByteArray*>(other));
}
void QByteArray_Push_front2(void* ptr, char* ch)
{
static_cast<QByteArray*>(ptr)->push_front(*ch);
}
void QByteArray_Push_front3(void* ptr, char* str)
{
static_cast<QByteArray*>(ptr)->push_front(const_cast<const char*>(str));
}
void* QByteArray_Remove(void* ptr, int pos, int l)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->remove(pos, l));
}
void* QByteArray_Repeated(void* ptr, int times)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->repeated(times));
}
void* QByteArray_Replace(void* ptr, int pos, int l, void* after)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->replace(pos, l, *static_cast<QByteArray*>(after)));
}
void* QByteArray_Replace2(void* ptr, int pos, int l, char* after)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->replace(pos, l, const_cast<const char*>(after)));
}
void* QByteArray_Replace3(void* ptr, int pos, int l, char* after, int alen)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->replace(pos, l, const_cast<const char*>(after), alen));
}
void* QByteArray_Replace4(void* ptr, char* before, char* after)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->replace(*before, const_cast<const char*>(after)));
}
void* QByteArray_Replace5(void* ptr, char* before, void* after)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->replace(*before, *static_cast<QByteArray*>(after)));
}
void* QByteArray_Replace6(void* ptr, char* before, char* after)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->replace(const_cast<const char*>(before), const_cast<const char*>(after)));
}
void* QByteArray_Replace7(void* ptr, char* before, int bsize, char* after, int asize)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->replace(const_cast<const char*>(before), bsize, const_cast<const char*>(after), asize));
}
void* QByteArray_Replace8(void* ptr, void* before, void* after)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->replace(*static_cast<QByteArray*>(before), *static_cast<QByteArray*>(after)));
}
void* QByteArray_Replace9(void* ptr, void* before, char* after)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->replace(*static_cast<QByteArray*>(before), const_cast<const char*>(after)));
}
void* QByteArray_Replace10(void* ptr, char* before, void* after)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->replace(const_cast<const char*>(before), *static_cast<QByteArray*>(after)));
}
void* QByteArray_Replace11(void* ptr, char* before, char* after)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->replace(*before, *after));
}
void* QByteArray_Replace12(void* ptr, struct QtCore_PackedString before, char* after)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->replace(QString::fromUtf8(before.data, before.len), const_cast<const char*>(after)));
}
void* QByteArray_Replace13(void* ptr, char* before, struct QtCore_PackedString after)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->replace(*before, QString::fromUtf8(after.data, after.len)));
}
void* QByteArray_Replace14(void* ptr, struct QtCore_PackedString before, void* after)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->replace(QString::fromUtf8(before.data, before.len), *static_cast<QByteArray*>(after)));
}
void QByteArray_Reserve(void* ptr, int size)
{
static_cast<QByteArray*>(ptr)->reserve(size);
}
void QByteArray_Resize(void* ptr, int size)
{
static_cast<QByteArray*>(ptr)->resize(size);
}
void* QByteArray_Right(void* ptr, int l)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->right(l));
}
void* QByteArray_RightJustified(void* ptr, int width, char* fill, char truncate)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->rightJustified(width, *fill, truncate != 0));
}
void* QByteArray_SetNum(void* ptr, int n, int base)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->setNum(n, base));
}
void* QByteArray_SetNum2(void* ptr, short n, int base)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->setNum(n, base));
}
void* QByteArray_SetNum3(void* ptr, unsigned short n, int base)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->setNum(n, base));
}
void* QByteArray_SetNum4(void* ptr, unsigned int n, int base)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->setNum(n, base));
}
void* QByteArray_SetNum5(void* ptr, long long n, int base)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->setNum(n, base));
}
void* QByteArray_SetNum6(void* ptr, unsigned long long n, int base)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->setNum(n, base));
}
void* QByteArray_SetNum7(void* ptr, float n, char* ff, int prec)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->setNum(n, *ff, prec));
}
void* QByteArray_SetNum8(void* ptr, double n, char* ff, int prec)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->setNum(n, *ff, prec));
}
void* QByteArray_SetRawData(void* ptr, char* data, unsigned int size)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->setRawData(const_cast<const char*>(data), size));
}
void QByteArray_Shrink_to_fit(void* ptr)
{
static_cast<QByteArray*>(ptr)->shrink_to_fit();
}
void* QByteArray_Simplified(void* ptr)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->simplified());
}
int QByteArray_Size(void* ptr)
{
return static_cast<QByteArray*>(ptr)->size();
}
struct QtCore_PackedList QByteArray_Split(void* ptr, char* sep)
{
return ({ QList<QByteArray>* tmpValue17cac8 = new QList<QByteArray>(static_cast<QByteArray*>(ptr)->split(*sep)); QtCore_PackedList { tmpValue17cac8, tmpValue17cac8->size() }; });
}
void QByteArray_Squeeze(void* ptr)
{
static_cast<QByteArray*>(ptr)->squeeze();
}
char QByteArray_StartsWith(void* ptr, void* ba)
{
return static_cast<QByteArray*>(ptr)->startsWith(*static_cast<QByteArray*>(ba));
}
char QByteArray_StartsWith2(void* ptr, char* ch)
{
return static_cast<QByteArray*>(ptr)->startsWith(*ch);
}
char QByteArray_StartsWith3(void* ptr, char* str)
{
return static_cast<QByteArray*>(ptr)->startsWith(const_cast<const char*>(str));
}
void QByteArray_Swap(void* ptr, void* other)
{
static_cast<QByteArray*>(ptr)->swap(*static_cast<QByteArray*>(other));
}
void* QByteArray_ToBase64(void* ptr)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->toBase64());
}
void* QByteArray_ToBase642(void* ptr, long long options)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->toBase64(static_cast<QByteArray::Base64Option>(options)));
}
double QByteArray_ToDouble(void* ptr, char* ok)
{
return static_cast<QByteArray*>(ptr)->toDouble(reinterpret_cast<bool*>(ok));
}
float QByteArray_ToFloat(void* ptr, char* ok)
{
return static_cast<QByteArray*>(ptr)->toFloat(reinterpret_cast<bool*>(ok));
}
void* QByteArray_ToHex(void* ptr)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->toHex());
}
void* QByteArray_ToHex2(void* ptr, char* separator)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->toHex(*separator));
}
int QByteArray_ToInt(void* ptr, char* ok, int base)
{
return static_cast<QByteArray*>(ptr)->toInt(reinterpret_cast<bool*>(ok), base);
}
long QByteArray_ToLong(void* ptr, char* ok, int base)
{
return static_cast<QByteArray*>(ptr)->toLong(reinterpret_cast<bool*>(ok), base);
}
long long QByteArray_ToLongLong(void* ptr, char* ok, int base)
{
return static_cast<QByteArray*>(ptr)->toLongLong(reinterpret_cast<bool*>(ok), base);
}
void* QByteArray_ToLower(void* ptr)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->toLower());
}
void* QByteArray_ToPercentEncoding(void* ptr, void* exclude, void* include, char* percent)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->toPercentEncoding(*static_cast<QByteArray*>(exclude), *static_cast<QByteArray*>(include), *percent));
}
short QByteArray_ToShort(void* ptr, char* ok, int base)
{
return static_cast<QByteArray*>(ptr)->toShort(reinterpret_cast<bool*>(ok), base);
}
unsigned int QByteArray_ToUInt(void* ptr, char* ok, int base)
{
return static_cast<QByteArray*>(ptr)->toUInt(reinterpret_cast<bool*>(ok), base);
}
unsigned long QByteArray_ToULong(void* ptr, char* ok, int base)
{
return static_cast<QByteArray*>(ptr)->toULong(reinterpret_cast<bool*>(ok), base);
}
unsigned long long QByteArray_ToULongLong(void* ptr, char* ok, int base)
{
return static_cast<QByteArray*>(ptr)->toULongLong(reinterpret_cast<bool*>(ok), base);
}
unsigned short QByteArray_ToUShort(void* ptr, char* ok, int base)
{
return static_cast<QByteArray*>(ptr)->toUShort(reinterpret_cast<bool*>(ok), base);
}
void* QByteArray_ToUpper(void* ptr)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->toUpper());
}
void* QByteArray_Trimmed(void* ptr)
{
return new QByteArray(static_cast<QByteArray*>(ptr)->trimmed());
}
void QByteArray_Truncate(void* ptr, int pos)
{
static_cast<QByteArray*>(ptr)->truncate(pos);
}
void QByteArray_DestroyQByteArray(void* ptr)
{
static_cast<QByteArray*>(ptr)->~QByteArray();
}
void* QByteArray___split_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QByteArray___split_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QByteArray___split_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
int QByteArrayList_IndexOf(void* ptr, char* needle, int from)
{
return static_cast<QByteArrayList*>(ptr)->indexOf(const_cast<const char*>(needle), from);
}
void* QByteArrayList_Join(void* ptr)
{
return new QByteArray(static_cast<QByteArrayList*>(ptr)->join());
}
void* QByteArrayList_Join2(void* ptr, void* separator)
{
return new QByteArray(static_cast<QByteArrayList*>(ptr)->join(*static_cast<QByteArray*>(separator)));
}
void* QByteArrayList_Join3(void* ptr, char* separator)
{
return new QByteArray(static_cast<QByteArrayList*>(ptr)->join(*separator));
}
Q_DECLARE_METATYPE(QByteArrayMatcher)
Q_DECLARE_METATYPE(QByteArrayMatcher*)
void* QByteArrayMatcher_NewQByteArrayMatcher()
{
return new QByteArrayMatcher();
}
void* QByteArrayMatcher_NewQByteArrayMatcher2(void* pattern)
{
return new QByteArrayMatcher(*static_cast<QByteArray*>(pattern));
}
void* QByteArrayMatcher_NewQByteArrayMatcher3(char* pattern, int length)
{
return new QByteArrayMatcher(const_cast<const char*>(pattern), length);
}
void* QByteArrayMatcher_NewQByteArrayMatcher4(void* other)
{
return new QByteArrayMatcher(*static_cast<QByteArrayMatcher*>(other));
}
int QByteArrayMatcher_IndexIn(void* ptr, void* ba, int from)
{
return static_cast<QByteArrayMatcher*>(ptr)->indexIn(*static_cast<QByteArray*>(ba), from);
}
int QByteArrayMatcher_IndexIn2(void* ptr, char* str, int l, int from)
{
return static_cast<QByteArrayMatcher*>(ptr)->indexIn(const_cast<const char*>(str), l, from);
}
void* QByteArrayMatcher_Pattern(void* ptr)
{
return new QByteArray(static_cast<QByteArrayMatcher*>(ptr)->pattern());
}
void QByteArrayMatcher_SetPattern(void* ptr, void* pattern)
{
static_cast<QByteArrayMatcher*>(ptr)->setPattern(*static_cast<QByteArray*>(pattern));
}
void QByteArrayMatcher_DestroyQByteArrayMatcher(void* ptr)
{
static_cast<QByteArrayMatcher*>(ptr)->~QByteArrayMatcher();
}
Q_DECLARE_METATYPE(QCborArray)
Q_DECLARE_METATYPE(QCborArray*)
void* QCborArray_NewQCborArray()
{
return new QCborArray();
}
void* QCborArray_NewQCborArray2(void* other)
{
return new QCborArray(*static_cast<QCborArray*>(other));
}
void QCborArray_Append(void* ptr, void* value)
{
static_cast<QCborArray*>(ptr)->append(*static_cast<QCborValue*>(value));
}
void QCborArray_Append2(void* ptr, void* value)
{
static_cast<QCborArray*>(ptr)->append(*static_cast<QCborValue*>(value));
}
void QCborArray_Clear(void* ptr)
{
static_cast<QCborArray*>(ptr)->clear();
}
int QCborArray_Compare(void* ptr, void* other)
{
return static_cast<QCborArray*>(ptr)->compare(*static_cast<QCborArray*>(other));
}
char QCborArray_Contains(void* ptr, void* value)
{
return static_cast<QCborArray*>(ptr)->contains(*static_cast<QCborValue*>(value));
}
char QCborArray_Empty(void* ptr)
{
return static_cast<QCborArray*>(ptr)->empty();
}
void* QCborArray_First(void* ptr)
{
return new QCborValue(static_cast<QCborArray*>(ptr)->first());
}
void* QCborArray_QCborArray_FromJsonArray(void* array)
{
return new QCborArray(QCborArray::fromJsonArray(*static_cast<QJsonArray*>(array)));
}
void* QCborArray_QCborArray_FromStringList(struct QtCore_PackedString list)
{
return new QCborArray(QCborArray::fromStringList(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts)));
}
void* QCborArray_QCborArray_FromVariantList(void* list)
{
return new QCborArray(QCborArray::fromVariantList(({ QList<QVariant>* tmpP = static_cast<QList<QVariant>*>(list); QList<QVariant> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; })));
}
char QCborArray_IsEmpty(void* ptr)
{
return static_cast<QCborArray*>(ptr)->isEmpty();
}
void* QCborArray_Last(void* ptr)
{
return new QCborValue(static_cast<QCborArray*>(ptr)->last());
}
void QCborArray_Pop_back(void* ptr)
{
static_cast<QCborArray*>(ptr)->pop_back();
}
void QCborArray_Pop_front(void* ptr)
{
static_cast<QCborArray*>(ptr)->pop_front();
}
void QCborArray_Prepend(void* ptr, void* value)
{
static_cast<QCborArray*>(ptr)->prepend(*static_cast<QCborValue*>(value));
}
void QCborArray_Prepend2(void* ptr, void* value)
{
static_cast<QCborArray*>(ptr)->prepend(*static_cast<QCborValue*>(value));
}
void QCborArray_Push_back(void* ptr, void* t)
{
static_cast<QCborArray*>(ptr)->push_back(*static_cast<QCborValue*>(t));
}
void QCborArray_Push_front(void* ptr, void* t)
{
static_cast<QCborArray*>(ptr)->push_front(*static_cast<QCborValue*>(t));
}
void QCborArray_RemoveFirst(void* ptr)
{
static_cast<QCborArray*>(ptr)->removeFirst();
}
void QCborArray_RemoveLast(void* ptr)
{
static_cast<QCborArray*>(ptr)->removeLast();
}
void QCborArray_Swap(void* ptr, void* other)
{
static_cast<QCborArray*>(ptr)->swap(*static_cast<QCborArray*>(other));
}
void* QCborArray_TakeFirst(void* ptr)
{
return new QCborValue(static_cast<QCborArray*>(ptr)->takeFirst());
}
void* QCborArray_TakeLast(void* ptr)
{
return new QCborValue(static_cast<QCborArray*>(ptr)->takeLast());
}
void* QCborArray_ToCborValue(void* ptr)
{
return new QCborValue(static_cast<QCborArray*>(ptr)->toCborValue());
}
void* QCborArray_ToJsonArray(void* ptr)
{
return new QJsonArray(static_cast<QCborArray*>(ptr)->toJsonArray());
}
struct QtCore_PackedList QCborArray_ToVariantList(void* ptr)
{
return ({ QList<QVariant>* tmpValue302507 = new QList<QVariant>(static_cast<QCborArray*>(ptr)->toVariantList()); QtCore_PackedList { tmpValue302507, tmpValue302507->size() }; });
}
void QCborArray_DestroyQCborArray(void* ptr)
{
static_cast<QCborArray*>(ptr)->~QCborArray();
}
void* QCborArray___fromVariantList_list_atList(void* ptr, int i)
{
return new QVariant(({QVariant tmp = static_cast<QList<QVariant>*>(ptr)->at(i); if (i == static_cast<QList<QVariant>*>(ptr)->size()-1) { static_cast<QList<QVariant>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QCborArray___fromVariantList_list_setList(void* ptr, void* i)
{
static_cast<QList<QVariant>*>(ptr)->append(*static_cast<QVariant*>(i));
}
void* QCborArray___fromVariantList_list_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QVariant>();
}
void* QCborArray___toVariantList_atList(void* ptr, int i)
{
return new QVariant(({QVariant tmp = static_cast<QList<QVariant>*>(ptr)->at(i); if (i == static_cast<QList<QVariant>*>(ptr)->size()-1) { static_cast<QList<QVariant>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QCborArray___toVariantList_setList(void* ptr, void* i)
{
static_cast<QList<QVariant>*>(ptr)->append(*static_cast<QVariant*>(i));
}
void* QCborArray___toVariantList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QVariant>();
}
struct QtCore_PackedString QCborError_ToString(void* ptr)
{
return ({ QByteArray* t344b49 = new QByteArray(static_cast<QCborError*>(ptr)->toString().toUtf8()); QtCore_PackedString { const_cast<char*>(t344b49->prepend("WHITESPACE").constData()+10), t344b49->size()-10, t344b49 }; });
}
Q_DECLARE_METATYPE(QCborMap)
Q_DECLARE_METATYPE(QCborMap*)
void* QCborMap_NewQCborMap()
{
return new QCborMap();
}
void* QCborMap_NewQCborMap2(void* other)
{
return new QCborMap(*static_cast<QCborMap*>(other));
}
void QCborMap_Clear(void* ptr)
{
static_cast<QCborMap*>(ptr)->clear();
}
int QCborMap_Compare(void* ptr, void* other)
{
return static_cast<QCborMap*>(ptr)->compare(*static_cast<QCborMap*>(other));
}
char QCborMap_Contains(void* ptr, long long key)
{
return static_cast<QCborMap*>(ptr)->contains(key);
}
char QCborMap_Contains2(void* ptr, void* key)
{
return static_cast<QCborMap*>(ptr)->contains(*static_cast<QLatin1String*>(key));
}
char QCborMap_Contains3(void* ptr, struct QtCore_PackedString key)
{
return static_cast<QCborMap*>(ptr)->contains(QString::fromUtf8(key.data, key.len));
}
char QCborMap_Contains4(void* ptr, void* key)
{
return static_cast<QCborMap*>(ptr)->contains(*static_cast<QCborValue*>(key));
}
char QCborMap_Empty(void* ptr)
{
return static_cast<QCborMap*>(ptr)->empty();
}
void* QCborMap_QCborMap_FromJsonObject(void* obj)
{
return new QCborMap(QCborMap::fromJsonObject(*static_cast<QJsonObject*>(obj)));
}
void* QCborMap_QCborMap_FromVariantHash(void* hash)
{
return new QCborMap(QCborMap::fromVariantHash(({ QHash<QString, QVariant>* tmpP = static_cast<QHash<QString, QVariant>*>(hash); QHash<QString, QVariant> tmpV = *tmpP; tmpP->~QHash(); free(tmpP); tmpV; })));
}
char QCborMap_IsEmpty(void* ptr)
{
return static_cast<QCborMap*>(ptr)->isEmpty();
}
struct QtCore_PackedList QCborMap_Keys(void* ptr)
{
return ({ QVector<QCborValue>* tmpValue42f4c1 = new QVector<QCborValue>(static_cast<QCborMap*>(ptr)->keys()); QtCore_PackedList { tmpValue42f4c1, tmpValue42f4c1->size() }; });
}
void QCborMap_Remove(void* ptr, long long key)
{
static_cast<QCborMap*>(ptr)->remove(key);
}
void QCborMap_Remove2(void* ptr, void* key)
{
static_cast<QCborMap*>(ptr)->remove(*static_cast<QLatin1String*>(key));
}
void QCborMap_Remove3(void* ptr, struct QtCore_PackedString key)
{
static_cast<QCborMap*>(ptr)->remove(QString::fromUtf8(key.data, key.len));
}
void QCborMap_Remove4(void* ptr, void* key)
{
static_cast<QCborMap*>(ptr)->remove(*static_cast<QCborValue*>(key));
}
void QCborMap_Swap(void* ptr, void* other)
{
static_cast<QCborMap*>(ptr)->swap(*static_cast<QCborMap*>(other));
}
void* QCborMap_Take(void* ptr, long long key)
{
return new QCborValue(static_cast<QCborMap*>(ptr)->take(key));
}
void* QCborMap_Take2(void* ptr, void* key)
{
return new QCborValue(static_cast<QCborMap*>(ptr)->take(*static_cast<QLatin1String*>(key)));
}
void* QCborMap_Take3(void* ptr, struct QtCore_PackedString key)
{
return new QCborValue(static_cast<QCborMap*>(ptr)->take(QString::fromUtf8(key.data, key.len)));
}
void* QCborMap_Take4(void* ptr, void* key)
{
return new QCborValue(static_cast<QCborMap*>(ptr)->take(*static_cast<QCborValue*>(key)));
}
void* QCborMap_ToCborValue(void* ptr)
{
return new QCborValue(static_cast<QCborMap*>(ptr)->toCborValue());
}
void* QCborMap_ToJsonObject(void* ptr)
{
return new QJsonObject(static_cast<QCborMap*>(ptr)->toJsonObject());
}
struct QtCore_PackedList QCborMap_ToVariantHash(void* ptr)
{
return ({ QHash<QString, QVariant>* tmpValuefd0242 = new QHash<QString, QVariant>(static_cast<QCborMap*>(ptr)->toVariantHash()); QtCore_PackedList { tmpValuefd0242, tmpValuefd0242->size() }; });
}
struct QtCore_PackedList QCborMap_ToVariantMap(void* ptr)
{
return ({ QMap<QString, QVariant>* tmpValue1441a6 = new QMap<QString, QVariant>(static_cast<QCborMap*>(ptr)->toVariantMap()); QtCore_PackedList { tmpValue1441a6, tmpValue1441a6->size() }; });
}
void* QCborMap_Value(void* ptr, long long key)
{
return new QCborValue(static_cast<QCborMap*>(ptr)->value(key));
}
void* QCborMap_Value2(void* ptr, void* key)
{
return new QCborValue(static_cast<QCborMap*>(ptr)->value(*static_cast<QLatin1String*>(key)));
}
void* QCborMap_Value3(void* ptr, struct QtCore_PackedString key)
{
return new QCborValue(static_cast<QCborMap*>(ptr)->value(QString::fromUtf8(key.data, key.len)));
}
void* QCborMap_Value4(void* ptr, void* key)
{
return new QCborValue(static_cast<QCborMap*>(ptr)->value(*static_cast<QCborValue*>(key)));
}
void QCborMap_DestroyQCborMap(void* ptr)
{
static_cast<QCborMap*>(ptr)->~QCborMap();
}
void* QCborMap___fromVariantHash_hash_atList(void* ptr, struct QtCore_PackedString v, int i)
{
return new QVariant(({ QVariant tmp = static_cast<QHash<QString, QVariant>*>(ptr)->value(QString::fromUtf8(v.data, v.len)); if (i == static_cast<QHash<QString, QVariant>*>(ptr)->size()-1) { static_cast<QHash<QString, QVariant>*>(ptr)->~QHash(); free(ptr); }; tmp; }));
}
void QCborMap___fromVariantHash_hash_setList(void* ptr, struct QtCore_PackedString key, void* i)
{
static_cast<QHash<QString, QVariant>*>(ptr)->insert(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(i));
}
void* QCborMap___fromVariantHash_hash_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QHash<QString, QVariant>();
}
struct QtCore_PackedList QCborMap___fromVariantHash_hash_keyList(void* ptr)
{
return ({ QList<QString>* tmpValuef43bc5 = new QList<QString>(static_cast<QHash<QString, QVariant>*>(ptr)->keys()); QtCore_PackedList { tmpValuef43bc5, tmpValuef43bc5->size() }; });
}
void* QCborMap___keys_atList(void* ptr, int i)
{
return new QCborValue(({QCborValue tmp = static_cast<QVector<QCborValue>*>(ptr)->at(i); if (i == static_cast<QVector<QCborValue>*>(ptr)->size()-1) { static_cast<QVector<QCborValue>*>(ptr)->~QVector(); free(ptr); }; tmp; }));
}
void QCborMap___keys_setList(void* ptr, void* i)
{
static_cast<QVector<QCborValue>*>(ptr)->append(*static_cast<QCborValue*>(i));
}
void* QCborMap___keys_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QCborValue>();
}
void* QCborMap___toVariantHash_atList(void* ptr, struct QtCore_PackedString v, int i)
{
return new QVariant(({ QVariant tmp = static_cast<QHash<QString, QVariant>*>(ptr)->value(QString::fromUtf8(v.data, v.len)); if (i == static_cast<QHash<QString, QVariant>*>(ptr)->size()-1) { static_cast<QHash<QString, QVariant>*>(ptr)->~QHash(); free(ptr); }; tmp; }));
}
void QCborMap___toVariantHash_setList(void* ptr, struct QtCore_PackedString key, void* i)
{
static_cast<QHash<QString, QVariant>*>(ptr)->insert(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(i));
}
void* QCborMap___toVariantHash_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QHash<QString, QVariant>();
}
struct QtCore_PackedList QCborMap___toVariantHash_keyList(void* ptr)
{
return ({ QList<QString>* tmpValuef43bc5 = new QList<QString>(static_cast<QHash<QString, QVariant>*>(ptr)->keys()); QtCore_PackedList { tmpValuef43bc5, tmpValuef43bc5->size() }; });
}
void* QCborMap___toVariantMap_atList(void* ptr, struct QtCore_PackedString v, int i)
{
return new QVariant(({ QVariant tmp = static_cast<QMap<QString, QVariant>*>(ptr)->value(QString::fromUtf8(v.data, v.len)); if (i == static_cast<QMap<QString, QVariant>*>(ptr)->size()-1) { static_cast<QMap<QString, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}
void QCborMap___toVariantMap_setList(void* ptr, struct QtCore_PackedString key, void* i)
{
static_cast<QMap<QString, QVariant>*>(ptr)->insert(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(i));
}
void* QCborMap___toVariantMap_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QMap<QString, QVariant>();
}
struct QtCore_PackedList QCborMap___toVariantMap_keyList(void* ptr)
{
return ({ QList<QString>* tmpValue1ab909 = new QList<QString>(static_cast<QMap<QString, QVariant>*>(ptr)->keys()); QtCore_PackedList { tmpValue1ab909, tmpValue1ab909->size() }; });
}
struct QtCore_PackedString QCborMap_____fromVariantHash_hash_keyList_atList(void* ptr, int i)
{
return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtCore_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}
void QCborMap_____fromVariantHash_hash_keyList_setList(void* ptr, struct QtCore_PackedString i)
{
static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}
void* QCborMap_____fromVariantHash_hash_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QString>();
}
struct QtCore_PackedString QCborMap_____fromVariantMap_map_keyList_atList(void* ptr, int i)
{
return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtCore_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}
void QCborMap_____fromVariantMap_map_keyList_setList(void* ptr, struct QtCore_PackedString i)
{
static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}
void* QCborMap_____fromVariantMap_map_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QString>();
}
struct QtCore_PackedString QCborMap_____toVariantHash_keyList_atList(void* ptr, int i)
{
return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtCore_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}
void QCborMap_____toVariantHash_keyList_setList(void* ptr, struct QtCore_PackedString i)
{
static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}
void* QCborMap_____toVariantHash_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QString>();
}
struct QtCore_PackedString QCborMap_____toVariantMap_keyList_atList(void* ptr, int i)
{
return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtCore_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}
void QCborMap_____toVariantMap_keyList_setList(void* ptr, struct QtCore_PackedString i)
{
static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}
void* QCborMap_____toVariantMap_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QString>();
}
struct QtCore_PackedString QCborParserError_ErrorString(void* ptr)
{
return ({ QByteArray* t4aa98b = new QByteArray(static_cast<QCborParserError*>(ptr)->errorString().toUtf8()); QtCore_PackedString { const_cast<char*>(t4aa98b->prepend("WHITESPACE").constData()+10), t4aa98b->size()-10, t4aa98b }; });
}
long long QCborParserError_Offset(void* ptr)
{
return static_cast<QCborParserError*>(ptr)->offset;
}
void QCborParserError_SetOffset(void* ptr, long long vqi)
{
static_cast<QCborParserError*>(ptr)->offset = vqi;
}
void QCborParserError_SetError(void* ptr, void* vqc)
{
static_cast<QCborParserError*>(ptr)->error = *static_cast<QCborError*>(vqc);
}
int QCborValue_False_Type()
{
return QCborValue::False;
}
int QCborValue_True_Type()
{
return QCborValue::True;
}
int QCborValue_Null_Type()
{
return QCborValue::Null;
}
int QCborValue_Undefined_Type()
{
return QCborValue::Undefined;
}
Q_DECLARE_METATYPE(QChar)
Q_DECLARE_METATYPE(QChar*)
void* QChar_NewQChar()
{
return new QChar();
}
void* QChar_NewQChar2(unsigned short code)
{
return new QChar(code);
}
void* QChar_NewQChar3(char* cell, char* row)
{
return new QChar(*static_cast<uchar*>(static_cast<void*>(cell)), *static_cast<uchar*>(static_cast<void*>(row)));
}
void* QChar_NewQChar4(short code)
{
return new QChar(code);
}
void* QChar_NewQChar5(unsigned int code)
{
return new QChar(code);
}
void* QChar_NewQChar6(int code)
{
return new QChar(code);
}
void* QChar_NewQChar7(long long ch)
{
return new QChar(static_cast<QChar::SpecialCharacter>(ch));
}
void* QChar_NewQChar8(void* ch)
{
return new QChar(*static_cast<QLatin1Char*>(ch));
}
void* QChar_NewQChar11(char* ch)
{
return new QChar(*ch);
}
void* QChar_NewQChar12(char* ch)
{
return new QChar(*static_cast<uchar*>(static_cast<void*>(ch)));
}
long long QChar_Category(void* ptr)
{
return static_cast<QChar*>(ptr)->category();
}
long long QChar_QChar_Category2(unsigned int ucs4)
{
return QChar::category(ucs4);
}
struct QtCore_PackedString QChar_Cell(void* ptr)
{
return ({ uchar pret5084cd = static_cast<QChar*>(ptr)->cell(); char* t5084cd = static_cast<char*>(static_cast<void*>(&pret5084cd)); QtCore_PackedString { t5084cd, -1, NULL }; });
}
long long QChar_QChar_CurrentUnicodeVersion()
{
return QChar::currentUnicodeVersion();
}
struct QtCore_PackedString QChar_Decomposition(void* ptr)
{
return ({ QByteArray* t1c0ad1 = new QByteArray(static_cast<QChar*>(ptr)->decomposition().toUtf8()); QtCore_PackedString { const_cast<char*>(t1c0ad1->prepend("WHITESPACE").constData()+10), t1c0ad1->size()-10, t1c0ad1 }; });
}
struct QtCore_PackedString QChar_QChar_Decomposition2(unsigned int ucs4)
{
return ({ QByteArray* tae885b = new QByteArray(QChar::decomposition(ucs4).toUtf8()); QtCore_PackedString { const_cast<char*>(tae885b->prepend("WHITESPACE").constData()+10), tae885b->size()-10, tae885b }; });
}
long long QChar_DecompositionTag(void* ptr)
{
return static_cast<QChar*>(ptr)->decompositionTag();
}
long long QChar_QChar_DecompositionTag2(unsigned int ucs4)
{
return QChar::decompositionTag(ucs4);
}
int QChar_DigitValue(void* ptr)
{
return static_cast<QChar*>(ptr)->digitValue();
}
int QChar_QChar_DigitValue2(unsigned int ucs4)
{
return QChar::digitValue(ucs4);
}
long long QChar_Direction(void* ptr)
{
return static_cast<QChar*>(ptr)->direction();
}
long long QChar_QChar_Direction2(unsigned int ucs4)
{
return QChar::direction(ucs4);
}
void* QChar_QChar_FromLatin1(char* c)
{
return new QChar(QChar::fromLatin1(*c));
}
char QChar_HasMirrored(void* ptr)
{
return static_cast<QChar*>(ptr)->hasMirrored();
}
char QChar_QChar_HasMirrored2(unsigned int ucs4)
{
return QChar::hasMirrored(ucs4);
}
unsigned short QChar_QChar_HighSurrogate(unsigned int ucs4)
{
return QChar::highSurrogate(ucs4);
}
char QChar_IsDigit(void* ptr)
{
return static_cast<QChar*>(ptr)->isDigit();
}
char QChar_QChar_IsDigit2(unsigned int ucs4)
{
return QChar::isDigit(ucs4);
}
char QChar_IsHighSurrogate(void* ptr)
{
return static_cast<QChar*>(ptr)->isHighSurrogate();
}
char QChar_QChar_IsHighSurrogate2(unsigned int ucs4)
{
return QChar::isHighSurrogate(ucs4);
}
char QChar_IsLetter(void* ptr)
{
return static_cast<QChar*>(ptr)->isLetter();
}
char QChar_QChar_IsLetter2(unsigned int ucs4)
{
return QChar::isLetter(ucs4);
}
char QChar_IsLetterOrNumber(void* ptr)
{
return static_cast<QChar*>(ptr)->isLetterOrNumber();
}
char QChar_QChar_IsLetterOrNumber2(unsigned int ucs4)
{
return QChar::isLetterOrNumber(ucs4);
}
char QChar_IsLowSurrogate(void* ptr)
{
return static_cast<QChar*>(ptr)->isLowSurrogate();
}
char QChar_QChar_IsLowSurrogate2(unsigned int ucs4)
{
return QChar::isLowSurrogate(ucs4);
}
char QChar_IsLower(void* ptr)
{
return static_cast<QChar*>(ptr)->isLower();
}
char QChar_QChar_IsLower2(unsigned int ucs4)
{
return QChar::isLower(ucs4);
}
char QChar_IsMark(void* ptr)
{
return static_cast<QChar*>(ptr)->isMark();
}
char QChar_QChar_IsMark2(unsigned int ucs4)
{
return QChar::isMark(ucs4);
}
char QChar_IsNonCharacter(void* ptr)
{
return static_cast<QChar*>(ptr)->isNonCharacter();
}
char QChar_QChar_IsNonCharacter2(unsigned int ucs4)
{
return QChar::isNonCharacter(ucs4);
}
char QChar_IsNull(void* ptr)
{
return static_cast<QChar*>(ptr)->isNull();
}
char QChar_IsNumber(void* ptr)
{
return static_cast<QChar*>(ptr)->isNumber();
}
char QChar_QChar_IsNumber2(unsigned int ucs4)
{
return QChar::isNumber(ucs4);
}
char QChar_IsPrint(void* ptr)
{
return static_cast<QChar*>(ptr)->isPrint();
}
char QChar_QChar_IsPrint2(unsigned int ucs4)
{
return QChar::isPrint(ucs4);
}
char QChar_IsPunct(void* ptr)
{
return static_cast<QChar*>(ptr)->isPunct();
}
char QChar_QChar_IsPunct2(unsigned int ucs4)
{
return QChar::isPunct(ucs4);
}
char QChar_IsSpace(void* ptr)
{
return static_cast<QChar*>(ptr)->isSpace();
}
char QChar_QChar_IsSpace2(unsigned int ucs4)
{
return QChar::isSpace(ucs4);
}
char QChar_IsSurrogate(void* ptr)
{
return static_cast<QChar*>(ptr)->isSurrogate();
}
char QChar_QChar_IsSurrogate2(unsigned int ucs4)
{
return QChar::isSurrogate(ucs4);
}
char QChar_IsSymbol(void* ptr)
{
return static_cast<QChar*>(ptr)->isSymbol();
}
char QChar_QChar_IsSymbol2(unsigned int ucs4)
{
return QChar::isSymbol(ucs4);
}
char QChar_IsTitleCase(void* ptr)
{
return static_cast<QChar*>(ptr)->isTitleCase();
}
char QChar_QChar_IsTitleCase2(unsigned int ucs4)
{
return QChar::isTitleCase(ucs4);
}
char QChar_IsUpper(void* ptr)
{
return static_cast<QChar*>(ptr)->isUpper();
}
char QChar_QChar_IsUpper2(unsigned int ucs4)
{
return QChar::isUpper(ucs4);
}
long long QChar_JoiningType(void* ptr)
{
return static_cast<QChar*>(ptr)->joiningType();
}
long long QChar_QChar_JoiningType2(unsigned int ucs4)
{
return QChar::joiningType(ucs4);
}
unsigned short QChar_QChar_LowSurrogate(unsigned int ucs4)
{
return QChar::lowSurrogate(ucs4);
}
void* QChar_MirroredChar(void* ptr)
{
return new QChar(static_cast<QChar*>(ptr)->mirroredChar());
}
unsigned int QChar_QChar_MirroredChar2(unsigned int ucs4)
{
return QChar::mirroredChar(ucs4);
}
char QChar_QChar_RequiresSurrogates(unsigned int ucs4)
{
return QChar::requiresSurrogates(ucs4);
}
struct QtCore_PackedString QChar_Row(void* ptr)
{
return ({ uchar pret52b865 = static_cast<QChar*>(ptr)->row(); char* t52b865 = static_cast<char*>(static_cast<void*>(&pret52b865)); QtCore_PackedString { t52b865, -1, NULL }; });
}
long long QChar_Script(void* ptr)
{
return static_cast<QChar*>(ptr)->script();
}
long long QChar_QChar_Script2(unsigned int ucs4)
{
return QChar::script(ucs4);
}
unsigned int QChar_QChar_SurrogateToUcs4(unsigned short high, unsigned short low)
{
return QChar::surrogateToUcs4(high, low);
}
unsigned int QChar_QChar_SurrogateToUcs42(void* high, void* low)
{
return QChar::surrogateToUcs4(*static_cast<QChar*>(high), *static_cast<QChar*>(low));
}
void* QChar_ToCaseFolded(void* ptr)
{
return new QChar(static_cast<QChar*>(ptr)->toCaseFolded());
}
unsigned int QChar_QChar_ToCaseFolded2(unsigned int ucs4)
{
return QChar::toCaseFolded(ucs4);
}
struct QtCore_PackedString QChar_ToLatin1(void* ptr)
{
return ({ char t24c86e = static_cast<QChar*>(ptr)->toLatin1(); QtCore_PackedString { &t24c86e, -1, NULL }; });
}
void* QChar_ToLower(void* ptr)
{
return new QChar(static_cast<QChar*>(ptr)->toLower());
}
unsigned int QChar_QChar_ToLower2(unsigned int ucs4)
{
return QChar::toLower(ucs4);
}
void* QChar_ToTitleCase(void* ptr)
{
return new QChar(static_cast<QChar*>(ptr)->toTitleCase());
}
unsigned int QChar_QChar_ToTitleCase2(unsigned int ucs4)
{
return QChar::toTitleCase(ucs4);
}
void* QChar_ToUpper(void* ptr)
{
return new QChar(static_cast<QChar*>(ptr)->toUpper());
}
unsigned int QChar_QChar_ToUpper2(unsigned int ucs4)
{
return QChar::toUpper(ucs4);
}
unsigned short QChar_Unicode(void* ptr)
{
return static_cast<QChar*>(ptr)->unicode();
}
unsigned short QChar_Unicode2(void* ptr)
{
return static_cast<QChar*>(ptr)->unicode();
}
long long QChar_UnicodeVersion(void* ptr)
{
return static_cast<QChar*>(ptr)->unicodeVersion();
}
long long QChar_QChar_UnicodeVersion2(unsigned int ucs4)
{
return QChar::unicodeVersion(ucs4);
}
class MyQChildEvent: public QChildEvent
{
public:
MyQChildEvent(QEvent::Type ty, QObject *child) : QChildEvent(ty, child) {QChildEvent_QChildEvent_QRegisterMetaType();};
};
Q_DECLARE_METATYPE(QChildEvent*)
Q_DECLARE_METATYPE(MyQChildEvent*)
int QChildEvent_QChildEvent_QRegisterMetaType(){qRegisterMetaType<QChildEvent*>(); return qRegisterMetaType<MyQChildEvent*>();}
void* QChildEvent_NewQChildEvent(long long ty, void* child)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QAudioSystemPlugin*>(child));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QCameraImageCapture*>(child));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QDBusPendingCallWatcher*>(child));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QExtensionFactory*>(child));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QExtensionManager*>(child));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QGraphicsObject*>(child));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QGraphicsWidget*>(child));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QLayout*>(child));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QMediaPlaylist*>(child));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QMediaRecorder*>(child));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QMediaServiceProviderPlugin*>(child));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QOffscreenSurface*>(child));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QPaintDeviceWindow*>(child));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QPdfWriter*>(child));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QQuickItem*>(child));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QRadioData*>(child));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QRemoteObjectPendingCallWatcher*>(child));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QScriptExtensionPlugin*>(child));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QWidget*>(child));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(child))) {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QWindow*>(child));
} else {
return new MyQChildEvent(static_cast<QEvent::Type>(ty), static_cast<QObject*>(child));
}
}
char QChildEvent_Added(void* ptr)
{
return static_cast<QChildEvent*>(ptr)->added();
}
void* QChildEvent_Child(void* ptr)
{
return static_cast<QChildEvent*>(ptr)->child();
}
char QChildEvent_Polished(void* ptr)
{
return static_cast<QChildEvent*>(ptr)->polished();
}
char QChildEvent_Removed(void* ptr)
{
return static_cast<QChildEvent*>(ptr)->removed();
}
Q_DECLARE_METATYPE(QCollator*)
void* QCollator_NewQCollator(void* locale)
{
return new QCollator(*static_cast<QLocale*>(locale));
}
void* QCollator_NewQCollator2(void* other)
{
return new QCollator(*static_cast<QCollator*>(other));
}
void* QCollator_NewQCollator3(void* other)
{
return new QCollator(*static_cast<QCollator*>(other));
}
long long QCollator_CaseSensitivity(void* ptr)
{
return static_cast<QCollator*>(ptr)->caseSensitivity();
}
int QCollator_Compare(void* ptr, struct QtCore_PackedString s1, struct QtCore_PackedString s2)
{
return static_cast<QCollator*>(ptr)->compare(QString::fromUtf8(s1.data, s1.len), QString::fromUtf8(s2.data, s2.len));
}
int QCollator_Compare2(void* ptr, void* s1, void* s2)
{
return static_cast<QCollator*>(ptr)->compare(*static_cast<QStringRef*>(s1), *static_cast<QStringRef*>(s2));
}
int QCollator_Compare3(void* ptr, void* s1, int len1, void* s2, int len2)
{
return static_cast<QCollator*>(ptr)->compare(static_cast<QChar*>(s1), len1, static_cast<QChar*>(s2), len2);
}
char QCollator_IgnorePunctuation(void* ptr)
{
return static_cast<QCollator*>(ptr)->ignorePunctuation();
}
void* QCollator_Locale(void* ptr)
{
return new QLocale(static_cast<QCollator*>(ptr)->locale());
}
char QCollator_NumericMode(void* ptr)
{
return static_cast<QCollator*>(ptr)->numericMode();
}
void QCollator_SetCaseSensitivity(void* ptr, long long sensitivity)
{
static_cast<QCollator*>(ptr)->setCaseSensitivity(static_cast<Qt::CaseSensitivity>(sensitivity));
}
void QCollator_SetIgnorePunctuation(void* ptr, char on)
{
static_cast<QCollator*>(ptr)->setIgnorePunctuation(on != 0);
}
void QCollator_SetLocale(void* ptr, void* locale)
{
static_cast<QCollator*>(ptr)->setLocale(*static_cast<QLocale*>(locale));
}
void QCollator_SetNumericMode(void* ptr, char on)
{
static_cast<QCollator*>(ptr)->setNumericMode(on != 0);
}
void* QCollator_SortKey(void* ptr, struct QtCore_PackedString stri)
{
return new QCollatorSortKey(static_cast<QCollator*>(ptr)->sortKey(QString::fromUtf8(stri.data, stri.len)));
}
void QCollator_Swap(void* ptr, void* other)
{
static_cast<QCollator*>(ptr)->swap(*static_cast<QCollator*>(other));
}
void QCollator_DestroyQCollator(void* ptr)
{
static_cast<QCollator*>(ptr)->~QCollator();
}
Q_DECLARE_METATYPE(QCollatorSortKey*)
void* QCollatorSortKey_NewQCollatorSortKey(void* other)
{
return new QCollatorSortKey(*static_cast<QCollatorSortKey*>(other));
}
int QCollatorSortKey_Compare(void* ptr, void* otherKey)
{
return static_cast<QCollatorSortKey*>(ptr)->compare(*static_cast<QCollatorSortKey*>(otherKey));
}
void QCollatorSortKey_Swap(void* ptr, void* other)
{
static_cast<QCollatorSortKey*>(ptr)->swap(*static_cast<QCollatorSortKey*>(other));
}
void QCollatorSortKey_DestroyQCollatorSortKey(void* ptr)
{
static_cast<QCollatorSortKey*>(ptr)->~QCollatorSortKey();
}
Q_DECLARE_METATYPE(QCommandLineOption*)
void* QCommandLineOption_NewQCommandLineOption(struct QtCore_PackedString name)
{
return new QCommandLineOption(QString::fromUtf8(name.data, name.len));
}
void* QCommandLineOption_NewQCommandLineOption2(struct QtCore_PackedString names)
{
return new QCommandLineOption(QString::fromUtf8(names.data, names.len).split("¡¦!", QString::SkipEmptyParts));
}
void* QCommandLineOption_NewQCommandLineOption3(struct QtCore_PackedString name, struct QtCore_PackedString description, struct QtCore_PackedString valueName, struct QtCore_PackedString defaultValue)
{
return new QCommandLineOption(QString::fromUtf8(name.data, name.len), QString::fromUtf8(description.data, description.len), QString::fromUtf8(valueName.data, valueName.len), QString::fromUtf8(defaultValue.data, defaultValue.len));
}
void* QCommandLineOption_NewQCommandLineOption4(struct QtCore_PackedString names, struct QtCore_PackedString description, struct QtCore_PackedString valueName, struct QtCore_PackedString defaultValue)
{
return new QCommandLineOption(QString::fromUtf8(names.data, names.len).split("¡¦!", QString::SkipEmptyParts), QString::fromUtf8(description.data, description.len), QString::fromUtf8(valueName.data, valueName.len), QString::fromUtf8(defaultValue.data, defaultValue.len));
}
void* QCommandLineOption_NewQCommandLineOption5(void* other)
{
return new QCommandLineOption(*static_cast<QCommandLineOption*>(other));
}
struct QtCore_PackedString QCommandLineOption_DefaultValues(void* ptr)
{
return ({ QByteArray* t2b2409 = new QByteArray(static_cast<QCommandLineOption*>(ptr)->defaultValues().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t2b2409->prepend("WHITESPACE").constData()+10), t2b2409->size()-10, t2b2409 }; });
}
struct QtCore_PackedString QCommandLineOption_Description(void* ptr)
{
return ({ QByteArray* t9df42f = new QByteArray(static_cast<QCommandLineOption*>(ptr)->description().toUtf8()); QtCore_PackedString { const_cast<char*>(t9df42f->prepend("WHITESPACE").constData()+10), t9df42f->size()-10, t9df42f }; });
}
long long QCommandLineOption_Flags(void* ptr)
{
return static_cast<QCommandLineOption*>(ptr)->flags();
}
struct QtCore_PackedString QCommandLineOption_Names(void* ptr)
{
return ({ QByteArray* t15f7c9 = new QByteArray(static_cast<QCommandLineOption*>(ptr)->names().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t15f7c9->prepend("WHITESPACE").constData()+10), t15f7c9->size()-10, t15f7c9 }; });
}
void QCommandLineOption_SetDefaultValue(void* ptr, struct QtCore_PackedString defaultValue)
{
static_cast<QCommandLineOption*>(ptr)->setDefaultValue(QString::fromUtf8(defaultValue.data, defaultValue.len));
}
void QCommandLineOption_SetDefaultValues(void* ptr, struct QtCore_PackedString defaultValues)
{
static_cast<QCommandLineOption*>(ptr)->setDefaultValues(QString::fromUtf8(defaultValues.data, defaultValues.len).split("¡¦!", QString::SkipEmptyParts));
}
void QCommandLineOption_SetDescription(void* ptr, struct QtCore_PackedString description)
{
static_cast<QCommandLineOption*>(ptr)->setDescription(QString::fromUtf8(description.data, description.len));
}
void QCommandLineOption_SetFlags(void* ptr, long long flags)
{
static_cast<QCommandLineOption*>(ptr)->setFlags(static_cast<QCommandLineOption::Flag>(flags));
}
void QCommandLineOption_SetValueName(void* ptr, struct QtCore_PackedString valueName)
{
static_cast<QCommandLineOption*>(ptr)->setValueName(QString::fromUtf8(valueName.data, valueName.len));
}
void QCommandLineOption_Swap(void* ptr, void* other)
{
static_cast<QCommandLineOption*>(ptr)->swap(*static_cast<QCommandLineOption*>(other));
}
struct QtCore_PackedString QCommandLineOption_ValueName(void* ptr)
{
return ({ QByteArray* t9c33ed = new QByteArray(static_cast<QCommandLineOption*>(ptr)->valueName().toUtf8()); QtCore_PackedString { const_cast<char*>(t9c33ed->prepend("WHITESPACE").constData()+10), t9c33ed->size()-10, t9c33ed }; });
}
void QCommandLineOption_DestroyQCommandLineOption(void* ptr)
{
static_cast<QCommandLineOption*>(ptr)->~QCommandLineOption();
}
Q_DECLARE_METATYPE(QCommandLineParser*)
void* QCommandLineParser_NewQCommandLineParser()
{
return new QCommandLineParser();
}
void* QCommandLineParser_AddHelpOption(void* ptr)
{
return new QCommandLineOption(static_cast<QCommandLineParser*>(ptr)->addHelpOption());
}
char QCommandLineParser_AddOption(void* ptr, void* option)
{
return static_cast<QCommandLineParser*>(ptr)->addOption(*static_cast<QCommandLineOption*>(option));
}
char QCommandLineParser_AddOptions(void* ptr, void* options)
{
return static_cast<QCommandLineParser*>(ptr)->addOptions(*static_cast<QList<QCommandLineOption>*>(options));
}
void QCommandLineParser_AddPositionalArgument(void* ptr, struct QtCore_PackedString name, struct QtCore_PackedString description, struct QtCore_PackedString syntax)
{
static_cast<QCommandLineParser*>(ptr)->addPositionalArgument(QString::fromUtf8(name.data, name.len), QString::fromUtf8(description.data, description.len), QString::fromUtf8(syntax.data, syntax.len));
}
void* QCommandLineParser_AddVersionOption(void* ptr)
{
return new QCommandLineOption(static_cast<QCommandLineParser*>(ptr)->addVersionOption());
}
struct QtCore_PackedString QCommandLineParser_ApplicationDescription(void* ptr)
{
return ({ QByteArray* tae4284 = new QByteArray(static_cast<QCommandLineParser*>(ptr)->applicationDescription().toUtf8()); QtCore_PackedString { const_cast<char*>(tae4284->prepend("WHITESPACE").constData()+10), tae4284->size()-10, tae4284 }; });
}
void QCommandLineParser_ClearPositionalArguments(void* ptr)
{
static_cast<QCommandLineParser*>(ptr)->clearPositionalArguments();
}
struct QtCore_PackedString QCommandLineParser_ErrorText(void* ptr)
{
return ({ QByteArray* t56b716 = new QByteArray(static_cast<QCommandLineParser*>(ptr)->errorText().toUtf8()); QtCore_PackedString { const_cast<char*>(t56b716->prepend("WHITESPACE").constData()+10), t56b716->size()-10, t56b716 }; });
}
struct QtCore_PackedString QCommandLineParser_HelpText(void* ptr)
{
return ({ QByteArray* t7ab9aa = new QByteArray(static_cast<QCommandLineParser*>(ptr)->helpText().toUtf8()); QtCore_PackedString { const_cast<char*>(t7ab9aa->prepend("WHITESPACE").constData()+10), t7ab9aa->size()-10, t7ab9aa }; });
}
char QCommandLineParser_IsSet(void* ptr, struct QtCore_PackedString name)
{
return static_cast<QCommandLineParser*>(ptr)->isSet(QString::fromUtf8(name.data, name.len));
}
char QCommandLineParser_IsSet2(void* ptr, void* option)
{
return static_cast<QCommandLineParser*>(ptr)->isSet(*static_cast<QCommandLineOption*>(option));
}
struct QtCore_PackedString QCommandLineParser_OptionNames(void* ptr)
{
return ({ QByteArray* tc902b8 = new QByteArray(static_cast<QCommandLineParser*>(ptr)->optionNames().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tc902b8->prepend("WHITESPACE").constData()+10), tc902b8->size()-10, tc902b8 }; });
}
char QCommandLineParser_Parse(void* ptr, struct QtCore_PackedString arguments)
{
return static_cast<QCommandLineParser*>(ptr)->parse(QString::fromUtf8(arguments.data, arguments.len).split("¡¦!", QString::SkipEmptyParts));
}
struct QtCore_PackedString QCommandLineParser_PositionalArguments(void* ptr)
{
return ({ QByteArray* t6fd298 = new QByteArray(static_cast<QCommandLineParser*>(ptr)->positionalArguments().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t6fd298->prepend("WHITESPACE").constData()+10), t6fd298->size()-10, t6fd298 }; });
}
void QCommandLineParser_Process(void* ptr, struct QtCore_PackedString arguments)
{
static_cast<QCommandLineParser*>(ptr)->process(QString::fromUtf8(arguments.data, arguments.len).split("¡¦!", QString::SkipEmptyParts));
}
void QCommandLineParser_Process2(void* ptr, void* app)
{
static_cast<QCommandLineParser*>(ptr)->process(*static_cast<QCoreApplication*>(app));
}
void QCommandLineParser_SetApplicationDescription(void* ptr, struct QtCore_PackedString description)
{
static_cast<QCommandLineParser*>(ptr)->setApplicationDescription(QString::fromUtf8(description.data, description.len));
}
void QCommandLineParser_SetOptionsAfterPositionalArgumentsMode(void* ptr, long long parsingMode)
{
static_cast<QCommandLineParser*>(ptr)->setOptionsAfterPositionalArgumentsMode(static_cast<QCommandLineParser::OptionsAfterPositionalArgumentsMode>(parsingMode));
}
void QCommandLineParser_SetSingleDashWordOptionMode(void* ptr, long long singleDashWordOptionMode)
{
static_cast<QCommandLineParser*>(ptr)->setSingleDashWordOptionMode(static_cast<QCommandLineParser::SingleDashWordOptionMode>(singleDashWordOptionMode));
}
void QCommandLineParser_ShowHelp(void* ptr, int exitCode)
{
static_cast<QCommandLineParser*>(ptr)->showHelp(exitCode);
}
void QCommandLineParser_ShowVersion(void* ptr)
{
static_cast<QCommandLineParser*>(ptr)->showVersion();
}
struct QtCore_PackedString QCommandLineParser_UnknownOptionNames(void* ptr)
{
return ({ QByteArray* t00a30a = new QByteArray(static_cast<QCommandLineParser*>(ptr)->unknownOptionNames().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t00a30a->prepend("WHITESPACE").constData()+10), t00a30a->size()-10, t00a30a }; });
}
struct QtCore_PackedString QCommandLineParser_Value(void* ptr, struct QtCore_PackedString optionName)
{
return ({ QByteArray* t86b3ac = new QByteArray(static_cast<QCommandLineParser*>(ptr)->value(QString::fromUtf8(optionName.data, optionName.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t86b3ac->prepend("WHITESPACE").constData()+10), t86b3ac->size()-10, t86b3ac }; });
}
struct QtCore_PackedString QCommandLineParser_Value2(void* ptr, void* option)
{
return ({ QByteArray* t36413b = new QByteArray(static_cast<QCommandLineParser*>(ptr)->value(*static_cast<QCommandLineOption*>(option)).toUtf8()); QtCore_PackedString { const_cast<char*>(t36413b->prepend("WHITESPACE").constData()+10), t36413b->size()-10, t36413b }; });
}
struct QtCore_PackedString QCommandLineParser_Values(void* ptr, struct QtCore_PackedString optionName)
{
return ({ QByteArray* te65c16 = new QByteArray(static_cast<QCommandLineParser*>(ptr)->values(QString::fromUtf8(optionName.data, optionName.len)).join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(te65c16->prepend("WHITESPACE").constData()+10), te65c16->size()-10, te65c16 }; });
}
struct QtCore_PackedString QCommandLineParser_Values2(void* ptr, void* option)
{
return ({ QByteArray* tafc470 = new QByteArray(static_cast<QCommandLineParser*>(ptr)->values(*static_cast<QCommandLineOption*>(option)).join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tafc470->prepend("WHITESPACE").constData()+10), tafc470->size()-10, tafc470 }; });
}
void QCommandLineParser_DestroyQCommandLineParser(void* ptr)
{
static_cast<QCommandLineParser*>(ptr)->~QCommandLineParser();
}
void* QCommandLineParser___addOptions_options_atList(void* ptr, int i)
{
return new QCommandLineOption(({QCommandLineOption tmp = static_cast<QList<QCommandLineOption>*>(ptr)->at(i); if (i == static_cast<QList<QCommandLineOption>*>(ptr)->size()-1) { static_cast<QList<QCommandLineOption>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QCommandLineParser___addOptions_options_setList(void* ptr, void* i)
{
static_cast<QList<QCommandLineOption>*>(ptr)->append(*static_cast<QCommandLineOption*>(i));
}
void* QCommandLineParser___addOptions_options_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QCommandLineOption>();
}
class MyQConcatenateTablesProxyModel: public QConcatenateTablesProxyModel
{
public:
MyQConcatenateTablesProxyModel(QObject *parent = Q_NULLPTR) : QConcatenateTablesProxyModel(parent) {QConcatenateTablesProxyModel_QConcatenateTablesProxyModel_QRegisterMetaType();};
bool canDropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) const { return callbackQAbstractItemModel_CanDropMimeData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
int columnCount(const QModelIndex & parent) const { return callbackQConcatenateTablesProxyModel_ColumnCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
QVariant data(const QModelIndex & index, int role) const { return *static_cast<QVariant*>(callbackQConcatenateTablesProxyModel_Data(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), role)); };
bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQAbstractItemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
Qt::ItemFlags flags(const QModelIndex & index) const { return static_cast<Qt::ItemFlag>(callbackQAbstractItemModel_Flags(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
QVariant headerData(int section, Qt::Orientation orientation, int role) const { return *static_cast<QVariant*>(callbackQAbstractItemModel_HeaderData(const_cast<void*>(static_cast<const void*>(this)), section, orientation, role)); };
QModelIndex index(int row, int column, const QModelIndex & parent) const { return *static_cast<QModelIndex*>(callbackQConcatenateTablesProxyModel_Index(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&parent))); };
QMap<int, QVariant> itemData(const QModelIndex & proxyIndex) const { return ({ QMap<int, QVariant>* tmpP = static_cast<QMap<int, QVariant>*>(callbackQAbstractItemModel_ItemData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&proxyIndex))); QMap<int, QVariant> tmpV = *tmpP; tmpP->~QMap(); free(tmpP); tmpV; }); };
QMimeData * mimeData(const QModelIndexList & indexes) const { return static_cast<QMimeData*>(callbackQAbstractItemModel_MimeData(const_cast<void*>(static_cast<const void*>(this)), ({ QList<QModelIndex>* tmpValuee0adf2 = new QList<QModelIndex>(indexes); QtCore_PackedList { tmpValuee0adf2, tmpValuee0adf2->size() }; }))); };
QStringList mimeTypes() const { return ({ QtCore_PackedString tempVal = callbackQAbstractItemModel_MimeTypes(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
QModelIndex parent(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQConcatenateTablesProxyModel_Parent(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
int rowCount(const QModelIndex & parent) const { return callbackQConcatenateTablesProxyModel_RowCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
bool setData(const QModelIndex & index, const QVariant & value, int role) { return callbackQAbstractItemModel_SetData(this, const_cast<QModelIndex*>(&index), const_cast<QVariant*>(&value), role) != 0; };
bool setItemData(const QModelIndex & proxyIndex, const QMap<int, QVariant> & roles) { return callbackQAbstractItemModel_SetItemData(this, const_cast<QModelIndex*>(&proxyIndex), ({ QMap<int, QVariant>* tmpValue037c88 = new QMap<int, QVariant>(roles); QtCore_PackedList { tmpValue037c88, tmpValue037c88->size() }; })) != 0; };
QSize span(const QModelIndex & index) const { return *static_cast<QSize*>(callbackQAbstractItemModel_Span(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
~MyQConcatenateTablesProxyModel() { callbackQConcatenateTablesProxyModel_DestroyQConcatenateTablesProxyModel(this); };
QModelIndex buddy(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Buddy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool canFetchMore(const QModelIndex & parent) const { return callbackQAbstractItemModel_CanFetchMore(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
void Signal_ColumnsAboutToBeInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationColumn) { callbackQAbstractItemModel_ColumnsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationColumn); };
void Signal_ColumnsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int column) { callbackQAbstractItemModel_ColumnsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), column); };
void Signal_ColumnsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_DataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQAbstractItemModel_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtCore_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
void fetchMore(const QModelIndex & parent) { callbackQAbstractItemModel_FetchMore(this, const_cast<QModelIndex*>(&parent)); };
bool hasChildren(const QModelIndex & parent) const { return callbackQAbstractItemModel_HasChildren(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
void Signal_HeaderDataChanged(Qt::Orientation orientation, int first, int last) { callbackQAbstractItemModel_HeaderDataChanged(this, orientation, first, last); };
bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
void Signal_LayoutAboutToBeChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQAbstractItemModel_LayoutAboutToBeChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtCore_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
void Signal_LayoutChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQAbstractItemModel_LayoutChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtCore_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
QList<QModelIndex> match(const QModelIndex & start, int role, const QVariant & value, int hits, Qt::MatchFlags flags) const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemModel_Match(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&start), role, const_cast<QVariant*>(&value), hits, flags)); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
void Signal_ModelAboutToBeReset() { callbackQAbstractItemModel_ModelAboutToBeReset(this); };
void Signal_ModelReset() { callbackQAbstractItemModel_ModelReset(this); };
bool moveColumns(const QModelIndex & sourceParent, int sourceColumn, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQAbstractItemModel_MoveColumns(this, const_cast<QModelIndex*>(&sourceParent), sourceColumn, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
bool moveRows(const QModelIndex & sourceParent, int sourceRow, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQAbstractItemModel_MoveRows(this, const_cast<QModelIndex*>(&sourceParent), sourceRow, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
bool removeColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool removeRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
void resetInternalData() { callbackQAbstractItemModel_ResetInternalData(this); };
void revert() { callbackQAbstractItemModel_Revert(this); };
QHash<int, QByteArray> roleNames() const { return ({ QHash<int, QByteArray>* tmpP = static_cast<QHash<int, QByteArray>*>(callbackQAbstractItemModel_RoleNames(const_cast<void*>(static_cast<const void*>(this)))); QHash<int, QByteArray> tmpV = *tmpP; tmpP->~QHash(); free(tmpP); tmpV; }); };
void Signal_RowsAboutToBeInserted(const QModelIndex & parent, int start, int end) { callbackQAbstractItemModel_RowsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
void Signal_RowsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationRow) { callbackQAbstractItemModel_RowsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationRow); };
void Signal_RowsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int row) { callbackQAbstractItemModel_RowsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), row); };
void Signal_RowsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQAbstractItemModel_SetHeaderData(this, section, orientation, const_cast<QVariant*>(&value), role) != 0; };
QModelIndex sibling(int row, int column, const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Sibling(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&index))); };
void sort(int column, Qt::SortOrder order) { callbackQAbstractItemModel_Sort(this, column, order); };
bool submit() { return callbackQAbstractItemModel_Submit(this) != 0; };
Qt::DropActions supportedDragActions() const { return static_cast<Qt::DropAction>(callbackQAbstractItemModel_SupportedDragActions(const_cast<void*>(static_cast<const void*>(this)))); };
Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQAbstractItemModel_SupportedDropActions(const_cast<void*>(static_cast<const void*>(this)))); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QConcatenateTablesProxyModel*)
Q_DECLARE_METATYPE(MyQConcatenateTablesProxyModel*)
int QConcatenateTablesProxyModel_QConcatenateTablesProxyModel_QRegisterMetaType(){qRegisterMetaType<QConcatenateTablesProxyModel*>(); return qRegisterMetaType<MyQConcatenateTablesProxyModel*>();}
void* QConcatenateTablesProxyModel_NewQConcatenateTablesProxyModel(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQConcatenateTablesProxyModel(static_cast<QWindow*>(parent));
} else {
return new MyQConcatenateTablesProxyModel(static_cast<QObject*>(parent));
}
}
void QConcatenateTablesProxyModel_AddSourceModel(void* ptr, void* sourceModel)
{
static_cast<QConcatenateTablesProxyModel*>(ptr)->addSourceModel(static_cast<QAbstractItemModel*>(sourceModel));
}
int QConcatenateTablesProxyModel_ColumnCount(void* ptr, void* parent)
{
return static_cast<QConcatenateTablesProxyModel*>(ptr)->columnCount(*static_cast<QModelIndex*>(parent));
}
int QConcatenateTablesProxyModel_ColumnCountDefault(void* ptr, void* parent)
{
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::columnCount(*static_cast<QModelIndex*>(parent));
}
void* QConcatenateTablesProxyModel_Data(void* ptr, void* index, int role)
{
return new QVariant(static_cast<QConcatenateTablesProxyModel*>(ptr)->data(*static_cast<QModelIndex*>(index), role));
}
void* QConcatenateTablesProxyModel_DataDefault(void* ptr, void* index, int role)
{
return new QVariant(static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::data(*static_cast<QModelIndex*>(index), role));
}
void* QConcatenateTablesProxyModel_Index(void* ptr, int row, int column, void* parent)
{
return new QModelIndex(static_cast<QConcatenateTablesProxyModel*>(ptr)->index(row, column, *static_cast<QModelIndex*>(parent)));
}
void* QConcatenateTablesProxyModel_IndexDefault(void* ptr, int row, int column, void* parent)
{
return new QModelIndex(static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::index(row, column, *static_cast<QModelIndex*>(parent)));
}
void* QConcatenateTablesProxyModel_MapFromSource(void* ptr, void* sourceIndex)
{
return new QModelIndex(static_cast<QConcatenateTablesProxyModel*>(ptr)->mapFromSource(*static_cast<QModelIndex*>(sourceIndex)));
}
void* QConcatenateTablesProxyModel_MapToSource(void* ptr, void* proxyIndex)
{
return new QModelIndex(static_cast<QConcatenateTablesProxyModel*>(ptr)->mapToSource(*static_cast<QModelIndex*>(proxyIndex)));
}
void* QConcatenateTablesProxyModel_Parent(void* ptr, void* index)
{
return new QModelIndex(static_cast<QConcatenateTablesProxyModel*>(ptr)->parent(*static_cast<QModelIndex*>(index)));
}
void* QConcatenateTablesProxyModel_ParentDefault(void* ptr, void* index)
{
return new QModelIndex(static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::parent(*static_cast<QModelIndex*>(index)));
}
void QConcatenateTablesProxyModel_RemoveSourceModel(void* ptr, void* sourceModel)
{
static_cast<QConcatenateTablesProxyModel*>(ptr)->removeSourceModel(static_cast<QAbstractItemModel*>(sourceModel));
}
int QConcatenateTablesProxyModel_RowCount(void* ptr, void* parent)
{
return static_cast<QConcatenateTablesProxyModel*>(ptr)->rowCount(*static_cast<QModelIndex*>(parent));
}
int QConcatenateTablesProxyModel_RowCountDefault(void* ptr, void* parent)
{
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::rowCount(*static_cast<QModelIndex*>(parent));
}
void QConcatenateTablesProxyModel_DestroyQConcatenateTablesProxyModel(void* ptr)
{
static_cast<QConcatenateTablesProxyModel*>(ptr)->~QConcatenateTablesProxyModel();
}
void QConcatenateTablesProxyModel_DestroyQConcatenateTablesProxyModelDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQCoreApplication: public QCoreApplication
{
public:
MyQCoreApplication(int &argc, char **argv) : QCoreApplication(argc, argv) {QCoreApplication_QCoreApplication_QRegisterMetaType();};
void Signal_AboutToQuit() { callbackQCoreApplication_AboutToQuit(this); };
void Signal_ApplicationNameChanged() { callbackQCoreApplication_ApplicationNameChanged(this); };
void Signal_ApplicationVersionChanged() { callbackQCoreApplication_ApplicationVersionChanged(this); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
void Signal_OrganizationDomainChanged() { callbackQCoreApplication_OrganizationDomainChanged(this); };
void Signal_OrganizationNameChanged() { callbackQCoreApplication_OrganizationNameChanged(this); };
void quit() { callbackQCoreApplication_Quit(this); };
~MyQCoreApplication() { callbackQCoreApplication_DestroyQCoreApplication(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QCoreApplication*)
Q_DECLARE_METATYPE(MyQCoreApplication*)
int QCoreApplication_QCoreApplication_QRegisterMetaType(){qRegisterMetaType<QCoreApplication*>(); return qRegisterMetaType<MyQCoreApplication*>();}
void* QCoreApplication_NewQCoreApplication(int argc, char* argv)
{
static int argcs = argc;
static char** argvs = static_cast<char**>(malloc(argcs * sizeof(char*)));
QList<QByteArray> aList = QByteArray(argv).split('|');
for (int i = 0; i < argcs; i++)
argvs[i] = (new QByteArray(aList.at(i)))->data();
return new MyQCoreApplication(argcs, argvs);
}
void QCoreApplication_ConnectAboutToQuit(void* ptr, long long t)
{
QObject::connect(static_cast<QCoreApplication*>(ptr), &QCoreApplication::aboutToQuit, static_cast<MyQCoreApplication*>(ptr), static_cast<void (MyQCoreApplication::*)()>(&MyQCoreApplication::Signal_AboutToQuit), static_cast<Qt::ConnectionType>(t));
}
void QCoreApplication_DisconnectAboutToQuit(void* ptr)
{
QObject::disconnect(static_cast<QCoreApplication*>(ptr), &QCoreApplication::aboutToQuit, static_cast<MyQCoreApplication*>(ptr), static_cast<void (MyQCoreApplication::*)()>(&MyQCoreApplication::Signal_AboutToQuit));
}
void QCoreApplication_QCoreApplication_AddLibraryPath(struct QtCore_PackedString path)
{
QCoreApplication::addLibraryPath(QString::fromUtf8(path.data, path.len));
}
struct QtCore_PackedString QCoreApplication_QCoreApplication_ApplicationDirPath()
{
return ({ QByteArray* t3c2a71 = new QByteArray(QCoreApplication::applicationDirPath().toUtf8()); QtCore_PackedString { const_cast<char*>(t3c2a71->prepend("WHITESPACE").constData()+10), t3c2a71->size()-10, t3c2a71 }; });
}
struct QtCore_PackedString QCoreApplication_QCoreApplication_ApplicationFilePath()
{
return ({ QByteArray* t189694 = new QByteArray(QCoreApplication::applicationFilePath().toUtf8()); QtCore_PackedString { const_cast<char*>(t189694->prepend("WHITESPACE").constData()+10), t189694->size()-10, t189694 }; });
}
struct QtCore_PackedString QCoreApplication_QCoreApplication_ApplicationName()
{
return ({ QByteArray* t704b73 = new QByteArray(QCoreApplication::applicationName().toUtf8()); QtCore_PackedString { const_cast<char*>(t704b73->prepend("WHITESPACE").constData()+10), t704b73->size()-10, t704b73 }; });
}
void QCoreApplication_ConnectApplicationNameChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QCoreApplication*>(ptr), static_cast<void (QCoreApplication::*)()>(&QCoreApplication::applicationNameChanged), static_cast<MyQCoreApplication*>(ptr), static_cast<void (MyQCoreApplication::*)()>(&MyQCoreApplication::Signal_ApplicationNameChanged), static_cast<Qt::ConnectionType>(t));
}
void QCoreApplication_DisconnectApplicationNameChanged(void* ptr)
{
QObject::disconnect(static_cast<QCoreApplication*>(ptr), static_cast<void (QCoreApplication::*)()>(&QCoreApplication::applicationNameChanged), static_cast<MyQCoreApplication*>(ptr), static_cast<void (MyQCoreApplication::*)()>(&MyQCoreApplication::Signal_ApplicationNameChanged));
}
void QCoreApplication_ApplicationNameChanged(void* ptr)
{
static_cast<QCoreApplication*>(ptr)->applicationNameChanged();
}
long long QCoreApplication_QCoreApplication_ApplicationPid()
{
return QCoreApplication::applicationPid();
}
struct QtCore_PackedString QCoreApplication_QCoreApplication_ApplicationVersion()
{
return ({ QByteArray* t9f1c49 = new QByteArray(QCoreApplication::applicationVersion().toUtf8()); QtCore_PackedString { const_cast<char*>(t9f1c49->prepend("WHITESPACE").constData()+10), t9f1c49->size()-10, t9f1c49 }; });
}
void QCoreApplication_ConnectApplicationVersionChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QCoreApplication*>(ptr), static_cast<void (QCoreApplication::*)()>(&QCoreApplication::applicationVersionChanged), static_cast<MyQCoreApplication*>(ptr), static_cast<void (MyQCoreApplication::*)()>(&MyQCoreApplication::Signal_ApplicationVersionChanged), static_cast<Qt::ConnectionType>(t));
}
void QCoreApplication_DisconnectApplicationVersionChanged(void* ptr)
{
QObject::disconnect(static_cast<QCoreApplication*>(ptr), static_cast<void (QCoreApplication::*)()>(&QCoreApplication::applicationVersionChanged), static_cast<MyQCoreApplication*>(ptr), static_cast<void (MyQCoreApplication::*)()>(&MyQCoreApplication::Signal_ApplicationVersionChanged));
}
void QCoreApplication_ApplicationVersionChanged(void* ptr)
{
static_cast<QCoreApplication*>(ptr)->applicationVersionChanged();
}
struct QtCore_PackedString QCoreApplication_QCoreApplication_Arguments()
{
return ({ QByteArray* tee588f = new QByteArray(QCoreApplication::arguments().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tee588f->prepend("WHITESPACE").constData()+10), tee588f->size()-10, tee588f }; });
}
char QCoreApplication_QCoreApplication_ClosingDown()
{
return QCoreApplication::closingDown();
}
void* QCoreApplication_QCoreApplication_EventDispatcher()
{
return QCoreApplication::eventDispatcher();
}
int QCoreApplication_QCoreApplication_Exec()
{
return QCoreApplication::exec();
}
void QCoreApplication_QCoreApplication_Exit(int returnCode)
{
QCoreApplication::exit(returnCode);
}
void QCoreApplication_InstallNativeEventFilter(void* ptr, void* filterObj)
{
static_cast<QCoreApplication*>(ptr)->installNativeEventFilter(static_cast<QAbstractNativeEventFilter*>(filterObj));
}
char QCoreApplication_QCoreApplication_InstallTranslator(void* translationFile)
{
return QCoreApplication::installTranslator(static_cast<QTranslator*>(translationFile));
}
void* QCoreApplication_QCoreApplication_Instance()
{
return QCoreApplication::instance();
}
char QCoreApplication_QCoreApplication_IsQuitLockEnabled()
{
return QCoreApplication::isQuitLockEnabled();
}
char QCoreApplication_QCoreApplication_IsSetuidAllowed()
{
return QCoreApplication::isSetuidAllowed();
}
struct QtCore_PackedString QCoreApplication_QCoreApplication_LibraryPaths()
{
return ({ QByteArray* tec17c7 = new QByteArray(QCoreApplication::libraryPaths().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tec17c7->prepend("WHITESPACE").constData()+10), tec17c7->size()-10, tec17c7 }; });
}
struct QtCore_PackedString QCoreApplication_QCoreApplication_OrganizationDomain()
{
return ({ QByteArray* t013a2e = new QByteArray(QCoreApplication::organizationDomain().toUtf8()); QtCore_PackedString { const_cast<char*>(t013a2e->prepend("WHITESPACE").constData()+10), t013a2e->size()-10, t013a2e }; });
}
void QCoreApplication_ConnectOrganizationDomainChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QCoreApplication*>(ptr), static_cast<void (QCoreApplication::*)()>(&QCoreApplication::organizationDomainChanged), static_cast<MyQCoreApplication*>(ptr), static_cast<void (MyQCoreApplication::*)()>(&MyQCoreApplication::Signal_OrganizationDomainChanged), static_cast<Qt::ConnectionType>(t));
}
void QCoreApplication_DisconnectOrganizationDomainChanged(void* ptr)
{
QObject::disconnect(static_cast<QCoreApplication*>(ptr), static_cast<void (QCoreApplication::*)()>(&QCoreApplication::organizationDomainChanged), static_cast<MyQCoreApplication*>(ptr), static_cast<void (MyQCoreApplication::*)()>(&MyQCoreApplication::Signal_OrganizationDomainChanged));
}
void QCoreApplication_OrganizationDomainChanged(void* ptr)
{
static_cast<QCoreApplication*>(ptr)->organizationDomainChanged();
}
struct QtCore_PackedString QCoreApplication_QCoreApplication_OrganizationName()
{
return ({ QByteArray* t6f3f58 = new QByteArray(QCoreApplication::organizationName().toUtf8()); QtCore_PackedString { const_cast<char*>(t6f3f58->prepend("WHITESPACE").constData()+10), t6f3f58->size()-10, t6f3f58 }; });
}
void QCoreApplication_ConnectOrganizationNameChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QCoreApplication*>(ptr), static_cast<void (QCoreApplication::*)()>(&QCoreApplication::organizationNameChanged), static_cast<MyQCoreApplication*>(ptr), static_cast<void (MyQCoreApplication::*)()>(&MyQCoreApplication::Signal_OrganizationNameChanged), static_cast<Qt::ConnectionType>(t));
}
void QCoreApplication_DisconnectOrganizationNameChanged(void* ptr)
{
QObject::disconnect(static_cast<QCoreApplication*>(ptr), static_cast<void (QCoreApplication::*)()>(&QCoreApplication::organizationNameChanged), static_cast<MyQCoreApplication*>(ptr), static_cast<void (MyQCoreApplication::*)()>(&MyQCoreApplication::Signal_OrganizationNameChanged));
}
void QCoreApplication_OrganizationNameChanged(void* ptr)
{
static_cast<QCoreApplication*>(ptr)->organizationNameChanged();
}
void QCoreApplication_QCoreApplication_PostEvent(void* receiver, void* event, int priority)
{
QCoreApplication::postEvent(static_cast<QObject*>(receiver), static_cast<QEvent*>(event), priority);
}
void QCoreApplication_QCoreApplication_ProcessEvents(long long flags)
{
QCoreApplication::processEvents(static_cast<QEventLoop::ProcessEventsFlag>(flags));
}
void QCoreApplication_QCoreApplication_ProcessEvents2(long long flags, int ms)
{
QCoreApplication::processEvents(static_cast<QEventLoop::ProcessEventsFlag>(flags), ms);
}
void QCoreApplication_Quit(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QCoreApplication*>(ptr), "quit");
}
void QCoreApplication_QuitDefault(void* ptr)
{
static_cast<QCoreApplication*>(ptr)->QCoreApplication::quit();
}
void QCoreApplication_QCoreApplication_RemoveLibraryPath(struct QtCore_PackedString path)
{
QCoreApplication::removeLibraryPath(QString::fromUtf8(path.data, path.len));
}
void QCoreApplication_RemoveNativeEventFilter(void* ptr, void* filterObject)
{
static_cast<QCoreApplication*>(ptr)->removeNativeEventFilter(static_cast<QAbstractNativeEventFilter*>(filterObject));
}
void QCoreApplication_QCoreApplication_RemovePostedEvents(void* receiver, int eventType)
{
QCoreApplication::removePostedEvents(static_cast<QObject*>(receiver), eventType);
}
char QCoreApplication_QCoreApplication_RemoveTranslator(void* translationFile)
{
return QCoreApplication::removeTranslator(static_cast<QTranslator*>(translationFile));
}
char QCoreApplication_QCoreApplication_SendEvent(void* receiver, void* event)
{
return QCoreApplication::sendEvent(static_cast<QObject*>(receiver), static_cast<QEvent*>(event));
}
void QCoreApplication_QCoreApplication_SendPostedEvents(void* receiver, int event_type)
{
QCoreApplication::sendPostedEvents(static_cast<QObject*>(receiver), event_type);
}
void QCoreApplication_QCoreApplication_SetApplicationName(struct QtCore_PackedString application)
{
QCoreApplication::setApplicationName(QString::fromUtf8(application.data, application.len));
}
void QCoreApplication_QCoreApplication_SetApplicationVersion(struct QtCore_PackedString version)
{
QCoreApplication::setApplicationVersion(QString::fromUtf8(version.data, version.len));
}
void QCoreApplication_QCoreApplication_SetAttribute(long long attribute, char on)
{
QCoreApplication::setAttribute(static_cast<Qt::ApplicationAttribute>(attribute), on != 0);
}
void QCoreApplication_QCoreApplication_SetEventDispatcher(void* eventDispatcher)
{
QCoreApplication::setEventDispatcher(static_cast<QAbstractEventDispatcher*>(eventDispatcher));
}
void QCoreApplication_QCoreApplication_SetLibraryPaths(struct QtCore_PackedString paths)
{
QCoreApplication::setLibraryPaths(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts));
}
void QCoreApplication_QCoreApplication_SetOrganizationDomain(struct QtCore_PackedString orgDomain)
{
QCoreApplication::setOrganizationDomain(QString::fromUtf8(orgDomain.data, orgDomain.len));
}
void QCoreApplication_QCoreApplication_SetOrganizationName(struct QtCore_PackedString orgName)
{
QCoreApplication::setOrganizationName(QString::fromUtf8(orgName.data, orgName.len));
}
void QCoreApplication_QCoreApplication_SetQuitLockEnabled(char enabled)
{
QCoreApplication::setQuitLockEnabled(enabled != 0);
}
void QCoreApplication_QCoreApplication_SetSetuidAllowed(char allow)
{
QCoreApplication::setSetuidAllowed(allow != 0);
}
char QCoreApplication_QCoreApplication_StartingUp()
{
return QCoreApplication::startingUp();
}
char QCoreApplication_QCoreApplication_TestAttribute(long long attribute)
{
return QCoreApplication::testAttribute(static_cast<Qt::ApplicationAttribute>(attribute));
}
struct QtCore_PackedString QCoreApplication_QCoreApplication_Translate(char* context, char* sourceText, char* disambiguation, int n)
{
return ({ QByteArray* t901eb0 = new QByteArray(QCoreApplication::translate(const_cast<const char*>(context), const_cast<const char*>(sourceText), const_cast<const char*>(disambiguation), n).toUtf8()); QtCore_PackedString { const_cast<char*>(t901eb0->prepend("WHITESPACE").constData()+10), t901eb0->size()-10, t901eb0 }; });
}
void QCoreApplication_DestroyQCoreApplication(void* ptr)
{
static_cast<QCoreApplication*>(ptr)->~QCoreApplication();
}
void QCoreApplication_DestroyQCoreApplicationDefault(void* ptr)
{
Q_UNUSED(ptr);
}
Q_DECLARE_METATYPE(QCryptographicHash*)
void* QCryptographicHash_NewQCryptographicHash(long long method)
{
return new QCryptographicHash(static_cast<QCryptographicHash::Algorithm>(method));
}
void QCryptographicHash_AddData(void* ptr, char* data, int length)
{
static_cast<QCryptographicHash*>(ptr)->addData(const_cast<const char*>(data), length);
}
void QCryptographicHash_AddData2(void* ptr, void* data)
{
static_cast<QCryptographicHash*>(ptr)->addData(*static_cast<QByteArray*>(data));
}
char QCryptographicHash_AddData3(void* ptr, void* device)
{
return static_cast<QCryptographicHash*>(ptr)->addData(static_cast<QIODevice*>(device));
}
void* QCryptographicHash_QCryptographicHash_Hash(void* data, long long method)
{
return new QByteArray(QCryptographicHash::hash(*static_cast<QByteArray*>(data), static_cast<QCryptographicHash::Algorithm>(method)));
}
int QCryptographicHash_QCryptographicHash_HashLength(long long method)
{
return QCryptographicHash::hashLength(static_cast<QCryptographicHash::Algorithm>(method));
}
void QCryptographicHash_Reset(void* ptr)
{
static_cast<QCryptographicHash*>(ptr)->reset();
}
void* QCryptographicHash_Result(void* ptr)
{
return new QByteArray(static_cast<QCryptographicHash*>(ptr)->result());
}
void QCryptographicHash_DestroyQCryptographicHash(void* ptr)
{
static_cast<QCryptographicHash*>(ptr)->~QCryptographicHash();
}
Q_DECLARE_METATYPE(QDataStream*)
void* QDataStream_NewQDataStream()
{
return new QDataStream();
}
void* QDataStream_NewQDataStream2(void* d)
{
return new QDataStream(static_cast<QIODevice*>(d));
}
void* QDataStream_NewQDataStream3(void* a, long long mode)
{
return new QDataStream(static_cast<QByteArray*>(a), static_cast<QIODevice::OpenModeFlag>(mode));
}
void* QDataStream_NewQDataStream4(void* a)
{
return new QDataStream(*static_cast<QByteArray*>(a));
}
void QDataStream_AbortTransaction(void* ptr)
{
static_cast<QDataStream*>(ptr)->abortTransaction();
}
char QDataStream_AtEnd(void* ptr)
{
return static_cast<QDataStream*>(ptr)->atEnd();
}
long long QDataStream_ByteOrder(void* ptr)
{
return static_cast<QDataStream*>(ptr)->byteOrder();
}
char QDataStream_CommitTransaction(void* ptr)
{
return static_cast<QDataStream*>(ptr)->commitTransaction();
}
void* QDataStream_Device(void* ptr)
{
return static_cast<QDataStream*>(ptr)->device();
}
long long QDataStream_FloatingPointPrecision(void* ptr)
{
return static_cast<QDataStream*>(ptr)->floatingPointPrecision();
}
int QDataStream_ReadRawData(void* ptr, char* s, int l)
{
return static_cast<QDataStream*>(ptr)->readRawData(s, l);
}
void QDataStream_ResetStatus(void* ptr)
{
static_cast<QDataStream*>(ptr)->resetStatus();
}
void QDataStream_RollbackTransaction(void* ptr)
{
static_cast<QDataStream*>(ptr)->rollbackTransaction();
}
void QDataStream_SetByteOrder(void* ptr, long long bo)
{
static_cast<QDataStream*>(ptr)->setByteOrder(static_cast<QDataStream::ByteOrder>(bo));
}
void QDataStream_SetDevice(void* ptr, void* d)
{
static_cast<QDataStream*>(ptr)->setDevice(static_cast<QIODevice*>(d));
}
void QDataStream_SetFloatingPointPrecision(void* ptr, long long precision)
{
static_cast<QDataStream*>(ptr)->setFloatingPointPrecision(static_cast<QDataStream::FloatingPointPrecision>(precision));
}
void QDataStream_SetStatus(void* ptr, long long status)
{
static_cast<QDataStream*>(ptr)->setStatus(static_cast<QDataStream::Status>(status));
}
void QDataStream_SetVersion(void* ptr, int v)
{
static_cast<QDataStream*>(ptr)->setVersion(v);
}
int QDataStream_SkipRawData(void* ptr, int l)
{
return static_cast<QDataStream*>(ptr)->skipRawData(l);
}
void QDataStream_StartTransaction(void* ptr)
{
static_cast<QDataStream*>(ptr)->startTransaction();
}
long long QDataStream_Status(void* ptr)
{
return static_cast<QDataStream*>(ptr)->status();
}
int QDataStream_Version(void* ptr)
{
return static_cast<QDataStream*>(ptr)->version();
}
int QDataStream_WriteRawData(void* ptr, char* s, int l)
{
return static_cast<QDataStream*>(ptr)->writeRawData(const_cast<const char*>(s), l);
}
void QDataStream_DestroyQDataStream(void* ptr)
{
static_cast<QDataStream*>(ptr)->~QDataStream();
}
Q_DECLARE_METATYPE(QDate)
Q_DECLARE_METATYPE(QDate*)
void* QDate_NewQDate2()
{
return new QDate();
}
void* QDate_NewQDate3(int y, int m, int d)
{
return new QDate(y, m, d);
}
void* QDate_AddDays(void* ptr, long long ndays)
{
return new QDate(static_cast<QDate*>(ptr)->addDays(ndays));
}
void* QDate_AddMonths(void* ptr, int nmonths)
{
return new QDate(static_cast<QDate*>(ptr)->addMonths(nmonths));
}
void* QDate_AddYears(void* ptr, int nyears)
{
return new QDate(static_cast<QDate*>(ptr)->addYears(nyears));
}
void* QDate_QDate_CurrentDate()
{
return new QDate(QDate::currentDate());
}
int QDate_Day(void* ptr)
{
return static_cast<QDate*>(ptr)->day();
}
int QDate_DayOfWeek(void* ptr)
{
return static_cast<QDate*>(ptr)->dayOfWeek();
}
int QDate_DayOfYear(void* ptr)
{
return static_cast<QDate*>(ptr)->dayOfYear();
}
int QDate_DaysInMonth(void* ptr)
{
return static_cast<QDate*>(ptr)->daysInMonth();
}
int QDate_DaysInYear(void* ptr)
{
return static_cast<QDate*>(ptr)->daysInYear();
}
long long QDate_DaysTo(void* ptr, void* d)
{
return static_cast<QDate*>(ptr)->daysTo(*static_cast<QDate*>(d));
}
void* QDate_QDate_FromJulianDay(long long jd)
{
return new QDate(QDate::fromJulianDay(jd));
}
void* QDate_QDate_FromString(struct QtCore_PackedString stri, long long format)
{
return new QDate(QDate::fromString(QString::fromUtf8(stri.data, stri.len), static_cast<Qt::DateFormat>(format)));
}
void* QDate_QDate_FromString2(struct QtCore_PackedString stri, struct QtCore_PackedString format)
{
return new QDate(QDate::fromString(QString::fromUtf8(stri.data, stri.len), QString::fromUtf8(format.data, format.len)));
}
void QDate_GetDate(void* ptr, int year, int month, int day)
{
static_cast<QDate*>(ptr)->getDate(&year, &month, &day);
}
char QDate_QDate_IsLeapYear(int year)
{
return QDate::isLeapYear(year);
}
char QDate_IsNull(void* ptr)
{
return static_cast<QDate*>(ptr)->isNull();
}
char QDate_IsValid(void* ptr)
{
return static_cast<QDate*>(ptr)->isValid();
}
char QDate_QDate_IsValid2(int year, int month, int day)
{
return QDate::isValid(year, month, day);
}
int QDate_Month(void* ptr)
{
return static_cast<QDate*>(ptr)->month();
}
char QDate_SetDate(void* ptr, int year, int month, int day)
{
return static_cast<QDate*>(ptr)->setDate(year, month, day);
}
long long QDate_ToJulianDay(void* ptr)
{
return static_cast<QDate*>(ptr)->toJulianDay();
}
struct QtCore_PackedString QDate_ToString(void* ptr, struct QtCore_PackedString format)
{
return ({ QByteArray* te68bf6 = new QByteArray(static_cast<QDate*>(ptr)->toString(QString::fromUtf8(format.data, format.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(te68bf6->prepend("WHITESPACE").constData()+10), te68bf6->size()-10, te68bf6 }; });
}
struct QtCore_PackedString QDate_ToString2(void* ptr, long long format)
{
return ({ QByteArray* tfa9ec6 = new QByteArray(static_cast<QDate*>(ptr)->toString(static_cast<Qt::DateFormat>(format)).toUtf8()); QtCore_PackedString { const_cast<char*>(tfa9ec6->prepend("WHITESPACE").constData()+10), tfa9ec6->size()-10, tfa9ec6 }; });
}
struct QtCore_PackedString QDate_ToString3(void* ptr, void* format)
{
return ({ QByteArray* tab5488 = new QByteArray(static_cast<QDate*>(ptr)->toString(*static_cast<QStringView*>(format)).toUtf8()); QtCore_PackedString { const_cast<char*>(tab5488->prepend("WHITESPACE").constData()+10), tab5488->size()-10, tab5488 }; });
}
int QDate_WeekNumber(void* ptr, int yearNumber)
{
return static_cast<QDate*>(ptr)->weekNumber(&yearNumber);
}
int QDate_Year(void* ptr)
{
return static_cast<QDate*>(ptr)->year();
}
Q_DECLARE_METATYPE(QDateTime)
Q_DECLARE_METATYPE(QDateTime*)
void* QDateTime_NewQDateTime()
{
return new QDateTime();
}
void* QDateTime_NewQDateTime2(void* date)
{
return new QDateTime(*static_cast<QDate*>(date));
}
void* QDateTime_NewQDateTime3(void* date, void* ti, long long spec)
{
return new QDateTime(*static_cast<QDate*>(date), *static_cast<QTime*>(ti), static_cast<Qt::TimeSpec>(spec));
}
void* QDateTime_NewQDateTime4(void* date, void* ti, long long spec, int offsetSeconds)
{
return new QDateTime(*static_cast<QDate*>(date), *static_cast<QTime*>(ti), static_cast<Qt::TimeSpec>(spec), offsetSeconds);
}
void* QDateTime_NewQDateTime5(void* date, void* ti, void* timeZone)
{
return new QDateTime(*static_cast<QDate*>(date), *static_cast<QTime*>(ti), *static_cast<QTimeZone*>(timeZone));
}
void* QDateTime_NewQDateTime6(void* other)
{
return new QDateTime(*static_cast<QDateTime*>(other));
}
void* QDateTime_NewQDateTime7(void* other)
{
return new QDateTime(*static_cast<QDateTime*>(other));
}
void* QDateTime_AddDays(void* ptr, long long ndays)
{
return new QDateTime(static_cast<QDateTime*>(ptr)->addDays(ndays));
}
void* QDateTime_AddMSecs(void* ptr, long long msecs)
{
return new QDateTime(static_cast<QDateTime*>(ptr)->addMSecs(msecs));
}
void* QDateTime_AddMonths(void* ptr, int nmonths)
{
return new QDateTime(static_cast<QDateTime*>(ptr)->addMonths(nmonths));
}
void* QDateTime_AddSecs(void* ptr, long long s)
{
return new QDateTime(static_cast<QDateTime*>(ptr)->addSecs(s));
}
void* QDateTime_AddYears(void* ptr, int nyears)
{
return new QDateTime(static_cast<QDateTime*>(ptr)->addYears(nyears));
}
void* QDateTime_QDateTime_CurrentDateTime()
{
return new QDateTime(QDateTime::currentDateTime());
}
void* QDateTime_QDateTime_CurrentDateTimeUtc()
{
return new QDateTime(QDateTime::currentDateTimeUtc());
}
long long QDateTime_QDateTime_CurrentMSecsSinceEpoch()
{
return QDateTime::currentMSecsSinceEpoch();
}
long long QDateTime_QDateTime_CurrentSecsSinceEpoch()
{
return QDateTime::currentSecsSinceEpoch();
}
void* QDateTime_Date(void* ptr)
{
return new QDate(static_cast<QDateTime*>(ptr)->date());
}
long long QDateTime_DaysTo(void* ptr, void* other)
{
return static_cast<QDateTime*>(ptr)->daysTo(*static_cast<QDateTime*>(other));
}
void* QDateTime_QDateTime_FromMSecsSinceEpoch(long long msecs)
{
return new QDateTime(QDateTime::fromMSecsSinceEpoch(msecs));
}
void* QDateTime_QDateTime_FromMSecsSinceEpoch2(long long msecs, long long spec, int offsetSeconds)
{
return new QDateTime(QDateTime::fromMSecsSinceEpoch(msecs, static_cast<Qt::TimeSpec>(spec), offsetSeconds));
}
void* QDateTime_QDateTime_FromMSecsSinceEpoch3(long long msecs, void* timeZone)
{
return new QDateTime(QDateTime::fromMSecsSinceEpoch(msecs, *static_cast<QTimeZone*>(timeZone)));
}
void* QDateTime_QDateTime_FromSecsSinceEpoch(long long secs, long long spec, int offsetSeconds)
{
return new QDateTime(QDateTime::fromSecsSinceEpoch(secs, static_cast<Qt::TimeSpec>(spec), offsetSeconds));
}
void* QDateTime_QDateTime_FromSecsSinceEpoch2(long long secs, void* timeZone)
{
return new QDateTime(QDateTime::fromSecsSinceEpoch(secs, *static_cast<QTimeZone*>(timeZone)));
}
void* QDateTime_QDateTime_FromString(struct QtCore_PackedString stri, long long format)
{
return new QDateTime(QDateTime::fromString(QString::fromUtf8(stri.data, stri.len), static_cast<Qt::DateFormat>(format)));
}
void* QDateTime_QDateTime_FromString2(struct QtCore_PackedString stri, struct QtCore_PackedString format)
{
return new QDateTime(QDateTime::fromString(QString::fromUtf8(stri.data, stri.len), QString::fromUtf8(format.data, format.len)));
}
char QDateTime_IsDaylightTime(void* ptr)
{
return static_cast<QDateTime*>(ptr)->isDaylightTime();
}
char QDateTime_IsNull(void* ptr)
{
return static_cast<QDateTime*>(ptr)->isNull();
}
char QDateTime_IsValid(void* ptr)
{
return static_cast<QDateTime*>(ptr)->isValid();
}
long long QDateTime_MsecsTo(void* ptr, void* other)
{
return static_cast<QDateTime*>(ptr)->msecsTo(*static_cast<QDateTime*>(other));
}
int QDateTime_OffsetFromUtc(void* ptr)
{
return static_cast<QDateTime*>(ptr)->offsetFromUtc();
}
long long QDateTime_SecsTo(void* ptr, void* other)
{
return static_cast<QDateTime*>(ptr)->secsTo(*static_cast<QDateTime*>(other));
}
void QDateTime_SetDate(void* ptr, void* date)
{
static_cast<QDateTime*>(ptr)->setDate(*static_cast<QDate*>(date));
}
void QDateTime_SetMSecsSinceEpoch(void* ptr, long long msecs)
{
static_cast<QDateTime*>(ptr)->setMSecsSinceEpoch(msecs);
}
void QDateTime_SetOffsetFromUtc(void* ptr, int offsetSeconds)
{
static_cast<QDateTime*>(ptr)->setOffsetFromUtc(offsetSeconds);
}
void QDateTime_SetSecsSinceEpoch(void* ptr, long long secs)
{
static_cast<QDateTime*>(ptr)->setSecsSinceEpoch(secs);
}
void QDateTime_SetTime(void* ptr, void* ti)
{
static_cast<QDateTime*>(ptr)->setTime(*static_cast<QTime*>(ti));
}
void QDateTime_SetTimeSpec(void* ptr, long long spec)
{
static_cast<QDateTime*>(ptr)->setTimeSpec(static_cast<Qt::TimeSpec>(spec));
}
void QDateTime_SetTimeZone(void* ptr, void* toZone)
{
static_cast<QDateTime*>(ptr)->setTimeZone(*static_cast<QTimeZone*>(toZone));
}
void QDateTime_Swap(void* ptr, void* other)
{
static_cast<QDateTime*>(ptr)->swap(*static_cast<QDateTime*>(other));
}
void* QDateTime_Time(void* ptr)
{
return new QTime(static_cast<QDateTime*>(ptr)->time());
}
long long QDateTime_TimeSpec(void* ptr)
{
return static_cast<QDateTime*>(ptr)->timeSpec();
}
void* QDateTime_TimeZone(void* ptr)
{
return new QTimeZone(static_cast<QDateTime*>(ptr)->timeZone());
}
struct QtCore_PackedString QDateTime_TimeZoneAbbreviation(void* ptr)
{
return ({ QByteArray* te524d2 = new QByteArray(static_cast<QDateTime*>(ptr)->timeZoneAbbreviation().toUtf8()); QtCore_PackedString { const_cast<char*>(te524d2->prepend("WHITESPACE").constData()+10), te524d2->size()-10, te524d2 }; });
}
void* QDateTime_ToLocalTime(void* ptr)
{
return new QDateTime(static_cast<QDateTime*>(ptr)->toLocalTime());
}
long long QDateTime_ToMSecsSinceEpoch(void* ptr)
{
return static_cast<QDateTime*>(ptr)->toMSecsSinceEpoch();
}
void* QDateTime_ToOffsetFromUtc(void* ptr, int offsetSeconds)
{
return new QDateTime(static_cast<QDateTime*>(ptr)->toOffsetFromUtc(offsetSeconds));
}
long long QDateTime_ToSecsSinceEpoch(void* ptr)
{
return static_cast<QDateTime*>(ptr)->toSecsSinceEpoch();
}
struct QtCore_PackedString QDateTime_ToString(void* ptr, struct QtCore_PackedString format)
{
return ({ QByteArray* t78bcae = new QByteArray(static_cast<QDateTime*>(ptr)->toString(QString::fromUtf8(format.data, format.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t78bcae->prepend("WHITESPACE").constData()+10), t78bcae->size()-10, t78bcae }; });
}
struct QtCore_PackedString QDateTime_ToString2(void* ptr, long long format)
{
return ({ QByteArray* tbd5547 = new QByteArray(static_cast<QDateTime*>(ptr)->toString(static_cast<Qt::DateFormat>(format)).toUtf8()); QtCore_PackedString { const_cast<char*>(tbd5547->prepend("WHITESPACE").constData()+10), tbd5547->size()-10, tbd5547 }; });
}
struct QtCore_PackedString QDateTime_ToString3(void* ptr, void* format)
{
return ({ QByteArray* t95196e = new QByteArray(static_cast<QDateTime*>(ptr)->toString(*static_cast<QStringView*>(format)).toUtf8()); QtCore_PackedString { const_cast<char*>(t95196e->prepend("WHITESPACE").constData()+10), t95196e->size()-10, t95196e }; });
}
void* QDateTime_ToTimeSpec(void* ptr, long long spec)
{
return new QDateTime(static_cast<QDateTime*>(ptr)->toTimeSpec(static_cast<Qt::TimeSpec>(spec)));
}
void* QDateTime_ToTimeZone(void* ptr, void* timeZone)
{
return new QDateTime(static_cast<QDateTime*>(ptr)->toTimeZone(*static_cast<QTimeZone*>(timeZone)));
}
void* QDateTime_ToUTC(void* ptr)
{
return new QDateTime(static_cast<QDateTime*>(ptr)->toUTC());
}
void QDateTime_DestroyQDateTime(void* ptr)
{
static_cast<QDateTime*>(ptr)->~QDateTime();
}
Q_DECLARE_METATYPE(QDeadlineTimer*)
void* QDeadlineTimer_NewQDeadlineTimer(long long timerType)
{
return new QDeadlineTimer(static_cast<Qt::TimerType>(timerType));
}
void* QDeadlineTimer_NewQDeadlineTimer2(long long vqd, long long timerType)
{
return new QDeadlineTimer(static_cast<QDeadlineTimer::ForeverConstant>(vqd), static_cast<Qt::TimerType>(timerType));
}
void* QDeadlineTimer_NewQDeadlineTimer3(long long msecs, long long ty)
{
return new QDeadlineTimer(msecs, static_cast<Qt::TimerType>(ty));
}
long long QDeadlineTimer_Deadline(void* ptr)
{
return static_cast<QDeadlineTimer*>(ptr)->deadline();
}
long long QDeadlineTimer_DeadlineNSecs(void* ptr)
{
return static_cast<QDeadlineTimer*>(ptr)->deadlineNSecs();
}
char QDeadlineTimer_HasExpired(void* ptr)
{
return static_cast<QDeadlineTimer*>(ptr)->hasExpired();
}
char QDeadlineTimer_IsForever(void* ptr)
{
return static_cast<QDeadlineTimer*>(ptr)->isForever();
}
long long QDeadlineTimer_RemainingTime(void* ptr)
{
return static_cast<QDeadlineTimer*>(ptr)->remainingTime();
}
long long QDeadlineTimer_RemainingTimeNSecs(void* ptr)
{
return static_cast<QDeadlineTimer*>(ptr)->remainingTimeNSecs();
}
void QDeadlineTimer_SetDeadline(void* ptr, long long msecs, long long timerType)
{
static_cast<QDeadlineTimer*>(ptr)->setDeadline(msecs, static_cast<Qt::TimerType>(timerType));
}
void QDeadlineTimer_SetPreciseDeadline(void* ptr, long long secs, long long nsecs, long long timerType)
{
static_cast<QDeadlineTimer*>(ptr)->setPreciseDeadline(secs, nsecs, static_cast<Qt::TimerType>(timerType));
}
void QDeadlineTimer_SetPreciseRemainingTime(void* ptr, long long secs, long long nsecs, long long timerType)
{
static_cast<QDeadlineTimer*>(ptr)->setPreciseRemainingTime(secs, nsecs, static_cast<Qt::TimerType>(timerType));
}
void QDeadlineTimer_SetRemainingTime(void* ptr, long long msecs, long long timerType)
{
static_cast<QDeadlineTimer*>(ptr)->setRemainingTime(msecs, static_cast<Qt::TimerType>(timerType));
}
void QDeadlineTimer_SetTimerType(void* ptr, long long timerType)
{
static_cast<QDeadlineTimer*>(ptr)->setTimerType(static_cast<Qt::TimerType>(timerType));
}
void QDeadlineTimer_Swap(void* ptr, void* other)
{
static_cast<QDeadlineTimer*>(ptr)->swap(*static_cast<QDeadlineTimer*>(other));
}
long long QDeadlineTimer_TimerType(void* ptr)
{
return static_cast<QDeadlineTimer*>(ptr)->timerType();
}
Q_DECLARE_METATYPE(QDebug*)
void* QDebug_NewQDebug(void* device)
{
return new QDebug(static_cast<QIODevice*>(device));
}
void* QDebug_NewQDebug2(struct QtCore_PackedString stri)
{
return new QDebug(new QString(QString::fromUtf8(stri.data, stri.len)));
}
void* QDebug_NewQDebug4(void* o)
{
return new QDebug(*static_cast<QDebug*>(o));
}
char QDebug_AutoInsertSpaces(void* ptr)
{
return static_cast<QDebug*>(ptr)->autoInsertSpaces();
}
void* QDebug_MaybeQuote(void* ptr, char* c)
{
return new QDebug(static_cast<QDebug*>(ptr)->maybeQuote(*c));
}
void* QDebug_MaybeSpace(void* ptr)
{
return new QDebug(static_cast<QDebug*>(ptr)->maybeSpace());
}
void* QDebug_Noquote(void* ptr)
{
return new QDebug(static_cast<QDebug*>(ptr)->noquote());
}
void* QDebug_Nospace(void* ptr)
{
return new QDebug(static_cast<QDebug*>(ptr)->nospace());
}
void* QDebug_Quote(void* ptr)
{
return new QDebug(static_cast<QDebug*>(ptr)->quote());
}
void* QDebug_ResetFormat(void* ptr)
{
return new QDebug(static_cast<QDebug*>(ptr)->resetFormat());
}
void QDebug_SetAutoInsertSpaces(void* ptr, char b)
{
static_cast<QDebug*>(ptr)->setAutoInsertSpaces(b != 0);
}
void QDebug_SetVerbosity(void* ptr, int verbosityLevel)
{
static_cast<QDebug*>(ptr)->setVerbosity(verbosityLevel);
}
void* QDebug_Space(void* ptr)
{
return new QDebug(static_cast<QDebug*>(ptr)->space());
}
void QDebug_Swap(void* ptr, void* other)
{
static_cast<QDebug*>(ptr)->swap(*static_cast<QDebug*>(other));
}
void* QDebug_Verbosity(void* ptr, int verbosityLevel)
{
return new QDebug(static_cast<QDebug*>(ptr)->verbosity(verbosityLevel));
}
int QDebug_Verbosity2(void* ptr)
{
return static_cast<QDebug*>(ptr)->verbosity();
}
void QDebug_DestroyQDebug(void* ptr)
{
static_cast<QDebug*>(ptr)->~QDebug();
}
Q_DECLARE_METATYPE(QDebugStateSaver*)
void* QDebugStateSaver_NewQDebugStateSaver(void* dbg)
{
return new QDebugStateSaver(*static_cast<QDebug*>(dbg));
}
void QDebugStateSaver_DestroyQDebugStateSaver(void* ptr)
{
static_cast<QDebugStateSaver*>(ptr)->~QDebugStateSaver();
}
class MyQDeferredDeleteEvent: public QDeferredDeleteEvent
{
public:
MyQDeferredDeleteEvent() : QDeferredDeleteEvent() {QDeferredDeleteEvent_QDeferredDeleteEvent_QRegisterMetaType();};
};
Q_DECLARE_METATYPE(QDeferredDeleteEvent*)
Q_DECLARE_METATYPE(MyQDeferredDeleteEvent*)
int QDeferredDeleteEvent_QDeferredDeleteEvent_QRegisterMetaType(){qRegisterMetaType<QDeferredDeleteEvent*>(); return qRegisterMetaType<MyQDeferredDeleteEvent*>();}
void* QDeferredDeleteEvent_NewQDeferredDeleteEvent()
{
return new MyQDeferredDeleteEvent();
}
int QDeferredDeleteEvent_LoopLevel(void* ptr)
{
return static_cast<QDeferredDeleteEvent*>(ptr)->loopLevel();
}
Q_DECLARE_METATYPE(QDir*)
void* QDir_NewQDir(void* dir)
{
return new QDir(*static_cast<QDir*>(dir));
}
void* QDir_NewQDir2(struct QtCore_PackedString path)
{
return new QDir(QString::fromUtf8(path.data, path.len));
}
void* QDir_NewQDir3(struct QtCore_PackedString path, struct QtCore_PackedString nameFilter, long long sort, long long filters)
{
return new QDir(QString::fromUtf8(path.data, path.len), QString::fromUtf8(nameFilter.data, nameFilter.len), static_cast<QDir::SortFlag>(sort), static_cast<QDir::Filter>(filters));
}
struct QtCore_PackedString QDir_AbsoluteFilePath(void* ptr, struct QtCore_PackedString fileName)
{
return ({ QByteArray* t084b4e = new QByteArray(static_cast<QDir*>(ptr)->absoluteFilePath(QString::fromUtf8(fileName.data, fileName.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t084b4e->prepend("WHITESPACE").constData()+10), t084b4e->size()-10, t084b4e }; });
}
struct QtCore_PackedString QDir_AbsolutePath(void* ptr)
{
return ({ QByteArray* t420972 = new QByteArray(static_cast<QDir*>(ptr)->absolutePath().toUtf8()); QtCore_PackedString { const_cast<char*>(t420972->prepend("WHITESPACE").constData()+10), t420972->size()-10, t420972 }; });
}
void QDir_QDir_AddSearchPath(struct QtCore_PackedString prefix, struct QtCore_PackedString path)
{
QDir::addSearchPath(QString::fromUtf8(prefix.data, prefix.len), QString::fromUtf8(path.data, path.len));
}
struct QtCore_PackedString QDir_CanonicalPath(void* ptr)
{
return ({ QByteArray* ta3771c = new QByteArray(static_cast<QDir*>(ptr)->canonicalPath().toUtf8()); QtCore_PackedString { const_cast<char*>(ta3771c->prepend("WHITESPACE").constData()+10), ta3771c->size()-10, ta3771c }; });
}
char QDir_Cd(void* ptr, struct QtCore_PackedString dirName)
{
return static_cast<QDir*>(ptr)->cd(QString::fromUtf8(dirName.data, dirName.len));
}
char QDir_CdUp(void* ptr)
{
return static_cast<QDir*>(ptr)->cdUp();
}
struct QtCore_PackedString QDir_QDir_CleanPath(struct QtCore_PackedString path)
{
return ({ QByteArray* tad90b4 = new QByteArray(QDir::cleanPath(QString::fromUtf8(path.data, path.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(tad90b4->prepend("WHITESPACE").constData()+10), tad90b4->size()-10, tad90b4 }; });
}
unsigned int QDir_Count(void* ptr)
{
return static_cast<QDir*>(ptr)->count();
}
void* QDir_QDir_Current()
{
return new QDir(QDir::current());
}
struct QtCore_PackedString QDir_QDir_CurrentPath()
{
return ({ QByteArray* t081208 = new QByteArray(QDir::currentPath().toUtf8()); QtCore_PackedString { const_cast<char*>(t081208->prepend("WHITESPACE").constData()+10), t081208->size()-10, t081208 }; });
}
struct QtCore_PackedString QDir_DirName(void* ptr)
{
return ({ QByteArray* td48935 = new QByteArray(static_cast<QDir*>(ptr)->dirName().toUtf8()); QtCore_PackedString { const_cast<char*>(td48935->prepend("WHITESPACE").constData()+10), td48935->size()-10, td48935 }; });
}
struct QtCore_PackedList QDir_QDir_Drives()
{
return ({ QList<QFileInfo>* tmpValued1e42f = new QList<QFileInfo>(QDir::drives()); QtCore_PackedList { tmpValued1e42f, tmpValued1e42f->size() }; });
}
struct QtCore_PackedList QDir_EntryInfoList(void* ptr, struct QtCore_PackedString nameFilters, long long filters, long long sort)
{
return ({ QList<QFileInfo>* tmpValue043d19 = new QList<QFileInfo>(static_cast<QDir*>(ptr)->entryInfoList(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort))); QtCore_PackedList { tmpValue043d19, tmpValue043d19->size() }; });
}
struct QtCore_PackedList QDir_EntryInfoList2(void* ptr, long long filters, long long sort)
{
return ({ QList<QFileInfo>* tmpValue718f78 = new QList<QFileInfo>(static_cast<QDir*>(ptr)->entryInfoList(static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort))); QtCore_PackedList { tmpValue718f78, tmpValue718f78->size() }; });
}
struct QtCore_PackedString QDir_EntryList(void* ptr, struct QtCore_PackedString nameFilters, long long filters, long long sort)
{
return ({ QByteArray* t2f8008 = new QByteArray(static_cast<QDir*>(ptr)->entryList(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort)).join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t2f8008->prepend("WHITESPACE").constData()+10), t2f8008->size()-10, t2f8008 }; });
}
struct QtCore_PackedString QDir_EntryList2(void* ptr, long long filters, long long sort)
{
return ({ QByteArray* t2244e4 = new QByteArray(static_cast<QDir*>(ptr)->entryList(static_cast<QDir::Filter>(filters), static_cast<QDir::SortFlag>(sort)).join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t2244e4->prepend("WHITESPACE").constData()+10), t2244e4->size()-10, t2244e4 }; });
}
char QDir_Exists(void* ptr, struct QtCore_PackedString name)
{
return static_cast<QDir*>(ptr)->exists(QString::fromUtf8(name.data, name.len));
}
char QDir_Exists2(void* ptr)
{
return static_cast<QDir*>(ptr)->exists();
}
struct QtCore_PackedString QDir_FilePath(void* ptr, struct QtCore_PackedString fileName)
{
return ({ QByteArray* te35159 = new QByteArray(static_cast<QDir*>(ptr)->filePath(QString::fromUtf8(fileName.data, fileName.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(te35159->prepend("WHITESPACE").constData()+10), te35159->size()-10, te35159 }; });
}
long long QDir_Filter(void* ptr)
{
return static_cast<QDir*>(ptr)->filter();
}
struct QtCore_PackedString QDir_QDir_FromNativeSeparators(struct QtCore_PackedString pathName)
{
return ({ QByteArray* tb29b44 = new QByteArray(QDir::fromNativeSeparators(QString::fromUtf8(pathName.data, pathName.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(tb29b44->prepend("WHITESPACE").constData()+10), tb29b44->size()-10, tb29b44 }; });
}
void* QDir_QDir_Home()
{
return new QDir(QDir::home());
}
struct QtCore_PackedString QDir_QDir_HomePath()
{
return ({ QByteArray* t93fee6 = new QByteArray(QDir::homePath().toUtf8()); QtCore_PackedString { const_cast<char*>(t93fee6->prepend("WHITESPACE").constData()+10), t93fee6->size()-10, t93fee6 }; });
}
char QDir_IsAbsolute(void* ptr)
{
return static_cast<QDir*>(ptr)->isAbsolute();
}
char QDir_QDir_IsAbsolutePath(struct QtCore_PackedString path)
{
return QDir::isAbsolutePath(QString::fromUtf8(path.data, path.len));
}
char QDir_IsEmpty(void* ptr, long long filters)
{
return static_cast<QDir*>(ptr)->isEmpty(static_cast<QDir::Filter>(filters));
}
char QDir_IsReadable(void* ptr)
{
return static_cast<QDir*>(ptr)->isReadable();
}
char QDir_IsRelative(void* ptr)
{
return static_cast<QDir*>(ptr)->isRelative();
}
char QDir_QDir_IsRelativePath(struct QtCore_PackedString path)
{
return QDir::isRelativePath(QString::fromUtf8(path.data, path.len));
}
char QDir_IsRoot(void* ptr)
{
return static_cast<QDir*>(ptr)->isRoot();
}
void* QDir_QDir_ListSeparator()
{
return new QChar(QDir::listSeparator());
}
char QDir_MakeAbsolute(void* ptr)
{
return static_cast<QDir*>(ptr)->makeAbsolute();
}
char QDir_QDir_Match(struct QtCore_PackedString filter, struct QtCore_PackedString fileName)
{
return QDir::match(QString::fromUtf8(filter.data, filter.len), QString::fromUtf8(fileName.data, fileName.len));
}
char QDir_QDir_Match2(struct QtCore_PackedString filters, struct QtCore_PackedString fileName)
{
return QDir::match(QString::fromUtf8(filters.data, filters.len).split("¡¦!", QString::SkipEmptyParts), QString::fromUtf8(fileName.data, fileName.len));
}
char QDir_Mkdir(void* ptr, struct QtCore_PackedString dirName)
{
return static_cast<QDir*>(ptr)->mkdir(QString::fromUtf8(dirName.data, dirName.len));
}
char QDir_Mkpath(void* ptr, struct QtCore_PackedString dirPath)
{
return static_cast<QDir*>(ptr)->mkpath(QString::fromUtf8(dirPath.data, dirPath.len));
}
struct QtCore_PackedString QDir_NameFilters(void* ptr)
{
return ({ QByteArray* t429f9f = new QByteArray(static_cast<QDir*>(ptr)->nameFilters().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t429f9f->prepend("WHITESPACE").constData()+10), t429f9f->size()-10, t429f9f }; });
}
struct QtCore_PackedString QDir_Path(void* ptr)
{
return ({ QByteArray* t1e0939 = new QByteArray(static_cast<QDir*>(ptr)->path().toUtf8()); QtCore_PackedString { const_cast<char*>(t1e0939->prepend("WHITESPACE").constData()+10), t1e0939->size()-10, t1e0939 }; });
}
void QDir_Refresh(void* ptr)
{
static_cast<QDir*>(ptr)->refresh();
}
struct QtCore_PackedString QDir_RelativeFilePath(void* ptr, struct QtCore_PackedString fileName)
{
return ({ QByteArray* t5e18c2 = new QByteArray(static_cast<QDir*>(ptr)->relativeFilePath(QString::fromUtf8(fileName.data, fileName.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t5e18c2->prepend("WHITESPACE").constData()+10), t5e18c2->size()-10, t5e18c2 }; });
}
char QDir_Remove(void* ptr, struct QtCore_PackedString fileName)
{
return static_cast<QDir*>(ptr)->remove(QString::fromUtf8(fileName.data, fileName.len));
}
char QDir_RemoveRecursively(void* ptr)
{
return static_cast<QDir*>(ptr)->removeRecursively();
}
char QDir_Rename(void* ptr, struct QtCore_PackedString oldName, struct QtCore_PackedString newName)
{
return static_cast<QDir*>(ptr)->rename(QString::fromUtf8(oldName.data, oldName.len), QString::fromUtf8(newName.data, newName.len));
}
char QDir_Rmdir(void* ptr, struct QtCore_PackedString dirName)
{
return static_cast<QDir*>(ptr)->rmdir(QString::fromUtf8(dirName.data, dirName.len));
}
char QDir_Rmpath(void* ptr, struct QtCore_PackedString dirPath)
{
return static_cast<QDir*>(ptr)->rmpath(QString::fromUtf8(dirPath.data, dirPath.len));
}
void* QDir_QDir_Root()
{
return new QDir(QDir::root());
}
struct QtCore_PackedString QDir_QDir_RootPath()
{
return ({ QByteArray* tc8c07d = new QByteArray(QDir::rootPath().toUtf8()); QtCore_PackedString { const_cast<char*>(tc8c07d->prepend("WHITESPACE").constData()+10), tc8c07d->size()-10, tc8c07d }; });
}
struct QtCore_PackedString QDir_QDir_SearchPaths(struct QtCore_PackedString prefix)
{
return ({ QByteArray* t5d6556 = new QByteArray(QDir::searchPaths(QString::fromUtf8(prefix.data, prefix.len)).join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t5d6556->prepend("WHITESPACE").constData()+10), t5d6556->size()-10, t5d6556 }; });
}
void* QDir_QDir_Separator()
{
return new QChar(QDir::separator());
}
char QDir_QDir_SetCurrent(struct QtCore_PackedString path)
{
return QDir::setCurrent(QString::fromUtf8(path.data, path.len));
}
void QDir_SetFilter(void* ptr, long long filters)
{
static_cast<QDir*>(ptr)->setFilter(static_cast<QDir::Filter>(filters));
}
void QDir_SetNameFilters(void* ptr, struct QtCore_PackedString nameFilters)
{
static_cast<QDir*>(ptr)->setNameFilters(QString::fromUtf8(nameFilters.data, nameFilters.len).split("¡¦!", QString::SkipEmptyParts));
}
void QDir_SetPath(void* ptr, struct QtCore_PackedString path)
{
static_cast<QDir*>(ptr)->setPath(QString::fromUtf8(path.data, path.len));
}
void QDir_QDir_SetSearchPaths(struct QtCore_PackedString prefix, struct QtCore_PackedString searchPaths)
{
QDir::setSearchPaths(QString::fromUtf8(prefix.data, prefix.len), QString::fromUtf8(searchPaths.data, searchPaths.len).split("¡¦!", QString::SkipEmptyParts));
}
void QDir_SetSorting(void* ptr, long long sort)
{
static_cast<QDir*>(ptr)->setSorting(static_cast<QDir::SortFlag>(sort));
}
long long QDir_Sorting(void* ptr)
{
return static_cast<QDir*>(ptr)->sorting();
}
void QDir_Swap(void* ptr, void* other)
{
static_cast<QDir*>(ptr)->swap(*static_cast<QDir*>(other));
}
void* QDir_QDir_Temp()
{
return new QDir(QDir::temp());
}
struct QtCore_PackedString QDir_QDir_TempPath()
{
return ({ QByteArray* t677bd4 = new QByteArray(QDir::tempPath().toUtf8()); QtCore_PackedString { const_cast<char*>(t677bd4->prepend("WHITESPACE").constData()+10), t677bd4->size()-10, t677bd4 }; });
}
struct QtCore_PackedString QDir_QDir_ToNativeSeparators(struct QtCore_PackedString pathName)
{
return ({ QByteArray* tf0acff = new QByteArray(QDir::toNativeSeparators(QString::fromUtf8(pathName.data, pathName.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(tf0acff->prepend("WHITESPACE").constData()+10), tf0acff->size()-10, tf0acff }; });
}
void QDir_DestroyQDir(void* ptr)
{
static_cast<QDir*>(ptr)->~QDir();
}
void* QDir___drives_atList(void* ptr, int i)
{
return new QFileInfo(({QFileInfo tmp = static_cast<QList<QFileInfo>*>(ptr)->at(i); if (i == static_cast<QList<QFileInfo>*>(ptr)->size()-1) { static_cast<QList<QFileInfo>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QDir___drives_setList(void* ptr, void* i)
{
static_cast<QList<QFileInfo>*>(ptr)->append(*static_cast<QFileInfo*>(i));
}
void* QDir___drives_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QFileInfo>();
}
void* QDir___entryInfoList_atList(void* ptr, int i)
{
return new QFileInfo(({QFileInfo tmp = static_cast<QList<QFileInfo>*>(ptr)->at(i); if (i == static_cast<QList<QFileInfo>*>(ptr)->size()-1) { static_cast<QList<QFileInfo>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QDir___entryInfoList_setList(void* ptr, void* i)
{
static_cast<QList<QFileInfo>*>(ptr)->append(*static_cast<QFileInfo*>(i));
}
void* QDir___entryInfoList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QFileInfo>();
}
void* QDir___entryInfoList_atList2(void* ptr, int i)
{
return new QFileInfo(({QFileInfo tmp = static_cast<QList<QFileInfo>*>(ptr)->at(i); if (i == static_cast<QList<QFileInfo>*>(ptr)->size()-1) { static_cast<QList<QFileInfo>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QDir___entryInfoList_setList2(void* ptr, void* i)
{
static_cast<QList<QFileInfo>*>(ptr)->append(*static_cast<QFileInfo*>(i));
}
void* QDir___entryInfoList_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QFileInfo>();
}
class MyQDynamicPropertyChangeEvent: public QDynamicPropertyChangeEvent
{
public:
MyQDynamicPropertyChangeEvent(const QByteArray &name) : QDynamicPropertyChangeEvent(name) {QDynamicPropertyChangeEvent_QDynamicPropertyChangeEvent_QRegisterMetaType();};
};
Q_DECLARE_METATYPE(QDynamicPropertyChangeEvent*)
Q_DECLARE_METATYPE(MyQDynamicPropertyChangeEvent*)
int QDynamicPropertyChangeEvent_QDynamicPropertyChangeEvent_QRegisterMetaType(){qRegisterMetaType<QDynamicPropertyChangeEvent*>(); return qRegisterMetaType<MyQDynamicPropertyChangeEvent*>();}
void* QDynamicPropertyChangeEvent_NewQDynamicPropertyChangeEvent(void* name)
{
return new MyQDynamicPropertyChangeEvent(*static_cast<QByteArray*>(name));
}
void* QDynamicPropertyChangeEvent_PropertyName(void* ptr)
{
return new QByteArray(static_cast<QDynamicPropertyChangeEvent*>(ptr)->propertyName());
}
Q_DECLARE_METATYPE(QEasingCurve*)
void* QEasingCurve_NewQEasingCurve(long long ty)
{
return new QEasingCurve(static_cast<QEasingCurve::Type>(ty));
}
void* QEasingCurve_NewQEasingCurve2(void* other)
{
return new QEasingCurve(*static_cast<QEasingCurve*>(other));
}
void* QEasingCurve_NewQEasingCurve3(void* other)
{
return new QEasingCurve(*static_cast<QEasingCurve*>(other));
}
void QEasingCurve_AddCubicBezierSegment(void* ptr, void* c1, void* c2, void* endPoint)
{
static_cast<QEasingCurve*>(ptr)->addCubicBezierSegment(*static_cast<QPointF*>(c1), *static_cast<QPointF*>(c2), *static_cast<QPointF*>(endPoint));
}
void QEasingCurve_AddTCBSegment(void* ptr, void* nextPoint, double t, double c, double b)
{
static_cast<QEasingCurve*>(ptr)->addTCBSegment(*static_cast<QPointF*>(nextPoint), t, c, b);
}
double QEasingCurve_Amplitude(void* ptr)
{
return static_cast<QEasingCurve*>(ptr)->amplitude();
}
double QEasingCurve_Overshoot(void* ptr)
{
return static_cast<QEasingCurve*>(ptr)->overshoot();
}
double QEasingCurve_Period(void* ptr)
{
return static_cast<QEasingCurve*>(ptr)->period();
}
void QEasingCurve_SetAmplitude(void* ptr, double amplitude)
{
static_cast<QEasingCurve*>(ptr)->setAmplitude(amplitude);
}
void QEasingCurve_SetOvershoot(void* ptr, double overshoot)
{
static_cast<QEasingCurve*>(ptr)->setOvershoot(overshoot);
}
void QEasingCurve_SetPeriod(void* ptr, double period)
{
static_cast<QEasingCurve*>(ptr)->setPeriod(period);
}
void QEasingCurve_SetType(void* ptr, long long ty)
{
static_cast<QEasingCurve*>(ptr)->setType(static_cast<QEasingCurve::Type>(ty));
}
void QEasingCurve_Swap(void* ptr, void* other)
{
static_cast<QEasingCurve*>(ptr)->swap(*static_cast<QEasingCurve*>(other));
}
struct QtCore_PackedList QEasingCurve_ToCubicSpline(void* ptr)
{
return ({ QVector<QPointF>* tmpValueb4db1b = new QVector<QPointF>(static_cast<QEasingCurve*>(ptr)->toCubicSpline()); QtCore_PackedList { tmpValueb4db1b, tmpValueb4db1b->size() }; });
}
long long QEasingCurve_Type(void* ptr)
{
return static_cast<QEasingCurve*>(ptr)->type();
}
double QEasingCurve_ValueForProgress(void* ptr, double progress)
{
return static_cast<QEasingCurve*>(ptr)->valueForProgress(progress);
}
void QEasingCurve_DestroyQEasingCurve(void* ptr)
{
static_cast<QEasingCurve*>(ptr)->~QEasingCurve();
}
void* QEasingCurve___cubicBezierSpline_atList(void* ptr, int i)
{
return ({ QPointF tmpValue = ({QPointF tmp = static_cast<QList<QPointF>*>(ptr)->at(i); if (i == static_cast<QList<QPointF>*>(ptr)->size()-1) { static_cast<QList<QPointF>*>(ptr)->~QList(); free(ptr); }; tmp; }); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QEasingCurve___cubicBezierSpline_setList(void* ptr, void* i)
{
static_cast<QList<QPointF>*>(ptr)->append(*static_cast<QPointF*>(i));
}
void* QEasingCurve___cubicBezierSpline_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QPointF>();
}
void* QEasingCurve___toCubicSpline_atList(void* ptr, int i)
{
return ({ QPointF tmpValue = ({QPointF tmp = static_cast<QVector<QPointF>*>(ptr)->at(i); if (i == static_cast<QVector<QPointF>*>(ptr)->size()-1) { static_cast<QVector<QPointF>*>(ptr)->~QVector(); free(ptr); }; tmp; }); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QEasingCurve___toCubicSpline_setList(void* ptr, void* i)
{
static_cast<QVector<QPointF>*>(ptr)->append(*static_cast<QPointF*>(i));
}
void* QEasingCurve___toCubicSpline_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QPointF>();
}
Q_DECLARE_METATYPE(QElapsedTimer)
Q_DECLARE_METATYPE(QElapsedTimer*)
void* QElapsedTimer_NewQElapsedTimer()
{
return new QElapsedTimer();
}
long long QElapsedTimer_QElapsedTimer_ClockType()
{
return QElapsedTimer::clockType();
}
long long QElapsedTimer_Elapsed(void* ptr)
{
return static_cast<QElapsedTimer*>(ptr)->elapsed();
}
char QElapsedTimer_HasExpired(void* ptr, long long timeout)
{
return static_cast<QElapsedTimer*>(ptr)->hasExpired(timeout);
}
void QElapsedTimer_Invalidate(void* ptr)
{
static_cast<QElapsedTimer*>(ptr)->invalidate();
}
char QElapsedTimer_QElapsedTimer_IsMonotonic()
{
return QElapsedTimer::isMonotonic();
}
char QElapsedTimer_IsValid(void* ptr)
{
return static_cast<QElapsedTimer*>(ptr)->isValid();
}
long long QElapsedTimer_MsecsSinceReference(void* ptr)
{
return static_cast<QElapsedTimer*>(ptr)->msecsSinceReference();
}
long long QElapsedTimer_MsecsTo(void* ptr, void* other)
{
return static_cast<QElapsedTimer*>(ptr)->msecsTo(*static_cast<QElapsedTimer*>(other));
}
long long QElapsedTimer_NsecsElapsed(void* ptr)
{
return static_cast<QElapsedTimer*>(ptr)->nsecsElapsed();
}
long long QElapsedTimer_Restart(void* ptr)
{
return static_cast<QElapsedTimer*>(ptr)->restart();
}
long long QElapsedTimer_SecsTo(void* ptr, void* other)
{
return static_cast<QElapsedTimer*>(ptr)->secsTo(*static_cast<QElapsedTimer*>(other));
}
void QElapsedTimer_Start(void* ptr)
{
static_cast<QElapsedTimer*>(ptr)->start();
}
class MyQEvent: public QEvent
{
public:
MyQEvent(QEvent::Type ty) : QEvent(ty) {QEvent_QEvent_QRegisterMetaType();};
~MyQEvent() { callbackQEvent_DestroyQEvent(this); };
};
Q_DECLARE_METATYPE(QEvent*)
Q_DECLARE_METATYPE(MyQEvent*)
int QEvent_QEvent_QRegisterMetaType(){qRegisterMetaType<QEvent*>(); return qRegisterMetaType<MyQEvent*>();}
void* QEvent_NewQEvent(long long ty)
{
return new MyQEvent(static_cast<QEvent::Type>(ty));
}
void QEvent_Accept(void* ptr)
{
static_cast<QEvent*>(ptr)->accept();
}
void QEvent_Ignore(void* ptr)
{
static_cast<QEvent*>(ptr)->ignore();
}
char QEvent_IsAccepted(void* ptr)
{
return static_cast<QEvent*>(ptr)->isAccepted();
}
int QEvent_QEvent_RegisterEventType(int hint)
{
return QEvent::registerEventType(hint);
}
void QEvent_SetAccepted(void* ptr, char accepted)
{
static_cast<QEvent*>(ptr)->setAccepted(accepted != 0);
}
char QEvent_Spontaneous(void* ptr)
{
return static_cast<QEvent*>(ptr)->spontaneous();
}
long long QEvent_Type(void* ptr)
{
return static_cast<QEvent*>(ptr)->type();
}
void QEvent_DestroyQEvent(void* ptr)
{
static_cast<QEvent*>(ptr)->~QEvent();
}
void QEvent_DestroyQEventDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQEventLoop: public QEventLoop
{
public:
MyQEventLoop(QObject *parent = Q_NULLPTR) : QEventLoop(parent) {QEventLoop_QEventLoop_QRegisterMetaType();};
bool event(QEvent * event) { return callbackQObject_Event(this, event) != 0; };
void quit() { callbackQEventLoop_Quit(this); };
~MyQEventLoop() { callbackQEventLoop_DestroyQEventLoop(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QEventLoop*)
Q_DECLARE_METATYPE(MyQEventLoop*)
int QEventLoop_QEventLoop_QRegisterMetaType(){qRegisterMetaType<QEventLoop*>(); return qRegisterMetaType<MyQEventLoop*>();}
void* QEventLoop_NewQEventLoop(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQEventLoop(static_cast<QWindow*>(parent));
} else {
return new MyQEventLoop(static_cast<QObject*>(parent));
}
}
int QEventLoop_Exec(void* ptr, long long flags)
{
return static_cast<QEventLoop*>(ptr)->exec(static_cast<QEventLoop::ProcessEventsFlag>(flags));
}
void QEventLoop_Exit(void* ptr, int returnCode)
{
static_cast<QEventLoop*>(ptr)->exit(returnCode);
}
char QEventLoop_IsRunning(void* ptr)
{
return static_cast<QEventLoop*>(ptr)->isRunning();
}
char QEventLoop_ProcessEvents(void* ptr, long long flags)
{
return static_cast<QEventLoop*>(ptr)->processEvents(static_cast<QEventLoop::ProcessEventsFlag>(flags));
}
void QEventLoop_ProcessEvents2(void* ptr, long long flags, int maxTime)
{
static_cast<QEventLoop*>(ptr)->processEvents(static_cast<QEventLoop::ProcessEventsFlag>(flags), maxTime);
}
void QEventLoop_Quit(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QEventLoop*>(ptr), "quit");
}
void QEventLoop_QuitDefault(void* ptr)
{
static_cast<QEventLoop*>(ptr)->QEventLoop::quit();
}
void QEventLoop_WakeUp(void* ptr)
{
static_cast<QEventLoop*>(ptr)->wakeUp();
}
void QEventLoop_DestroyQEventLoop(void* ptr)
{
static_cast<QEventLoop*>(ptr)->~QEventLoop();
}
void QEventLoop_DestroyQEventLoopDefault(void* ptr)
{
Q_UNUSED(ptr);
}
Q_DECLARE_METATYPE(QEventLoopLocker*)
void* QEventLoopLocker_NewQEventLoopLocker()
{
return new QEventLoopLocker();
}
void* QEventLoopLocker_NewQEventLoopLocker2(void* loop)
{
return new QEventLoopLocker(static_cast<QEventLoop*>(loop));
}
void* QEventLoopLocker_NewQEventLoopLocker3(void* thread)
{
return new QEventLoopLocker(static_cast<QThread*>(thread));
}
void QEventLoopLocker_DestroyQEventLoopLocker(void* ptr)
{
static_cast<QEventLoopLocker*>(ptr)->~QEventLoopLocker();
}
class MyQEventTransition: public QEventTransition
{
public:
MyQEventTransition(QState *sourceState = Q_NULLPTR) : QEventTransition(sourceState) {QEventTransition_QEventTransition_QRegisterMetaType();};
MyQEventTransition(QObject *object, QEvent::Type ty, QState *sourceState = Q_NULLPTR) : QEventTransition(object, ty, sourceState) {QEventTransition_QEventTransition_QRegisterMetaType();};
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventTest(QEvent * event) { return callbackQEventTransition_EventTest(this, event) != 0; };
void onTransition(QEvent * event) { callbackQEventTransition_OnTransition(this, event); };
~MyQEventTransition() { callbackQEventTransition_DestroyQEventTransition(this); };
void Signal_TargetStateChanged() { callbackQAbstractTransition_TargetStateChanged(this); };
void Signal_TargetStatesChanged() { callbackQAbstractTransition_TargetStatesChanged(this); };
void Signal_Triggered() { callbackQAbstractTransition_Triggered(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QEventTransition*)
Q_DECLARE_METATYPE(MyQEventTransition*)
int QEventTransition_QEventTransition_QRegisterMetaType(){qRegisterMetaType<QEventTransition*>(); return qRegisterMetaType<MyQEventTransition*>();}
void* QEventTransition_NewQEventTransition(void* sourceState)
{
return new MyQEventTransition(static_cast<QState*>(sourceState));
}
void* QEventTransition_NewQEventTransition2(void* object, long long ty, void* sourceState)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QAudioSystemPlugin*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QCameraImageCapture*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QDBusPendingCallWatcher*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QExtensionFactory*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QExtensionManager*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QGraphicsObject*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QGraphicsWidget*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QLayout*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QMediaPlaylist*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QMediaRecorder*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QMediaServiceProviderPlugin*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QOffscreenSurface*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QPaintDeviceWindow*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QPdfWriter*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QQuickItem*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QRadioData*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QRemoteObjectPendingCallWatcher*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QScriptExtensionPlugin*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QWidget*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
return new MyQEventTransition(static_cast<QWindow*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
} else {
return new MyQEventTransition(static_cast<QObject*>(object), static_cast<QEvent::Type>(ty), static_cast<QState*>(sourceState));
}
}
void* QEventTransition_EventSource(void* ptr)
{
return static_cast<QEventTransition*>(ptr)->eventSource();
}
char QEventTransition_EventTest(void* ptr, void* event)
{
return static_cast<QEventTransition*>(ptr)->eventTest(static_cast<QEvent*>(event));
}
char QEventTransition_EventTestDefault(void* ptr, void* event)
{
return static_cast<QEventTransition*>(ptr)->QEventTransition::eventTest(static_cast<QEvent*>(event));
}
long long QEventTransition_EventType(void* ptr)
{
return static_cast<QEventTransition*>(ptr)->eventType();
}
void QEventTransition_OnTransition(void* ptr, void* event)
{
static_cast<QEventTransition*>(ptr)->onTransition(static_cast<QEvent*>(event));
}
void QEventTransition_OnTransitionDefault(void* ptr, void* event)
{
static_cast<QEventTransition*>(ptr)->QEventTransition::onTransition(static_cast<QEvent*>(event));
}
void QEventTransition_SetEventSource(void* ptr, void* object)
{
static_cast<QEventTransition*>(ptr)->setEventSource(static_cast<QObject*>(object));
}
void QEventTransition_SetEventType(void* ptr, long long ty)
{
static_cast<QEventTransition*>(ptr)->setEventType(static_cast<QEvent::Type>(ty));
}
void QEventTransition_DestroyQEventTransition(void* ptr)
{
static_cast<QEventTransition*>(ptr)->~QEventTransition();
}
void QEventTransition_DestroyQEventTransitionDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQFile: public QFile
{
public:
MyQFile() : QFile() {QFile_QFile_QRegisterMetaType();};
MyQFile(const QString &name) : QFile(name) {QFile_QFile_QRegisterMetaType();};
MyQFile(QObject *parent) : QFile(parent) {QFile_QFile_QRegisterMetaType();};
MyQFile(const QString &name, QObject *parent) : QFile(name, parent) {QFile_QFile_QRegisterMetaType();};
QString fileName() const { return ({ QtCore_PackedString tempVal = callbackQFileDevice_FileName(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
bool open(QIODevice::OpenMode mode) { return callbackQIODevice_Open(this, mode) != 0; };
QFileDevice::Permissions permissions() const { return static_cast<QFileDevice::Permission>(callbackQFileDevice_Permissions(const_cast<void*>(static_cast<const void*>(this)))); };
bool resize(qint64 sz) { return callbackQFileDevice_Resize(this, sz) != 0; };
bool setPermissions(QFileDevice::Permissions permissions) { return callbackQFileDevice_SetPermissions(this, permissions) != 0; };
qint64 size() const { return callbackQIODevice_Size(const_cast<void*>(static_cast<const void*>(this))); };
~MyQFile() { callbackQFile_DestroyQFile(this); };
bool atEnd() const { return callbackQIODevice_AtEnd(const_cast<void*>(static_cast<const void*>(this))) != 0; };
void close() { callbackQIODevice_Close(this); };
bool isSequential() const { return callbackQIODevice_IsSequential(const_cast<void*>(static_cast<const void*>(this))) != 0; };
qint64 pos() const { return callbackQIODevice_Pos(const_cast<void*>(static_cast<const void*>(this))); };
qint64 readData(char * data, qint64 l) { QtCore_PackedString dataPacked = { data, l, NULL };return callbackQFileDevice_ReadData(this, dataPacked, l); };
qint64 readLineData(char * data, qint64 maxlen) { QtCore_PackedString dataPacked = { data, maxlen, NULL };return callbackQIODevice_ReadLineData(this, dataPacked, maxlen); };
bool seek(qint64 pos) { return callbackQIODevice_Seek(this, pos) != 0; };
qint64 writeData(const char * data, qint64 l) { QtCore_PackedString dataPacked = { const_cast<char*>(data), l, NULL };return callbackQFileDevice_WriteData(this, dataPacked, l); };
void Signal_AboutToClose() { callbackQIODevice_AboutToClose(this); };
qint64 bytesAvailable() const { return callbackQIODevice_BytesAvailable(const_cast<void*>(static_cast<const void*>(this))); };
qint64 bytesToWrite() const { return callbackQIODevice_BytesToWrite(const_cast<void*>(static_cast<const void*>(this))); };
void Signal_BytesWritten(qint64 bytes) { callbackQIODevice_BytesWritten(this, bytes); };
bool canReadLine() const { return callbackQIODevice_CanReadLine(const_cast<void*>(static_cast<const void*>(this))) != 0; };
void Signal_ChannelBytesWritten(int channel, qint64 bytes) { callbackQIODevice_ChannelBytesWritten(this, channel, bytes); };
void Signal_ChannelReadyRead(int channel) { callbackQIODevice_ChannelReadyRead(this, channel); };
void Signal_ReadChannelFinished() { callbackQIODevice_ReadChannelFinished(this); };
void Signal_ReadyRead() { callbackQIODevice_ReadyRead(this); };
bool reset() { return callbackQIODevice_Reset(this) != 0; };
bool waitForBytesWritten(int msecs) { return callbackQIODevice_WaitForBytesWritten(this, msecs) != 0; };
bool waitForReadyRead(int msecs) { return callbackQIODevice_WaitForReadyRead(this, msecs) != 0; };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QFile*)
Q_DECLARE_METATYPE(MyQFile*)
int QFile_QFile_QRegisterMetaType(){qRegisterMetaType<QFile*>(); return qRegisterMetaType<MyQFile*>();}
void* QFile_NewQFile()
{
return new MyQFile();
}
void* QFile_NewQFile2(struct QtCore_PackedString name)
{
return new MyQFile(QString::fromUtf8(name.data, name.len));
}
void* QFile_NewQFile3(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQFile(static_cast<QWindow*>(parent));
} else {
return new MyQFile(static_cast<QObject*>(parent));
}
}
void* QFile_NewQFile4(struct QtCore_PackedString name, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QWindow*>(parent));
} else {
return new MyQFile(QString::fromUtf8(name.data, name.len), static_cast<QObject*>(parent));
}
}
char QFile_Copy(void* ptr, struct QtCore_PackedString newName)
{
return static_cast<QFile*>(ptr)->copy(QString::fromUtf8(newName.data, newName.len));
}
char QFile_QFile_Copy2(struct QtCore_PackedString fileName, struct QtCore_PackedString newName)
{
return QFile::copy(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(newName.data, newName.len));
}
struct QtCore_PackedString QFile_QFile_DecodeName(void* localFileName)
{
return ({ QByteArray* t6223ce = new QByteArray(QFile::decodeName(*static_cast<QByteArray*>(localFileName)).toUtf8()); QtCore_PackedString { const_cast<char*>(t6223ce->prepend("WHITESPACE").constData()+10), t6223ce->size()-10, t6223ce }; });
}
struct QtCore_PackedString QFile_QFile_DecodeName2(char* localFileName)
{
return ({ QByteArray* t699d57 = new QByteArray(QFile::decodeName(const_cast<const char*>(localFileName)).toUtf8()); QtCore_PackedString { const_cast<char*>(t699d57->prepend("WHITESPACE").constData()+10), t699d57->size()-10, t699d57 }; });
}
void* QFile_QFile_EncodeName(struct QtCore_PackedString fileName)
{
return new QByteArray(QFile::encodeName(QString::fromUtf8(fileName.data, fileName.len)));
}
char QFile_QFile_Exists(struct QtCore_PackedString fileName)
{
return QFile::exists(QString::fromUtf8(fileName.data, fileName.len));
}
char QFile_Exists2(void* ptr)
{
return static_cast<QFile*>(ptr)->exists();
}
char QFile_Link(void* ptr, struct QtCore_PackedString linkName)
{
return static_cast<QFile*>(ptr)->link(QString::fromUtf8(linkName.data, linkName.len));
}
char QFile_QFile_Link2(struct QtCore_PackedString fileName, struct QtCore_PackedString linkName)
{
return QFile::link(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(linkName.data, linkName.len));
}
char QFile_Open3(void* ptr, int fd, long long mode, long long handleFlags)
{
return static_cast<QFile*>(ptr)->open(fd, static_cast<QIODevice::OpenModeFlag>(mode), static_cast<QFileDevice::FileHandleFlag>(handleFlags));
}
long long QFile_QFile_Permissions2(struct QtCore_PackedString fileName)
{
return QFile::permissions(QString::fromUtf8(fileName.data, fileName.len));
}
char QFile_Remove(void* ptr)
{
return static_cast<QFile*>(ptr)->remove();
}
char QFile_QFile_Remove2(struct QtCore_PackedString fileName)
{
return QFile::remove(QString::fromUtf8(fileName.data, fileName.len));
}
char QFile_Rename(void* ptr, struct QtCore_PackedString newName)
{
return static_cast<QFile*>(ptr)->rename(QString::fromUtf8(newName.data, newName.len));
}
char QFile_QFile_Rename2(struct QtCore_PackedString oldName, struct QtCore_PackedString newName)
{
return QFile::rename(QString::fromUtf8(oldName.data, oldName.len), QString::fromUtf8(newName.data, newName.len));
}
char QFile_QFile_Resize2(struct QtCore_PackedString fileName, long long sz)
{
return QFile::resize(QString::fromUtf8(fileName.data, fileName.len), sz);
}
void QFile_SetFileName(void* ptr, struct QtCore_PackedString name)
{
static_cast<QFile*>(ptr)->setFileName(QString::fromUtf8(name.data, name.len));
}
char QFile_QFile_SetPermissions2(struct QtCore_PackedString fileName, long long permissions)
{
return QFile::setPermissions(QString::fromUtf8(fileName.data, fileName.len), static_cast<QFileDevice::Permission>(permissions));
}
struct QtCore_PackedString QFile_QFile_SymLinkTarget(struct QtCore_PackedString fileName)
{
return ({ QByteArray* t53c74a = new QByteArray(QFile::symLinkTarget(QString::fromUtf8(fileName.data, fileName.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t53c74a->prepend("WHITESPACE").constData()+10), t53c74a->size()-10, t53c74a }; });
}
struct QtCore_PackedString QFile_SymLinkTarget2(void* ptr)
{
return ({ QByteArray* tfaa232 = new QByteArray(static_cast<QFile*>(ptr)->symLinkTarget().toUtf8()); QtCore_PackedString { const_cast<char*>(tfaa232->prepend("WHITESPACE").constData()+10), tfaa232->size()-10, tfaa232 }; });
}
void QFile_DestroyQFile(void* ptr)
{
static_cast<QFile*>(ptr)->~QFile();
}
void QFile_DestroyQFileDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQFileDevice: public QFileDevice
{
public:
bool atEnd() const { return callbackQIODevice_AtEnd(const_cast<void*>(static_cast<const void*>(this))) != 0; };
void close() { callbackQIODevice_Close(this); };
QString fileName() const { return ({ QtCore_PackedString tempVal = callbackQFileDevice_FileName(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
bool isSequential() const { return callbackQIODevice_IsSequential(const_cast<void*>(static_cast<const void*>(this))) != 0; };
QFileDevice::Permissions permissions() const { return static_cast<QFileDevice::Permission>(callbackQFileDevice_Permissions(const_cast<void*>(static_cast<const void*>(this)))); };
qint64 pos() const { return callbackQIODevice_Pos(const_cast<void*>(static_cast<const void*>(this))); };
qint64 readData(char * data, qint64 l) { QtCore_PackedString dataPacked = { data, l, NULL };return callbackQFileDevice_ReadData(this, dataPacked, l); };
qint64 readLineData(char * data, qint64 maxlen) { QtCore_PackedString dataPacked = { data, maxlen, NULL };return callbackQIODevice_ReadLineData(this, dataPacked, maxlen); };
bool resize(qint64 sz) { return callbackQFileDevice_Resize(this, sz) != 0; };
bool seek(qint64 pos) { return callbackQIODevice_Seek(this, pos) != 0; };
bool setPermissions(QFileDevice::Permissions permissions) { return callbackQFileDevice_SetPermissions(this, permissions) != 0; };
qint64 size() const { return callbackQIODevice_Size(const_cast<void*>(static_cast<const void*>(this))); };
qint64 writeData(const char * data, qint64 l) { QtCore_PackedString dataPacked = { const_cast<char*>(data), l, NULL };return callbackQFileDevice_WriteData(this, dataPacked, l); };
~MyQFileDevice() { callbackQFileDevice_DestroyQFileDevice(this); };
void Signal_AboutToClose() { callbackQIODevice_AboutToClose(this); };
qint64 bytesAvailable() const { return callbackQIODevice_BytesAvailable(const_cast<void*>(static_cast<const void*>(this))); };
qint64 bytesToWrite() const { return callbackQIODevice_BytesToWrite(const_cast<void*>(static_cast<const void*>(this))); };
void Signal_BytesWritten(qint64 bytes) { callbackQIODevice_BytesWritten(this, bytes); };
bool canReadLine() const { return callbackQIODevice_CanReadLine(const_cast<void*>(static_cast<const void*>(this))) != 0; };
void Signal_ChannelBytesWritten(int channel, qint64 bytes) { callbackQIODevice_ChannelBytesWritten(this, channel, bytes); };
void Signal_ChannelReadyRead(int channel) { callbackQIODevice_ChannelReadyRead(this, channel); };
bool open(QIODevice::OpenMode mode) { return callbackQIODevice_Open(this, mode) != 0; };
void Signal_ReadChannelFinished() { callbackQIODevice_ReadChannelFinished(this); };
void Signal_ReadyRead() { callbackQIODevice_ReadyRead(this); };
bool reset() { return callbackQIODevice_Reset(this) != 0; };
bool waitForBytesWritten(int msecs) { return callbackQIODevice_WaitForBytesWritten(this, msecs) != 0; };
bool waitForReadyRead(int msecs) { return callbackQIODevice_WaitForReadyRead(this, msecs) != 0; };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QFileDevice*)
Q_DECLARE_METATYPE(MyQFileDevice*)
int QFileDevice_QFileDevice_QRegisterMetaType(){qRegisterMetaType<QFileDevice*>(); return qRegisterMetaType<MyQFileDevice*>();}
long long QFileDevice_Error(void* ptr)
{
return static_cast<QFileDevice*>(ptr)->error();
}
struct QtCore_PackedString QFileDevice_FileName(void* ptr)
{
return ({ QByteArray* t4e2118 = new QByteArray(static_cast<QFileDevice*>(ptr)->fileName().toUtf8()); QtCore_PackedString { const_cast<char*>(t4e2118->prepend("WHITESPACE").constData()+10), t4e2118->size()-10, t4e2118 }; });
}
struct QtCore_PackedString QFileDevice_FileNameDefault(void* ptr)
{
if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return ({ QByteArray* tb198ab = new QByteArray(static_cast<QSaveFile*>(ptr)->QSaveFile::fileName().toUtf8()); QtCore_PackedString { const_cast<char*>(tb198ab->prepend("WHITESPACE").constData()+10), tb198ab->size()-10, tb198ab }; });
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return ({ QByteArray* tb198ab = new QByteArray(static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::fileName().toUtf8()); QtCore_PackedString { const_cast<char*>(tb198ab->prepend("WHITESPACE").constData()+10), tb198ab->size()-10, tb198ab }; });
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return ({ QByteArray* tb198ab = new QByteArray(static_cast<QFile*>(ptr)->QFile::fileName().toUtf8()); QtCore_PackedString { const_cast<char*>(tb198ab->prepend("WHITESPACE").constData()+10), tb198ab->size()-10, tb198ab }; });
} else {
return ({ QByteArray* tb198ab = new QByteArray(static_cast<QFileDevice*>(ptr)->QFileDevice::fileName().toUtf8()); QtCore_PackedString { const_cast<char*>(tb198ab->prepend("WHITESPACE").constData()+10), tb198ab->size()-10, tb198ab }; });
}
}
void* QFileDevice_FileTime(void* ptr, long long ti)
{
return new QDateTime(static_cast<QFileDevice*>(ptr)->fileTime(static_cast<QFileDevice::FileTime>(ti)));
}
char QFileDevice_Flush(void* ptr)
{
return static_cast<QFileDevice*>(ptr)->flush();
}
int QFileDevice_Handle(void* ptr)
{
return static_cast<QFileDevice*>(ptr)->handle();
}
struct QtCore_PackedString QFileDevice_Map(void* ptr, long long offset, long long size, long long flags)
{
return ({ char* t4b412c = static_cast<char*>(static_cast<void*>(static_cast<QFileDevice*>(ptr)->map(offset, size, static_cast<QFileDevice::MemoryMapFlags>(flags)))); QtCore_PackedString { t4b412c, -1, NULL }; });
}
long long QFileDevice_Permissions(void* ptr)
{
return static_cast<QFileDevice*>(ptr)->permissions();
}
long long QFileDevice_PermissionsDefault(void* ptr)
{
if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::permissions();
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::permissions();
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::permissions();
} else {
return static_cast<QFileDevice*>(ptr)->QFileDevice::permissions();
}
}
long long QFileDevice_ReadData(void* ptr, char* data, long long l)
{
return static_cast<QFileDevice*>(ptr)->readData(data, l);
}
long long QFileDevice_ReadDataDefault(void* ptr, char* data, long long l)
{
if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::readData(data, l);
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::readData(data, l);
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::readData(data, l);
} else {
return static_cast<QFileDevice*>(ptr)->QFileDevice::readData(data, l);
}
}
char QFileDevice_Resize(void* ptr, long long sz)
{
return static_cast<QFileDevice*>(ptr)->resize(sz);
}
char QFileDevice_ResizeDefault(void* ptr, long long sz)
{
if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::resize(sz);
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::resize(sz);
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::resize(sz);
} else {
return static_cast<QFileDevice*>(ptr)->QFileDevice::resize(sz);
}
}
char QFileDevice_SetFileTime(void* ptr, void* newDate, long long fileTime)
{
return static_cast<QFileDevice*>(ptr)->setFileTime(*static_cast<QDateTime*>(newDate), static_cast<QFileDevice::FileTime>(fileTime));
}
char QFileDevice_SetPermissions(void* ptr, long long permissions)
{
return static_cast<QFileDevice*>(ptr)->setPermissions(static_cast<QFileDevice::Permission>(permissions));
}
char QFileDevice_SetPermissionsDefault(void* ptr, long long permissions)
{
if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::setPermissions(static_cast<QFileDevice::Permission>(permissions));
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::setPermissions(static_cast<QFileDevice::Permission>(permissions));
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::setPermissions(static_cast<QFileDevice::Permission>(permissions));
} else {
return static_cast<QFileDevice*>(ptr)->QFileDevice::setPermissions(static_cast<QFileDevice::Permission>(permissions));
}
}
char QFileDevice_Unmap(void* ptr, char* address)
{
return static_cast<QFileDevice*>(ptr)->unmap(static_cast<uchar*>(static_cast<void*>(address)));
}
void QFileDevice_UnsetError(void* ptr)
{
static_cast<QFileDevice*>(ptr)->unsetError();
}
long long QFileDevice_WriteData(void* ptr, char* data, long long l)
{
return static_cast<QFileDevice*>(ptr)->writeData(const_cast<const char*>(data), l);
}
long long QFileDevice_WriteDataDefault(void* ptr, char* data, long long l)
{
if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::writeData(const_cast<const char*>(data), l);
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::writeData(const_cast<const char*>(data), l);
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::writeData(const_cast<const char*>(data), l);
} else {
return static_cast<QFileDevice*>(ptr)->QFileDevice::writeData(const_cast<const char*>(data), l);
}
}
void QFileDevice_DestroyQFileDevice(void* ptr)
{
static_cast<QFileDevice*>(ptr)->~QFileDevice();
}
void QFileDevice_DestroyQFileDeviceDefault(void* ptr)
{
Q_UNUSED(ptr);
}
Q_DECLARE_METATYPE(QFileInfo*)
void* QFileInfo_NewQFileInfo2()
{
return new QFileInfo();
}
void* QFileInfo_NewQFileInfo3(struct QtCore_PackedString file)
{
return new QFileInfo(QString::fromUtf8(file.data, file.len));
}
void* QFileInfo_NewQFileInfo4(void* file)
{
return new QFileInfo(*static_cast<QFile*>(file));
}
void* QFileInfo_NewQFileInfo5(void* dir, struct QtCore_PackedString file)
{
return new QFileInfo(*static_cast<QDir*>(dir), QString::fromUtf8(file.data, file.len));
}
void* QFileInfo_NewQFileInfo6(void* fileinfo)
{
return new QFileInfo(*static_cast<QFileInfo*>(fileinfo));
}
void* QFileInfo_AbsoluteDir(void* ptr)
{
return new QDir(static_cast<QFileInfo*>(ptr)->absoluteDir());
}
struct QtCore_PackedString QFileInfo_AbsoluteFilePath(void* ptr)
{
return ({ QByteArray* t97ee30 = new QByteArray(static_cast<QFileInfo*>(ptr)->absoluteFilePath().toUtf8()); QtCore_PackedString { const_cast<char*>(t97ee30->prepend("WHITESPACE").constData()+10), t97ee30->size()-10, t97ee30 }; });
}
struct QtCore_PackedString QFileInfo_AbsolutePath(void* ptr)
{
return ({ QByteArray* tcab43d = new QByteArray(static_cast<QFileInfo*>(ptr)->absolutePath().toUtf8()); QtCore_PackedString { const_cast<char*>(tcab43d->prepend("WHITESPACE").constData()+10), tcab43d->size()-10, tcab43d }; });
}
struct QtCore_PackedString QFileInfo_BaseName(void* ptr)
{
return ({ QByteArray* t02e589 = new QByteArray(static_cast<QFileInfo*>(ptr)->baseName().toUtf8()); QtCore_PackedString { const_cast<char*>(t02e589->prepend("WHITESPACE").constData()+10), t02e589->size()-10, t02e589 }; });
}
void* QFileInfo_BirthTime(void* ptr)
{
return new QDateTime(static_cast<QFileInfo*>(ptr)->birthTime());
}
struct QtCore_PackedString QFileInfo_BundleName(void* ptr)
{
return ({ QByteArray* tab958d = new QByteArray(static_cast<QFileInfo*>(ptr)->bundleName().toUtf8()); QtCore_PackedString { const_cast<char*>(tab958d->prepend("WHITESPACE").constData()+10), tab958d->size()-10, tab958d }; });
}
char QFileInfo_Caching(void* ptr)
{
return static_cast<QFileInfo*>(ptr)->caching();
}
struct QtCore_PackedString QFileInfo_CanonicalFilePath(void* ptr)
{
return ({ QByteArray* teeef69 = new QByteArray(static_cast<QFileInfo*>(ptr)->canonicalFilePath().toUtf8()); QtCore_PackedString { const_cast<char*>(teeef69->prepend("WHITESPACE").constData()+10), teeef69->size()-10, teeef69 }; });
}
struct QtCore_PackedString QFileInfo_CanonicalPath(void* ptr)
{
return ({ QByteArray* t32e17a = new QByteArray(static_cast<QFileInfo*>(ptr)->canonicalPath().toUtf8()); QtCore_PackedString { const_cast<char*>(t32e17a->prepend("WHITESPACE").constData()+10), t32e17a->size()-10, t32e17a }; });
}
struct QtCore_PackedString QFileInfo_CompleteBaseName(void* ptr)
{
return ({ QByteArray* t3f5264 = new QByteArray(static_cast<QFileInfo*>(ptr)->completeBaseName().toUtf8()); QtCore_PackedString { const_cast<char*>(t3f5264->prepend("WHITESPACE").constData()+10), t3f5264->size()-10, t3f5264 }; });
}
struct QtCore_PackedString QFileInfo_CompleteSuffix(void* ptr)
{
return ({ QByteArray* t780837 = new QByteArray(static_cast<QFileInfo*>(ptr)->completeSuffix().toUtf8()); QtCore_PackedString { const_cast<char*>(t780837->prepend("WHITESPACE").constData()+10), t780837->size()-10, t780837 }; });
}
void* QFileInfo_Dir(void* ptr)
{
return new QDir(static_cast<QFileInfo*>(ptr)->dir());
}
char QFileInfo_Exists(void* ptr)
{
return static_cast<QFileInfo*>(ptr)->exists();
}
char QFileInfo_QFileInfo_Exists2(struct QtCore_PackedString file)
{
return QFileInfo::exists(QString::fromUtf8(file.data, file.len));
}
struct QtCore_PackedString QFileInfo_FileName(void* ptr)
{
return ({ QByteArray* t8cf8a1 = new QByteArray(static_cast<QFileInfo*>(ptr)->fileName().toUtf8()); QtCore_PackedString { const_cast<char*>(t8cf8a1->prepend("WHITESPACE").constData()+10), t8cf8a1->size()-10, t8cf8a1 }; });
}
struct QtCore_PackedString QFileInfo_FilePath(void* ptr)
{
return ({ QByteArray* tc6ca11 = new QByteArray(static_cast<QFileInfo*>(ptr)->filePath().toUtf8()); QtCore_PackedString { const_cast<char*>(tc6ca11->prepend("WHITESPACE").constData()+10), tc6ca11->size()-10, tc6ca11 }; });
}
struct QtCore_PackedString QFileInfo_Group(void* ptr)
{
return ({ QByteArray* ta89964 = new QByteArray(static_cast<QFileInfo*>(ptr)->group().toUtf8()); QtCore_PackedString { const_cast<char*>(ta89964->prepend("WHITESPACE").constData()+10), ta89964->size()-10, ta89964 }; });
}
unsigned int QFileInfo_GroupId(void* ptr)
{
return static_cast<QFileInfo*>(ptr)->groupId();
}
char QFileInfo_IsAbsolute(void* ptr)
{
return static_cast<QFileInfo*>(ptr)->isAbsolute();
}
char QFileInfo_IsBundle(void* ptr)
{
return static_cast<QFileInfo*>(ptr)->isBundle();
}
char QFileInfo_IsDir(void* ptr)
{
return static_cast<QFileInfo*>(ptr)->isDir();
}
char QFileInfo_IsExecutable(void* ptr)
{
return static_cast<QFileInfo*>(ptr)->isExecutable();
}
char QFileInfo_IsFile(void* ptr)
{
return static_cast<QFileInfo*>(ptr)->isFile();
}
char QFileInfo_IsHidden(void* ptr)
{
return static_cast<QFileInfo*>(ptr)->isHidden();
}
char QFileInfo_IsNativePath(void* ptr)
{
return static_cast<QFileInfo*>(ptr)->isNativePath();
}
char QFileInfo_IsReadable(void* ptr)
{
return static_cast<QFileInfo*>(ptr)->isReadable();
}
char QFileInfo_IsRelative(void* ptr)
{
return static_cast<QFileInfo*>(ptr)->isRelative();
}
char QFileInfo_IsRoot(void* ptr)
{
return static_cast<QFileInfo*>(ptr)->isRoot();
}
char QFileInfo_IsSymLink(void* ptr)
{
return static_cast<QFileInfo*>(ptr)->isSymLink();
}
char QFileInfo_IsWritable(void* ptr)
{
return static_cast<QFileInfo*>(ptr)->isWritable();
}
void* QFileInfo_LastModified(void* ptr)
{
return new QDateTime(static_cast<QFileInfo*>(ptr)->lastModified());
}
void* QFileInfo_LastRead(void* ptr)
{
return new QDateTime(static_cast<QFileInfo*>(ptr)->lastRead());
}
char QFileInfo_MakeAbsolute(void* ptr)
{
return static_cast<QFileInfo*>(ptr)->makeAbsolute();
}
void* QFileInfo_MetadataChangeTime(void* ptr)
{
return new QDateTime(static_cast<QFileInfo*>(ptr)->metadataChangeTime());
}
struct QtCore_PackedString QFileInfo_Owner(void* ptr)
{
return ({ QByteArray* t63af1f = new QByteArray(static_cast<QFileInfo*>(ptr)->owner().toUtf8()); QtCore_PackedString { const_cast<char*>(t63af1f->prepend("WHITESPACE").constData()+10), t63af1f->size()-10, t63af1f }; });
}
unsigned int QFileInfo_OwnerId(void* ptr)
{
return static_cast<QFileInfo*>(ptr)->ownerId();
}
struct QtCore_PackedString QFileInfo_Path(void* ptr)
{
return ({ QByteArray* tdcd027 = new QByteArray(static_cast<QFileInfo*>(ptr)->path().toUtf8()); QtCore_PackedString { const_cast<char*>(tdcd027->prepend("WHITESPACE").constData()+10), tdcd027->size()-10, tdcd027 }; });
}
void QFileInfo_Refresh(void* ptr)
{
static_cast<QFileInfo*>(ptr)->refresh();
}
void QFileInfo_SetCaching(void* ptr, char enable)
{
static_cast<QFileInfo*>(ptr)->setCaching(enable != 0);
}
void QFileInfo_SetFile(void* ptr, struct QtCore_PackedString file)
{
static_cast<QFileInfo*>(ptr)->setFile(QString::fromUtf8(file.data, file.len));
}
void QFileInfo_SetFile2(void* ptr, void* file)
{
static_cast<QFileInfo*>(ptr)->setFile(*static_cast<QFile*>(file));
}
void QFileInfo_SetFile3(void* ptr, void* dir, struct QtCore_PackedString file)
{
static_cast<QFileInfo*>(ptr)->setFile(*static_cast<QDir*>(dir), QString::fromUtf8(file.data, file.len));
}
long long QFileInfo_Size(void* ptr)
{
return static_cast<QFileInfo*>(ptr)->size();
}
struct QtCore_PackedString QFileInfo_Suffix(void* ptr)
{
return ({ QByteArray* t1b5684 = new QByteArray(static_cast<QFileInfo*>(ptr)->suffix().toUtf8()); QtCore_PackedString { const_cast<char*>(t1b5684->prepend("WHITESPACE").constData()+10), t1b5684->size()-10, t1b5684 }; });
}
void QFileInfo_Swap(void* ptr, void* other)
{
static_cast<QFileInfo*>(ptr)->swap(*static_cast<QFileInfo*>(other));
}
struct QtCore_PackedString QFileInfo_SymLinkTarget(void* ptr)
{
return ({ QByteArray* tbe6e66 = new QByteArray(static_cast<QFileInfo*>(ptr)->symLinkTarget().toUtf8()); QtCore_PackedString { const_cast<char*>(tbe6e66->prepend("WHITESPACE").constData()+10), tbe6e66->size()-10, tbe6e66 }; });
}
void QFileInfo_DestroyQFileInfo(void* ptr)
{
static_cast<QFileInfo*>(ptr)->~QFileInfo();
}
class MyQFileSelector: public QFileSelector
{
public:
MyQFileSelector(QObject *parent = Q_NULLPTR) : QFileSelector(parent) {QFileSelector_QFileSelector_QRegisterMetaType();};
~MyQFileSelector() { callbackQFileSelector_DestroyQFileSelector(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QFileSelector*)
Q_DECLARE_METATYPE(MyQFileSelector*)
int QFileSelector_QFileSelector_QRegisterMetaType(){qRegisterMetaType<QFileSelector*>(); return qRegisterMetaType<MyQFileSelector*>();}
void* QFileSelector_NewQFileSelector(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQFileSelector(static_cast<QWindow*>(parent));
} else {
return new MyQFileSelector(static_cast<QObject*>(parent));
}
}
struct QtCore_PackedString QFileSelector_AllSelectors(void* ptr)
{
return ({ QByteArray* tac6e92 = new QByteArray(static_cast<QFileSelector*>(ptr)->allSelectors().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tac6e92->prepend("WHITESPACE").constData()+10), tac6e92->size()-10, tac6e92 }; });
}
struct QtCore_PackedString QFileSelector_ExtraSelectors(void* ptr)
{
return ({ QByteArray* t31d53e = new QByteArray(static_cast<QFileSelector*>(ptr)->extraSelectors().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t31d53e->prepend("WHITESPACE").constData()+10), t31d53e->size()-10, t31d53e }; });
}
struct QtCore_PackedString QFileSelector_Select(void* ptr, struct QtCore_PackedString filePath)
{
return ({ QByteArray* ta8a230 = new QByteArray(static_cast<QFileSelector*>(ptr)->select(QString::fromUtf8(filePath.data, filePath.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(ta8a230->prepend("WHITESPACE").constData()+10), ta8a230->size()-10, ta8a230 }; });
}
void* QFileSelector_Select2(void* ptr, void* filePath)
{
return new QUrl(static_cast<QFileSelector*>(ptr)->select(*static_cast<QUrl*>(filePath)));
}
void QFileSelector_SetExtraSelectors(void* ptr, struct QtCore_PackedString list)
{
static_cast<QFileSelector*>(ptr)->setExtraSelectors(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts));
}
void QFileSelector_DestroyQFileSelector(void* ptr)
{
static_cast<QFileSelector*>(ptr)->~QFileSelector();
}
void QFileSelector_DestroyQFileSelectorDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQFileSystemWatcher: public QFileSystemWatcher
{
public:
MyQFileSystemWatcher(QObject *parent = Q_NULLPTR) : QFileSystemWatcher(parent) {QFileSystemWatcher_QFileSystemWatcher_QRegisterMetaType();};
MyQFileSystemWatcher(const QStringList &paths, QObject *parent = Q_NULLPTR) : QFileSystemWatcher(paths, parent) {QFileSystemWatcher_QFileSystemWatcher_QRegisterMetaType();};
void Signal_DirectoryChanged(const QString & path) { QByteArray* t3150ec = new QByteArray(path.toUtf8()); QtCore_PackedString pathPacked = { const_cast<char*>(t3150ec->prepend("WHITESPACE").constData()+10), t3150ec->size()-10, t3150ec };callbackQFileSystemWatcher_DirectoryChanged(this, pathPacked); };
void Signal_FileChanged(const QString & path) { QByteArray* t3150ec = new QByteArray(path.toUtf8()); QtCore_PackedString pathPacked = { const_cast<char*>(t3150ec->prepend("WHITESPACE").constData()+10), t3150ec->size()-10, t3150ec };callbackQFileSystemWatcher_FileChanged(this, pathPacked); };
~MyQFileSystemWatcher() { callbackQFileSystemWatcher_DestroyQFileSystemWatcher(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QFileSystemWatcher*)
Q_DECLARE_METATYPE(MyQFileSystemWatcher*)
int QFileSystemWatcher_QFileSystemWatcher_QRegisterMetaType(){qRegisterMetaType<QFileSystemWatcher*>(); return qRegisterMetaType<MyQFileSystemWatcher*>();}
void* QFileSystemWatcher_NewQFileSystemWatcher(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(static_cast<QWindow*>(parent));
} else {
return new MyQFileSystemWatcher(static_cast<QObject*>(parent));
}
}
void* QFileSystemWatcher_NewQFileSystemWatcher2(struct QtCore_PackedString paths, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QWindow*>(parent));
} else {
return new MyQFileSystemWatcher(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QObject*>(parent));
}
}
char QFileSystemWatcher_AddPath(void* ptr, struct QtCore_PackedString path)
{
return static_cast<QFileSystemWatcher*>(ptr)->addPath(QString::fromUtf8(path.data, path.len));
}
struct QtCore_PackedString QFileSystemWatcher_AddPaths(void* ptr, struct QtCore_PackedString paths)
{
return ({ QByteArray* t3b4030 = new QByteArray(static_cast<QFileSystemWatcher*>(ptr)->addPaths(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts)).join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t3b4030->prepend("WHITESPACE").constData()+10), t3b4030->size()-10, t3b4030 }; });
}
struct QtCore_PackedString QFileSystemWatcher_Directories(void* ptr)
{
return ({ QByteArray* t4c1489 = new QByteArray(static_cast<QFileSystemWatcher*>(ptr)->directories().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t4c1489->prepend("WHITESPACE").constData()+10), t4c1489->size()-10, t4c1489 }; });
}
void QFileSystemWatcher_ConnectDirectoryChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QFileSystemWatcher*>(ptr), &QFileSystemWatcher::directoryChanged, static_cast<MyQFileSystemWatcher*>(ptr), static_cast<void (MyQFileSystemWatcher::*)(const QString &)>(&MyQFileSystemWatcher::Signal_DirectoryChanged), static_cast<Qt::ConnectionType>(t));
}
void QFileSystemWatcher_DisconnectDirectoryChanged(void* ptr)
{
QObject::disconnect(static_cast<QFileSystemWatcher*>(ptr), &QFileSystemWatcher::directoryChanged, static_cast<MyQFileSystemWatcher*>(ptr), static_cast<void (MyQFileSystemWatcher::*)(const QString &)>(&MyQFileSystemWatcher::Signal_DirectoryChanged));
}
void QFileSystemWatcher_ConnectFileChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QFileSystemWatcher*>(ptr), &QFileSystemWatcher::fileChanged, static_cast<MyQFileSystemWatcher*>(ptr), static_cast<void (MyQFileSystemWatcher::*)(const QString &)>(&MyQFileSystemWatcher::Signal_FileChanged), static_cast<Qt::ConnectionType>(t));
}
void QFileSystemWatcher_DisconnectFileChanged(void* ptr)
{
QObject::disconnect(static_cast<QFileSystemWatcher*>(ptr), &QFileSystemWatcher::fileChanged, static_cast<MyQFileSystemWatcher*>(ptr), static_cast<void (MyQFileSystemWatcher::*)(const QString &)>(&MyQFileSystemWatcher::Signal_FileChanged));
}
struct QtCore_PackedString QFileSystemWatcher_Files(void* ptr)
{
return ({ QByteArray* t536197 = new QByteArray(static_cast<QFileSystemWatcher*>(ptr)->files().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t536197->prepend("WHITESPACE").constData()+10), t536197->size()-10, t536197 }; });
}
char QFileSystemWatcher_RemovePath(void* ptr, struct QtCore_PackedString path)
{
return static_cast<QFileSystemWatcher*>(ptr)->removePath(QString::fromUtf8(path.data, path.len));
}
struct QtCore_PackedString QFileSystemWatcher_RemovePaths(void* ptr, struct QtCore_PackedString paths)
{
return ({ QByteArray* te8a7c4 = new QByteArray(static_cast<QFileSystemWatcher*>(ptr)->removePaths(QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts)).join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(te8a7c4->prepend("WHITESPACE").constData()+10), te8a7c4->size()-10, te8a7c4 }; });
}
void QFileSystemWatcher_DestroyQFileSystemWatcher(void* ptr)
{
static_cast<QFileSystemWatcher*>(ptr)->~QFileSystemWatcher();
}
void QFileSystemWatcher_DestroyQFileSystemWatcherDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQFinalState: public QFinalState
{
public:
MyQFinalState(QState *parent = Q_NULLPTR) : QFinalState(parent) {QFinalState_QFinalState_QRegisterMetaType();};
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
void onEntry(QEvent * event) { callbackQFinalState_OnEntry(this, event); };
void onExit(QEvent * event) { callbackQFinalState_OnExit(this, event); };
~MyQFinalState() { callbackQFinalState_DestroyQFinalState(this); };
void Signal_ActiveChanged(bool active) { callbackQAbstractState_ActiveChanged(this, active); };
void Signal_Entered() { callbackQAbstractState_Entered(this); };
void Signal_Exited() { callbackQAbstractState_Exited(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QFinalState*)
Q_DECLARE_METATYPE(MyQFinalState*)
int QFinalState_QFinalState_QRegisterMetaType(){qRegisterMetaType<QFinalState*>(); return qRegisterMetaType<MyQFinalState*>();}
void* QFinalState_NewQFinalState(void* parent)
{
return new MyQFinalState(static_cast<QState*>(parent));
}
void QFinalState_OnEntry(void* ptr, void* event)
{
static_cast<QFinalState*>(ptr)->onEntry(static_cast<QEvent*>(event));
}
void QFinalState_OnEntryDefault(void* ptr, void* event)
{
static_cast<QFinalState*>(ptr)->QFinalState::onEntry(static_cast<QEvent*>(event));
}
void QFinalState_OnExit(void* ptr, void* event)
{
static_cast<QFinalState*>(ptr)->onExit(static_cast<QEvent*>(event));
}
void QFinalState_OnExitDefault(void* ptr, void* event)
{
static_cast<QFinalState*>(ptr)->QFinalState::onExit(static_cast<QEvent*>(event));
}
void QFinalState_DestroyQFinalState(void* ptr)
{
static_cast<QFinalState*>(ptr)->~QFinalState();
}
void QFinalState_DestroyQFinalStateDefault(void* ptr)
{
Q_UNUSED(ptr);
}
Q_DECLARE_METATYPE(QFlag*)
void* QFlag_NewQFlag(int value)
{
return new QFlag(value);
}
void* QFlag_NewQFlag2(unsigned int value)
{
return new QFlag(value);
}
void* QFlag_NewQFlag3(short value)
{
return new QFlag(value);
}
void* QFlag_NewQFlag4(unsigned short value)
{
return new QFlag(value);
}
void* QFutureInterface___reportResults_results_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QFutureInterface___reportResults_results_setList(void* ptr, void* i)
{
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
void* QFutureInterface___reportResults_results_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QFutureInterface___results_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QFutureInterface___results_setList(void* ptr, void* i)
{
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
void* QFutureInterface___results_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
class MyQFutureWatcherBase: public QFutureWatcherBase
{
public:
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QFutureWatcherBase*)
Q_DECLARE_METATYPE(MyQFutureWatcherBase*)
int QFutureWatcherBase_QFutureWatcherBase_QRegisterMetaType(){qRegisterMetaType<QFutureWatcherBase*>(); return qRegisterMetaType<MyQFutureWatcherBase*>();}
Q_DECLARE_METATYPE(QGenericArgument*)
void* QGenericArgument_NewQGenericArgument(char* name, void* data)
{
return new QGenericArgument(const_cast<const char*>(name), data);
}
void* QGenericArgument_Data(void* ptr)
{
return static_cast<QGenericArgument*>(ptr)->data();
}
struct QtCore_PackedString QGenericArgument_Name(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QGenericArgument*>(ptr)->name()), -1, NULL };
}
Q_DECLARE_METATYPE(QGenericReturnArgument*)
void* QGenericReturnArgument_NewQGenericReturnArgument(char* name, void* data)
{
return new QGenericReturnArgument(const_cast<const char*>(name), data);
}
class MyQHistoryState: public QHistoryState
{
public:
MyQHistoryState(QState *parent = Q_NULLPTR) : QHistoryState(parent) {QHistoryState_QHistoryState_QRegisterMetaType();};
MyQHistoryState(QHistoryState::HistoryType ty, QState *parent = Q_NULLPTR) : QHistoryState(ty, parent) {QHistoryState_QHistoryState_QRegisterMetaType();};
void Signal_DefaultStateChanged() { callbackQHistoryState_DefaultStateChanged(this); };
void Signal_DefaultTransitionChanged() { callbackQHistoryState_DefaultTransitionChanged(this); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
void Signal_HistoryTypeChanged() { callbackQHistoryState_HistoryTypeChanged(this); };
void onEntry(QEvent * event) { callbackQHistoryState_OnEntry(this, event); };
void onExit(QEvent * event) { callbackQHistoryState_OnExit(this, event); };
~MyQHistoryState() { callbackQHistoryState_DestroyQHistoryState(this); };
void Signal_ActiveChanged(bool active) { callbackQAbstractState_ActiveChanged(this, active); };
void Signal_Entered() { callbackQAbstractState_Entered(this); };
void Signal_Exited() { callbackQAbstractState_Exited(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QHistoryState*)
Q_DECLARE_METATYPE(MyQHistoryState*)
int QHistoryState_QHistoryState_QRegisterMetaType(){qRegisterMetaType<QHistoryState*>(); return qRegisterMetaType<MyQHistoryState*>();}
void* QHistoryState_NewQHistoryState(void* parent)
{
return new MyQHistoryState(static_cast<QState*>(parent));
}
void* QHistoryState_NewQHistoryState2(long long ty, void* parent)
{
return new MyQHistoryState(static_cast<QHistoryState::HistoryType>(ty), static_cast<QState*>(parent));
}
void* QHistoryState_DefaultState(void* ptr)
{
return static_cast<QHistoryState*>(ptr)->defaultState();
}
void QHistoryState_ConnectDefaultStateChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QHistoryState*>(ptr), &QHistoryState::defaultStateChanged, static_cast<MyQHistoryState*>(ptr), static_cast<void (MyQHistoryState::*)()>(&MyQHistoryState::Signal_DefaultStateChanged), static_cast<Qt::ConnectionType>(t));
}
void QHistoryState_DisconnectDefaultStateChanged(void* ptr)
{
QObject::disconnect(static_cast<QHistoryState*>(ptr), &QHistoryState::defaultStateChanged, static_cast<MyQHistoryState*>(ptr), static_cast<void (MyQHistoryState::*)()>(&MyQHistoryState::Signal_DefaultStateChanged));
}
void* QHistoryState_DefaultTransition(void* ptr)
{
return static_cast<QHistoryState*>(ptr)->defaultTransition();
}
void QHistoryState_ConnectDefaultTransitionChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QHistoryState*>(ptr), &QHistoryState::defaultTransitionChanged, static_cast<MyQHistoryState*>(ptr), static_cast<void (MyQHistoryState::*)()>(&MyQHistoryState::Signal_DefaultTransitionChanged), static_cast<Qt::ConnectionType>(t));
}
void QHistoryState_DisconnectDefaultTransitionChanged(void* ptr)
{
QObject::disconnect(static_cast<QHistoryState*>(ptr), &QHistoryState::defaultTransitionChanged, static_cast<MyQHistoryState*>(ptr), static_cast<void (MyQHistoryState::*)()>(&MyQHistoryState::Signal_DefaultTransitionChanged));
}
long long QHistoryState_HistoryType(void* ptr)
{
return static_cast<QHistoryState*>(ptr)->historyType();
}
void QHistoryState_ConnectHistoryTypeChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QHistoryState*>(ptr), &QHistoryState::historyTypeChanged, static_cast<MyQHistoryState*>(ptr), static_cast<void (MyQHistoryState::*)()>(&MyQHistoryState::Signal_HistoryTypeChanged), static_cast<Qt::ConnectionType>(t));
}
void QHistoryState_DisconnectHistoryTypeChanged(void* ptr)
{
QObject::disconnect(static_cast<QHistoryState*>(ptr), &QHistoryState::historyTypeChanged, static_cast<MyQHistoryState*>(ptr), static_cast<void (MyQHistoryState::*)()>(&MyQHistoryState::Signal_HistoryTypeChanged));
}
void QHistoryState_OnEntry(void* ptr, void* event)
{
static_cast<QHistoryState*>(ptr)->onEntry(static_cast<QEvent*>(event));
}
void QHistoryState_OnEntryDefault(void* ptr, void* event)
{
static_cast<QHistoryState*>(ptr)->QHistoryState::onEntry(static_cast<QEvent*>(event));
}
void QHistoryState_OnExit(void* ptr, void* event)
{
static_cast<QHistoryState*>(ptr)->onExit(static_cast<QEvent*>(event));
}
void QHistoryState_OnExitDefault(void* ptr, void* event)
{
static_cast<QHistoryState*>(ptr)->QHistoryState::onExit(static_cast<QEvent*>(event));
}
void QHistoryState_SetDefaultState(void* ptr, void* state)
{
static_cast<QHistoryState*>(ptr)->setDefaultState(static_cast<QAbstractState*>(state));
}
void QHistoryState_SetDefaultTransition(void* ptr, void* transition)
{
static_cast<QHistoryState*>(ptr)->setDefaultTransition(static_cast<QAbstractTransition*>(transition));
}
void QHistoryState_SetHistoryType(void* ptr, long long ty)
{
static_cast<QHistoryState*>(ptr)->setHistoryType(static_cast<QHistoryState::HistoryType>(ty));
}
void QHistoryState_DestroyQHistoryState(void* ptr)
{
static_cast<QHistoryState*>(ptr)->~QHistoryState();
}
void QHistoryState_DestroyQHistoryStateDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQIODevice: public QIODevice
{
public:
MyQIODevice() : QIODevice() {QIODevice_QIODevice_QRegisterMetaType();};
MyQIODevice(QObject *parent) : QIODevice(parent) {QIODevice_QIODevice_QRegisterMetaType();};
void Signal_AboutToClose() { callbackQIODevice_AboutToClose(this); };
bool atEnd() const { return callbackQIODevice_AtEnd(const_cast<void*>(static_cast<const void*>(this))) != 0; };
qint64 bytesAvailable() const { return callbackQIODevice_BytesAvailable(const_cast<void*>(static_cast<const void*>(this))); };
qint64 bytesToWrite() const { return callbackQIODevice_BytesToWrite(const_cast<void*>(static_cast<const void*>(this))); };
void Signal_BytesWritten(qint64 bytes) { callbackQIODevice_BytesWritten(this, bytes); };
bool canReadLine() const { return callbackQIODevice_CanReadLine(const_cast<void*>(static_cast<const void*>(this))) != 0; };
void Signal_ChannelBytesWritten(int channel, qint64 bytes) { callbackQIODevice_ChannelBytesWritten(this, channel, bytes); };
void Signal_ChannelReadyRead(int channel) { callbackQIODevice_ChannelReadyRead(this, channel); };
void close() { callbackQIODevice_Close(this); };
bool isSequential() const { return callbackQIODevice_IsSequential(const_cast<void*>(static_cast<const void*>(this))) != 0; };
bool open(QIODevice::OpenMode mode) { return callbackQIODevice_Open(this, mode) != 0; };
qint64 pos() const { return callbackQIODevice_Pos(const_cast<void*>(static_cast<const void*>(this))); };
void Signal_ReadChannelFinished() { callbackQIODevice_ReadChannelFinished(this); };
qint64 readData(char * data, qint64 maxSize) { QtCore_PackedString dataPacked = { data, maxSize, NULL };return callbackQIODevice_ReadData(this, dataPacked, maxSize); };
qint64 readLineData(char * data, qint64 maxSize) { QtCore_PackedString dataPacked = { data, maxSize, NULL };return callbackQIODevice_ReadLineData(this, dataPacked, maxSize); };
void Signal_ReadyRead() { callbackQIODevice_ReadyRead(this); };
bool reset() { return callbackQIODevice_Reset(this) != 0; };
bool seek(qint64 pos) { return callbackQIODevice_Seek(this, pos) != 0; };
qint64 size() const { return callbackQIODevice_Size(const_cast<void*>(static_cast<const void*>(this))); };
bool waitForBytesWritten(int msecs) { return callbackQIODevice_WaitForBytesWritten(this, msecs) != 0; };
bool waitForReadyRead(int msecs) { return callbackQIODevice_WaitForReadyRead(this, msecs) != 0; };
qint64 writeData(const char * data, qint64 maxSize) { QtCore_PackedString dataPacked = { const_cast<char*>(data), maxSize, NULL };return callbackQIODevice_WriteData(this, dataPacked, maxSize); };
~MyQIODevice() { callbackQIODevice_DestroyQIODevice(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QIODevice*)
Q_DECLARE_METATYPE(MyQIODevice*)
int QIODevice_QIODevice_QRegisterMetaType(){qRegisterMetaType<QIODevice*>(); return qRegisterMetaType<MyQIODevice*>();}
void* QIODevice_NewQIODevice()
{
return new MyQIODevice();
}
void* QIODevice_NewQIODevice2(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQIODevice(static_cast<QWindow*>(parent));
} else {
return new MyQIODevice(static_cast<QObject*>(parent));
}
}
void QIODevice_ConnectAboutToClose(void* ptr, long long t)
{
QObject::connect(static_cast<QIODevice*>(ptr), static_cast<void (QIODevice::*)()>(&QIODevice::aboutToClose), static_cast<MyQIODevice*>(ptr), static_cast<void (MyQIODevice::*)()>(&MyQIODevice::Signal_AboutToClose), static_cast<Qt::ConnectionType>(t));
}
void QIODevice_DisconnectAboutToClose(void* ptr)
{
QObject::disconnect(static_cast<QIODevice*>(ptr), static_cast<void (QIODevice::*)()>(&QIODevice::aboutToClose), static_cast<MyQIODevice*>(ptr), static_cast<void (MyQIODevice::*)()>(&MyQIODevice::Signal_AboutToClose));
}
void QIODevice_AboutToClose(void* ptr)
{
static_cast<QIODevice*>(ptr)->aboutToClose();
}
char QIODevice_AtEnd(void* ptr)
{
return static_cast<QIODevice*>(ptr)->atEnd();
}
char QIODevice_AtEndDefault(void* ptr)
{
if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
return static_cast<QProcess*>(ptr)->QProcess::atEnd();
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::atEnd();
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::atEnd();
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::atEnd();
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileDevice*>(ptr)->QFileDevice::atEnd();
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
return static_cast<QBuffer*>(ptr)->QBuffer::atEnd();
} else {
return static_cast<QIODevice*>(ptr)->QIODevice::atEnd();
}
}
long long QIODevice_BytesAvailable(void* ptr)
{
return static_cast<QIODevice*>(ptr)->bytesAvailable();
}
long long QIODevice_BytesAvailableDefault(void* ptr)
{
if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
return static_cast<QProcess*>(ptr)->QProcess::bytesAvailable();
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::bytesAvailable();
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::bytesAvailable();
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::bytesAvailable();
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileDevice*>(ptr)->QFileDevice::bytesAvailable();
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
return static_cast<QBuffer*>(ptr)->QBuffer::bytesAvailable();
} else {
return static_cast<QIODevice*>(ptr)->QIODevice::bytesAvailable();
}
}
long long QIODevice_BytesToWrite(void* ptr)
{
return static_cast<QIODevice*>(ptr)->bytesToWrite();
}
long long QIODevice_BytesToWriteDefault(void* ptr)
{
if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
return static_cast<QProcess*>(ptr)->QProcess::bytesToWrite();
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::bytesToWrite();
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::bytesToWrite();
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::bytesToWrite();
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileDevice*>(ptr)->QFileDevice::bytesToWrite();
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
return static_cast<QBuffer*>(ptr)->QBuffer::bytesToWrite();
} else {
return static_cast<QIODevice*>(ptr)->QIODevice::bytesToWrite();
}
}
void QIODevice_ConnectBytesWritten(void* ptr, long long t)
{
QObject::connect(static_cast<QIODevice*>(ptr), static_cast<void (QIODevice::*)(qint64)>(&QIODevice::bytesWritten), static_cast<MyQIODevice*>(ptr), static_cast<void (MyQIODevice::*)(qint64)>(&MyQIODevice::Signal_BytesWritten), static_cast<Qt::ConnectionType>(t));
}
void QIODevice_DisconnectBytesWritten(void* ptr)
{
QObject::disconnect(static_cast<QIODevice*>(ptr), static_cast<void (QIODevice::*)(qint64)>(&QIODevice::bytesWritten), static_cast<MyQIODevice*>(ptr), static_cast<void (MyQIODevice::*)(qint64)>(&MyQIODevice::Signal_BytesWritten));
}
void QIODevice_BytesWritten(void* ptr, long long bytes)
{
static_cast<QIODevice*>(ptr)->bytesWritten(bytes);
}
char QIODevice_CanReadLine(void* ptr)
{
return static_cast<QIODevice*>(ptr)->canReadLine();
}
char QIODevice_CanReadLineDefault(void* ptr)
{
if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
return static_cast<QProcess*>(ptr)->QProcess::canReadLine();
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::canReadLine();
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::canReadLine();
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::canReadLine();
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileDevice*>(ptr)->QFileDevice::canReadLine();
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
return static_cast<QBuffer*>(ptr)->QBuffer::canReadLine();
} else {
return static_cast<QIODevice*>(ptr)->QIODevice::canReadLine();
}
}
void QIODevice_ConnectChannelBytesWritten(void* ptr, long long t)
{
QObject::connect(static_cast<QIODevice*>(ptr), static_cast<void (QIODevice::*)(int, qint64)>(&QIODevice::channelBytesWritten), static_cast<MyQIODevice*>(ptr), static_cast<void (MyQIODevice::*)(int, qint64)>(&MyQIODevice::Signal_ChannelBytesWritten), static_cast<Qt::ConnectionType>(t));
}
void QIODevice_DisconnectChannelBytesWritten(void* ptr)
{
QObject::disconnect(static_cast<QIODevice*>(ptr), static_cast<void (QIODevice::*)(int, qint64)>(&QIODevice::channelBytesWritten), static_cast<MyQIODevice*>(ptr), static_cast<void (MyQIODevice::*)(int, qint64)>(&MyQIODevice::Signal_ChannelBytesWritten));
}
void QIODevice_ChannelBytesWritten(void* ptr, int channel, long long bytes)
{
static_cast<QIODevice*>(ptr)->channelBytesWritten(channel, bytes);
}
void QIODevice_ConnectChannelReadyRead(void* ptr, long long t)
{
QObject::connect(static_cast<QIODevice*>(ptr), static_cast<void (QIODevice::*)(int)>(&QIODevice::channelReadyRead), static_cast<MyQIODevice*>(ptr), static_cast<void (MyQIODevice::*)(int)>(&MyQIODevice::Signal_ChannelReadyRead), static_cast<Qt::ConnectionType>(t));
}
void QIODevice_DisconnectChannelReadyRead(void* ptr)
{
QObject::disconnect(static_cast<QIODevice*>(ptr), static_cast<void (QIODevice::*)(int)>(&QIODevice::channelReadyRead), static_cast<MyQIODevice*>(ptr), static_cast<void (MyQIODevice::*)(int)>(&MyQIODevice::Signal_ChannelReadyRead));
}
void QIODevice_ChannelReadyRead(void* ptr, int channel)
{
static_cast<QIODevice*>(ptr)->channelReadyRead(channel);
}
void QIODevice_Close(void* ptr)
{
static_cast<QIODevice*>(ptr)->close();
}
void QIODevice_CloseDefault(void* ptr)
{
if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
static_cast<QProcess*>(ptr)->QProcess::close();
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
static_cast<QSaveFile*>(ptr)->QSaveFile::close();
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::close();
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
static_cast<QFile*>(ptr)->QFile::close();
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
static_cast<QFileDevice*>(ptr)->QFileDevice::close();
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
static_cast<QBuffer*>(ptr)->QBuffer::close();
} else {
static_cast<QIODevice*>(ptr)->QIODevice::close();
}
}
void QIODevice_CommitTransaction(void* ptr)
{
static_cast<QIODevice*>(ptr)->commitTransaction();
}
int QIODevice_CurrentReadChannel(void* ptr)
{
return static_cast<QIODevice*>(ptr)->currentReadChannel();
}
int QIODevice_CurrentWriteChannel(void* ptr)
{
return static_cast<QIODevice*>(ptr)->currentWriteChannel();
}
struct QtCore_PackedString QIODevice_ErrorString(void* ptr)
{
return ({ QByteArray* t7db24b = new QByteArray(static_cast<QIODevice*>(ptr)->errorString().toUtf8()); QtCore_PackedString { const_cast<char*>(t7db24b->prepend("WHITESPACE").constData()+10), t7db24b->size()-10, t7db24b }; });
}
char QIODevice_GetChar(void* ptr, char* c)
{
return static_cast<QIODevice*>(ptr)->getChar(c);
}
char QIODevice_IsOpen(void* ptr)
{
return static_cast<QIODevice*>(ptr)->isOpen();
}
char QIODevice_IsReadable(void* ptr)
{
return static_cast<QIODevice*>(ptr)->isReadable();
}
char QIODevice_IsSequential(void* ptr)
{
return static_cast<QIODevice*>(ptr)->isSequential();
}
char QIODevice_IsSequentialDefault(void* ptr)
{
if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
return static_cast<QProcess*>(ptr)->QProcess::isSequential();
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::isSequential();
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::isSequential();
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::isSequential();
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileDevice*>(ptr)->QFileDevice::isSequential();
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
return static_cast<QBuffer*>(ptr)->QBuffer::isSequential();
} else {
return static_cast<QIODevice*>(ptr)->QIODevice::isSequential();
}
}
char QIODevice_IsTextModeEnabled(void* ptr)
{
return static_cast<QIODevice*>(ptr)->isTextModeEnabled();
}
char QIODevice_IsTransactionStarted(void* ptr)
{
return static_cast<QIODevice*>(ptr)->isTransactionStarted();
}
char QIODevice_IsWritable(void* ptr)
{
return static_cast<QIODevice*>(ptr)->isWritable();
}
char QIODevice_Open(void* ptr, long long mode)
{
return static_cast<QIODevice*>(ptr)->open(static_cast<QIODevice::OpenModeFlag>(mode));
}
char QIODevice_OpenDefault(void* ptr, long long mode)
{
if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
return static_cast<QProcess*>(ptr)->QProcess::open(static_cast<QIODevice::OpenModeFlag>(mode));
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::open(static_cast<QIODevice::OpenModeFlag>(mode));
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::open(static_cast<QIODevice::OpenModeFlag>(mode));
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::open(static_cast<QIODevice::OpenModeFlag>(mode));
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileDevice*>(ptr)->QFileDevice::open(static_cast<QIODevice::OpenModeFlag>(mode));
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
return static_cast<QBuffer*>(ptr)->QBuffer::open(static_cast<QIODevice::OpenModeFlag>(mode));
} else {
return static_cast<QIODevice*>(ptr)->QIODevice::open(static_cast<QIODevice::OpenModeFlag>(mode));
}
}
long long QIODevice_OpenMode(void* ptr)
{
return static_cast<QIODevice*>(ptr)->openMode();
}
long long QIODevice_Peek(void* ptr, char* data, long long maxSize)
{
return static_cast<QIODevice*>(ptr)->peek(data, maxSize);
}
void* QIODevice_Peek2(void* ptr, long long maxSize)
{
return new QByteArray(static_cast<QIODevice*>(ptr)->peek(maxSize));
}
long long QIODevice_Pos(void* ptr)
{
return static_cast<QIODevice*>(ptr)->pos();
}
long long QIODevice_PosDefault(void* ptr)
{
if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
return static_cast<QProcess*>(ptr)->QProcess::pos();
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::pos();
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::pos();
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::pos();
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileDevice*>(ptr)->QFileDevice::pos();
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
return static_cast<QBuffer*>(ptr)->QBuffer::pos();
} else {
return static_cast<QIODevice*>(ptr)->QIODevice::pos();
}
}
char QIODevice_PutChar(void* ptr, char* c)
{
return static_cast<QIODevice*>(ptr)->putChar(*c);
}
long long QIODevice_Read(void* ptr, char* data, long long maxSize)
{
return static_cast<QIODevice*>(ptr)->read(data, maxSize);
}
void* QIODevice_Read2(void* ptr, long long maxSize)
{
return new QByteArray(static_cast<QIODevice*>(ptr)->read(maxSize));
}
void* QIODevice_ReadAll(void* ptr)
{
return new QByteArray(static_cast<QIODevice*>(ptr)->readAll());
}
int QIODevice_ReadChannelCount(void* ptr)
{
return static_cast<QIODevice*>(ptr)->readChannelCount();
}
void QIODevice_ConnectReadChannelFinished(void* ptr, long long t)
{
QObject::connect(static_cast<QIODevice*>(ptr), static_cast<void (QIODevice::*)()>(&QIODevice::readChannelFinished), static_cast<MyQIODevice*>(ptr), static_cast<void (MyQIODevice::*)()>(&MyQIODevice::Signal_ReadChannelFinished), static_cast<Qt::ConnectionType>(t));
}
void QIODevice_DisconnectReadChannelFinished(void* ptr)
{
QObject::disconnect(static_cast<QIODevice*>(ptr), static_cast<void (QIODevice::*)()>(&QIODevice::readChannelFinished), static_cast<MyQIODevice*>(ptr), static_cast<void (MyQIODevice::*)()>(&MyQIODevice::Signal_ReadChannelFinished));
}
void QIODevice_ReadChannelFinished(void* ptr)
{
static_cast<QIODevice*>(ptr)->readChannelFinished();
}
long long QIODevice_ReadData(void* ptr, char* data, long long maxSize)
{
return static_cast<QIODevice*>(ptr)->readData(data, maxSize);
}
long long QIODevice_ReadLine(void* ptr, char* data, long long maxSize)
{
return static_cast<QIODevice*>(ptr)->readLine(data, maxSize);
}
void* QIODevice_ReadLine2(void* ptr, long long maxSize)
{
return new QByteArray(static_cast<QIODevice*>(ptr)->readLine(maxSize));
}
long long QIODevice_ReadLineData(void* ptr, char* data, long long maxSize)
{
return static_cast<QIODevice*>(ptr)->readLineData(data, maxSize);
}
long long QIODevice_ReadLineDataDefault(void* ptr, char* data, long long maxSize)
{
if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
return static_cast<QProcess*>(ptr)->QProcess::readLineData(data, maxSize);
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::readLineData(data, maxSize);
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::readLineData(data, maxSize);
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::readLineData(data, maxSize);
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileDevice*>(ptr)->QFileDevice::readLineData(data, maxSize);
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
return static_cast<QBuffer*>(ptr)->QBuffer::readLineData(data, maxSize);
} else {
return static_cast<QIODevice*>(ptr)->QIODevice::readLineData(data, maxSize);
}
}
void QIODevice_ConnectReadyRead(void* ptr, long long t)
{
QObject::connect(static_cast<QIODevice*>(ptr), static_cast<void (QIODevice::*)()>(&QIODevice::readyRead), static_cast<MyQIODevice*>(ptr), static_cast<void (MyQIODevice::*)()>(&MyQIODevice::Signal_ReadyRead), static_cast<Qt::ConnectionType>(t));
}
void QIODevice_DisconnectReadyRead(void* ptr)
{
QObject::disconnect(static_cast<QIODevice*>(ptr), static_cast<void (QIODevice::*)()>(&QIODevice::readyRead), static_cast<MyQIODevice*>(ptr), static_cast<void (MyQIODevice::*)()>(&MyQIODevice::Signal_ReadyRead));
}
void QIODevice_ReadyRead(void* ptr)
{
static_cast<QIODevice*>(ptr)->readyRead();
}
char QIODevice_Reset(void* ptr)
{
return static_cast<QIODevice*>(ptr)->reset();
}
char QIODevice_ResetDefault(void* ptr)
{
if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
return static_cast<QProcess*>(ptr)->QProcess::reset();
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::reset();
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::reset();
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::reset();
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileDevice*>(ptr)->QFileDevice::reset();
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
return static_cast<QBuffer*>(ptr)->QBuffer::reset();
} else {
return static_cast<QIODevice*>(ptr)->QIODevice::reset();
}
}
void QIODevice_RollbackTransaction(void* ptr)
{
static_cast<QIODevice*>(ptr)->rollbackTransaction();
}
char QIODevice_Seek(void* ptr, long long pos)
{
return static_cast<QIODevice*>(ptr)->seek(pos);
}
char QIODevice_SeekDefault(void* ptr, long long pos)
{
if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
return static_cast<QProcess*>(ptr)->QProcess::seek(pos);
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::seek(pos);
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::seek(pos);
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::seek(pos);
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileDevice*>(ptr)->QFileDevice::seek(pos);
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
return static_cast<QBuffer*>(ptr)->QBuffer::seek(pos);
} else {
return static_cast<QIODevice*>(ptr)->QIODevice::seek(pos);
}
}
void QIODevice_SetCurrentReadChannel(void* ptr, int channel)
{
static_cast<QIODevice*>(ptr)->setCurrentReadChannel(channel);
}
void QIODevice_SetCurrentWriteChannel(void* ptr, int channel)
{
static_cast<QIODevice*>(ptr)->setCurrentWriteChannel(channel);
}
void QIODevice_SetErrorString(void* ptr, struct QtCore_PackedString str)
{
static_cast<QIODevice*>(ptr)->setErrorString(QString::fromUtf8(str.data, str.len));
}
void QIODevice_SetOpenMode(void* ptr, long long openMode)
{
static_cast<QIODevice*>(ptr)->setOpenMode(static_cast<QIODevice::OpenModeFlag>(openMode));
}
void QIODevice_SetTextModeEnabled(void* ptr, char enabled)
{
static_cast<QIODevice*>(ptr)->setTextModeEnabled(enabled != 0);
}
long long QIODevice_Size(void* ptr)
{
return static_cast<QIODevice*>(ptr)->size();
}
long long QIODevice_SizeDefault(void* ptr)
{
if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
return static_cast<QProcess*>(ptr)->QProcess::size();
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::size();
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::size();
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::size();
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileDevice*>(ptr)->QFileDevice::size();
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
return static_cast<QBuffer*>(ptr)->QBuffer::size();
} else {
return static_cast<QIODevice*>(ptr)->QIODevice::size();
}
}
long long QIODevice_Skip(void* ptr, long long maxSize)
{
return static_cast<QIODevice*>(ptr)->skip(maxSize);
}
void QIODevice_StartTransaction(void* ptr)
{
static_cast<QIODevice*>(ptr)->startTransaction();
}
void QIODevice_UngetChar(void* ptr, char* c)
{
static_cast<QIODevice*>(ptr)->ungetChar(*c);
}
char QIODevice_WaitForBytesWritten(void* ptr, int msecs)
{
return static_cast<QIODevice*>(ptr)->waitForBytesWritten(msecs);
}
char QIODevice_WaitForBytesWrittenDefault(void* ptr, int msecs)
{
if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
return static_cast<QProcess*>(ptr)->QProcess::waitForBytesWritten(msecs);
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::waitForBytesWritten(msecs);
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::waitForBytesWritten(msecs);
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::waitForBytesWritten(msecs);
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileDevice*>(ptr)->QFileDevice::waitForBytesWritten(msecs);
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
return static_cast<QBuffer*>(ptr)->QBuffer::waitForBytesWritten(msecs);
} else {
return static_cast<QIODevice*>(ptr)->QIODevice::waitForBytesWritten(msecs);
}
}
char QIODevice_WaitForReadyRead(void* ptr, int msecs)
{
return static_cast<QIODevice*>(ptr)->waitForReadyRead(msecs);
}
char QIODevice_WaitForReadyReadDefault(void* ptr, int msecs)
{
if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
return static_cast<QProcess*>(ptr)->QProcess::waitForReadyRead(msecs);
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::waitForReadyRead(msecs);
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::waitForReadyRead(msecs);
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::waitForReadyRead(msecs);
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileDevice*>(ptr)->QFileDevice::waitForReadyRead(msecs);
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
return static_cast<QBuffer*>(ptr)->QBuffer::waitForReadyRead(msecs);
} else {
return static_cast<QIODevice*>(ptr)->QIODevice::waitForReadyRead(msecs);
}
}
long long QIODevice_Write(void* ptr, char* data, long long maxSize)
{
return static_cast<QIODevice*>(ptr)->write(const_cast<const char*>(data), maxSize);
}
long long QIODevice_Write2(void* ptr, char* data)
{
return static_cast<QIODevice*>(ptr)->write(const_cast<const char*>(data));
}
long long QIODevice_Write3(void* ptr, void* byteArray)
{
return static_cast<QIODevice*>(ptr)->write(*static_cast<QByteArray*>(byteArray));
}
int QIODevice_WriteChannelCount(void* ptr)
{
return static_cast<QIODevice*>(ptr)->writeChannelCount();
}
long long QIODevice_WriteData(void* ptr, char* data, long long maxSize)
{
return static_cast<QIODevice*>(ptr)->writeData(const_cast<const char*>(data), maxSize);
}
void QIODevice_DestroyQIODevice(void* ptr)
{
static_cast<QIODevice*>(ptr)->~QIODevice();
}
void QIODevice_DestroyQIODeviceDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQIdentityProxyModel: public QIdentityProxyModel
{
public:
MyQIdentityProxyModel(QObject *parent = Q_NULLPTR) : QIdentityProxyModel(parent) {QIdentityProxyModel_QIdentityProxyModel_QRegisterMetaType();};
int columnCount(const QModelIndex & parent) const { return callbackQIdentityProxyModel_ColumnCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQAbstractItemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
QVariant headerData(int section, Qt::Orientation orientation, int role) const { return *static_cast<QVariant*>(callbackQAbstractItemModel_HeaderData(const_cast<void*>(static_cast<const void*>(this)), section, orientation, role)); };
QModelIndex index(int row, int column, const QModelIndex & parent) const { return *static_cast<QModelIndex*>(callbackQIdentityProxyModel_Index(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&parent))); };
bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
QModelIndex mapFromSource(const QModelIndex & sourceIndex) const { return *static_cast<QModelIndex*>(callbackQIdentityProxyModel_MapFromSource(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&sourceIndex))); };
QItemSelection mapSelectionFromSource(const QItemSelection & selection) const { return *static_cast<QItemSelection*>(callbackQAbstractProxyModel_MapSelectionFromSource(const_cast<void*>(static_cast<const void*>(this)), const_cast<QItemSelection*>(&selection))); };
QItemSelection mapSelectionToSource(const QItemSelection & selection) const { return *static_cast<QItemSelection*>(callbackQAbstractProxyModel_MapSelectionToSource(const_cast<void*>(static_cast<const void*>(this)), const_cast<QItemSelection*>(&selection))); };
QModelIndex mapToSource(const QModelIndex & proxyIndex) const { return *static_cast<QModelIndex*>(callbackQIdentityProxyModel_MapToSource(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&proxyIndex))); };
QList<QModelIndex> match(const QModelIndex & start, int role, const QVariant & value, int hits, Qt::MatchFlags flags) const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemModel_Match(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&start), role, const_cast<QVariant*>(&value), hits, flags)); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
QModelIndex parent(const QModelIndex & child) const { return *static_cast<QModelIndex*>(callbackQIdentityProxyModel_Parent(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&child))); };
bool removeColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool removeRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
int rowCount(const QModelIndex & parent) const { return callbackQIdentityProxyModel_RowCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
void setSourceModel(QAbstractItemModel * newSourceModel) { callbackQAbstractProxyModel_SetSourceModel(this, newSourceModel); };
QModelIndex sibling(int row, int column, const QModelIndex & idx) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Sibling(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&idx))); };
~MyQIdentityProxyModel() { callbackQIdentityProxyModel_DestroyQIdentityProxyModel(this); };
QModelIndex buddy(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Buddy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool canDropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) const { return callbackQAbstractItemModel_CanDropMimeData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
bool canFetchMore(const QModelIndex & parent) const { return callbackQAbstractItemModel_CanFetchMore(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
QVariant data(const QModelIndex & proxyIndex, int role) const { return *static_cast<QVariant*>(callbackQAbstractProxyModel_Data(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&proxyIndex), role)); };
void fetchMore(const QModelIndex & parent) { callbackQAbstractItemModel_FetchMore(this, const_cast<QModelIndex*>(&parent)); };
Qt::ItemFlags flags(const QModelIndex & index) const { return static_cast<Qt::ItemFlag>(callbackQAbstractItemModel_Flags(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool hasChildren(const QModelIndex & parent) const { return callbackQAbstractItemModel_HasChildren(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
QMap<int, QVariant> itemData(const QModelIndex & proxyIndex) const { return ({ QMap<int, QVariant>* tmpP = static_cast<QMap<int, QVariant>*>(callbackQAbstractItemModel_ItemData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&proxyIndex))); QMap<int, QVariant> tmpV = *tmpP; tmpP->~QMap(); free(tmpP); tmpV; }); };
QMimeData * mimeData(const QModelIndexList & indexes) const { return static_cast<QMimeData*>(callbackQAbstractItemModel_MimeData(const_cast<void*>(static_cast<const void*>(this)), ({ QList<QModelIndex>* tmpValuee0adf2 = new QList<QModelIndex>(indexes); QtCore_PackedList { tmpValuee0adf2, tmpValuee0adf2->size() }; }))); };
QStringList mimeTypes() const { return ({ QtCore_PackedString tempVal = callbackQAbstractItemModel_MimeTypes(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
void resetInternalData() { callbackQAbstractItemModel_ResetInternalData(this); };
void revert() { callbackQAbstractProxyModel_Revert(this); };
bool setData(const QModelIndex & index, const QVariant & value, int role) { return callbackQAbstractItemModel_SetData(this, const_cast<QModelIndex*>(&index), const_cast<QVariant*>(&value), role) != 0; };
bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQAbstractItemModel_SetHeaderData(this, section, orientation, const_cast<QVariant*>(&value), role) != 0; };
bool setItemData(const QModelIndex & index, const QMap<int, QVariant> & roles) { return callbackQAbstractItemModel_SetItemData(this, const_cast<QModelIndex*>(&index), ({ QMap<int, QVariant>* tmpValue037c88 = new QMap<int, QVariant>(roles); QtCore_PackedList { tmpValue037c88, tmpValue037c88->size() }; })) != 0; };
void sort(int column, Qt::SortOrder order) { callbackQAbstractItemModel_Sort(this, column, order); };
void Signal_SourceModelChanged() { callbackQAbstractProxyModel_SourceModelChanged(this); };
QSize span(const QModelIndex & index) const { return *static_cast<QSize*>(callbackQAbstractItemModel_Span(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool submit() { return callbackQAbstractProxyModel_Submit(this) != 0; };
Qt::DropActions supportedDragActions() const { return static_cast<Qt::DropAction>(callbackQAbstractItemModel_SupportedDragActions(const_cast<void*>(static_cast<const void*>(this)))); };
Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQAbstractItemModel_SupportedDropActions(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ColumnsAboutToBeInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationColumn) { callbackQAbstractItemModel_ColumnsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationColumn); };
void Signal_ColumnsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int column) { callbackQAbstractItemModel_ColumnsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), column); };
void Signal_ColumnsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_DataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQAbstractItemModel_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtCore_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
void Signal_HeaderDataChanged(Qt::Orientation orientation, int first, int last) { callbackQAbstractItemModel_HeaderDataChanged(this, orientation, first, last); };
void Signal_LayoutAboutToBeChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQAbstractItemModel_LayoutAboutToBeChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtCore_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
void Signal_LayoutChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQAbstractItemModel_LayoutChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtCore_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
void Signal_ModelAboutToBeReset() { callbackQAbstractItemModel_ModelAboutToBeReset(this); };
void Signal_ModelReset() { callbackQAbstractItemModel_ModelReset(this); };
bool moveColumns(const QModelIndex & sourceParent, int sourceColumn, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQAbstractItemModel_MoveColumns(this, const_cast<QModelIndex*>(&sourceParent), sourceColumn, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
bool moveRows(const QModelIndex & sourceParent, int sourceRow, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQAbstractItemModel_MoveRows(this, const_cast<QModelIndex*>(&sourceParent), sourceRow, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
QHash<int, QByteArray> roleNames() const { return ({ QHash<int, QByteArray>* tmpP = static_cast<QHash<int, QByteArray>*>(callbackQAbstractItemModel_RoleNames(const_cast<void*>(static_cast<const void*>(this)))); QHash<int, QByteArray> tmpV = *tmpP; tmpP->~QHash(); free(tmpP); tmpV; }); };
void Signal_RowsAboutToBeInserted(const QModelIndex & parent, int start, int end) { callbackQAbstractItemModel_RowsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
void Signal_RowsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationRow) { callbackQAbstractItemModel_RowsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationRow); };
void Signal_RowsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int row) { callbackQAbstractItemModel_RowsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), row); };
void Signal_RowsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QIdentityProxyModel*)
Q_DECLARE_METATYPE(MyQIdentityProxyModel*)
int QIdentityProxyModel_QIdentityProxyModel_QRegisterMetaType(){qRegisterMetaType<QIdentityProxyModel*>(); return qRegisterMetaType<MyQIdentityProxyModel*>();}
void* QIdentityProxyModel_NewQIdentityProxyModel(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQIdentityProxyModel(static_cast<QWindow*>(parent));
} else {
return new MyQIdentityProxyModel(static_cast<QObject*>(parent));
}
}
int QIdentityProxyModel_ColumnCount(void* ptr, void* parent)
{
return static_cast<QIdentityProxyModel*>(ptr)->columnCount(*static_cast<QModelIndex*>(parent));
}
int QIdentityProxyModel_ColumnCountDefault(void* ptr, void* parent)
{
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::columnCount(*static_cast<QModelIndex*>(parent));
}
void* QIdentityProxyModel_Index(void* ptr, int row, int column, void* parent)
{
return new QModelIndex(static_cast<QIdentityProxyModel*>(ptr)->index(row, column, *static_cast<QModelIndex*>(parent)));
}
void* QIdentityProxyModel_IndexDefault(void* ptr, int row, int column, void* parent)
{
return new QModelIndex(static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::index(row, column, *static_cast<QModelIndex*>(parent)));
}
void* QIdentityProxyModel_MapFromSource(void* ptr, void* sourceIndex)
{
return new QModelIndex(static_cast<QIdentityProxyModel*>(ptr)->mapFromSource(*static_cast<QModelIndex*>(sourceIndex)));
}
void* QIdentityProxyModel_MapFromSourceDefault(void* ptr, void* sourceIndex)
{
return new QModelIndex(static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::mapFromSource(*static_cast<QModelIndex*>(sourceIndex)));
}
void* QIdentityProxyModel_MapToSource(void* ptr, void* proxyIndex)
{
return new QModelIndex(static_cast<QIdentityProxyModel*>(ptr)->mapToSource(*static_cast<QModelIndex*>(proxyIndex)));
}
void* QIdentityProxyModel_MapToSourceDefault(void* ptr, void* proxyIndex)
{
return new QModelIndex(static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::mapToSource(*static_cast<QModelIndex*>(proxyIndex)));
}
void* QIdentityProxyModel_Parent(void* ptr, void* child)
{
return new QModelIndex(static_cast<QIdentityProxyModel*>(ptr)->parent(*static_cast<QModelIndex*>(child)));
}
void* QIdentityProxyModel_ParentDefault(void* ptr, void* child)
{
return new QModelIndex(static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::parent(*static_cast<QModelIndex*>(child)));
}
int QIdentityProxyModel_RowCount(void* ptr, void* parent)
{
return static_cast<QIdentityProxyModel*>(ptr)->rowCount(*static_cast<QModelIndex*>(parent));
}
int QIdentityProxyModel_RowCountDefault(void* ptr, void* parent)
{
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::rowCount(*static_cast<QModelIndex*>(parent));
}
void QIdentityProxyModel_DestroyQIdentityProxyModel(void* ptr)
{
static_cast<QIdentityProxyModel*>(ptr)->~QIdentityProxyModel();
}
void QIdentityProxyModel_DestroyQIdentityProxyModelDefault(void* ptr)
{
Q_UNUSED(ptr);
}
Q_DECLARE_METATYPE(QItemSelection*)
void* QItemSelection_NewQItemSelection()
{
return new QItemSelection();
}
void* QItemSelection_NewQItemSelection2(void* topLeft, void* bottomRight)
{
return new QItemSelection(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight));
}
char QItemSelection_Contains(void* ptr, void* index)
{
return static_cast<QItemSelection*>(ptr)->contains(*static_cast<QModelIndex*>(index));
}
struct QtCore_PackedList QItemSelection_Indexes(void* ptr)
{
return ({ QList<QModelIndex>* tmpValue5090cf = new QList<QModelIndex>(static_cast<QItemSelection*>(ptr)->indexes()); QtCore_PackedList { tmpValue5090cf, tmpValue5090cf->size() }; });
}
void QItemSelection_Merge(void* ptr, void* other, long long command)
{
static_cast<QItemSelection*>(ptr)->merge(*static_cast<QItemSelection*>(other), static_cast<QItemSelectionModel::SelectionFlag>(command));
}
void QItemSelection_Select(void* ptr, void* topLeft, void* bottomRight)
{
static_cast<QItemSelection*>(ptr)->select(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight));
}
void QItemSelection_QItemSelection_Split(void* ran, void* other, void* result)
{
QItemSelection::split(*static_cast<QItemSelectionRange*>(ran), *static_cast<QItemSelectionRange*>(other), static_cast<QItemSelection*>(result));
}
void* QItemSelection___indexes_atList(void* ptr, int i)
{
return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QItemSelection___indexes_setList(void* ptr, void* i)
{
static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}
void* QItemSelection___indexes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QModelIndex>();
}
class MyQItemSelectionModel: public QItemSelectionModel
{
public:
MyQItemSelectionModel(QAbstractItemModel *model = Q_NULLPTR) : QItemSelectionModel(model) {QItemSelectionModel_QItemSelectionModel_QRegisterMetaType();};
MyQItemSelectionModel(QAbstractItemModel *model, QObject *parent) : QItemSelectionModel(model, parent) {QItemSelectionModel_QItemSelectionModel_QRegisterMetaType();};
void clear() { callbackQItemSelectionModel_Clear(this); };
void clearCurrentIndex() { callbackQItemSelectionModel_ClearCurrentIndex(this); };
void clearSelection() { callbackQItemSelectionModel_ClearSelection(this); };
void Signal_CurrentChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQItemSelectionModel_CurrentChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&previous)); };
void Signal_CurrentColumnChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQItemSelectionModel_CurrentColumnChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&previous)); };
void Signal_CurrentRowChanged(const QModelIndex & current, const QModelIndex & previous) { callbackQItemSelectionModel_CurrentRowChanged(this, const_cast<QModelIndex*>(&current), const_cast<QModelIndex*>(&previous)); };
void Signal_ModelChanged(QAbstractItemModel * model) { callbackQItemSelectionModel_ModelChanged(this, model); };
void reset() { callbackQItemSelectionModel_Reset(this); };
void select(const QModelIndex & index, QItemSelectionModel::SelectionFlags command) { callbackQItemSelectionModel_Select(this, const_cast<QModelIndex*>(&index), command); };
void select(const QItemSelection & selection, QItemSelectionModel::SelectionFlags command) { callbackQItemSelectionModel_Select2(this, const_cast<QItemSelection*>(&selection), command); };
void Signal_SelectionChanged(const QItemSelection & selected, const QItemSelection & deselected) { callbackQItemSelectionModel_SelectionChanged(this, const_cast<QItemSelection*>(&selected), const_cast<QItemSelection*>(&deselected)); };
void setCurrentIndex(const QModelIndex & index, QItemSelectionModel::SelectionFlags command) { callbackQItemSelectionModel_SetCurrentIndex(this, const_cast<QModelIndex*>(&index), command); };
~MyQItemSelectionModel() { callbackQItemSelectionModel_DestroyQItemSelectionModel(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QItemSelectionModel*)
Q_DECLARE_METATYPE(MyQItemSelectionModel*)
int QItemSelectionModel_QItemSelectionModel_QRegisterMetaType(){qRegisterMetaType<QItemSelectionModel*>(); return qRegisterMetaType<MyQItemSelectionModel*>();}
void* QItemSelectionModel_NewQItemSelectionModel(void* model)
{
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model));
}
void* QItemSelectionModel_NewQItemSelectionModel2(void* model, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QWindow*>(parent));
} else {
return new MyQItemSelectionModel(static_cast<QAbstractItemModel*>(model), static_cast<QObject*>(parent));
}
}
void QItemSelectionModel_Clear(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QItemSelectionModel*>(ptr), "clear");
}
void QItemSelectionModel_ClearDefault(void* ptr)
{
static_cast<QItemSelectionModel*>(ptr)->QItemSelectionModel::clear();
}
void QItemSelectionModel_ClearCurrentIndex(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QItemSelectionModel*>(ptr), "clearCurrentIndex");
}
void QItemSelectionModel_ClearCurrentIndexDefault(void* ptr)
{
static_cast<QItemSelectionModel*>(ptr)->QItemSelectionModel::clearCurrentIndex();
}
void QItemSelectionModel_ClearSelection(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QItemSelectionModel*>(ptr), "clearSelection");
}
void QItemSelectionModel_ClearSelectionDefault(void* ptr)
{
static_cast<QItemSelectionModel*>(ptr)->QItemSelectionModel::clearSelection();
}
char QItemSelectionModel_ColumnIntersectsSelection(void* ptr, int column, void* parent)
{
return static_cast<QItemSelectionModel*>(ptr)->columnIntersectsSelection(column, *static_cast<QModelIndex*>(parent));
}
void QItemSelectionModel_ConnectCurrentChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QItemSelectionModel*>(ptr), static_cast<void (QItemSelectionModel::*)(const QModelIndex &, const QModelIndex &)>(&QItemSelectionModel::currentChanged), static_cast<MyQItemSelectionModel*>(ptr), static_cast<void (MyQItemSelectionModel::*)(const QModelIndex &, const QModelIndex &)>(&MyQItemSelectionModel::Signal_CurrentChanged), static_cast<Qt::ConnectionType>(t));
}
void QItemSelectionModel_DisconnectCurrentChanged(void* ptr)
{
QObject::disconnect(static_cast<QItemSelectionModel*>(ptr), static_cast<void (QItemSelectionModel::*)(const QModelIndex &, const QModelIndex &)>(&QItemSelectionModel::currentChanged), static_cast<MyQItemSelectionModel*>(ptr), static_cast<void (MyQItemSelectionModel::*)(const QModelIndex &, const QModelIndex &)>(&MyQItemSelectionModel::Signal_CurrentChanged));
}
void QItemSelectionModel_CurrentChanged(void* ptr, void* current, void* previous)
{
static_cast<QItemSelectionModel*>(ptr)->currentChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}
void QItemSelectionModel_ConnectCurrentColumnChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QItemSelectionModel*>(ptr), static_cast<void (QItemSelectionModel::*)(const QModelIndex &, const QModelIndex &)>(&QItemSelectionModel::currentColumnChanged), static_cast<MyQItemSelectionModel*>(ptr), static_cast<void (MyQItemSelectionModel::*)(const QModelIndex &, const QModelIndex &)>(&MyQItemSelectionModel::Signal_CurrentColumnChanged), static_cast<Qt::ConnectionType>(t));
}
void QItemSelectionModel_DisconnectCurrentColumnChanged(void* ptr)
{
QObject::disconnect(static_cast<QItemSelectionModel*>(ptr), static_cast<void (QItemSelectionModel::*)(const QModelIndex &, const QModelIndex &)>(&QItemSelectionModel::currentColumnChanged), static_cast<MyQItemSelectionModel*>(ptr), static_cast<void (MyQItemSelectionModel::*)(const QModelIndex &, const QModelIndex &)>(&MyQItemSelectionModel::Signal_CurrentColumnChanged));
}
void QItemSelectionModel_CurrentColumnChanged(void* ptr, void* current, void* previous)
{
static_cast<QItemSelectionModel*>(ptr)->currentColumnChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}
void* QItemSelectionModel_CurrentIndex(void* ptr)
{
return new QModelIndex(static_cast<QItemSelectionModel*>(ptr)->currentIndex());
}
void QItemSelectionModel_ConnectCurrentRowChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QItemSelectionModel*>(ptr), static_cast<void (QItemSelectionModel::*)(const QModelIndex &, const QModelIndex &)>(&QItemSelectionModel::currentRowChanged), static_cast<MyQItemSelectionModel*>(ptr), static_cast<void (MyQItemSelectionModel::*)(const QModelIndex &, const QModelIndex &)>(&MyQItemSelectionModel::Signal_CurrentRowChanged), static_cast<Qt::ConnectionType>(t));
}
void QItemSelectionModel_DisconnectCurrentRowChanged(void* ptr)
{
QObject::disconnect(static_cast<QItemSelectionModel*>(ptr), static_cast<void (QItemSelectionModel::*)(const QModelIndex &, const QModelIndex &)>(&QItemSelectionModel::currentRowChanged), static_cast<MyQItemSelectionModel*>(ptr), static_cast<void (MyQItemSelectionModel::*)(const QModelIndex &, const QModelIndex &)>(&MyQItemSelectionModel::Signal_CurrentRowChanged));
}
void QItemSelectionModel_CurrentRowChanged(void* ptr, void* current, void* previous)
{
static_cast<QItemSelectionModel*>(ptr)->currentRowChanged(*static_cast<QModelIndex*>(current), *static_cast<QModelIndex*>(previous));
}
void QItemSelectionModel_EmitSelectionChanged(void* ptr, void* newSelection, void* oldSelection)
{
static_cast<QItemSelectionModel*>(ptr)->emitSelectionChanged(*static_cast<QItemSelection*>(newSelection), *static_cast<QItemSelection*>(oldSelection));
}
char QItemSelectionModel_HasSelection(void* ptr)
{
return static_cast<QItemSelectionModel*>(ptr)->hasSelection();
}
char QItemSelectionModel_IsColumnSelected(void* ptr, int column, void* parent)
{
return static_cast<QItemSelectionModel*>(ptr)->isColumnSelected(column, *static_cast<QModelIndex*>(parent));
}
char QItemSelectionModel_IsRowSelected(void* ptr, int row, void* parent)
{
return static_cast<QItemSelectionModel*>(ptr)->isRowSelected(row, *static_cast<QModelIndex*>(parent));
}
char QItemSelectionModel_IsSelected(void* ptr, void* index)
{
return static_cast<QItemSelectionModel*>(ptr)->isSelected(*static_cast<QModelIndex*>(index));
}
void* QItemSelectionModel_Model(void* ptr)
{
return const_cast<QAbstractItemModel*>(static_cast<QItemSelectionModel*>(ptr)->model());
}
void* QItemSelectionModel_Model2(void* ptr)
{
return static_cast<QItemSelectionModel*>(ptr)->model();
}
void QItemSelectionModel_ConnectModelChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QItemSelectionModel*>(ptr), static_cast<void (QItemSelectionModel::*)(QAbstractItemModel *)>(&QItemSelectionModel::modelChanged), static_cast<MyQItemSelectionModel*>(ptr), static_cast<void (MyQItemSelectionModel::*)(QAbstractItemModel *)>(&MyQItemSelectionModel::Signal_ModelChanged), static_cast<Qt::ConnectionType>(t));
}
void QItemSelectionModel_DisconnectModelChanged(void* ptr)
{
QObject::disconnect(static_cast<QItemSelectionModel*>(ptr), static_cast<void (QItemSelectionModel::*)(QAbstractItemModel *)>(&QItemSelectionModel::modelChanged), static_cast<MyQItemSelectionModel*>(ptr), static_cast<void (MyQItemSelectionModel::*)(QAbstractItemModel *)>(&MyQItemSelectionModel::Signal_ModelChanged));
}
void QItemSelectionModel_ModelChanged(void* ptr, void* model)
{
static_cast<QItemSelectionModel*>(ptr)->modelChanged(static_cast<QAbstractItemModel*>(model));
}
void QItemSelectionModel_Reset(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QItemSelectionModel*>(ptr), "reset");
}
void QItemSelectionModel_ResetDefault(void* ptr)
{
static_cast<QItemSelectionModel*>(ptr)->QItemSelectionModel::reset();
}
char QItemSelectionModel_RowIntersectsSelection(void* ptr, int row, void* parent)
{
return static_cast<QItemSelectionModel*>(ptr)->rowIntersectsSelection(row, *static_cast<QModelIndex*>(parent));
}
void QItemSelectionModel_Select(void* ptr, void* index, long long command)
{
qRegisterMetaType<QItemSelectionModel::SelectionFlags>();
QMetaObject::invokeMethod(static_cast<QItemSelectionModel*>(ptr), "select", Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(index)), Q_ARG(QItemSelectionModel::SelectionFlags, static_cast<QItemSelectionModel::SelectionFlag>(command)));
}
void QItemSelectionModel_SelectDefault(void* ptr, void* index, long long command)
{
static_cast<QItemSelectionModel*>(ptr)->QItemSelectionModel::select(*static_cast<QModelIndex*>(index), static_cast<QItemSelectionModel::SelectionFlag>(command));
}
void QItemSelectionModel_Select2(void* ptr, void* selection, long long command)
{
qRegisterMetaType<QItemSelectionModel::SelectionFlags>();
QMetaObject::invokeMethod(static_cast<QItemSelectionModel*>(ptr), "select", Q_ARG(const QItemSelection, *static_cast<QItemSelection*>(selection)), Q_ARG(QItemSelectionModel::SelectionFlags, static_cast<QItemSelectionModel::SelectionFlag>(command)));
}
void QItemSelectionModel_Select2Default(void* ptr, void* selection, long long command)
{
static_cast<QItemSelectionModel*>(ptr)->QItemSelectionModel::select(*static_cast<QItemSelection*>(selection), static_cast<QItemSelectionModel::SelectionFlag>(command));
}
struct QtCore_PackedList QItemSelectionModel_SelectedColumns(void* ptr, int row)
{
return ({ QList<QModelIndex>* tmpValue9dab4f = new QList<QModelIndex>(static_cast<QItemSelectionModel*>(ptr)->selectedColumns(row)); QtCore_PackedList { tmpValue9dab4f, tmpValue9dab4f->size() }; });
}
struct QtCore_PackedList QItemSelectionModel_SelectedIndexes(void* ptr)
{
return ({ QList<QModelIndex>* tmpValue1476df = new QList<QModelIndex>(static_cast<QItemSelectionModel*>(ptr)->selectedIndexes()); QtCore_PackedList { tmpValue1476df, tmpValue1476df->size() }; });
}
struct QtCore_PackedList QItemSelectionModel_SelectedRows(void* ptr, int column)
{
return ({ QList<QModelIndex>* tmpValueedb157 = new QList<QModelIndex>(static_cast<QItemSelectionModel*>(ptr)->selectedRows(column)); QtCore_PackedList { tmpValueedb157, tmpValueedb157->size() }; });
}
void* QItemSelectionModel_Selection(void* ptr)
{
return new QItemSelection(static_cast<QItemSelectionModel*>(ptr)->selection());
}
void QItemSelectionModel_ConnectSelectionChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QItemSelectionModel*>(ptr), static_cast<void (QItemSelectionModel::*)(const QItemSelection &, const QItemSelection &)>(&QItemSelectionModel::selectionChanged), static_cast<MyQItemSelectionModel*>(ptr), static_cast<void (MyQItemSelectionModel::*)(const QItemSelection &, const QItemSelection &)>(&MyQItemSelectionModel::Signal_SelectionChanged), static_cast<Qt::ConnectionType>(t));
}
void QItemSelectionModel_DisconnectSelectionChanged(void* ptr)
{
QObject::disconnect(static_cast<QItemSelectionModel*>(ptr), static_cast<void (QItemSelectionModel::*)(const QItemSelection &, const QItemSelection &)>(&QItemSelectionModel::selectionChanged), static_cast<MyQItemSelectionModel*>(ptr), static_cast<void (MyQItemSelectionModel::*)(const QItemSelection &, const QItemSelection &)>(&MyQItemSelectionModel::Signal_SelectionChanged));
}
void QItemSelectionModel_SelectionChanged(void* ptr, void* selected, void* deselected)
{
static_cast<QItemSelectionModel*>(ptr)->selectionChanged(*static_cast<QItemSelection*>(selected), *static_cast<QItemSelection*>(deselected));
}
void QItemSelectionModel_SetCurrentIndex(void* ptr, void* index, long long command)
{
qRegisterMetaType<QItemSelectionModel::SelectionFlags>();
QMetaObject::invokeMethod(static_cast<QItemSelectionModel*>(ptr), "setCurrentIndex", Q_ARG(const QModelIndex, *static_cast<QModelIndex*>(index)), Q_ARG(QItemSelectionModel::SelectionFlags, static_cast<QItemSelectionModel::SelectionFlag>(command)));
}
void QItemSelectionModel_SetCurrentIndexDefault(void* ptr, void* index, long long command)
{
static_cast<QItemSelectionModel*>(ptr)->QItemSelectionModel::setCurrentIndex(*static_cast<QModelIndex*>(index), static_cast<QItemSelectionModel::SelectionFlag>(command));
}
void QItemSelectionModel_SetModel(void* ptr, void* model)
{
static_cast<QItemSelectionModel*>(ptr)->setModel(static_cast<QAbstractItemModel*>(model));
}
void QItemSelectionModel_DestroyQItemSelectionModel(void* ptr)
{
static_cast<QItemSelectionModel*>(ptr)->~QItemSelectionModel();
}
void QItemSelectionModel_DestroyQItemSelectionModelDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QItemSelectionModel___selectedColumns_atList(void* ptr, int i)
{
return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QItemSelectionModel___selectedColumns_setList(void* ptr, void* i)
{
static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}
void* QItemSelectionModel___selectedColumns_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QModelIndex>();
}
void* QItemSelectionModel___selectedIndexes_atList(void* ptr, int i)
{
return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QItemSelectionModel___selectedIndexes_setList(void* ptr, void* i)
{
static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}
void* QItemSelectionModel___selectedIndexes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QModelIndex>();
}
void* QItemSelectionModel___selectedRows_atList(void* ptr, int i)
{
return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QItemSelectionModel___selectedRows_setList(void* ptr, void* i)
{
static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}
void* QItemSelectionModel___selectedRows_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QModelIndex>();
}
Q_DECLARE_METATYPE(QItemSelectionRange*)
void* QItemSelectionRange_NewQItemSelectionRange()
{
return new QItemSelectionRange();
}
void* QItemSelectionRange_NewQItemSelectionRange2(void* other)
{
return new QItemSelectionRange(*static_cast<QItemSelectionRange*>(other));
}
void* QItemSelectionRange_NewQItemSelectionRange4(void* topLeft, void* bottomRight)
{
return new QItemSelectionRange(*static_cast<QModelIndex*>(topLeft), *static_cast<QModelIndex*>(bottomRight));
}
void* QItemSelectionRange_NewQItemSelectionRange5(void* index)
{
return new QItemSelectionRange(*static_cast<QModelIndex*>(index));
}
int QItemSelectionRange_Bottom(void* ptr)
{
return static_cast<QItemSelectionRange*>(ptr)->bottom();
}
void* QItemSelectionRange_BottomRight(void* ptr)
{
return const_cast<QPersistentModelIndex*>(&static_cast<QItemSelectionRange*>(ptr)->bottomRight());
}
char QItemSelectionRange_Contains(void* ptr, void* index)
{
return static_cast<QItemSelectionRange*>(ptr)->contains(*static_cast<QModelIndex*>(index));
}
char QItemSelectionRange_Contains2(void* ptr, int row, int column, void* parentIndex)
{
return static_cast<QItemSelectionRange*>(ptr)->contains(row, column, *static_cast<QModelIndex*>(parentIndex));
}
int QItemSelectionRange_Height(void* ptr)
{
return static_cast<QItemSelectionRange*>(ptr)->height();
}
struct QtCore_PackedList QItemSelectionRange_Indexes(void* ptr)
{
return ({ QList<QModelIndex>* tmpValuecb2327 = new QList<QModelIndex>(static_cast<QItemSelectionRange*>(ptr)->indexes()); QtCore_PackedList { tmpValuecb2327, tmpValuecb2327->size() }; });
}
void* QItemSelectionRange_Intersected(void* ptr, void* other)
{
return new QItemSelectionRange(static_cast<QItemSelectionRange*>(ptr)->intersected(*static_cast<QItemSelectionRange*>(other)));
}
char QItemSelectionRange_Intersects(void* ptr, void* other)
{
return static_cast<QItemSelectionRange*>(ptr)->intersects(*static_cast<QItemSelectionRange*>(other));
}
char QItemSelectionRange_IsEmpty(void* ptr)
{
return static_cast<QItemSelectionRange*>(ptr)->isEmpty();
}
char QItemSelectionRange_IsValid(void* ptr)
{
return static_cast<QItemSelectionRange*>(ptr)->isValid();
}
int QItemSelectionRange_Left(void* ptr)
{
return static_cast<QItemSelectionRange*>(ptr)->left();
}
void* QItemSelectionRange_Model(void* ptr)
{
return const_cast<QAbstractItemModel*>(static_cast<QItemSelectionRange*>(ptr)->model());
}
void* QItemSelectionRange_Parent(void* ptr)
{
return new QModelIndex(static_cast<QItemSelectionRange*>(ptr)->parent());
}
int QItemSelectionRange_Right(void* ptr)
{
return static_cast<QItemSelectionRange*>(ptr)->right();
}
void QItemSelectionRange_Swap(void* ptr, void* other)
{
static_cast<QItemSelectionRange*>(ptr)->swap(*static_cast<QItemSelectionRange*>(other));
}
int QItemSelectionRange_Top(void* ptr)
{
return static_cast<QItemSelectionRange*>(ptr)->top();
}
void* QItemSelectionRange_TopLeft(void* ptr)
{
return const_cast<QPersistentModelIndex*>(&static_cast<QItemSelectionRange*>(ptr)->topLeft());
}
int QItemSelectionRange_Width(void* ptr)
{
return static_cast<QItemSelectionRange*>(ptr)->width();
}
void* QItemSelectionRange___indexes_atList(void* ptr, int i)
{
return new QModelIndex(({QModelIndex tmp = static_cast<QList<QModelIndex>*>(ptr)->at(i); if (i == static_cast<QList<QModelIndex>*>(ptr)->size()-1) { static_cast<QList<QModelIndex>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QItemSelectionRange___indexes_setList(void* ptr, void* i)
{
static_cast<QList<QModelIndex>*>(ptr)->append(*static_cast<QModelIndex*>(i));
}
void* QItemSelectionRange___indexes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QModelIndex>();
}
Q_DECLARE_METATYPE(QJsonArray)
Q_DECLARE_METATYPE(QJsonArray*)
void* QJsonArray_NewQJsonArray()
{
return new QJsonArray();
}
void* QJsonArray_NewQJsonArray3(void* other)
{
return new QJsonArray(*static_cast<QJsonArray*>(other));
}
void* QJsonArray_NewQJsonArray4(void* other)
{
return new QJsonArray(*static_cast<QJsonArray*>(other));
}
void QJsonArray_Append(void* ptr, void* value)
{
static_cast<QJsonArray*>(ptr)->append(*static_cast<QJsonValue*>(value));
}
void* QJsonArray_At(void* ptr, int i)
{
return new QJsonValue(static_cast<QJsonArray*>(ptr)->at(i));
}
char QJsonArray_Contains(void* ptr, void* value)
{
return static_cast<QJsonArray*>(ptr)->contains(*static_cast<QJsonValue*>(value));
}
int QJsonArray_Count(void* ptr)
{
return static_cast<QJsonArray*>(ptr)->count();
}
char QJsonArray_Empty(void* ptr)
{
return static_cast<QJsonArray*>(ptr)->empty();
}
void* QJsonArray_First(void* ptr)
{
return new QJsonValue(static_cast<QJsonArray*>(ptr)->first());
}
void* QJsonArray_QJsonArray_FromStringList(struct QtCore_PackedString list)
{
return new QJsonArray(QJsonArray::fromStringList(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts)));
}
void* QJsonArray_QJsonArray_FromVariantList(void* list)
{
return new QJsonArray(QJsonArray::fromVariantList(({ QList<QVariant>* tmpP = static_cast<QList<QVariant>*>(list); QList<QVariant> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; })));
}
void QJsonArray_Insert(void* ptr, int i, void* value)
{
static_cast<QJsonArray*>(ptr)->insert(i, *static_cast<QJsonValue*>(value));
}
char QJsonArray_IsEmpty(void* ptr)
{
return static_cast<QJsonArray*>(ptr)->isEmpty();
}
void* QJsonArray_Last(void* ptr)
{
return new QJsonValue(static_cast<QJsonArray*>(ptr)->last());
}
void QJsonArray_Pop_back(void* ptr)
{
static_cast<QJsonArray*>(ptr)->pop_back();
}
void QJsonArray_Pop_front(void* ptr)
{
static_cast<QJsonArray*>(ptr)->pop_front();
}
void QJsonArray_Prepend(void* ptr, void* value)
{
static_cast<QJsonArray*>(ptr)->prepend(*static_cast<QJsonValue*>(value));
}
void QJsonArray_Push_back(void* ptr, void* value)
{
static_cast<QJsonArray*>(ptr)->push_back(*static_cast<QJsonValue*>(value));
}
void QJsonArray_Push_front(void* ptr, void* value)
{
static_cast<QJsonArray*>(ptr)->push_front(*static_cast<QJsonValue*>(value));
}
void QJsonArray_RemoveAt(void* ptr, int i)
{
static_cast<QJsonArray*>(ptr)->removeAt(i);
}
void QJsonArray_RemoveFirst(void* ptr)
{
static_cast<QJsonArray*>(ptr)->removeFirst();
}
void QJsonArray_RemoveLast(void* ptr)
{
static_cast<QJsonArray*>(ptr)->removeLast();
}
void QJsonArray_Replace(void* ptr, int i, void* value)
{
static_cast<QJsonArray*>(ptr)->replace(i, *static_cast<QJsonValue*>(value));
}
int QJsonArray_Size(void* ptr)
{
return static_cast<QJsonArray*>(ptr)->size();
}
void QJsonArray_Swap(void* ptr, void* other)
{
static_cast<QJsonArray*>(ptr)->swap(*static_cast<QJsonArray*>(other));
}
void* QJsonArray_TakeAt(void* ptr, int i)
{
return new QJsonValue(static_cast<QJsonArray*>(ptr)->takeAt(i));
}
struct QtCore_PackedList QJsonArray_ToVariantList(void* ptr)
{
return ({ QList<QVariant>* tmpValue10940c = new QList<QVariant>(static_cast<QJsonArray*>(ptr)->toVariantList()); QtCore_PackedList { tmpValue10940c, tmpValue10940c->size() }; });
}
void QJsonArray_DestroyQJsonArray(void* ptr)
{
static_cast<QJsonArray*>(ptr)->~QJsonArray();
}
void* QJsonArray___fromVariantList_list_atList(void* ptr, int i)
{
return new QVariant(({QVariant tmp = static_cast<QList<QVariant>*>(ptr)->at(i); if (i == static_cast<QList<QVariant>*>(ptr)->size()-1) { static_cast<QList<QVariant>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QJsonArray___fromVariantList_list_setList(void* ptr, void* i)
{
static_cast<QList<QVariant>*>(ptr)->append(*static_cast<QVariant*>(i));
}
void* QJsonArray___fromVariantList_list_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QVariant>();
}
void* QJsonArray___toVariantList_atList(void* ptr, int i)
{
return new QVariant(({QVariant tmp = static_cast<QList<QVariant>*>(ptr)->at(i); if (i == static_cast<QList<QVariant>*>(ptr)->size()-1) { static_cast<QList<QVariant>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QJsonArray___toVariantList_setList(void* ptr, void* i)
{
static_cast<QList<QVariant>*>(ptr)->append(*static_cast<QVariant*>(i));
}
void* QJsonArray___toVariantList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QVariant>();
}
Q_DECLARE_METATYPE(QJsonDocument)
Q_DECLARE_METATYPE(QJsonDocument*)
void* QJsonDocument_NewQJsonDocument()
{
return new QJsonDocument();
}
void* QJsonDocument_NewQJsonDocument2(void* object)
{
return new QJsonDocument(*static_cast<QJsonObject*>(object));
}
void* QJsonDocument_NewQJsonDocument3(void* array)
{
return new QJsonDocument(*static_cast<QJsonArray*>(array));
}
void* QJsonDocument_NewQJsonDocument4(void* other)
{
return new QJsonDocument(*static_cast<QJsonDocument*>(other));
}
void* QJsonDocument_NewQJsonDocument5(void* other)
{
return new QJsonDocument(*static_cast<QJsonDocument*>(other));
}
void* QJsonDocument_Array(void* ptr)
{
return new QJsonArray(static_cast<QJsonDocument*>(ptr)->array());
}
void* QJsonDocument_QJsonDocument_FromBinaryData(void* data, long long validation)
{
return new QJsonDocument(QJsonDocument::fromBinaryData(*static_cast<QByteArray*>(data), static_cast<QJsonDocument::DataValidation>(validation)));
}
void* QJsonDocument_QJsonDocument_FromJson(void* json, void* error)
{
return new QJsonDocument(QJsonDocument::fromJson(*static_cast<QByteArray*>(json), static_cast<QJsonParseError*>(error)));
}
void* QJsonDocument_QJsonDocument_FromRawData(char* data, int size, long long validation)
{
return new QJsonDocument(QJsonDocument::fromRawData(const_cast<const char*>(data), size, static_cast<QJsonDocument::DataValidation>(validation)));
}
void* QJsonDocument_QJsonDocument_FromVariant(void* variant)
{
return new QJsonDocument(QJsonDocument::fromVariant(*static_cast<QVariant*>(variant)));
}
char QJsonDocument_IsArray(void* ptr)
{
return static_cast<QJsonDocument*>(ptr)->isArray();
}
char QJsonDocument_IsEmpty(void* ptr)
{
return static_cast<QJsonDocument*>(ptr)->isEmpty();
}
char QJsonDocument_IsNull(void* ptr)
{
return static_cast<QJsonDocument*>(ptr)->isNull();
}
char QJsonDocument_IsObject(void* ptr)
{
return static_cast<QJsonDocument*>(ptr)->isObject();
}
void* QJsonDocument_Object(void* ptr)
{
return new QJsonObject(static_cast<QJsonDocument*>(ptr)->object());
}
struct QtCore_PackedString QJsonDocument_RawData(void* ptr, int size)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QJsonDocument*>(ptr)->rawData(&size)), size, NULL };
}
void QJsonDocument_SetArray(void* ptr, void* array)
{
static_cast<QJsonDocument*>(ptr)->setArray(*static_cast<QJsonArray*>(array));
}
void QJsonDocument_SetObject(void* ptr, void* object)
{
static_cast<QJsonDocument*>(ptr)->setObject(*static_cast<QJsonObject*>(object));
}
void QJsonDocument_Swap(void* ptr, void* other)
{
static_cast<QJsonDocument*>(ptr)->swap(*static_cast<QJsonDocument*>(other));
}
void* QJsonDocument_ToBinaryData(void* ptr)
{
return new QByteArray(static_cast<QJsonDocument*>(ptr)->toBinaryData());
}
void* QJsonDocument_ToJson(void* ptr)
{
return new QByteArray(static_cast<QJsonDocument*>(ptr)->toJson());
}
void* QJsonDocument_ToJson2(void* ptr, long long format)
{
return new QByteArray(static_cast<QJsonDocument*>(ptr)->toJson(static_cast<QJsonDocument::JsonFormat>(format)));
}
void* QJsonDocument_ToVariant(void* ptr)
{
return new QVariant(static_cast<QJsonDocument*>(ptr)->toVariant());
}
void QJsonDocument_DestroyQJsonDocument(void* ptr)
{
static_cast<QJsonDocument*>(ptr)->~QJsonDocument();
}
Q_DECLARE_METATYPE(QJsonObject)
Q_DECLARE_METATYPE(QJsonObject*)
void* QJsonObject_NewQJsonObject()
{
return new QJsonObject();
}
void* QJsonObject_NewQJsonObject3(void* other)
{
return new QJsonObject(*static_cast<QJsonObject*>(other));
}
void* QJsonObject_NewQJsonObject4(void* other)
{
return new QJsonObject(*static_cast<QJsonObject*>(other));
}
char QJsonObject_Contains(void* ptr, struct QtCore_PackedString key)
{
return static_cast<QJsonObject*>(ptr)->contains(QString::fromUtf8(key.data, key.len));
}
char QJsonObject_Contains2(void* ptr, void* key)
{
return static_cast<QJsonObject*>(ptr)->contains(*static_cast<QLatin1String*>(key));
}
int QJsonObject_Count(void* ptr)
{
return static_cast<QJsonObject*>(ptr)->count();
}
char QJsonObject_Empty(void* ptr)
{
return static_cast<QJsonObject*>(ptr)->empty();
}
void* QJsonObject_QJsonObject_FromVariantHash(void* hash)
{
return new QJsonObject(QJsonObject::fromVariantHash(({ QHash<QString, QVariant>* tmpP = static_cast<QHash<QString, QVariant>*>(hash); QHash<QString, QVariant> tmpV = *tmpP; tmpP->~QHash(); free(tmpP); tmpV; })));
}
char QJsonObject_IsEmpty(void* ptr)
{
return static_cast<QJsonObject*>(ptr)->isEmpty();
}
struct QtCore_PackedString QJsonObject_Keys(void* ptr)
{
return ({ QByteArray* t6c6b45 = new QByteArray(static_cast<QJsonObject*>(ptr)->keys().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t6c6b45->prepend("WHITESPACE").constData()+10), t6c6b45->size()-10, t6c6b45 }; });
}
int QJsonObject_Length(void* ptr)
{
return static_cast<QJsonObject*>(ptr)->length();
}
void QJsonObject_Remove(void* ptr, struct QtCore_PackedString key)
{
static_cast<QJsonObject*>(ptr)->remove(QString::fromUtf8(key.data, key.len));
}
int QJsonObject_Size(void* ptr)
{
return static_cast<QJsonObject*>(ptr)->size();
}
void QJsonObject_Swap(void* ptr, void* other)
{
static_cast<QJsonObject*>(ptr)->swap(*static_cast<QJsonObject*>(other));
}
void* QJsonObject_Take(void* ptr, struct QtCore_PackedString key)
{
return new QJsonValue(static_cast<QJsonObject*>(ptr)->take(QString::fromUtf8(key.data, key.len)));
}
struct QtCore_PackedList QJsonObject_ToVariantHash(void* ptr)
{
return ({ QHash<QString, QVariant>* tmpValue275a06 = new QHash<QString, QVariant>(static_cast<QJsonObject*>(ptr)->toVariantHash()); QtCore_PackedList { tmpValue275a06, tmpValue275a06->size() }; });
}
struct QtCore_PackedList QJsonObject_ToVariantMap(void* ptr)
{
return ({ QMap<QString, QVariant>* tmpValuebc2a1c = new QMap<QString, QVariant>(static_cast<QJsonObject*>(ptr)->toVariantMap()); QtCore_PackedList { tmpValuebc2a1c, tmpValuebc2a1c->size() }; });
}
void* QJsonObject_Value(void* ptr, struct QtCore_PackedString key)
{
return new QJsonValue(static_cast<QJsonObject*>(ptr)->value(QString::fromUtf8(key.data, key.len)));
}
void* QJsonObject_Value2(void* ptr, void* key)
{
return new QJsonValue(static_cast<QJsonObject*>(ptr)->value(*static_cast<QLatin1String*>(key)));
}
void QJsonObject_DestroyQJsonObject(void* ptr)
{
static_cast<QJsonObject*>(ptr)->~QJsonObject();
}
void* QJsonObject___fromVariantHash_hash_atList(void* ptr, struct QtCore_PackedString v, int i)
{
return new QVariant(({ QVariant tmp = static_cast<QHash<QString, QVariant>*>(ptr)->value(QString::fromUtf8(v.data, v.len)); if (i == static_cast<QHash<QString, QVariant>*>(ptr)->size()-1) { static_cast<QHash<QString, QVariant>*>(ptr)->~QHash(); free(ptr); }; tmp; }));
}
void QJsonObject___fromVariantHash_hash_setList(void* ptr, struct QtCore_PackedString key, void* i)
{
static_cast<QHash<QString, QVariant>*>(ptr)->insert(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(i));
}
void* QJsonObject___fromVariantHash_hash_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QHash<QString, QVariant>();
}
struct QtCore_PackedList QJsonObject___fromVariantHash_hash_keyList(void* ptr)
{
return ({ QList<QString>* tmpValuef43bc5 = new QList<QString>(static_cast<QHash<QString, QVariant>*>(ptr)->keys()); QtCore_PackedList { tmpValuef43bc5, tmpValuef43bc5->size() }; });
}
void* QJsonObject___toVariantHash_atList(void* ptr, struct QtCore_PackedString v, int i)
{
return new QVariant(({ QVariant tmp = static_cast<QHash<QString, QVariant>*>(ptr)->value(QString::fromUtf8(v.data, v.len)); if (i == static_cast<QHash<QString, QVariant>*>(ptr)->size()-1) { static_cast<QHash<QString, QVariant>*>(ptr)->~QHash(); free(ptr); }; tmp; }));
}
void QJsonObject___toVariantHash_setList(void* ptr, struct QtCore_PackedString key, void* i)
{
static_cast<QHash<QString, QVariant>*>(ptr)->insert(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(i));
}
void* QJsonObject___toVariantHash_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QHash<QString, QVariant>();
}
struct QtCore_PackedList QJsonObject___toVariantHash_keyList(void* ptr)
{
return ({ QList<QString>* tmpValuef43bc5 = new QList<QString>(static_cast<QHash<QString, QVariant>*>(ptr)->keys()); QtCore_PackedList { tmpValuef43bc5, tmpValuef43bc5->size() }; });
}
void* QJsonObject___toVariantMap_atList(void* ptr, struct QtCore_PackedString v, int i)
{
return new QVariant(({ QVariant tmp = static_cast<QMap<QString, QVariant>*>(ptr)->value(QString::fromUtf8(v.data, v.len)); if (i == static_cast<QMap<QString, QVariant>*>(ptr)->size()-1) { static_cast<QMap<QString, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}
void QJsonObject___toVariantMap_setList(void* ptr, struct QtCore_PackedString key, void* i)
{
static_cast<QMap<QString, QVariant>*>(ptr)->insert(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(i));
}
void* QJsonObject___toVariantMap_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QMap<QString, QVariant>();
}
struct QtCore_PackedList QJsonObject___toVariantMap_keyList(void* ptr)
{
return ({ QList<QString>* tmpValue1ab909 = new QList<QString>(static_cast<QMap<QString, QVariant>*>(ptr)->keys()); QtCore_PackedList { tmpValue1ab909, tmpValue1ab909->size() }; });
}
struct QtCore_PackedString QJsonObject_____fromVariantHash_hash_keyList_atList(void* ptr, int i)
{
return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtCore_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}
void QJsonObject_____fromVariantHash_hash_keyList_setList(void* ptr, struct QtCore_PackedString i)
{
static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}
void* QJsonObject_____fromVariantHash_hash_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QString>();
}
struct QtCore_PackedString QJsonObject_____fromVariantMap_map_keyList_atList(void* ptr, int i)
{
return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtCore_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}
void QJsonObject_____fromVariantMap_map_keyList_setList(void* ptr, struct QtCore_PackedString i)
{
static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}
void* QJsonObject_____fromVariantMap_map_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QString>();
}
struct QtCore_PackedString QJsonObject_____toVariantHash_keyList_atList(void* ptr, int i)
{
return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtCore_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}
void QJsonObject_____toVariantHash_keyList_setList(void* ptr, struct QtCore_PackedString i)
{
static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}
void* QJsonObject_____toVariantHash_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QString>();
}
struct QtCore_PackedString QJsonObject_____toVariantMap_keyList_atList(void* ptr, int i)
{
return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtCore_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}
void QJsonObject_____toVariantMap_keyList_setList(void* ptr, struct QtCore_PackedString i)
{
static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}
void* QJsonObject_____toVariantMap_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QString>();
}
struct QtCore_PackedString QJsonParseError_ErrorString(void* ptr)
{
return ({ QByteArray* t740a50 = new QByteArray(static_cast<QJsonParseError*>(ptr)->errorString().toUtf8()); QtCore_PackedString { const_cast<char*>(t740a50->prepend("WHITESPACE").constData()+10), t740a50->size()-10, t740a50 }; });
}
int QJsonParseError_Offset(void* ptr)
{
return static_cast<QJsonParseError*>(ptr)->offset;
}
void QJsonParseError_SetOffset(void* ptr, int vin)
{
static_cast<QJsonParseError*>(ptr)->offset = vin;
}
long long QJsonParseError_Error(void* ptr)
{
return static_cast<QJsonParseError*>(ptr)->error;
}
void QJsonParseError_SetError(void* ptr, long long vqj)
{
static_cast<QJsonParseError*>(ptr)->error = static_cast<QJsonParseError::ParseError>(vqj);
}
Q_DECLARE_METATYPE(QJsonValue*)
void* QJsonValue_NewQJsonValue(long long ty)
{
return new QJsonValue(static_cast<QJsonValue::Type>(ty));
}
void* QJsonValue_NewQJsonValue2(char b)
{
return new QJsonValue(b != 0);
}
void* QJsonValue_NewQJsonValue3(double n)
{
return new QJsonValue(n);
}
void* QJsonValue_NewQJsonValue4(int n)
{
return new QJsonValue(n);
}
void* QJsonValue_NewQJsonValue5(long long n)
{
return new QJsonValue(n);
}
void* QJsonValue_NewQJsonValue6(struct QtCore_PackedString s)
{
return new QJsonValue(QString::fromUtf8(s.data, s.len));
}
void* QJsonValue_NewQJsonValue7(void* s)
{
return new QJsonValue(*static_cast<QLatin1String*>(s));
}
void* QJsonValue_NewQJsonValue8(char* s)
{
return new QJsonValue(const_cast<const char*>(s));
}
void* QJsonValue_NewQJsonValue9(void* a)
{
return new QJsonValue(*static_cast<QJsonArray*>(a));
}
void* QJsonValue_NewQJsonValue10(void* o)
{
return new QJsonValue(*static_cast<QJsonObject*>(o));
}
void* QJsonValue_NewQJsonValue11(void* other)
{
return new QJsonValue(*static_cast<QJsonValue*>(other));
}
void* QJsonValue_NewQJsonValue12(void* other)
{
return new QJsonValue(*static_cast<QJsonValue*>(other));
}
void* QJsonValue_QJsonValue_FromVariant(void* variant)
{
return new QJsonValue(QJsonValue::fromVariant(*static_cast<QVariant*>(variant)));
}
char QJsonValue_IsArray(void* ptr)
{
return static_cast<QJsonValue*>(ptr)->isArray();
}
char QJsonValue_IsBool(void* ptr)
{
return static_cast<QJsonValue*>(ptr)->isBool();
}
char QJsonValue_IsDouble(void* ptr)
{
return static_cast<QJsonValue*>(ptr)->isDouble();
}
char QJsonValue_IsNull(void* ptr)
{
return static_cast<QJsonValue*>(ptr)->isNull();
}
char QJsonValue_IsObject(void* ptr)
{
return static_cast<QJsonValue*>(ptr)->isObject();
}
char QJsonValue_IsString(void* ptr)
{
return static_cast<QJsonValue*>(ptr)->isString();
}
char QJsonValue_IsUndefined(void* ptr)
{
return static_cast<QJsonValue*>(ptr)->isUndefined();
}
void QJsonValue_Swap(void* ptr, void* other)
{
static_cast<QJsonValue*>(ptr)->swap(*static_cast<QJsonValue*>(other));
}
void* QJsonValue_ToArray(void* ptr, void* defaultValue)
{
return new QJsonArray(static_cast<QJsonValue*>(ptr)->toArray(*static_cast<QJsonArray*>(defaultValue)));
}
void* QJsonValue_ToArray2(void* ptr)
{
return new QJsonArray(static_cast<QJsonValue*>(ptr)->toArray());
}
char QJsonValue_ToBool(void* ptr, char defaultValue)
{
return static_cast<QJsonValue*>(ptr)->toBool(defaultValue != 0);
}
double QJsonValue_ToDouble(void* ptr, double defaultValue)
{
return static_cast<QJsonValue*>(ptr)->toDouble(defaultValue);
}
int QJsonValue_ToInt(void* ptr, int defaultValue)
{
return static_cast<QJsonValue*>(ptr)->toInt(defaultValue);
}
void* QJsonValue_ToObject(void* ptr, void* defaultValue)
{
return new QJsonObject(static_cast<QJsonValue*>(ptr)->toObject(*static_cast<QJsonObject*>(defaultValue)));
}
void* QJsonValue_ToObject2(void* ptr)
{
return new QJsonObject(static_cast<QJsonValue*>(ptr)->toObject());
}
struct QtCore_PackedString QJsonValue_ToString(void* ptr)
{
return ({ QByteArray* t54cc8a = new QByteArray(static_cast<QJsonValue*>(ptr)->toString().toUtf8()); QtCore_PackedString { const_cast<char*>(t54cc8a->prepend("WHITESPACE").constData()+10), t54cc8a->size()-10, t54cc8a }; });
}
struct QtCore_PackedString QJsonValue_ToString2(void* ptr, struct QtCore_PackedString defaultValue)
{
return ({ QByteArray* tb25a8c = new QByteArray(static_cast<QJsonValue*>(ptr)->toString(QString::fromUtf8(defaultValue.data, defaultValue.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(tb25a8c->prepend("WHITESPACE").constData()+10), tb25a8c->size()-10, tb25a8c }; });
}
void* QJsonValue_ToVariant(void* ptr)
{
return new QVariant(static_cast<QJsonValue*>(ptr)->toVariant());
}
long long QJsonValue_Type(void* ptr)
{
return static_cast<QJsonValue*>(ptr)->type();
}
void QJsonValue_DestroyQJsonValue(void* ptr)
{
static_cast<QJsonValue*>(ptr)->~QJsonValue();
}
Q_DECLARE_METATYPE(QLatin1Char*)
void* QLatin1Char_NewQLatin1Char(char* c)
{
return new QLatin1Char(*c);
}
struct QtCore_PackedString QLatin1Char_ToLatin1(void* ptr)
{
return ({ char te73025 = static_cast<QLatin1Char*>(ptr)->toLatin1(); QtCore_PackedString { &te73025, -1, NULL }; });
}
unsigned short QLatin1Char_Unicode(void* ptr)
{
return static_cast<QLatin1Char*>(ptr)->unicode();
}
Q_DECLARE_METATYPE(QLatin1String)
Q_DECLARE_METATYPE(QLatin1String*)
void* QLatin1String_NewQLatin1String()
{
return new QLatin1String();
}
void* QLatin1String_NewQLatin1String2(char* str)
{
return new QLatin1String(const_cast<const char*>(str));
}
void* QLatin1String_NewQLatin1String3(char* first, char* last)
{
return new QLatin1String(const_cast<const char*>(first), const_cast<const char*>(last));
}
void* QLatin1String_NewQLatin1String4(char* str, int size)
{
return new QLatin1String(const_cast<const char*>(str), size);
}
void* QLatin1String_NewQLatin1String5(void* str)
{
return new QLatin1String(*static_cast<QByteArray*>(str));
}
void QLatin1String_Chop(void* ptr, int length)
{
static_cast<QLatin1String*>(ptr)->chop(length);
}
void* QLatin1String_Chopped(void* ptr, int length)
{
return new QLatin1String(static_cast<QLatin1String*>(ptr)->chopped(length));
}
struct QtCore_PackedString QLatin1String_Data(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QLatin1String*>(ptr)->data()), static_cast<QLatin1String*>(ptr)->size(), NULL };
}
char QLatin1String_EndsWith(void* ptr, void* str, long long cs)
{
return static_cast<QLatin1String*>(ptr)->endsWith(*static_cast<QStringView*>(str), static_cast<Qt::CaseSensitivity>(cs));
}
char QLatin1String_EndsWith2(void* ptr, void* l1, long long cs)
{
return static_cast<QLatin1String*>(ptr)->endsWith(*static_cast<QLatin1String*>(l1), static_cast<Qt::CaseSensitivity>(cs));
}
char QLatin1String_EndsWith3(void* ptr, void* ch)
{
return static_cast<QLatin1String*>(ptr)->endsWith(*static_cast<QChar*>(ch));
}
char QLatin1String_EndsWith4(void* ptr, void* ch, long long cs)
{
return static_cast<QLatin1String*>(ptr)->endsWith(*static_cast<QChar*>(ch), static_cast<Qt::CaseSensitivity>(cs));
}
char QLatin1String_IsEmpty(void* ptr)
{
return static_cast<QLatin1String*>(ptr)->isEmpty();
}
char QLatin1String_IsNull(void* ptr)
{
return static_cast<QLatin1String*>(ptr)->isNull();
}
struct QtCore_PackedString QLatin1String_Latin1(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QLatin1String*>(ptr)->latin1()), -1, NULL };
}
void* QLatin1String_Left(void* ptr, int length)
{
return new QLatin1String(static_cast<QLatin1String*>(ptr)->left(length));
}
void* QLatin1String_Mid(void* ptr, int start)
{
return new QLatin1String(static_cast<QLatin1String*>(ptr)->mid(start));
}
void* QLatin1String_Mid2(void* ptr, int start, int length)
{
return new QLatin1String(static_cast<QLatin1String*>(ptr)->mid(start, length));
}
void* QLatin1String_Right(void* ptr, int length)
{
return new QLatin1String(static_cast<QLatin1String*>(ptr)->right(length));
}
int QLatin1String_Size(void* ptr)
{
return static_cast<QLatin1String*>(ptr)->size();
}
char QLatin1String_StartsWith(void* ptr, void* str, long long cs)
{
return static_cast<QLatin1String*>(ptr)->startsWith(*static_cast<QStringView*>(str), static_cast<Qt::CaseSensitivity>(cs));
}
char QLatin1String_StartsWith2(void* ptr, void* l1, long long cs)
{
return static_cast<QLatin1String*>(ptr)->startsWith(*static_cast<QLatin1String*>(l1), static_cast<Qt::CaseSensitivity>(cs));
}
char QLatin1String_StartsWith3(void* ptr, void* ch)
{
return static_cast<QLatin1String*>(ptr)->startsWith(*static_cast<QChar*>(ch));
}
char QLatin1String_StartsWith4(void* ptr, void* ch, long long cs)
{
return static_cast<QLatin1String*>(ptr)->startsWith(*static_cast<QChar*>(ch), static_cast<Qt::CaseSensitivity>(cs));
}
void* QLatin1String_Trimmed(void* ptr)
{
return new QLatin1String(static_cast<QLatin1String*>(ptr)->trimmed());
}
void QLatin1String_Truncate(void* ptr, int length)
{
static_cast<QLatin1String*>(ptr)->truncate(length);
}
class MyQLibrary: public QLibrary
{
public:
MyQLibrary(QObject *parent = Q_NULLPTR) : QLibrary(parent) {QLibrary_QLibrary_QRegisterMetaType();};
MyQLibrary(const QString &fileName, QObject *parent = Q_NULLPTR) : QLibrary(fileName, parent) {QLibrary_QLibrary_QRegisterMetaType();};
MyQLibrary(const QString &fileName, int verNum, QObject *parent = Q_NULLPTR) : QLibrary(fileName, verNum, parent) {QLibrary_QLibrary_QRegisterMetaType();};
MyQLibrary(const QString &fileName, const QString &version, QObject *parent = Q_NULLPTR) : QLibrary(fileName, version, parent) {QLibrary_QLibrary_QRegisterMetaType();};
~MyQLibrary() { callbackQLibrary_DestroyQLibrary(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QLibrary*)
Q_DECLARE_METATYPE(MyQLibrary*)
int QLibrary_QLibrary_QRegisterMetaType(){qRegisterMetaType<QLibrary*>(); return qRegisterMetaType<MyQLibrary*>();}
void* QLibrary_NewQLibrary(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(static_cast<QWindow*>(parent));
} else {
return new MyQLibrary(static_cast<QObject*>(parent));
}
}
void* QLibrary_NewQLibrary2(struct QtCore_PackedString fileName, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QWindow*>(parent));
} else {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), static_cast<QObject*>(parent));
}
}
void* QLibrary_NewQLibrary3(struct QtCore_PackedString fileName, int verNum, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QWindow*>(parent));
} else {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), verNum, static_cast<QObject*>(parent));
}
}
void* QLibrary_NewQLibrary4(struct QtCore_PackedString fileName, struct QtCore_PackedString version, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QWindow*>(parent));
} else {
return new MyQLibrary(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len), static_cast<QObject*>(parent));
}
}
struct QtCore_PackedString QLibrary_ErrorString(void* ptr)
{
return ({ QByteArray* te92b99 = new QByteArray(static_cast<QLibrary*>(ptr)->errorString().toUtf8()); QtCore_PackedString { const_cast<char*>(te92b99->prepend("WHITESPACE").constData()+10), te92b99->size()-10, te92b99 }; });
}
struct QtCore_PackedString QLibrary_FileName(void* ptr)
{
return ({ QByteArray* t11b574 = new QByteArray(static_cast<QLibrary*>(ptr)->fileName().toUtf8()); QtCore_PackedString { const_cast<char*>(t11b574->prepend("WHITESPACE").constData()+10), t11b574->size()-10, t11b574 }; });
}
char QLibrary_QLibrary_IsLibrary(struct QtCore_PackedString fileName)
{
return QLibrary::isLibrary(QString::fromUtf8(fileName.data, fileName.len));
}
char QLibrary_IsLoaded(void* ptr)
{
return static_cast<QLibrary*>(ptr)->isLoaded();
}
char QLibrary_Load(void* ptr)
{
return static_cast<QLibrary*>(ptr)->load();
}
long long QLibrary_LoadHints(void* ptr)
{
return static_cast<QLibrary*>(ptr)->loadHints();
}
void QLibrary_SetFileName(void* ptr, struct QtCore_PackedString fileName)
{
static_cast<QLibrary*>(ptr)->setFileName(QString::fromUtf8(fileName.data, fileName.len));
}
void QLibrary_SetFileNameAndVersion(void* ptr, struct QtCore_PackedString fileName, int versionNumber)
{
static_cast<QLibrary*>(ptr)->setFileNameAndVersion(QString::fromUtf8(fileName.data, fileName.len), versionNumber);
}
void QLibrary_SetFileNameAndVersion2(void* ptr, struct QtCore_PackedString fileName, struct QtCore_PackedString version)
{
static_cast<QLibrary*>(ptr)->setFileNameAndVersion(QString::fromUtf8(fileName.data, fileName.len), QString::fromUtf8(version.data, version.len));
}
void QLibrary_SetLoadHints(void* ptr, long long hints)
{
static_cast<QLibrary*>(ptr)->setLoadHints(static_cast<QLibrary::LoadHint>(hints));
}
char QLibrary_Unload(void* ptr)
{
return static_cast<QLibrary*>(ptr)->unload();
}
void QLibrary_DestroyQLibrary(void* ptr)
{
static_cast<QLibrary*>(ptr)->~QLibrary();
}
void QLibrary_DestroyQLibraryDefault(void* ptr)
{
Q_UNUSED(ptr);
}
char QLibraryInfo_QLibraryInfo_IsDebugBuild()
{
return QLibraryInfo::isDebugBuild();
}
struct QtCore_PackedString QLibraryInfo_QLibraryInfo_Location(long long loc)
{
return ({ QByteArray* t19b89f = new QByteArray(QLibraryInfo::location(static_cast<QLibraryInfo::LibraryLocation>(loc)).toUtf8()); QtCore_PackedString { const_cast<char*>(t19b89f->prepend("WHITESPACE").constData()+10), t19b89f->size()-10, t19b89f }; });
}
void* QLibraryInfo_QLibraryInfo_Version()
{
return new QVersionNumber(QLibraryInfo::version());
}
Q_DECLARE_METATYPE(QLine)
Q_DECLARE_METATYPE(QLine*)
void* QLine_NewQLine()
{
return new QLine();
}
void* QLine_NewQLine2(void* p1, void* p2)
{
return new QLine(*static_cast<QPoint*>(p1), *static_cast<QPoint*>(p2));
}
void* QLine_NewQLine3(int x1, int y1, int x2, int y2)
{
return new QLine(x1, y1, x2, y2);
}
void* QLine_Center(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QLine*>(ptr)->center(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
int QLine_Dx(void* ptr)
{
return static_cast<QLine*>(ptr)->dx();
}
int QLine_Dy(void* ptr)
{
return static_cast<QLine*>(ptr)->dy();
}
char QLine_IsNull(void* ptr)
{
return static_cast<QLine*>(ptr)->isNull();
}
void* QLine_P1(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QLine*>(ptr)->p1(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QLine_P2(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QLine*>(ptr)->p2(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void QLine_SetLine(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QLine*>(ptr)->setLine(x1, y1, x2, y2);
}
void QLine_SetP1(void* ptr, void* p1)
{
static_cast<QLine*>(ptr)->setP1(*static_cast<QPoint*>(p1));
}
void QLine_SetP2(void* ptr, void* p2)
{
static_cast<QLine*>(ptr)->setP2(*static_cast<QPoint*>(p2));
}
void QLine_SetPoints(void* ptr, void* p1, void* p2)
{
static_cast<QLine*>(ptr)->setPoints(*static_cast<QPoint*>(p1), *static_cast<QPoint*>(p2));
}
void QLine_Translate(void* ptr, void* offset)
{
static_cast<QLine*>(ptr)->translate(*static_cast<QPoint*>(offset));
}
void QLine_Translate2(void* ptr, int dx, int dy)
{
static_cast<QLine*>(ptr)->translate(dx, dy);
}
void* QLine_Translated(void* ptr, void* offset)
{
return ({ QLine tmpValue = static_cast<QLine*>(ptr)->translated(*static_cast<QPoint*>(offset)); new QLine(tmpValue.p1(), tmpValue.p2()); });
}
void* QLine_Translated2(void* ptr, int dx, int dy)
{
return ({ QLine tmpValue = static_cast<QLine*>(ptr)->translated(dx, dy); new QLine(tmpValue.p1(), tmpValue.p2()); });
}
int QLine_X1(void* ptr)
{
return static_cast<QLine*>(ptr)->x1();
}
int QLine_X2(void* ptr)
{
return static_cast<QLine*>(ptr)->x2();
}
int QLine_Y1(void* ptr)
{
return static_cast<QLine*>(ptr)->y1();
}
int QLine_Y2(void* ptr)
{
return static_cast<QLine*>(ptr)->y2();
}
Q_DECLARE_METATYPE(QLineF)
Q_DECLARE_METATYPE(QLineF*)
void* QLineF_NewQLineF()
{
return new QLineF();
}
void* QLineF_NewQLineF2(void* p1, void* p2)
{
return new QLineF(*static_cast<QPointF*>(p1), *static_cast<QPointF*>(p2));
}
void* QLineF_NewQLineF3(double x1, double y1, double x2, double y2)
{
return new QLineF(x1, y1, x2, y2);
}
void* QLineF_NewQLineF4(void* line)
{
return new QLineF(*static_cast<QLine*>(line));
}
double QLineF_Angle(void* ptr)
{
return static_cast<QLineF*>(ptr)->angle();
}
double QLineF_AngleTo(void* ptr, void* line)
{
return static_cast<QLineF*>(ptr)->angleTo(*static_cast<QLineF*>(line));
}
void* QLineF_Center(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QLineF*>(ptr)->center(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
double QLineF_Dx(void* ptr)
{
return static_cast<QLineF*>(ptr)->dx();
}
double QLineF_Dy(void* ptr)
{
return static_cast<QLineF*>(ptr)->dy();
}
void* QLineF_QLineF_FromPolar(double length, double angle)
{
return ({ QLineF tmpValue = QLineF::fromPolar(length, angle); new QLineF(tmpValue.p1(), tmpValue.p2()); });
}
long long QLineF_Intersect(void* ptr, void* line, void* intersectionPoint)
{
return static_cast<QLineF*>(ptr)->intersect(*static_cast<QLineF*>(line), static_cast<QPointF*>(intersectionPoint));
}
char QLineF_IsNull(void* ptr)
{
return static_cast<QLineF*>(ptr)->isNull();
}
double QLineF_Length(void* ptr)
{
return static_cast<QLineF*>(ptr)->length();
}
void* QLineF_NormalVector(void* ptr)
{
return ({ QLineF tmpValue = static_cast<QLineF*>(ptr)->normalVector(); new QLineF(tmpValue.p1(), tmpValue.p2()); });
}
void* QLineF_P1(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QLineF*>(ptr)->p1(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QLineF_P2(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QLineF*>(ptr)->p2(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QLineF_PointAt(void* ptr, double t)
{
return ({ QPointF tmpValue = static_cast<QLineF*>(ptr)->pointAt(t); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QLineF_SetAngle(void* ptr, double angle)
{
static_cast<QLineF*>(ptr)->setAngle(angle);
}
void QLineF_SetLength(void* ptr, double length)
{
static_cast<QLineF*>(ptr)->setLength(length);
}
void QLineF_SetLine(void* ptr, double x1, double y1, double x2, double y2)
{
static_cast<QLineF*>(ptr)->setLine(x1, y1, x2, y2);
}
void QLineF_SetP1(void* ptr, void* p1)
{
static_cast<QLineF*>(ptr)->setP1(*static_cast<QPointF*>(p1));
}
void QLineF_SetP2(void* ptr, void* p2)
{
static_cast<QLineF*>(ptr)->setP2(*static_cast<QPointF*>(p2));
}
void QLineF_SetPoints(void* ptr, void* p1, void* p2)
{
static_cast<QLineF*>(ptr)->setPoints(*static_cast<QPointF*>(p1), *static_cast<QPointF*>(p2));
}
void* QLineF_ToLine(void* ptr)
{
return ({ QLine tmpValue = static_cast<QLineF*>(ptr)->toLine(); new QLine(tmpValue.p1(), tmpValue.p2()); });
}
void QLineF_Translate(void* ptr, void* offset)
{
static_cast<QLineF*>(ptr)->translate(*static_cast<QPointF*>(offset));
}
void QLineF_Translate2(void* ptr, double dx, double dy)
{
static_cast<QLineF*>(ptr)->translate(dx, dy);
}
void* QLineF_Translated(void* ptr, void* offset)
{
return ({ QLineF tmpValue = static_cast<QLineF*>(ptr)->translated(*static_cast<QPointF*>(offset)); new QLineF(tmpValue.p1(), tmpValue.p2()); });
}
void* QLineF_Translated2(void* ptr, double dx, double dy)
{
return ({ QLineF tmpValue = static_cast<QLineF*>(ptr)->translated(dx, dy); new QLineF(tmpValue.p1(), tmpValue.p2()); });
}
void* QLineF_UnitVector(void* ptr)
{
return ({ QLineF tmpValue = static_cast<QLineF*>(ptr)->unitVector(); new QLineF(tmpValue.p1(), tmpValue.p2()); });
}
double QLineF_X1(void* ptr)
{
return static_cast<QLineF*>(ptr)->x1();
}
double QLineF_X2(void* ptr)
{
return static_cast<QLineF*>(ptr)->x2();
}
double QLineF_Y1(void* ptr)
{
return static_cast<QLineF*>(ptr)->y1();
}
double QLineF_Y2(void* ptr)
{
return static_cast<QLineF*>(ptr)->y2();
}
Q_DECLARE_METATYPE(QLocale)
Q_DECLARE_METATYPE(QLocale*)
void* QLocale_NewQLocale()
{
return new QLocale();
}
void* QLocale_NewQLocale2(struct QtCore_PackedString name)
{
return new QLocale(QString::fromUtf8(name.data, name.len));
}
void* QLocale_NewQLocale3(long long language, long long country)
{
return new QLocale(static_cast<QLocale::Language>(language), static_cast<QLocale::Country>(country));
}
void* QLocale_NewQLocale4(long long language, long long scri, long long country)
{
return new QLocale(static_cast<QLocale::Language>(language), static_cast<QLocale::Script>(scri), static_cast<QLocale::Country>(country));
}
void* QLocale_NewQLocale5(void* other)
{
return new QLocale(*static_cast<QLocale*>(other));
}
struct QtCore_PackedString QLocale_AmText(void* ptr)
{
return ({ QByteArray* t5fc4d4 = new QByteArray(static_cast<QLocale*>(ptr)->amText().toUtf8()); QtCore_PackedString { const_cast<char*>(t5fc4d4->prepend("WHITESPACE").constData()+10), t5fc4d4->size()-10, t5fc4d4 }; });
}
struct QtCore_PackedString QLocale_Bcp47Name(void* ptr)
{
return ({ QByteArray* t0246a7 = new QByteArray(static_cast<QLocale*>(ptr)->bcp47Name().toUtf8()); QtCore_PackedString { const_cast<char*>(t0246a7->prepend("WHITESPACE").constData()+10), t0246a7->size()-10, t0246a7 }; });
}
void* QLocale_QLocale_C()
{
return new QLocale(QLocale::c());
}
long long QLocale_Country(void* ptr)
{
return static_cast<QLocale*>(ptr)->country();
}
struct QtCore_PackedString QLocale_QLocale_CountryToString(long long country)
{
return ({ QByteArray* tbdb30e = new QByteArray(QLocale::countryToString(static_cast<QLocale::Country>(country)).toUtf8()); QtCore_PackedString { const_cast<char*>(tbdb30e->prepend("WHITESPACE").constData()+10), tbdb30e->size()-10, tbdb30e }; });
}
struct QtCore_PackedString QLocale_CreateSeparatedList(void* ptr, struct QtCore_PackedString list)
{
return ({ QByteArray* t6f2da9 = new QByteArray(static_cast<QLocale*>(ptr)->createSeparatedList(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts)).toUtf8()); QtCore_PackedString { const_cast<char*>(t6f2da9->prepend("WHITESPACE").constData()+10), t6f2da9->size()-10, t6f2da9 }; });
}
struct QtCore_PackedString QLocale_CurrencySymbol(void* ptr, long long format)
{
return ({ QByteArray* t19bd4c = new QByteArray(static_cast<QLocale*>(ptr)->currencySymbol(static_cast<QLocale::CurrencySymbolFormat>(format)).toUtf8()); QtCore_PackedString { const_cast<char*>(t19bd4c->prepend("WHITESPACE").constData()+10), t19bd4c->size()-10, t19bd4c }; });
}
struct QtCore_PackedString QLocale_DateFormat(void* ptr, long long format)
{
return ({ QByteArray* t3ea82c = new QByteArray(static_cast<QLocale*>(ptr)->dateFormat(static_cast<QLocale::FormatType>(format)).toUtf8()); QtCore_PackedString { const_cast<char*>(t3ea82c->prepend("WHITESPACE").constData()+10), t3ea82c->size()-10, t3ea82c }; });
}
struct QtCore_PackedString QLocale_DateTimeFormat(void* ptr, long long format)
{
return ({ QByteArray* t3e01fc = new QByteArray(static_cast<QLocale*>(ptr)->dateTimeFormat(static_cast<QLocale::FormatType>(format)).toUtf8()); QtCore_PackedString { const_cast<char*>(t3e01fc->prepend("WHITESPACE").constData()+10), t3e01fc->size()-10, t3e01fc }; });
}
struct QtCore_PackedString QLocale_DayName(void* ptr, int day, long long ty)
{
return ({ QByteArray* t4220d0 = new QByteArray(static_cast<QLocale*>(ptr)->dayName(day, static_cast<QLocale::FormatType>(ty)).toUtf8()); QtCore_PackedString { const_cast<char*>(t4220d0->prepend("WHITESPACE").constData()+10), t4220d0->size()-10, t4220d0 }; });
}
void* QLocale_DecimalPoint(void* ptr)
{
return new QChar(static_cast<QLocale*>(ptr)->decimalPoint());
}
void* QLocale_Exponential(void* ptr)
{
return new QChar(static_cast<QLocale*>(ptr)->exponential());
}
long long QLocale_FirstDayOfWeek(void* ptr)
{
return static_cast<QLocale*>(ptr)->firstDayOfWeek();
}
struct QtCore_PackedString QLocale_FormattedDataSize2(void* ptr, long long bytes, int precision, long long format)
{
return ({ QByteArray* t3e7c75 = new QByteArray(static_cast<QLocale*>(ptr)->formattedDataSize(bytes, precision, static_cast<QLocale::DataSizeFormat>(format)).toUtf8()); QtCore_PackedString { const_cast<char*>(t3e7c75->prepend("WHITESPACE").constData()+10), t3e7c75->size()-10, t3e7c75 }; });
}
void* QLocale_GroupSeparator(void* ptr)
{
return new QChar(static_cast<QLocale*>(ptr)->groupSeparator());
}
long long QLocale_Language(void* ptr)
{
return static_cast<QLocale*>(ptr)->language();
}
struct QtCore_PackedString QLocale_QLocale_LanguageToString(long long language)
{
return ({ QByteArray* t29d017 = new QByteArray(QLocale::languageToString(static_cast<QLocale::Language>(language)).toUtf8()); QtCore_PackedString { const_cast<char*>(t29d017->prepend("WHITESPACE").constData()+10), t29d017->size()-10, t29d017 }; });
}
struct QtCore_PackedList QLocale_QLocale_MatchingLocales(long long language, long long scri, long long country)
{
return ({ QList<QLocale>* tmpValue0a12b0 = new QList<QLocale>(QLocale::matchingLocales(static_cast<QLocale::Language>(language), static_cast<QLocale::Script>(scri), static_cast<QLocale::Country>(country))); QtCore_PackedList { tmpValue0a12b0, tmpValue0a12b0->size() }; });
}
long long QLocale_MeasurementSystem(void* ptr)
{
return static_cast<QLocale*>(ptr)->measurementSystem();
}
struct QtCore_PackedString QLocale_MonthName(void* ptr, int month, long long ty)
{
return ({ QByteArray* t17d183 = new QByteArray(static_cast<QLocale*>(ptr)->monthName(month, static_cast<QLocale::FormatType>(ty)).toUtf8()); QtCore_PackedString { const_cast<char*>(t17d183->prepend("WHITESPACE").constData()+10), t17d183->size()-10, t17d183 }; });
}
struct QtCore_PackedString QLocale_Name(void* ptr)
{
return ({ QByteArray* tee867e = new QByteArray(static_cast<QLocale*>(ptr)->name().toUtf8()); QtCore_PackedString { const_cast<char*>(tee867e->prepend("WHITESPACE").constData()+10), tee867e->size()-10, tee867e }; });
}
struct QtCore_PackedString QLocale_NativeCountryName(void* ptr)
{
return ({ QByteArray* t08c386 = new QByteArray(static_cast<QLocale*>(ptr)->nativeCountryName().toUtf8()); QtCore_PackedString { const_cast<char*>(t08c386->prepend("WHITESPACE").constData()+10), t08c386->size()-10, t08c386 }; });
}
struct QtCore_PackedString QLocale_NativeLanguageName(void* ptr)
{
return ({ QByteArray* t34cbe6 = new QByteArray(static_cast<QLocale*>(ptr)->nativeLanguageName().toUtf8()); QtCore_PackedString { const_cast<char*>(t34cbe6->prepend("WHITESPACE").constData()+10), t34cbe6->size()-10, t34cbe6 }; });
}
void* QLocale_NegativeSign(void* ptr)
{
return new QChar(static_cast<QLocale*>(ptr)->negativeSign());
}
long long QLocale_NumberOptions(void* ptr)
{
return static_cast<QLocale*>(ptr)->numberOptions();
}
void* QLocale_Percent(void* ptr)
{
return new QChar(static_cast<QLocale*>(ptr)->percent());
}
struct QtCore_PackedString QLocale_PmText(void* ptr)
{
return ({ QByteArray* t37d9b2 = new QByteArray(static_cast<QLocale*>(ptr)->pmText().toUtf8()); QtCore_PackedString { const_cast<char*>(t37d9b2->prepend("WHITESPACE").constData()+10), t37d9b2->size()-10, t37d9b2 }; });
}
void* QLocale_PositiveSign(void* ptr)
{
return new QChar(static_cast<QLocale*>(ptr)->positiveSign());
}
struct QtCore_PackedString QLocale_QuoteString(void* ptr, struct QtCore_PackedString str, long long style)
{
return ({ QByteArray* t76145a = new QByteArray(static_cast<QLocale*>(ptr)->quoteString(QString::fromUtf8(str.data, str.len), static_cast<QLocale::QuotationStyle>(style)).toUtf8()); QtCore_PackedString { const_cast<char*>(t76145a->prepend("WHITESPACE").constData()+10), t76145a->size()-10, t76145a }; });
}
struct QtCore_PackedString QLocale_QuoteString2(void* ptr, void* str, long long style)
{
return ({ QByteArray* tef32e3 = new QByteArray(static_cast<QLocale*>(ptr)->quoteString(*static_cast<QStringRef*>(str), static_cast<QLocale::QuotationStyle>(style)).toUtf8()); QtCore_PackedString { const_cast<char*>(tef32e3->prepend("WHITESPACE").constData()+10), tef32e3->size()-10, tef32e3 }; });
}
long long QLocale_Script(void* ptr)
{
return static_cast<QLocale*>(ptr)->script();
}
struct QtCore_PackedString QLocale_QLocale_ScriptToString(long long scri)
{
return ({ QByteArray* t535509 = new QByteArray(QLocale::scriptToString(static_cast<QLocale::Script>(scri)).toUtf8()); QtCore_PackedString { const_cast<char*>(t535509->prepend("WHITESPACE").constData()+10), t535509->size()-10, t535509 }; });
}
void QLocale_QLocale_SetDefault(void* locale)
{
QLocale::setDefault(*static_cast<QLocale*>(locale));
}
void QLocale_SetNumberOptions(void* ptr, long long options)
{
static_cast<QLocale*>(ptr)->setNumberOptions(static_cast<QLocale::NumberOption>(options));
}
struct QtCore_PackedString QLocale_StandaloneDayName(void* ptr, int day, long long ty)
{
return ({ QByteArray* t7850cf = new QByteArray(static_cast<QLocale*>(ptr)->standaloneDayName(day, static_cast<QLocale::FormatType>(ty)).toUtf8()); QtCore_PackedString { const_cast<char*>(t7850cf->prepend("WHITESPACE").constData()+10), t7850cf->size()-10, t7850cf }; });
}
struct QtCore_PackedString QLocale_StandaloneMonthName(void* ptr, int month, long long ty)
{
return ({ QByteArray* t9ff9e7 = new QByteArray(static_cast<QLocale*>(ptr)->standaloneMonthName(month, static_cast<QLocale::FormatType>(ty)).toUtf8()); QtCore_PackedString { const_cast<char*>(t9ff9e7->prepend("WHITESPACE").constData()+10), t9ff9e7->size()-10, t9ff9e7 }; });
}
void QLocale_Swap(void* ptr, void* other)
{
static_cast<QLocale*>(ptr)->swap(*static_cast<QLocale*>(other));
}
void* QLocale_QLocale_System()
{
return new QLocale(QLocale::system());
}
long long QLocale_TextDirection(void* ptr)
{
return static_cast<QLocale*>(ptr)->textDirection();
}
struct QtCore_PackedString QLocale_TimeFormat(void* ptr, long long format)
{
return ({ QByteArray* t94be08 = new QByteArray(static_cast<QLocale*>(ptr)->timeFormat(static_cast<QLocale::FormatType>(format)).toUtf8()); QtCore_PackedString { const_cast<char*>(t94be08->prepend("WHITESPACE").constData()+10), t94be08->size()-10, t94be08 }; });
}
struct QtCore_PackedString QLocale_ToCurrencyString(void* ptr, long long value, struct QtCore_PackedString symbol)
{
return ({ QByteArray* t0fa4d2 = new QByteArray(static_cast<QLocale*>(ptr)->toCurrencyString(value, QString::fromUtf8(symbol.data, symbol.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t0fa4d2->prepend("WHITESPACE").constData()+10), t0fa4d2->size()-10, t0fa4d2 }; });
}
struct QtCore_PackedString QLocale_ToCurrencyString2(void* ptr, unsigned long long value, struct QtCore_PackedString symbol)
{
return ({ QByteArray* t0fa4d2 = new QByteArray(static_cast<QLocale*>(ptr)->toCurrencyString(value, QString::fromUtf8(symbol.data, symbol.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t0fa4d2->prepend("WHITESPACE").constData()+10), t0fa4d2->size()-10, t0fa4d2 }; });
}
struct QtCore_PackedString QLocale_ToCurrencyString3(void* ptr, short value, struct QtCore_PackedString symbol)
{
return ({ QByteArray* t0fa4d2 = new QByteArray(static_cast<QLocale*>(ptr)->toCurrencyString(value, QString::fromUtf8(symbol.data, symbol.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t0fa4d2->prepend("WHITESPACE").constData()+10), t0fa4d2->size()-10, t0fa4d2 }; });
}
struct QtCore_PackedString QLocale_ToCurrencyString4(void* ptr, unsigned short value, struct QtCore_PackedString symbol)
{
return ({ QByteArray* t0fa4d2 = new QByteArray(static_cast<QLocale*>(ptr)->toCurrencyString(value, QString::fromUtf8(symbol.data, symbol.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t0fa4d2->prepend("WHITESPACE").constData()+10), t0fa4d2->size()-10, t0fa4d2 }; });
}
struct QtCore_PackedString QLocale_ToCurrencyString5(void* ptr, int value, struct QtCore_PackedString symbol)
{
return ({ QByteArray* t0fa4d2 = new QByteArray(static_cast<QLocale*>(ptr)->toCurrencyString(value, QString::fromUtf8(symbol.data, symbol.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t0fa4d2->prepend("WHITESPACE").constData()+10), t0fa4d2->size()-10, t0fa4d2 }; });
}
struct QtCore_PackedString QLocale_ToCurrencyString6(void* ptr, unsigned int value, struct QtCore_PackedString symbol)
{
return ({ QByteArray* t0fa4d2 = new QByteArray(static_cast<QLocale*>(ptr)->toCurrencyString(value, QString::fromUtf8(symbol.data, symbol.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t0fa4d2->prepend("WHITESPACE").constData()+10), t0fa4d2->size()-10, t0fa4d2 }; });
}
struct QtCore_PackedString QLocale_ToCurrencyString7(void* ptr, double value, struct QtCore_PackedString symbol)
{
return ({ QByteArray* t0fa4d2 = new QByteArray(static_cast<QLocale*>(ptr)->toCurrencyString(value, QString::fromUtf8(symbol.data, symbol.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t0fa4d2->prepend("WHITESPACE").constData()+10), t0fa4d2->size()-10, t0fa4d2 }; });
}
struct QtCore_PackedString QLocale_ToCurrencyString8(void* ptr, double value, struct QtCore_PackedString symbol, int precision)
{
return ({ QByteArray* t891a06 = new QByteArray(static_cast<QLocale*>(ptr)->toCurrencyString(value, QString::fromUtf8(symbol.data, symbol.len), precision).toUtf8()); QtCore_PackedString { const_cast<char*>(t891a06->prepend("WHITESPACE").constData()+10), t891a06->size()-10, t891a06 }; });
}
struct QtCore_PackedString QLocale_ToCurrencyString9(void* ptr, float value, struct QtCore_PackedString symbol)
{
return ({ QByteArray* t0fa4d2 = new QByteArray(static_cast<QLocale*>(ptr)->toCurrencyString(value, QString::fromUtf8(symbol.data, symbol.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t0fa4d2->prepend("WHITESPACE").constData()+10), t0fa4d2->size()-10, t0fa4d2 }; });
}
struct QtCore_PackedString QLocale_ToCurrencyString10(void* ptr, float i, struct QtCore_PackedString symbol, int precision)
{
return ({ QByteArray* t32b253 = new QByteArray(static_cast<QLocale*>(ptr)->toCurrencyString(i, QString::fromUtf8(symbol.data, symbol.len), precision).toUtf8()); QtCore_PackedString { const_cast<char*>(t32b253->prepend("WHITESPACE").constData()+10), t32b253->size()-10, t32b253 }; });
}
void* QLocale_ToDate(void* ptr, struct QtCore_PackedString stri, long long format)
{
return new QDate(static_cast<QLocale*>(ptr)->toDate(QString::fromUtf8(stri.data, stri.len), static_cast<QLocale::FormatType>(format)));
}
void* QLocale_ToDate2(void* ptr, struct QtCore_PackedString stri, struct QtCore_PackedString format)
{
return new QDate(static_cast<QLocale*>(ptr)->toDate(QString::fromUtf8(stri.data, stri.len), QString::fromUtf8(format.data, format.len)));
}
void* QLocale_ToDateTime(void* ptr, struct QtCore_PackedString stri, long long format)
{
return new QDateTime(static_cast<QLocale*>(ptr)->toDateTime(QString::fromUtf8(stri.data, stri.len), static_cast<QLocale::FormatType>(format)));
}
void* QLocale_ToDateTime2(void* ptr, struct QtCore_PackedString stri, struct QtCore_PackedString format)
{
return new QDateTime(static_cast<QLocale*>(ptr)->toDateTime(QString::fromUtf8(stri.data, stri.len), QString::fromUtf8(format.data, format.len)));
}
double QLocale_ToDouble(void* ptr, struct QtCore_PackedString s, char* ok)
{
return static_cast<QLocale*>(ptr)->toDouble(QString::fromUtf8(s.data, s.len), reinterpret_cast<bool*>(ok));
}
double QLocale_ToDouble2(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toDouble(*static_cast<QStringRef*>(s), reinterpret_cast<bool*>(ok));
}
double QLocale_ToDouble3(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toDouble(*static_cast<QStringView*>(s), reinterpret_cast<bool*>(ok));
}
float QLocale_ToFloat(void* ptr, struct QtCore_PackedString s, char* ok)
{
return static_cast<QLocale*>(ptr)->toFloat(QString::fromUtf8(s.data, s.len), reinterpret_cast<bool*>(ok));
}
float QLocale_ToFloat2(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toFloat(*static_cast<QStringRef*>(s), reinterpret_cast<bool*>(ok));
}
float QLocale_ToFloat3(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toFloat(*static_cast<QStringView*>(s), reinterpret_cast<bool*>(ok));
}
int QLocale_ToInt(void* ptr, struct QtCore_PackedString s, char* ok)
{
return static_cast<QLocale*>(ptr)->toInt(QString::fromUtf8(s.data, s.len), reinterpret_cast<bool*>(ok));
}
int QLocale_ToInt2(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toInt(*static_cast<QStringRef*>(s), reinterpret_cast<bool*>(ok));
}
int QLocale_ToInt3(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toInt(*static_cast<QStringView*>(s), reinterpret_cast<bool*>(ok));
}
long QLocale_ToLong(void* ptr, struct QtCore_PackedString s, char* ok)
{
return static_cast<QLocale*>(ptr)->toLong(QString::fromUtf8(s.data, s.len), reinterpret_cast<bool*>(ok));
}
long QLocale_ToLong2(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toLong(*static_cast<QStringRef*>(s), reinterpret_cast<bool*>(ok));
}
long QLocale_ToLong3(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toLong(*static_cast<QStringView*>(s), reinterpret_cast<bool*>(ok));
}
long long QLocale_ToLongLong(void* ptr, struct QtCore_PackedString s, char* ok)
{
return static_cast<QLocale*>(ptr)->toLongLong(QString::fromUtf8(s.data, s.len), reinterpret_cast<bool*>(ok));
}
long long QLocale_ToLongLong2(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toLongLong(*static_cast<QStringRef*>(s), reinterpret_cast<bool*>(ok));
}
long long QLocale_ToLongLong3(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toLongLong(*static_cast<QStringView*>(s), reinterpret_cast<bool*>(ok));
}
struct QtCore_PackedString QLocale_ToLower(void* ptr, struct QtCore_PackedString str)
{
return ({ QByteArray* t112fbe = new QByteArray(static_cast<QLocale*>(ptr)->toLower(QString::fromUtf8(str.data, str.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t112fbe->prepend("WHITESPACE").constData()+10), t112fbe->size()-10, t112fbe }; });
}
short QLocale_ToShort(void* ptr, struct QtCore_PackedString s, char* ok)
{
return static_cast<QLocale*>(ptr)->toShort(QString::fromUtf8(s.data, s.len), reinterpret_cast<bool*>(ok));
}
short QLocale_ToShort2(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toShort(*static_cast<QStringRef*>(s), reinterpret_cast<bool*>(ok));
}
short QLocale_ToShort3(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toShort(*static_cast<QStringView*>(s), reinterpret_cast<bool*>(ok));
}
struct QtCore_PackedString QLocale_ToString(void* ptr, long long i)
{
return ({ QByteArray* teea9c2 = new QByteArray(static_cast<QLocale*>(ptr)->toString(i).toUtf8()); QtCore_PackedString { const_cast<char*>(teea9c2->prepend("WHITESPACE").constData()+10), teea9c2->size()-10, teea9c2 }; });
}
struct QtCore_PackedString QLocale_ToString2(void* ptr, unsigned long long i)
{
return ({ QByteArray* teea9c2 = new QByteArray(static_cast<QLocale*>(ptr)->toString(i).toUtf8()); QtCore_PackedString { const_cast<char*>(teea9c2->prepend("WHITESPACE").constData()+10), teea9c2->size()-10, teea9c2 }; });
}
struct QtCore_PackedString QLocale_ToString3(void* ptr, long i)
{
return ({ QByteArray* teea9c2 = new QByteArray(static_cast<QLocale*>(ptr)->toString(i).toUtf8()); QtCore_PackedString { const_cast<char*>(teea9c2->prepend("WHITESPACE").constData()+10), teea9c2->size()-10, teea9c2 }; });
}
struct QtCore_PackedString QLocale_ToString4(void* ptr, unsigned long i)
{
return ({ QByteArray* teea9c2 = new QByteArray(static_cast<QLocale*>(ptr)->toString(i).toUtf8()); QtCore_PackedString { const_cast<char*>(teea9c2->prepend("WHITESPACE").constData()+10), teea9c2->size()-10, teea9c2 }; });
}
struct QtCore_PackedString QLocale_ToString5(void* ptr, short i)
{
return ({ QByteArray* teea9c2 = new QByteArray(static_cast<QLocale*>(ptr)->toString(i).toUtf8()); QtCore_PackedString { const_cast<char*>(teea9c2->prepend("WHITESPACE").constData()+10), teea9c2->size()-10, teea9c2 }; });
}
struct QtCore_PackedString QLocale_ToString6(void* ptr, unsigned short i)
{
return ({ QByteArray* teea9c2 = new QByteArray(static_cast<QLocale*>(ptr)->toString(i).toUtf8()); QtCore_PackedString { const_cast<char*>(teea9c2->prepend("WHITESPACE").constData()+10), teea9c2->size()-10, teea9c2 }; });
}
struct QtCore_PackedString QLocale_ToString7(void* ptr, int i)
{
return ({ QByteArray* teea9c2 = new QByteArray(static_cast<QLocale*>(ptr)->toString(i).toUtf8()); QtCore_PackedString { const_cast<char*>(teea9c2->prepend("WHITESPACE").constData()+10), teea9c2->size()-10, teea9c2 }; });
}
struct QtCore_PackedString QLocale_ToString8(void* ptr, unsigned int i)
{
return ({ QByteArray* teea9c2 = new QByteArray(static_cast<QLocale*>(ptr)->toString(i).toUtf8()); QtCore_PackedString { const_cast<char*>(teea9c2->prepend("WHITESPACE").constData()+10), teea9c2->size()-10, teea9c2 }; });
}
struct QtCore_PackedString QLocale_ToString9(void* ptr, double i, char* ff, int prec)
{
return ({ QByteArray* t07d146 = new QByteArray(static_cast<QLocale*>(ptr)->toString(i, *ff, prec).toUtf8()); QtCore_PackedString { const_cast<char*>(t07d146->prepend("WHITESPACE").constData()+10), t07d146->size()-10, t07d146 }; });
}
struct QtCore_PackedString QLocale_ToString10(void* ptr, float i, char* ff, int prec)
{
return ({ QByteArray* t07d146 = new QByteArray(static_cast<QLocale*>(ptr)->toString(i, *ff, prec).toUtf8()); QtCore_PackedString { const_cast<char*>(t07d146->prepend("WHITESPACE").constData()+10), t07d146->size()-10, t07d146 }; });
}
struct QtCore_PackedString QLocale_ToString11(void* ptr, void* date, struct QtCore_PackedString format)
{
return ({ QByteArray* t198629 = new QByteArray(static_cast<QLocale*>(ptr)->toString(*static_cast<QDate*>(date), QString::fromUtf8(format.data, format.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t198629->prepend("WHITESPACE").constData()+10), t198629->size()-10, t198629 }; });
}
struct QtCore_PackedString QLocale_ToString12(void* ptr, void* ti, struct QtCore_PackedString format)
{
return ({ QByteArray* t607af9 = new QByteArray(static_cast<QLocale*>(ptr)->toString(*static_cast<QTime*>(ti), QString::fromUtf8(format.data, format.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t607af9->prepend("WHITESPACE").constData()+10), t607af9->size()-10, t607af9 }; });
}
struct QtCore_PackedString QLocale_ToString13(void* ptr, void* dateTime, struct QtCore_PackedString format)
{
return ({ QByteArray* t336e5f = new QByteArray(static_cast<QLocale*>(ptr)->toString(*static_cast<QDateTime*>(dateTime), QString::fromUtf8(format.data, format.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t336e5f->prepend("WHITESPACE").constData()+10), t336e5f->size()-10, t336e5f }; });
}
struct QtCore_PackedString QLocale_ToString14(void* ptr, void* date, void* format)
{
return ({ QByteArray* t08b601 = new QByteArray(static_cast<QLocale*>(ptr)->toString(*static_cast<QDate*>(date), *static_cast<QStringView*>(format)).toUtf8()); QtCore_PackedString { const_cast<char*>(t08b601->prepend("WHITESPACE").constData()+10), t08b601->size()-10, t08b601 }; });
}
struct QtCore_PackedString QLocale_ToString15(void* ptr, void* ti, void* format)
{
return ({ QByteArray* t697961 = new QByteArray(static_cast<QLocale*>(ptr)->toString(*static_cast<QTime*>(ti), *static_cast<QStringView*>(format)).toUtf8()); QtCore_PackedString { const_cast<char*>(t697961->prepend("WHITESPACE").constData()+10), t697961->size()-10, t697961 }; });
}
struct QtCore_PackedString QLocale_ToString16(void* ptr, void* dateTime, void* format)
{
return ({ QByteArray* t5abf1a = new QByteArray(static_cast<QLocale*>(ptr)->toString(*static_cast<QDateTime*>(dateTime), *static_cast<QStringView*>(format)).toUtf8()); QtCore_PackedString { const_cast<char*>(t5abf1a->prepend("WHITESPACE").constData()+10), t5abf1a->size()-10, t5abf1a }; });
}
struct QtCore_PackedString QLocale_ToString17(void* ptr, void* date, long long format)
{
return ({ QByteArray* t1fa262 = new QByteArray(static_cast<QLocale*>(ptr)->toString(*static_cast<QDate*>(date), static_cast<QLocale::FormatType>(format)).toUtf8()); QtCore_PackedString { const_cast<char*>(t1fa262->prepend("WHITESPACE").constData()+10), t1fa262->size()-10, t1fa262 }; });
}
struct QtCore_PackedString QLocale_ToString18(void* ptr, void* ti, long long format)
{
return ({ QByteArray* tb6230e = new QByteArray(static_cast<QLocale*>(ptr)->toString(*static_cast<QTime*>(ti), static_cast<QLocale::FormatType>(format)).toUtf8()); QtCore_PackedString { const_cast<char*>(tb6230e->prepend("WHITESPACE").constData()+10), tb6230e->size()-10, tb6230e }; });
}
struct QtCore_PackedString QLocale_ToString19(void* ptr, void* dateTime, long long format)
{
return ({ QByteArray* t96745f = new QByteArray(static_cast<QLocale*>(ptr)->toString(*static_cast<QDateTime*>(dateTime), static_cast<QLocale::FormatType>(format)).toUtf8()); QtCore_PackedString { const_cast<char*>(t96745f->prepend("WHITESPACE").constData()+10), t96745f->size()-10, t96745f }; });
}
void* QLocale_ToTime(void* ptr, struct QtCore_PackedString stri, long long format)
{
return new QTime(static_cast<QLocale*>(ptr)->toTime(QString::fromUtf8(stri.data, stri.len), static_cast<QLocale::FormatType>(format)));
}
void* QLocale_ToTime2(void* ptr, struct QtCore_PackedString stri, struct QtCore_PackedString format)
{
return new QTime(static_cast<QLocale*>(ptr)->toTime(QString::fromUtf8(stri.data, stri.len), QString::fromUtf8(format.data, format.len)));
}
unsigned int QLocale_ToUInt(void* ptr, struct QtCore_PackedString s, char* ok)
{
return static_cast<QLocale*>(ptr)->toUInt(QString::fromUtf8(s.data, s.len), reinterpret_cast<bool*>(ok));
}
unsigned int QLocale_ToUInt2(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toUInt(*static_cast<QStringRef*>(s), reinterpret_cast<bool*>(ok));
}
unsigned int QLocale_ToUInt3(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toUInt(*static_cast<QStringView*>(s), reinterpret_cast<bool*>(ok));
}
unsigned long QLocale_ToULong(void* ptr, struct QtCore_PackedString s, char* ok)
{
return static_cast<QLocale*>(ptr)->toULong(QString::fromUtf8(s.data, s.len), reinterpret_cast<bool*>(ok));
}
unsigned long QLocale_ToULong2(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toULong(*static_cast<QStringRef*>(s), reinterpret_cast<bool*>(ok));
}
unsigned long QLocale_ToULong3(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toULong(*static_cast<QStringView*>(s), reinterpret_cast<bool*>(ok));
}
unsigned long long QLocale_ToULongLong(void* ptr, struct QtCore_PackedString s, char* ok)
{
return static_cast<QLocale*>(ptr)->toULongLong(QString::fromUtf8(s.data, s.len), reinterpret_cast<bool*>(ok));
}
unsigned long long QLocale_ToULongLong2(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toULongLong(*static_cast<QStringRef*>(s), reinterpret_cast<bool*>(ok));
}
unsigned long long QLocale_ToULongLong3(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toULongLong(*static_cast<QStringView*>(s), reinterpret_cast<bool*>(ok));
}
unsigned short QLocale_ToUShort(void* ptr, struct QtCore_PackedString s, char* ok)
{
return static_cast<QLocale*>(ptr)->toUShort(QString::fromUtf8(s.data, s.len), reinterpret_cast<bool*>(ok));
}
unsigned short QLocale_ToUShort2(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toUShort(*static_cast<QStringRef*>(s), reinterpret_cast<bool*>(ok));
}
unsigned short QLocale_ToUShort3(void* ptr, void* s, char* ok)
{
return static_cast<QLocale*>(ptr)->toUShort(*static_cast<QStringView*>(s), reinterpret_cast<bool*>(ok));
}
struct QtCore_PackedString QLocale_ToUpper(void* ptr, struct QtCore_PackedString str)
{
return ({ QByteArray* t6969d0 = new QByteArray(static_cast<QLocale*>(ptr)->toUpper(QString::fromUtf8(str.data, str.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t6969d0->prepend("WHITESPACE").constData()+10), t6969d0->size()-10, t6969d0 }; });
}
struct QtCore_PackedString QLocale_UiLanguages(void* ptr)
{
return ({ QByteArray* tf4f58b = new QByteArray(static_cast<QLocale*>(ptr)->uiLanguages().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tf4f58b->prepend("WHITESPACE").constData()+10), tf4f58b->size()-10, tf4f58b }; });
}
struct QtCore_PackedList QLocale_Weekdays(void* ptr)
{
return ({ QList<Qt::DayOfWeek>* tmpValueae25dd = new QList<Qt::DayOfWeek>(static_cast<QLocale*>(ptr)->weekdays()); QtCore_PackedList { tmpValueae25dd, tmpValueae25dd->size() }; });
}
void* QLocale_ZeroDigit(void* ptr)
{
return new QChar(static_cast<QLocale*>(ptr)->zeroDigit());
}
void QLocale_DestroyQLocale(void* ptr)
{
static_cast<QLocale*>(ptr)->~QLocale();
}
void* QLocale___matchingLocales_atList(void* ptr, int i)
{
return new QLocale(({QLocale tmp = static_cast<QList<QLocale>*>(ptr)->at(i); if (i == static_cast<QList<QLocale>*>(ptr)->size()-1) { static_cast<QList<QLocale>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QLocale___matchingLocales_setList(void* ptr, void* i)
{
static_cast<QList<QLocale>*>(ptr)->append(*static_cast<QLocale*>(i));
}
void* QLocale___matchingLocales_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QLocale>();
}
long long QLocale___weekdays_atList(void* ptr, int i)
{
return ({Qt::DayOfWeek tmp = static_cast<QList<Qt::DayOfWeek>*>(ptr)->at(i); if (i == static_cast<QList<Qt::DayOfWeek>*>(ptr)->size()-1) { static_cast<QList<Qt::DayOfWeek>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QLocale___weekdays_setList(void* ptr, long long i)
{
static_cast<QList<Qt::DayOfWeek>*>(ptr)->append(static_cast<Qt::DayOfWeek>(i));
}
void* QLocale___weekdays_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<Qt::DayOfWeek>();
}
Q_DECLARE_METATYPE(QLockFile*)
void* QLockFile_NewQLockFile(struct QtCore_PackedString fileName)
{
return new QLockFile(QString::fromUtf8(fileName.data, fileName.len));
}
long long QLockFile_Error(void* ptr)
{
return static_cast<QLockFile*>(ptr)->error();
}
char QLockFile_GetLockInfo(void* ptr, long long pid, struct QtCore_PackedString hostname, struct QtCore_PackedString appname)
{
return static_cast<QLockFile*>(ptr)->getLockInfo(&pid, new QString(QString::fromUtf8(hostname.data, hostname.len)), new QString(QString::fromUtf8(appname.data, appname.len)));
}
char QLockFile_IsLocked(void* ptr)
{
return static_cast<QLockFile*>(ptr)->isLocked();
}
char QLockFile_Lock(void* ptr)
{
return static_cast<QLockFile*>(ptr)->lock();
}
char QLockFile_RemoveStaleLockFile(void* ptr)
{
return static_cast<QLockFile*>(ptr)->removeStaleLockFile();
}
void QLockFile_SetStaleLockTime(void* ptr, int staleLockTime)
{
static_cast<QLockFile*>(ptr)->setStaleLockTime(staleLockTime);
}
int QLockFile_StaleLockTime(void* ptr)
{
return static_cast<QLockFile*>(ptr)->staleLockTime();
}
char QLockFile_TryLock(void* ptr, int timeout)
{
return static_cast<QLockFile*>(ptr)->tryLock(timeout);
}
void QLockFile_Unlock(void* ptr)
{
static_cast<QLockFile*>(ptr)->unlock();
}
void QLockFile_DestroyQLockFile(void* ptr)
{
static_cast<QLockFile*>(ptr)->~QLockFile();
}
Q_DECLARE_METATYPE(QLoggingCategory*)
void* QLoggingCategory_NewQLoggingCategory2(char* category)
{
return new QLoggingCategory(const_cast<const char*>(category));
}
struct QtCore_PackedString QLoggingCategory_CategoryName(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QLoggingCategory*>(ptr)->categoryName()), -1, NULL };
}
void* QLoggingCategory_QLoggingCategory_DefaultCategory()
{
return QLoggingCategory::defaultCategory();
}
char QLoggingCategory_IsCriticalEnabled(void* ptr)
{
return static_cast<QLoggingCategory*>(ptr)->isCriticalEnabled();
}
char QLoggingCategory_IsDebugEnabled(void* ptr)
{
return static_cast<QLoggingCategory*>(ptr)->isDebugEnabled();
}
char QLoggingCategory_IsInfoEnabled(void* ptr)
{
return static_cast<QLoggingCategory*>(ptr)->isInfoEnabled();
}
char QLoggingCategory_IsWarningEnabled(void* ptr)
{
return static_cast<QLoggingCategory*>(ptr)->isWarningEnabled();
}
void QLoggingCategory_QLoggingCategory_SetFilterRules(struct QtCore_PackedString rules)
{
QLoggingCategory::setFilterRules(QString::fromUtf8(rules.data, rules.len));
}
void QLoggingCategory_DestroyQLoggingCategory(void* ptr)
{
static_cast<QLoggingCategory*>(ptr)->~QLoggingCategory();
}
Q_DECLARE_METATYPE(QMargins)
Q_DECLARE_METATYPE(QMargins*)
void* QMargins_NewQMargins()
{
return new QMargins();
}
void* QMargins_NewQMargins2(int left, int top, int right, int bottom)
{
return new QMargins(left, top, right, bottom);
}
int QMargins_Bottom(void* ptr)
{
return static_cast<QMargins*>(ptr)->bottom();
}
char QMargins_IsNull(void* ptr)
{
return static_cast<QMargins*>(ptr)->isNull();
}
int QMargins_Left(void* ptr)
{
return static_cast<QMargins*>(ptr)->left();
}
int QMargins_Right(void* ptr)
{
return static_cast<QMargins*>(ptr)->right();
}
void QMargins_SetBottom(void* ptr, int bottom)
{
static_cast<QMargins*>(ptr)->setBottom(bottom);
}
void QMargins_SetLeft(void* ptr, int left)
{
static_cast<QMargins*>(ptr)->setLeft(left);
}
void QMargins_SetRight(void* ptr, int right)
{
static_cast<QMargins*>(ptr)->setRight(right);
}
void QMargins_SetTop(void* ptr, int Top)
{
static_cast<QMargins*>(ptr)->setTop(Top);
}
int QMargins_Top(void* ptr)
{
return static_cast<QMargins*>(ptr)->top();
}
Q_DECLARE_METATYPE(QMarginsF)
Q_DECLARE_METATYPE(QMarginsF*)
void* QMarginsF_NewQMarginsF()
{
return new QMarginsF();
}
void* QMarginsF_NewQMarginsF2(double left, double top, double right, double bottom)
{
return new QMarginsF(left, top, right, bottom);
}
void* QMarginsF_NewQMarginsF3(void* margins)
{
return new QMarginsF(*static_cast<QMargins*>(margins));
}
double QMarginsF_Bottom(void* ptr)
{
return static_cast<QMarginsF*>(ptr)->bottom();
}
char QMarginsF_IsNull(void* ptr)
{
return static_cast<QMarginsF*>(ptr)->isNull();
}
double QMarginsF_Left(void* ptr)
{
return static_cast<QMarginsF*>(ptr)->left();
}
double QMarginsF_Right(void* ptr)
{
return static_cast<QMarginsF*>(ptr)->right();
}
void QMarginsF_SetBottom(void* ptr, double bottom)
{
static_cast<QMarginsF*>(ptr)->setBottom(bottom);
}
void QMarginsF_SetLeft(void* ptr, double left)
{
static_cast<QMarginsF*>(ptr)->setLeft(left);
}
void QMarginsF_SetRight(void* ptr, double right)
{
static_cast<QMarginsF*>(ptr)->setRight(right);
}
void QMarginsF_SetTop(void* ptr, double Top)
{
static_cast<QMarginsF*>(ptr)->setTop(Top);
}
void* QMarginsF_ToMargins(void* ptr)
{
return ({ QMargins tmpValue = static_cast<QMarginsF*>(ptr)->toMargins(); new QMargins(tmpValue.left(), tmpValue.top(), tmpValue.right(), tmpValue.bottom()); });
}
double QMarginsF_Top(void* ptr)
{
return static_cast<QMarginsF*>(ptr)->top();
}
Q_DECLARE_METATYPE(QMessageAuthenticationCode*)
void* QMessageAuthenticationCode_NewQMessageAuthenticationCode(long long method, void* key)
{
return new QMessageAuthenticationCode(static_cast<QCryptographicHash::Algorithm>(method), *static_cast<QByteArray*>(key));
}
void QMessageAuthenticationCode_AddData(void* ptr, char* data, int length)
{
static_cast<QMessageAuthenticationCode*>(ptr)->addData(const_cast<const char*>(data), length);
}
void QMessageAuthenticationCode_AddData2(void* ptr, void* data)
{
static_cast<QMessageAuthenticationCode*>(ptr)->addData(*static_cast<QByteArray*>(data));
}
char QMessageAuthenticationCode_AddData3(void* ptr, void* device)
{
return static_cast<QMessageAuthenticationCode*>(ptr)->addData(static_cast<QIODevice*>(device));
}
void* QMessageAuthenticationCode_QMessageAuthenticationCode_Hash(void* message, void* key, long long method)
{
return new QByteArray(QMessageAuthenticationCode::hash(*static_cast<QByteArray*>(message), *static_cast<QByteArray*>(key), static_cast<QCryptographicHash::Algorithm>(method)));
}
void QMessageAuthenticationCode_Reset(void* ptr)
{
static_cast<QMessageAuthenticationCode*>(ptr)->reset();
}
void* QMessageAuthenticationCode_Result(void* ptr)
{
return new QByteArray(static_cast<QMessageAuthenticationCode*>(ptr)->result());
}
void QMessageAuthenticationCode_SetKey(void* ptr, void* key)
{
static_cast<QMessageAuthenticationCode*>(ptr)->setKey(*static_cast<QByteArray*>(key));
}
void QMessageAuthenticationCode_DestroyQMessageAuthenticationCode(void* ptr)
{
static_cast<QMessageAuthenticationCode*>(ptr)->~QMessageAuthenticationCode();
}
Q_DECLARE_METATYPE(QMessageLogger*)
void* QMessageLogger_NewQMessageLogger2()
{
return new QMessageLogger();
}
void* QMessageLogger_NewQMessageLogger3(char* file, int line, char* function)
{
return new QMessageLogger(const_cast<const char*>(file), line, const_cast<const char*>(function));
}
void* QMessageLogger_NewQMessageLogger4(char* file, int line, char* function, char* category)
{
return new QMessageLogger(const_cast<const char*>(file), line, const_cast<const char*>(function), const_cast<const char*>(category));
}
void* QMessageLogger_Critical4(void* ptr)
{
return new QDebug(static_cast<QMessageLogger*>(ptr)->critical());
}
void* QMessageLogger_Critical5(void* ptr, void* cat)
{
return new QDebug(static_cast<QMessageLogger*>(ptr)->critical(*static_cast<QLoggingCategory*>(cat)));
}
void* QMessageLogger_Debug4(void* ptr)
{
return new QDebug(static_cast<QMessageLogger*>(ptr)->debug());
}
void* QMessageLogger_Debug5(void* ptr, void* cat)
{
return new QDebug(static_cast<QMessageLogger*>(ptr)->debug(*static_cast<QLoggingCategory*>(cat)));
}
void* QMessageLogger_Info4(void* ptr)
{
return new QDebug(static_cast<QMessageLogger*>(ptr)->info());
}
void* QMessageLogger_Info5(void* ptr, void* cat)
{
return new QDebug(static_cast<QMessageLogger*>(ptr)->info(*static_cast<QLoggingCategory*>(cat)));
}
void* QMessageLogger_Warning4(void* ptr)
{
return new QDebug(static_cast<QMessageLogger*>(ptr)->warning());
}
void* QMessageLogger_Warning5(void* ptr, void* cat)
{
return new QDebug(static_cast<QMessageLogger*>(ptr)->warning(*static_cast<QLoggingCategory*>(cat)));
}
struct QtCore_PackedString QMetaClassInfo_Name(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QMetaClassInfo*>(ptr)->name()), -1, NULL };
}
struct QtCore_PackedString QMetaClassInfo_Value(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QMetaClassInfo*>(ptr)->value()), -1, NULL };
}
struct QtCore_PackedString QMetaEnum_EnumName(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QMetaEnum*>(ptr)->enumName()), -1, NULL };
}
char QMetaEnum_IsFlag(void* ptr)
{
return static_cast<QMetaEnum*>(ptr)->isFlag();
}
char QMetaEnum_IsScoped(void* ptr)
{
return static_cast<QMetaEnum*>(ptr)->isScoped();
}
char QMetaEnum_IsValid(void* ptr)
{
return static_cast<QMetaEnum*>(ptr)->isValid();
}
struct QtCore_PackedString QMetaEnum_Key(void* ptr, int index)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QMetaEnum*>(ptr)->key(index)), index, NULL };
}
int QMetaEnum_KeyCount(void* ptr)
{
return static_cast<QMetaEnum*>(ptr)->keyCount();
}
int QMetaEnum_KeyToValue(void* ptr, char* key, char* ok)
{
return static_cast<QMetaEnum*>(ptr)->keyToValue(const_cast<const char*>(key), reinterpret_cast<bool*>(ok));
}
int QMetaEnum_KeysToValue(void* ptr, char* keys, char* ok)
{
return static_cast<QMetaEnum*>(ptr)->keysToValue(const_cast<const char*>(keys), reinterpret_cast<bool*>(ok));
}
struct QtCore_PackedString QMetaEnum_Name(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QMetaEnum*>(ptr)->name()), -1, NULL };
}
struct QtCore_PackedString QMetaEnum_Scope(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QMetaEnum*>(ptr)->scope()), -1, NULL };
}
int QMetaEnum_Value(void* ptr, int index)
{
return static_cast<QMetaEnum*>(ptr)->value(index);
}
struct QtCore_PackedString QMetaEnum_ValueToKey(void* ptr, int value)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QMetaEnum*>(ptr)->valueToKey(value)), value, NULL };
}
void* QMetaEnum_ValueToKeys(void* ptr, int value)
{
return new QByteArray(static_cast<QMetaEnum*>(ptr)->valueToKeys(value));
}
long long QMetaMethod_Access(void* ptr)
{
return static_cast<QMetaMethod*>(ptr)->access();
}
char QMetaMethod_Invoke(void* ptr, void* object, long long connectionType, void* returnValue, void* val0, void* val1, void* val2, void* val3, void* val4, void* val5, void* val6, void* val7, void* val8, void* val9)
{
return static_cast<QMetaMethod*>(ptr)->invoke(static_cast<QObject*>(object), static_cast<Qt::ConnectionType>(connectionType), *static_cast<QGenericReturnArgument*>(returnValue), *static_cast<QGenericArgument*>(val0), *static_cast<QGenericArgument*>(val1), *static_cast<QGenericArgument*>(val2), *static_cast<QGenericArgument*>(val3), *static_cast<QGenericArgument*>(val4), *static_cast<QGenericArgument*>(val5), *static_cast<QGenericArgument*>(val6), *static_cast<QGenericArgument*>(val7), *static_cast<QGenericArgument*>(val8), *static_cast<QGenericArgument*>(val9));
}
char QMetaMethod_Invoke2(void* ptr, void* object, void* returnValue, void* val0, void* val1, void* val2, void* val3, void* val4, void* val5, void* val6, void* val7, void* val8, void* val9)
{
return static_cast<QMetaMethod*>(ptr)->invoke(static_cast<QObject*>(object), *static_cast<QGenericReturnArgument*>(returnValue), *static_cast<QGenericArgument*>(val0), *static_cast<QGenericArgument*>(val1), *static_cast<QGenericArgument*>(val2), *static_cast<QGenericArgument*>(val3), *static_cast<QGenericArgument*>(val4), *static_cast<QGenericArgument*>(val5), *static_cast<QGenericArgument*>(val6), *static_cast<QGenericArgument*>(val7), *static_cast<QGenericArgument*>(val8), *static_cast<QGenericArgument*>(val9));
}
char QMetaMethod_Invoke3(void* ptr, void* object, long long connectionType, void* val0, void* val1, void* val2, void* val3, void* val4, void* val5, void* val6, void* val7, void* val8, void* val9)
{
return static_cast<QMetaMethod*>(ptr)->invoke(static_cast<QObject*>(object), static_cast<Qt::ConnectionType>(connectionType), *static_cast<QGenericArgument*>(val0), *static_cast<QGenericArgument*>(val1), *static_cast<QGenericArgument*>(val2), *static_cast<QGenericArgument*>(val3), *static_cast<QGenericArgument*>(val4), *static_cast<QGenericArgument*>(val5), *static_cast<QGenericArgument*>(val6), *static_cast<QGenericArgument*>(val7), *static_cast<QGenericArgument*>(val8), *static_cast<QGenericArgument*>(val9));
}
char QMetaMethod_Invoke4(void* ptr, void* object, void* val0, void* val1, void* val2, void* val3, void* val4, void* val5, void* val6, void* val7, void* val8, void* val9)
{
return static_cast<QMetaMethod*>(ptr)->invoke(static_cast<QObject*>(object), *static_cast<QGenericArgument*>(val0), *static_cast<QGenericArgument*>(val1), *static_cast<QGenericArgument*>(val2), *static_cast<QGenericArgument*>(val3), *static_cast<QGenericArgument*>(val4), *static_cast<QGenericArgument*>(val5), *static_cast<QGenericArgument*>(val6), *static_cast<QGenericArgument*>(val7), *static_cast<QGenericArgument*>(val8), *static_cast<QGenericArgument*>(val9));
}
char QMetaMethod_InvokeOnGadget(void* ptr, void* gadget, void* returnValue, void* val0, void* val1, void* val2, void* val3, void* val4, void* val5, void* val6, void* val7, void* val8, void* val9)
{
return static_cast<QMetaMethod*>(ptr)->invokeOnGadget(gadget, *static_cast<QGenericReturnArgument*>(returnValue), *static_cast<QGenericArgument*>(val0), *static_cast<QGenericArgument*>(val1), *static_cast<QGenericArgument*>(val2), *static_cast<QGenericArgument*>(val3), *static_cast<QGenericArgument*>(val4), *static_cast<QGenericArgument*>(val5), *static_cast<QGenericArgument*>(val6), *static_cast<QGenericArgument*>(val7), *static_cast<QGenericArgument*>(val8), *static_cast<QGenericArgument*>(val9));
}
char QMetaMethod_InvokeOnGadget2(void* ptr, void* gadget, void* val0, void* val1, void* val2, void* val3, void* val4, void* val5, void* val6, void* val7, void* val8, void* val9)
{
return static_cast<QMetaMethod*>(ptr)->invokeOnGadget(gadget, *static_cast<QGenericArgument*>(val0), *static_cast<QGenericArgument*>(val1), *static_cast<QGenericArgument*>(val2), *static_cast<QGenericArgument*>(val3), *static_cast<QGenericArgument*>(val4), *static_cast<QGenericArgument*>(val5), *static_cast<QGenericArgument*>(val6), *static_cast<QGenericArgument*>(val7), *static_cast<QGenericArgument*>(val8), *static_cast<QGenericArgument*>(val9));
}
char QMetaMethod_IsValid(void* ptr)
{
return static_cast<QMetaMethod*>(ptr)->isValid();
}
int QMetaMethod_MethodIndex(void* ptr)
{
return static_cast<QMetaMethod*>(ptr)->methodIndex();
}
void* QMetaMethod_MethodSignature(void* ptr)
{
return new QByteArray(static_cast<QMetaMethod*>(ptr)->methodSignature());
}
long long QMetaMethod_MethodType(void* ptr)
{
return static_cast<QMetaMethod*>(ptr)->methodType();
}
void* QMetaMethod_Name(void* ptr)
{
return new QByteArray(static_cast<QMetaMethod*>(ptr)->name());
}
int QMetaMethod_ParameterCount(void* ptr)
{
return static_cast<QMetaMethod*>(ptr)->parameterCount();
}
struct QtCore_PackedList QMetaMethod_ParameterNames(void* ptr)
{
return ({ QList<QByteArray>* tmpValuec7ea97 = new QList<QByteArray>(static_cast<QMetaMethod*>(ptr)->parameterNames()); QtCore_PackedList { tmpValuec7ea97, tmpValuec7ea97->size() }; });
}
int QMetaMethod_ParameterType(void* ptr, int index)
{
return static_cast<QMetaMethod*>(ptr)->parameterType(index);
}
struct QtCore_PackedList QMetaMethod_ParameterTypes(void* ptr)
{
return ({ QList<QByteArray>* tmpValue4f9e78 = new QList<QByteArray>(static_cast<QMetaMethod*>(ptr)->parameterTypes()); QtCore_PackedList { tmpValue4f9e78, tmpValue4f9e78->size() }; });
}
int QMetaMethod_ReturnType(void* ptr)
{
return static_cast<QMetaMethod*>(ptr)->returnType();
}
int QMetaMethod_Revision(void* ptr)
{
return static_cast<QMetaMethod*>(ptr)->revision();
}
struct QtCore_PackedString QMetaMethod_Tag(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QMetaMethod*>(ptr)->tag()), -1, NULL };
}
struct QtCore_PackedString QMetaMethod_TypeName(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QMetaMethod*>(ptr)->typeName()), -1, NULL };
}
void* QMetaMethod___parameterNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QMetaMethod___parameterNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QMetaMethod___parameterNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QMetaMethod___parameterTypes_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QMetaMethod___parameterTypes_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QMetaMethod___parameterTypes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
char QMetaObject_QMetaObject_CheckConnectArgs(char* sign, char* method)
{
return QMetaObject::checkConnectArgs(const_cast<const char*>(sign), const_cast<const char*>(method));
}
char QMetaObject_QMetaObject_CheckConnectArgs2(void* sign, void* method)
{
return QMetaObject::checkConnectArgs(*static_cast<QMetaMethod*>(sign), *static_cast<QMetaMethod*>(method));
}
int QMetaObject_ClassInfoCount(void* ptr)
{
return static_cast<QMetaObject*>(ptr)->classInfoCount();
}
int QMetaObject_ClassInfoOffset(void* ptr)
{
return static_cast<QMetaObject*>(ptr)->classInfoOffset();
}
struct QtCore_PackedString QMetaObject_ClassName(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QMetaObject*>(ptr)->className()), -1, NULL };
}
void QMetaObject_QMetaObject_ConnectSlotsByName(void* object)
{
QMetaObject::connectSlotsByName(static_cast<QObject*>(object));
}
void* QMetaObject_Constructor(void* ptr, int index)
{
return new QMetaMethod(static_cast<QMetaObject*>(ptr)->constructor(index));
}
int QMetaObject_ConstructorCount(void* ptr)
{
return static_cast<QMetaObject*>(ptr)->constructorCount();
}
int QMetaObject_EnumeratorCount(void* ptr)
{
return static_cast<QMetaObject*>(ptr)->enumeratorCount();
}
int QMetaObject_EnumeratorOffset(void* ptr)
{
return static_cast<QMetaObject*>(ptr)->enumeratorOffset();
}
int QMetaObject_IndexOfClassInfo(void* ptr, char* name)
{
return static_cast<QMetaObject*>(ptr)->indexOfClassInfo(const_cast<const char*>(name));
}
int QMetaObject_IndexOfConstructor(void* ptr, char* constructor)
{
return static_cast<QMetaObject*>(ptr)->indexOfConstructor(const_cast<const char*>(constructor));
}
int QMetaObject_IndexOfEnumerator(void* ptr, char* name)
{
return static_cast<QMetaObject*>(ptr)->indexOfEnumerator(const_cast<const char*>(name));
}
int QMetaObject_IndexOfMethod(void* ptr, char* method)
{
return static_cast<QMetaObject*>(ptr)->indexOfMethod(const_cast<const char*>(method));
}
int QMetaObject_IndexOfProperty(void* ptr, char* name)
{
return static_cast<QMetaObject*>(ptr)->indexOfProperty(const_cast<const char*>(name));
}
int QMetaObject_IndexOfSignal(void* ptr, char* sign)
{
return static_cast<QMetaObject*>(ptr)->indexOfSignal(const_cast<const char*>(sign));
}
int QMetaObject_IndexOfSlot(void* ptr, char* slot)
{
return static_cast<QMetaObject*>(ptr)->indexOfSlot(const_cast<const char*>(slot));
}
char QMetaObject_Inherits(void* ptr, void* metaObject)
{
return static_cast<QMetaObject*>(ptr)->inherits(static_cast<QMetaObject*>(metaObject));
}
char QMetaObject_QMetaObject_InvokeMethod(void* obj, char* member, long long ty, void* ret, void* val0, void* val1, void* val2, void* val3, void* val4, void* val5, void* val6, void* val7, void* val8, void* val9)
{
return QMetaObject::invokeMethod(static_cast<QObject*>(obj), const_cast<const char*>(member), static_cast<Qt::ConnectionType>(ty), *static_cast<QGenericReturnArgument*>(ret), *static_cast<QGenericArgument*>(val0), *static_cast<QGenericArgument*>(val1), *static_cast<QGenericArgument*>(val2), *static_cast<QGenericArgument*>(val3), *static_cast<QGenericArgument*>(val4), *static_cast<QGenericArgument*>(val5), *static_cast<QGenericArgument*>(val6), *static_cast<QGenericArgument*>(val7), *static_cast<QGenericArgument*>(val8), *static_cast<QGenericArgument*>(val9));
}
char QMetaObject_QMetaObject_InvokeMethod2(void* obj, char* member, void* ret, void* val0, void* val1, void* val2, void* val3, void* val4, void* val5, void* val6, void* val7, void* val8, void* val9)
{
return QMetaObject::invokeMethod(static_cast<QObject*>(obj), const_cast<const char*>(member), *static_cast<QGenericReturnArgument*>(ret), *static_cast<QGenericArgument*>(val0), *static_cast<QGenericArgument*>(val1), *static_cast<QGenericArgument*>(val2), *static_cast<QGenericArgument*>(val3), *static_cast<QGenericArgument*>(val4), *static_cast<QGenericArgument*>(val5), *static_cast<QGenericArgument*>(val6), *static_cast<QGenericArgument*>(val7), *static_cast<QGenericArgument*>(val8), *static_cast<QGenericArgument*>(val9));
}
char QMetaObject_QMetaObject_InvokeMethod3(void* obj, char* member, long long ty, void* val0, void* val1, void* val2, void* val3, void* val4, void* val5, void* val6, void* val7, void* val8, void* val9)
{
return QMetaObject::invokeMethod(static_cast<QObject*>(obj), const_cast<const char*>(member), static_cast<Qt::ConnectionType>(ty), *static_cast<QGenericArgument*>(val0), *static_cast<QGenericArgument*>(val1), *static_cast<QGenericArgument*>(val2), *static_cast<QGenericArgument*>(val3), *static_cast<QGenericArgument*>(val4), *static_cast<QGenericArgument*>(val5), *static_cast<QGenericArgument*>(val6), *static_cast<QGenericArgument*>(val7), *static_cast<QGenericArgument*>(val8), *static_cast<QGenericArgument*>(val9));
}
char QMetaObject_QMetaObject_InvokeMethod4(void* obj, char* member, void* val0, void* val1, void* val2, void* val3, void* val4, void* val5, void* val6, void* val7, void* val8, void* val9)
{
return QMetaObject::invokeMethod(static_cast<QObject*>(obj), const_cast<const char*>(member), *static_cast<QGenericArgument*>(val0), *static_cast<QGenericArgument*>(val1), *static_cast<QGenericArgument*>(val2), *static_cast<QGenericArgument*>(val3), *static_cast<QGenericArgument*>(val4), *static_cast<QGenericArgument*>(val5), *static_cast<QGenericArgument*>(val6), *static_cast<QGenericArgument*>(val7), *static_cast<QGenericArgument*>(val8), *static_cast<QGenericArgument*>(val9));
}
void* QMetaObject_Method(void* ptr, int index)
{
return new QMetaMethod(static_cast<QMetaObject*>(ptr)->method(index));
}
int QMetaObject_MethodCount(void* ptr)
{
return static_cast<QMetaObject*>(ptr)->methodCount();
}
int QMetaObject_MethodOffset(void* ptr)
{
return static_cast<QMetaObject*>(ptr)->methodOffset();
}
void* QMetaObject_NewInstance(void* ptr, void* val0, void* val1, void* val2, void* val3, void* val4, void* val5, void* val6, void* val7, void* val8, void* val9)
{
return static_cast<QMetaObject*>(ptr)->newInstance(*static_cast<QGenericArgument*>(val0), *static_cast<QGenericArgument*>(val1), *static_cast<QGenericArgument*>(val2), *static_cast<QGenericArgument*>(val3), *static_cast<QGenericArgument*>(val4), *static_cast<QGenericArgument*>(val5), *static_cast<QGenericArgument*>(val6), *static_cast<QGenericArgument*>(val7), *static_cast<QGenericArgument*>(val8), *static_cast<QGenericArgument*>(val9));
}
void* QMetaObject_QMetaObject_NormalizedSignature(char* method)
{
return new QByteArray(QMetaObject::normalizedSignature(const_cast<const char*>(method)));
}
void* QMetaObject_QMetaObject_NormalizedType(char* ty)
{
return new QByteArray(QMetaObject::normalizedType(const_cast<const char*>(ty)));
}
int QMetaObject_PropertyCount(void* ptr)
{
return static_cast<QMetaObject*>(ptr)->propertyCount();
}
int QMetaObject_PropertyOffset(void* ptr)
{
return static_cast<QMetaObject*>(ptr)->propertyOffset();
}
void* QMetaObject_SuperClass(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QMetaObject*>(ptr)->superClass());
}
char QMetaProperty_HasNotifySignal(void* ptr)
{
return static_cast<QMetaProperty*>(ptr)->hasNotifySignal();
}
char QMetaProperty_IsConstant(void* ptr)
{
return static_cast<QMetaProperty*>(ptr)->isConstant();
}
char QMetaProperty_IsDesignable(void* ptr, void* object)
{
return static_cast<QMetaProperty*>(ptr)->isDesignable(static_cast<QObject*>(object));
}
char QMetaProperty_IsEnumType(void* ptr)
{
return static_cast<QMetaProperty*>(ptr)->isEnumType();
}
char QMetaProperty_IsFinal(void* ptr)
{
return static_cast<QMetaProperty*>(ptr)->isFinal();
}
char QMetaProperty_IsFlagType(void* ptr)
{
return static_cast<QMetaProperty*>(ptr)->isFlagType();
}
char QMetaProperty_IsReadable(void* ptr)
{
return static_cast<QMetaProperty*>(ptr)->isReadable();
}
char QMetaProperty_IsResettable(void* ptr)
{
return static_cast<QMetaProperty*>(ptr)->isResettable();
}
char QMetaProperty_IsScriptable(void* ptr, void* object)
{
return static_cast<QMetaProperty*>(ptr)->isScriptable(static_cast<QObject*>(object));
}
char QMetaProperty_IsStored(void* ptr, void* object)
{
return static_cast<QMetaProperty*>(ptr)->isStored(static_cast<QObject*>(object));
}
char QMetaProperty_IsUser(void* ptr, void* object)
{
return static_cast<QMetaProperty*>(ptr)->isUser(static_cast<QObject*>(object));
}
char QMetaProperty_IsValid(void* ptr)
{
return static_cast<QMetaProperty*>(ptr)->isValid();
}
char QMetaProperty_IsWritable(void* ptr)
{
return static_cast<QMetaProperty*>(ptr)->isWritable();
}
struct QtCore_PackedString QMetaProperty_Name(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QMetaProperty*>(ptr)->name()), -1, NULL };
}
void* QMetaProperty_NotifySignal(void* ptr)
{
return new QMetaMethod(static_cast<QMetaProperty*>(ptr)->notifySignal());
}
int QMetaProperty_NotifySignalIndex(void* ptr)
{
return static_cast<QMetaProperty*>(ptr)->notifySignalIndex();
}
int QMetaProperty_PropertyIndex(void* ptr)
{
return static_cast<QMetaProperty*>(ptr)->propertyIndex();
}
void* QMetaProperty_Read(void* ptr, void* object)
{
return new QVariant(static_cast<QMetaProperty*>(ptr)->read(static_cast<QObject*>(object)));
}
void* QMetaProperty_ReadOnGadget(void* ptr, void* gadget)
{
return new QVariant(static_cast<QMetaProperty*>(ptr)->readOnGadget(gadget));
}
char QMetaProperty_Reset(void* ptr, void* object)
{
return static_cast<QMetaProperty*>(ptr)->reset(static_cast<QObject*>(object));
}
char QMetaProperty_ResetOnGadget(void* ptr, void* gadget)
{
return static_cast<QMetaProperty*>(ptr)->resetOnGadget(gadget);
}
int QMetaProperty_Revision(void* ptr)
{
return static_cast<QMetaProperty*>(ptr)->revision();
}
long long QMetaProperty_Type(void* ptr)
{
return static_cast<QMetaProperty*>(ptr)->type();
}
struct QtCore_PackedString QMetaProperty_TypeName(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QMetaProperty*>(ptr)->typeName()), -1, NULL };
}
int QMetaProperty_UserType(void* ptr)
{
return static_cast<QMetaProperty*>(ptr)->userType();
}
char QMetaProperty_Write(void* ptr, void* object, void* value)
{
return static_cast<QMetaProperty*>(ptr)->write(static_cast<QObject*>(object), *static_cast<QVariant*>(value));
}
char QMetaProperty_WriteOnGadget(void* ptr, void* gadget, void* value)
{
return static_cast<QMetaProperty*>(ptr)->writeOnGadget(gadget, *static_cast<QVariant*>(value));
}
Q_DECLARE_METATYPE(QMetaType*)
void* QMetaType_NewQMetaType(int typeId)
{
return new QMetaType(typeId);
}
char QMetaType_QMetaType_Compare(void* lhs, void* rhs, int typeId, int result)
{
return QMetaType::compare(lhs, rhs, typeId, &result);
}
void* QMetaType_QMetaType_Construct2(int ty, void* where, void* copy)
{
return QMetaType::construct(ty, where, copy);
}
void* QMetaType_Construct3(void* ptr, void* where, void* copy)
{
return static_cast<QMetaType*>(ptr)->construct(where, copy);
}
char QMetaType_QMetaType_Convert(void* from, int fromTypeId, void* to, int toTypeId)
{
return QMetaType::convert(from, fromTypeId, to, toTypeId);
}
void* QMetaType_QMetaType_Create(int ty, void* copy)
{
return QMetaType::create(ty, copy);
}
void* QMetaType_Create2(void* ptr, void* copy)
{
return static_cast<QMetaType*>(ptr)->create(copy);
}
char QMetaType_QMetaType_DebugStream(void* dbg, void* rhs, int typeId)
{
return QMetaType::debugStream(*static_cast<QDebug*>(dbg), rhs, typeId);
}
void QMetaType_QMetaType_Destroy(int ty, void* data)
{
QMetaType::destroy(ty, data);
}
void QMetaType_Destroy2(void* ptr, void* data)
{
static_cast<QMetaType*>(ptr)->destroy(data);
}
void QMetaType_QMetaType_Destruct(int ty, void* where)
{
QMetaType::destruct(ty, where);
}
void QMetaType_Destruct2(void* ptr, void* data)
{
static_cast<QMetaType*>(ptr)->destruct(data);
}
char QMetaType_QMetaType_Equals(void* lhs, void* rhs, int typeId, int result)
{
return QMetaType::equals(lhs, rhs, typeId, &result);
}
long long QMetaType_Flags(void* ptr)
{
return static_cast<QMetaType*>(ptr)->flags();
}
int QMetaType_Id(void* ptr)
{
return static_cast<QMetaType*>(ptr)->id();
}
char QMetaType_QMetaType_IsRegistered(int ty)
{
return QMetaType::isRegistered(ty);
}
char QMetaType_IsRegistered2(void* ptr)
{
return static_cast<QMetaType*>(ptr)->isRegistered();
}
char QMetaType_IsValid(void* ptr)
{
return static_cast<QMetaType*>(ptr)->isValid();
}
char QMetaType_QMetaType_Load(void* stream, int ty, void* data)
{
return QMetaType::load(*static_cast<QDataStream*>(stream), ty, data);
}
void* QMetaType_MetaObject(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QMetaType*>(ptr)->metaObject());
}
void* QMetaType_QMetaType_MetaObjectForType(int ty)
{
return const_cast<QMetaObject*>(QMetaType::metaObjectForType(ty));
}
char QMetaType_QMetaType_Save(void* stream, int ty, void* data)
{
return QMetaType::save(*static_cast<QDataStream*>(stream), ty, data);
}
int QMetaType_QMetaType_SizeOf(int ty)
{
return QMetaType::sizeOf(ty);
}
int QMetaType_SizeOf2(void* ptr)
{
return static_cast<QMetaType*>(ptr)->sizeOf();
}
int QMetaType_QMetaType_Type(char* typeName)
{
return QMetaType::type(const_cast<const char*>(typeName));
}
int QMetaType_QMetaType_Type2(void* typeName)
{
return QMetaType::type(*static_cast<QByteArray*>(typeName));
}
long long QMetaType_QMetaType_TypeFlags(int ty)
{
return QMetaType::typeFlags(ty);
}
struct QtCore_PackedString QMetaType_QMetaType_TypeName(int typeId)
{
return QtCore_PackedString { const_cast<char*>(QMetaType::typeName(typeId)), typeId, NULL };
}
void QMetaType_DestroyQMetaType(void* ptr)
{
static_cast<QMetaType*>(ptr)->~QMetaType();
}
class MyQMimeData: public QMimeData
{
public:
MyQMimeData() : QMimeData() {QMimeData_QMimeData_QRegisterMetaType();};
QStringList formats() const { return ({ QtCore_PackedString tempVal = callbackQMimeData_Formats(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
bool hasFormat(const QString & mimeType) const { QByteArray* t3313b8 = new QByteArray(mimeType.toUtf8()); QtCore_PackedString mimeTypePacked = { const_cast<char*>(t3313b8->prepend("WHITESPACE").constData()+10), t3313b8->size()-10, t3313b8 };return callbackQMimeData_HasFormat(const_cast<void*>(static_cast<const void*>(this)), mimeTypePacked) != 0; };
QVariant retrieveData(const QString & mimeType, QVariant::Type ty) const { QByteArray* t3313b8 = new QByteArray(mimeType.toUtf8()); QtCore_PackedString mimeTypePacked = { const_cast<char*>(t3313b8->prepend("WHITESPACE").constData()+10), t3313b8->size()-10, t3313b8 };return *static_cast<QVariant*>(callbackQMimeData_RetrieveData(const_cast<void*>(static_cast<const void*>(this)), mimeTypePacked, ty)); };
~MyQMimeData() { callbackQMimeData_DestroyQMimeData(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QMimeData*)
Q_DECLARE_METATYPE(MyQMimeData*)
int QMimeData_QMimeData_QRegisterMetaType(){qRegisterMetaType<QMimeData*>(); return qRegisterMetaType<MyQMimeData*>();}
void* QMimeData_NewQMimeData()
{
return new MyQMimeData();
}
void QMimeData_Clear(void* ptr)
{
static_cast<QMimeData*>(ptr)->clear();
}
void* QMimeData_ColorData(void* ptr)
{
return new QVariant(static_cast<QMimeData*>(ptr)->colorData());
}
void* QMimeData_Data(void* ptr, struct QtCore_PackedString mimeType)
{
return new QByteArray(static_cast<QMimeData*>(ptr)->data(QString::fromUtf8(mimeType.data, mimeType.len)));
}
struct QtCore_PackedString QMimeData_Formats(void* ptr)
{
return ({ QByteArray* t353e58 = new QByteArray(static_cast<QMimeData*>(ptr)->formats().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t353e58->prepend("WHITESPACE").constData()+10), t353e58->size()-10, t353e58 }; });
}
struct QtCore_PackedString QMimeData_FormatsDefault(void* ptr)
{
return ({ QByteArray* td5c1b6 = new QByteArray(static_cast<QMimeData*>(ptr)->QMimeData::formats().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(td5c1b6->prepend("WHITESPACE").constData()+10), td5c1b6->size()-10, td5c1b6 }; });
}
char QMimeData_HasColor(void* ptr)
{
return static_cast<QMimeData*>(ptr)->hasColor();
}
char QMimeData_HasFormat(void* ptr, struct QtCore_PackedString mimeType)
{
return static_cast<QMimeData*>(ptr)->hasFormat(QString::fromUtf8(mimeType.data, mimeType.len));
}
char QMimeData_HasFormatDefault(void* ptr, struct QtCore_PackedString mimeType)
{
return static_cast<QMimeData*>(ptr)->QMimeData::hasFormat(QString::fromUtf8(mimeType.data, mimeType.len));
}
char QMimeData_HasHtml(void* ptr)
{
return static_cast<QMimeData*>(ptr)->hasHtml();
}
char QMimeData_HasImage(void* ptr)
{
return static_cast<QMimeData*>(ptr)->hasImage();
}
char QMimeData_HasText(void* ptr)
{
return static_cast<QMimeData*>(ptr)->hasText();
}
char QMimeData_HasUrls(void* ptr)
{
return static_cast<QMimeData*>(ptr)->hasUrls();
}
struct QtCore_PackedString QMimeData_Html(void* ptr)
{
return ({ QByteArray* te6f56b = new QByteArray(static_cast<QMimeData*>(ptr)->html().toUtf8()); QtCore_PackedString { const_cast<char*>(te6f56b->prepend("WHITESPACE").constData()+10), te6f56b->size()-10, te6f56b }; });
}
void* QMimeData_ImageData(void* ptr)
{
return new QVariant(static_cast<QMimeData*>(ptr)->imageData());
}
void QMimeData_RemoveFormat(void* ptr, struct QtCore_PackedString mimeType)
{
static_cast<QMimeData*>(ptr)->removeFormat(QString::fromUtf8(mimeType.data, mimeType.len));
}
void* QMimeData_RetrieveData(void* ptr, struct QtCore_PackedString mimeType, long long ty)
{
return new QVariant(static_cast<QMimeData*>(ptr)->retrieveData(QString::fromUtf8(mimeType.data, mimeType.len), static_cast<QVariant::Type>(ty)));
}
void* QMimeData_RetrieveDataDefault(void* ptr, struct QtCore_PackedString mimeType, long long ty)
{
return new QVariant(static_cast<QMimeData*>(ptr)->QMimeData::retrieveData(QString::fromUtf8(mimeType.data, mimeType.len), static_cast<QVariant::Type>(ty)));
}
void QMimeData_SetColorData(void* ptr, void* color)
{
static_cast<QMimeData*>(ptr)->setColorData(*static_cast<QVariant*>(color));
}
void QMimeData_SetData(void* ptr, struct QtCore_PackedString mimeType, void* data)
{
static_cast<QMimeData*>(ptr)->setData(QString::fromUtf8(mimeType.data, mimeType.len), *static_cast<QByteArray*>(data));
}
void QMimeData_SetHtml(void* ptr, struct QtCore_PackedString html)
{
static_cast<QMimeData*>(ptr)->setHtml(QString::fromUtf8(html.data, html.len));
}
void QMimeData_SetImageData(void* ptr, void* image)
{
static_cast<QMimeData*>(ptr)->setImageData(*static_cast<QVariant*>(image));
}
void QMimeData_SetText(void* ptr, struct QtCore_PackedString text)
{
static_cast<QMimeData*>(ptr)->setText(QString::fromUtf8(text.data, text.len));
}
void QMimeData_SetUrls(void* ptr, void* urls)
{
static_cast<QMimeData*>(ptr)->setUrls(*static_cast<QList<QUrl>*>(urls));
}
struct QtCore_PackedString QMimeData_Text(void* ptr)
{
return ({ QByteArray* t2355ec = new QByteArray(static_cast<QMimeData*>(ptr)->text().toUtf8()); QtCore_PackedString { const_cast<char*>(t2355ec->prepend("WHITESPACE").constData()+10), t2355ec->size()-10, t2355ec }; });
}
struct QtCore_PackedList QMimeData_Urls(void* ptr)
{
return ({ QList<QUrl>* tmpValuea61c1b = new QList<QUrl>(static_cast<QMimeData*>(ptr)->urls()); QtCore_PackedList { tmpValuea61c1b, tmpValuea61c1b->size() }; });
}
void QMimeData_DestroyQMimeData(void* ptr)
{
static_cast<QMimeData*>(ptr)->~QMimeData();
}
void QMimeData_DestroyQMimeDataDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QMimeData___setUrls_urls_atList(void* ptr, int i)
{
return new QUrl(({QUrl tmp = static_cast<QList<QUrl>*>(ptr)->at(i); if (i == static_cast<QList<QUrl>*>(ptr)->size()-1) { static_cast<QList<QUrl>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QMimeData___setUrls_urls_setList(void* ptr, void* i)
{
static_cast<QList<QUrl>*>(ptr)->append(*static_cast<QUrl*>(i));
}
void* QMimeData___setUrls_urls_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QUrl>();
}
void* QMimeData___urls_atList(void* ptr, int i)
{
return new QUrl(({QUrl tmp = static_cast<QList<QUrl>*>(ptr)->at(i); if (i == static_cast<QList<QUrl>*>(ptr)->size()-1) { static_cast<QList<QUrl>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QMimeData___urls_setList(void* ptr, void* i)
{
static_cast<QList<QUrl>*>(ptr)->append(*static_cast<QUrl*>(i));
}
void* QMimeData___urls_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QUrl>();
}
Q_DECLARE_METATYPE(QMimeDatabase*)
void* QMimeDatabase_NewQMimeDatabase2()
{
return new QMimeDatabase();
}
struct QtCore_PackedList QMimeDatabase_AllMimeTypes(void* ptr)
{
return ({ QList<QMimeType>* tmpValuebf56ee = new QList<QMimeType>(static_cast<QMimeDatabase*>(ptr)->allMimeTypes()); QtCore_PackedList { tmpValuebf56ee, tmpValuebf56ee->size() }; });
}
void* QMimeDatabase_MimeTypeForData(void* ptr, void* data)
{
return new QMimeType(static_cast<QMimeDatabase*>(ptr)->mimeTypeForData(*static_cast<QByteArray*>(data)));
}
void* QMimeDatabase_MimeTypeForData2(void* ptr, void* device)
{
return new QMimeType(static_cast<QMimeDatabase*>(ptr)->mimeTypeForData(static_cast<QIODevice*>(device)));
}
void* QMimeDatabase_MimeTypeForFile(void* ptr, void* fileInfo, long long mode)
{
return new QMimeType(static_cast<QMimeDatabase*>(ptr)->mimeTypeForFile(*static_cast<QFileInfo*>(fileInfo), static_cast<QMimeDatabase::MatchMode>(mode)));
}
void* QMimeDatabase_MimeTypeForFile2(void* ptr, struct QtCore_PackedString fileName, long long mode)
{
return new QMimeType(static_cast<QMimeDatabase*>(ptr)->mimeTypeForFile(QString::fromUtf8(fileName.data, fileName.len), static_cast<QMimeDatabase::MatchMode>(mode)));
}
void* QMimeDatabase_MimeTypeForFileNameAndData(void* ptr, struct QtCore_PackedString fileName, void* device)
{
return new QMimeType(static_cast<QMimeDatabase*>(ptr)->mimeTypeForFileNameAndData(QString::fromUtf8(fileName.data, fileName.len), static_cast<QIODevice*>(device)));
}
void* QMimeDatabase_MimeTypeForFileNameAndData2(void* ptr, struct QtCore_PackedString fileName, void* data)
{
return new QMimeType(static_cast<QMimeDatabase*>(ptr)->mimeTypeForFileNameAndData(QString::fromUtf8(fileName.data, fileName.len), *static_cast<QByteArray*>(data)));
}
void* QMimeDatabase_MimeTypeForName(void* ptr, struct QtCore_PackedString nameOrAlias)
{
return new QMimeType(static_cast<QMimeDatabase*>(ptr)->mimeTypeForName(QString::fromUtf8(nameOrAlias.data, nameOrAlias.len)));
}
void* QMimeDatabase_MimeTypeForUrl(void* ptr, void* url)
{
return new QMimeType(static_cast<QMimeDatabase*>(ptr)->mimeTypeForUrl(*static_cast<QUrl*>(url)));
}
struct QtCore_PackedList QMimeDatabase_MimeTypesForFileName(void* ptr, struct QtCore_PackedString fileName)
{
return ({ QList<QMimeType>* tmpValue31f4f7 = new QList<QMimeType>(static_cast<QMimeDatabase*>(ptr)->mimeTypesForFileName(QString::fromUtf8(fileName.data, fileName.len))); QtCore_PackedList { tmpValue31f4f7, tmpValue31f4f7->size() }; });
}
struct QtCore_PackedString QMimeDatabase_SuffixForFileName(void* ptr, struct QtCore_PackedString fileName)
{
return ({ QByteArray* te4c687 = new QByteArray(static_cast<QMimeDatabase*>(ptr)->suffixForFileName(QString::fromUtf8(fileName.data, fileName.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(te4c687->prepend("WHITESPACE").constData()+10), te4c687->size()-10, te4c687 }; });
}
void QMimeDatabase_DestroyQMimeDatabase(void* ptr)
{
static_cast<QMimeDatabase*>(ptr)->~QMimeDatabase();
}
void* QMimeDatabase___allMimeTypes_atList(void* ptr, int i)
{
return new QMimeType(({QMimeType tmp = static_cast<QList<QMimeType>*>(ptr)->at(i); if (i == static_cast<QList<QMimeType>*>(ptr)->size()-1) { static_cast<QList<QMimeType>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QMimeDatabase___allMimeTypes_setList(void* ptr, void* i)
{
static_cast<QList<QMimeType>*>(ptr)->append(*static_cast<QMimeType*>(i));
}
void* QMimeDatabase___allMimeTypes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QMimeType>();
}
void* QMimeDatabase___mimeTypesForFileName_atList(void* ptr, int i)
{
return new QMimeType(({QMimeType tmp = static_cast<QList<QMimeType>*>(ptr)->at(i); if (i == static_cast<QList<QMimeType>*>(ptr)->size()-1) { static_cast<QList<QMimeType>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QMimeDatabase___mimeTypesForFileName_setList(void* ptr, void* i)
{
static_cast<QList<QMimeType>*>(ptr)->append(*static_cast<QMimeType*>(i));
}
void* QMimeDatabase___mimeTypesForFileName_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QMimeType>();
}
Q_DECLARE_METATYPE(QMimeType)
Q_DECLARE_METATYPE(QMimeType*)
void* QMimeType_NewQMimeType()
{
return new QMimeType();
}
void* QMimeType_NewQMimeType2(void* other)
{
return new QMimeType(*static_cast<QMimeType*>(other));
}
struct QtCore_PackedString QMimeType_Aliases(void* ptr)
{
return ({ QByteArray* t7480d3 = new QByteArray(static_cast<QMimeType*>(ptr)->aliases().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t7480d3->prepend("WHITESPACE").constData()+10), t7480d3->size()-10, t7480d3 }; });
}
struct QtCore_PackedString QMimeType_AllAncestors(void* ptr)
{
return ({ QByteArray* tf171fc = new QByteArray(static_cast<QMimeType*>(ptr)->allAncestors().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tf171fc->prepend("WHITESPACE").constData()+10), tf171fc->size()-10, tf171fc }; });
}
struct QtCore_PackedString QMimeType_Comment(void* ptr)
{
return ({ QByteArray* ta1538d = new QByteArray(static_cast<QMimeType*>(ptr)->comment().toUtf8()); QtCore_PackedString { const_cast<char*>(ta1538d->prepend("WHITESPACE").constData()+10), ta1538d->size()-10, ta1538d }; });
}
struct QtCore_PackedString QMimeType_FilterString(void* ptr)
{
return ({ QByteArray* t332dc9 = new QByteArray(static_cast<QMimeType*>(ptr)->filterString().toUtf8()); QtCore_PackedString { const_cast<char*>(t332dc9->prepend("WHITESPACE").constData()+10), t332dc9->size()-10, t332dc9 }; });
}
struct QtCore_PackedString QMimeType_GenericIconName(void* ptr)
{
return ({ QByteArray* te218a0 = new QByteArray(static_cast<QMimeType*>(ptr)->genericIconName().toUtf8()); QtCore_PackedString { const_cast<char*>(te218a0->prepend("WHITESPACE").constData()+10), te218a0->size()-10, te218a0 }; });
}
struct QtCore_PackedString QMimeType_GlobPatterns(void* ptr)
{
return ({ QByteArray* te56904 = new QByteArray(static_cast<QMimeType*>(ptr)->globPatterns().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(te56904->prepend("WHITESPACE").constData()+10), te56904->size()-10, te56904 }; });
}
struct QtCore_PackedString QMimeType_IconName(void* ptr)
{
return ({ QByteArray* tc23ba4 = new QByteArray(static_cast<QMimeType*>(ptr)->iconName().toUtf8()); QtCore_PackedString { const_cast<char*>(tc23ba4->prepend("WHITESPACE").constData()+10), tc23ba4->size()-10, tc23ba4 }; });
}
char QMimeType_Inherits(void* ptr, struct QtCore_PackedString mimeTypeName)
{
return static_cast<QMimeType*>(ptr)->inherits(QString::fromUtf8(mimeTypeName.data, mimeTypeName.len));
}
char QMimeType_IsDefault(void* ptr)
{
return static_cast<QMimeType*>(ptr)->isDefault();
}
char QMimeType_IsValid(void* ptr)
{
return static_cast<QMimeType*>(ptr)->isValid();
}
struct QtCore_PackedString QMimeType_Name(void* ptr)
{
return ({ QByteArray* ta4c2a4 = new QByteArray(static_cast<QMimeType*>(ptr)->name().toUtf8()); QtCore_PackedString { const_cast<char*>(ta4c2a4->prepend("WHITESPACE").constData()+10), ta4c2a4->size()-10, ta4c2a4 }; });
}
struct QtCore_PackedString QMimeType_ParentMimeTypes(void* ptr)
{
return ({ QByteArray* t4917fb = new QByteArray(static_cast<QMimeType*>(ptr)->parentMimeTypes().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t4917fb->prepend("WHITESPACE").constData()+10), t4917fb->size()-10, t4917fb }; });
}
struct QtCore_PackedString QMimeType_PreferredSuffix(void* ptr)
{
return ({ QByteArray* t3aa3ee = new QByteArray(static_cast<QMimeType*>(ptr)->preferredSuffix().toUtf8()); QtCore_PackedString { const_cast<char*>(t3aa3ee->prepend("WHITESPACE").constData()+10), t3aa3ee->size()-10, t3aa3ee }; });
}
struct QtCore_PackedString QMimeType_Suffixes(void* ptr)
{
return ({ QByteArray* t2e296a = new QByteArray(static_cast<QMimeType*>(ptr)->suffixes().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t2e296a->prepend("WHITESPACE").constData()+10), t2e296a->size()-10, t2e296a }; });
}
void QMimeType_Swap(void* ptr, void* other)
{
static_cast<QMimeType*>(ptr)->swap(*static_cast<QMimeType*>(other));
}
void QMimeType_DestroyQMimeType(void* ptr)
{
static_cast<QMimeType*>(ptr)->~QMimeType();
}
Q_DECLARE_METATYPE(QModelIndex)
Q_DECLARE_METATYPE(QModelIndex*)
void* QModelIndex_NewQModelIndex()
{
return new QModelIndex();
}
int QModelIndex_Column(void* ptr)
{
return static_cast<QModelIndex*>(ptr)->column();
}
void* QModelIndex_Data(void* ptr, int role)
{
return new QVariant(static_cast<QModelIndex*>(ptr)->data(role));
}
long long QModelIndex_Flags(void* ptr)
{
return static_cast<QModelIndex*>(ptr)->flags();
}
uintptr_t QModelIndex_InternalId(void* ptr)
{
return static_cast<QModelIndex*>(ptr)->internalId();
}
void* QModelIndex_InternalPointer(void* ptr)
{
return static_cast<QModelIndex*>(ptr)->internalPointer();
}
char QModelIndex_IsValid(void* ptr)
{
return static_cast<QModelIndex*>(ptr)->isValid();
}
void* QModelIndex_Model(void* ptr)
{
return const_cast<QAbstractItemModel*>(static_cast<QModelIndex*>(ptr)->model());
}
void* QModelIndex_Parent(void* ptr)
{
return new QModelIndex(static_cast<QModelIndex*>(ptr)->parent());
}
int QModelIndex_Row(void* ptr)
{
return static_cast<QModelIndex*>(ptr)->row();
}
void* QModelIndex_Sibling(void* ptr, int row, int column)
{
return new QModelIndex(static_cast<QModelIndex*>(ptr)->sibling(row, column));
}
void* QModelIndex_SiblingAtColumn(void* ptr, int column)
{
return new QModelIndex(static_cast<QModelIndex*>(ptr)->siblingAtColumn(column));
}
void* QModelIndex_SiblingAtRow(void* ptr, int row)
{
return new QModelIndex(static_cast<QModelIndex*>(ptr)->siblingAtRow(row));
}
Q_DECLARE_METATYPE(QMutex*)
void* QMutex_NewQMutex(long long mode)
{
return new QMutex(static_cast<QMutex::RecursionMode>(mode));
}
void QMutex_Lock(void* ptr)
{
static_cast<QMutex*>(ptr)->lock();
}
char QMutex_TryLock(void* ptr, int timeout)
{
return static_cast<QMutex*>(ptr)->tryLock(timeout);
}
char QMutex_Try_lock(void* ptr)
{
return static_cast<QMutex*>(ptr)->try_lock();
}
void QMutex_Unlock(void* ptr)
{
static_cast<QMutex*>(ptr)->unlock();
}
void QMutex_DestroyQMutex(void* ptr)
{
static_cast<QMutex*>(ptr)->~QMutex();
}
Q_DECLARE_METATYPE(QMutexLocker*)
void* QMutexLocker_NewQMutexLocker(void* mutex)
{
return new QMutexLocker(static_cast<QMutex*>(mutex));
}
void* QMutexLocker_Mutex(void* ptr)
{
return static_cast<QMutexLocker*>(ptr)->mutex();
}
void QMutexLocker_Relock(void* ptr)
{
static_cast<QMutexLocker*>(ptr)->relock();
}
void QMutexLocker_Unlock(void* ptr)
{
static_cast<QMutexLocker*>(ptr)->unlock();
}
void QMutexLocker_DestroyQMutexLocker(void* ptr)
{
static_cast<QMutexLocker*>(ptr)->~QMutexLocker();
}
class MyQObject: public QObject
{
public:
MyQObject(QObject *parent = Q_NULLPTR) : QObject(parent) {QObject_QObject_QRegisterMetaType();};
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
~MyQObject() { callbackQObject_DestroyQObject(this); };
};
Q_DECLARE_METATYPE(MyQObject*)
int QObject_QObject_QRegisterMetaType(){qRegisterMetaType<QObject*>(); return qRegisterMetaType<MyQObject*>();}
void* QObject_NewQObject(void* parent)
{
return new MyQObject(static_cast<QObject*>(parent));
}
char QObject_BlockSignals(void* ptr, char block)
{
return static_cast<QObject*>(ptr)->blockSignals(block != 0);
}
void QObject_ChildEvent(void* ptr, void* event)
{
static_cast<QObject*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
}
void QObject_ChildEventDefault(void* ptr, void* event)
{
if (dynamic_cast<QTranslator*>(static_cast<QObject*>(ptr))) {
static_cast<QTranslator*>(ptr)->QTranslator::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QTimer*>(static_cast<QObject*>(ptr))) {
static_cast<QTimer*>(ptr)->QTimer::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QTimeLine*>(static_cast<QObject*>(ptr))) {
static_cast<QTimeLine*>(ptr)->QTimeLine::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QThreadPool*>(static_cast<QObject*>(ptr))) {
static_cast<QThreadPool*>(ptr)->QThreadPool::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QThread*>(static_cast<QObject*>(ptr))) {
static_cast<QThread*>(ptr)->QThread::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QSocketNotifier*>(static_cast<QObject*>(ptr))) {
static_cast<QSocketNotifier*>(ptr)->QSocketNotifier::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QSharedMemory*>(static_cast<QObject*>(ptr))) {
static_cast<QSharedMemory*>(ptr)->QSharedMemory::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QSettings*>(static_cast<QObject*>(ptr))) {
static_cast<QSettings*>(ptr)->QSettings::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QPluginLoader*>(static_cast<QObject*>(ptr))) {
static_cast<QPluginLoader*>(ptr)->QPluginLoader::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QObjectCleanupHandler*>(static_cast<QObject*>(ptr))) {
static_cast<QObjectCleanupHandler*>(ptr)->QObjectCleanupHandler::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QMimeData*>(static_cast<QObject*>(ptr))) {
static_cast<QMimeData*>(ptr)->QMimeData::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QLibrary*>(static_cast<QObject*>(ptr))) {
static_cast<QLibrary*>(ptr)->QLibrary::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QItemSelectionModel*>(static_cast<QObject*>(ptr))) {
static_cast<QItemSelectionModel*>(ptr)->QItemSelectionModel::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QFutureWatcherBase*>(static_cast<QObject*>(ptr))) {
static_cast<QFutureWatcherBase*>(ptr)->QFutureWatcherBase::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QFileSystemWatcher*>(static_cast<QObject*>(ptr))) {
static_cast<QFileSystemWatcher*>(ptr)->QFileSystemWatcher::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QFileSelector*>(static_cast<QObject*>(ptr))) {
static_cast<QFileSelector*>(ptr)->QFileSelector::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QCoreApplication*>(static_cast<QObject*>(ptr))) {
static_cast<QCoreApplication*>(ptr)->QCoreApplication::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
static_cast<QProcess*>(ptr)->QProcess::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
static_cast<QSaveFile*>(ptr)->QSaveFile::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
static_cast<QFile*>(ptr)->QFile::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
static_cast<QFileDevice*>(ptr)->QFileDevice::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
static_cast<QBuffer*>(ptr)->QBuffer::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QIODevice*>(static_cast<QObject*>(ptr))) {
static_cast<QIODevice*>(ptr)->QIODevice::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QSignalTransition*>(static_cast<QObject*>(ptr))) {
static_cast<QSignalTransition*>(ptr)->QSignalTransition::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QEventTransition*>(static_cast<QObject*>(ptr))) {
static_cast<QEventTransition*>(ptr)->QEventTransition::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QAbstractTransition*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractTransition*>(ptr)->QAbstractTransition::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QStateMachine*>(static_cast<QObject*>(ptr))) {
static_cast<QStateMachine*>(ptr)->QStateMachine::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QState*>(static_cast<QObject*>(ptr))) {
static_cast<QState*>(ptr)->QState::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QHistoryState*>(static_cast<QObject*>(ptr))) {
static_cast<QHistoryState*>(ptr)->QHistoryState::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QFinalState*>(static_cast<QObject*>(ptr))) {
static_cast<QFinalState*>(ptr)->QFinalState::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QAbstractState*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractState*>(ptr)->QAbstractState::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QStringListModel*>(ptr)->QStringListModel::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QAbstractItemModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QAbstractEventDispatcher*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractEventDispatcher*>(ptr)->QAbstractEventDispatcher::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QEventLoop*>(static_cast<QObject*>(ptr))) {
static_cast<QEventLoop*>(ptr)->QEventLoop::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QVariantAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QPauseAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QAnimationGroup*>(ptr)->QAnimationGroup::childEvent(static_cast<QChildEvent*>(event));
} else if (dynamic_cast<QAbstractAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractAnimation*>(ptr)->QAbstractAnimation::childEvent(static_cast<QChildEvent*>(event));
} else {
static_cast<QObject*>(ptr)->QObject::childEvent(static_cast<QChildEvent*>(event));
}
}
struct QtCore_PackedList QObject_Children(void* ptr)
{
return ({ QList<QObject *>* tmpValue53f390 = new QList<QObject *>(static_cast<QObject*>(ptr)->children()); QtCore_PackedList { tmpValue53f390, tmpValue53f390->size() }; });
}
void QObject_ConnectNotify(void* ptr, void* sign)
{
static_cast<QObject*>(ptr)->connectNotify(*static_cast<QMetaMethod*>(sign));
}
void QObject_ConnectNotifyDefault(void* ptr, void* sign)
{
if (dynamic_cast<QTranslator*>(static_cast<QObject*>(ptr))) {
static_cast<QTranslator*>(ptr)->QTranslator::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QTimer*>(static_cast<QObject*>(ptr))) {
static_cast<QTimer*>(ptr)->QTimer::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QTimeLine*>(static_cast<QObject*>(ptr))) {
static_cast<QTimeLine*>(ptr)->QTimeLine::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QThreadPool*>(static_cast<QObject*>(ptr))) {
static_cast<QThreadPool*>(ptr)->QThreadPool::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QThread*>(static_cast<QObject*>(ptr))) {
static_cast<QThread*>(ptr)->QThread::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QSocketNotifier*>(static_cast<QObject*>(ptr))) {
static_cast<QSocketNotifier*>(ptr)->QSocketNotifier::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QSharedMemory*>(static_cast<QObject*>(ptr))) {
static_cast<QSharedMemory*>(ptr)->QSharedMemory::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QSettings*>(static_cast<QObject*>(ptr))) {
static_cast<QSettings*>(ptr)->QSettings::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QPluginLoader*>(static_cast<QObject*>(ptr))) {
static_cast<QPluginLoader*>(ptr)->QPluginLoader::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QObjectCleanupHandler*>(static_cast<QObject*>(ptr))) {
static_cast<QObjectCleanupHandler*>(ptr)->QObjectCleanupHandler::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QMimeData*>(static_cast<QObject*>(ptr))) {
static_cast<QMimeData*>(ptr)->QMimeData::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QLibrary*>(static_cast<QObject*>(ptr))) {
static_cast<QLibrary*>(ptr)->QLibrary::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QItemSelectionModel*>(static_cast<QObject*>(ptr))) {
static_cast<QItemSelectionModel*>(ptr)->QItemSelectionModel::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QFutureWatcherBase*>(static_cast<QObject*>(ptr))) {
static_cast<QFutureWatcherBase*>(ptr)->QFutureWatcherBase::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QFileSystemWatcher*>(static_cast<QObject*>(ptr))) {
static_cast<QFileSystemWatcher*>(ptr)->QFileSystemWatcher::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QFileSelector*>(static_cast<QObject*>(ptr))) {
static_cast<QFileSelector*>(ptr)->QFileSelector::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QCoreApplication*>(static_cast<QObject*>(ptr))) {
static_cast<QCoreApplication*>(ptr)->QCoreApplication::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
static_cast<QProcess*>(ptr)->QProcess::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
static_cast<QSaveFile*>(ptr)->QSaveFile::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
static_cast<QFile*>(ptr)->QFile::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
static_cast<QFileDevice*>(ptr)->QFileDevice::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
static_cast<QBuffer*>(ptr)->QBuffer::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QIODevice*>(static_cast<QObject*>(ptr))) {
static_cast<QIODevice*>(ptr)->QIODevice::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QSignalTransition*>(static_cast<QObject*>(ptr))) {
static_cast<QSignalTransition*>(ptr)->QSignalTransition::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QEventTransition*>(static_cast<QObject*>(ptr))) {
static_cast<QEventTransition*>(ptr)->QEventTransition::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QAbstractTransition*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractTransition*>(ptr)->QAbstractTransition::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QStateMachine*>(static_cast<QObject*>(ptr))) {
static_cast<QStateMachine*>(ptr)->QStateMachine::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QState*>(static_cast<QObject*>(ptr))) {
static_cast<QState*>(ptr)->QState::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QHistoryState*>(static_cast<QObject*>(ptr))) {
static_cast<QHistoryState*>(ptr)->QHistoryState::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QFinalState*>(static_cast<QObject*>(ptr))) {
static_cast<QFinalState*>(ptr)->QFinalState::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QAbstractState*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractState*>(ptr)->QAbstractState::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QStringListModel*>(ptr)->QStringListModel::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QAbstractItemModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QAbstractEventDispatcher*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractEventDispatcher*>(ptr)->QAbstractEventDispatcher::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QEventLoop*>(static_cast<QObject*>(ptr))) {
static_cast<QEventLoop*>(ptr)->QEventLoop::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QVariantAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QPauseAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QAnimationGroup*>(ptr)->QAnimationGroup::connectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QAbstractAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractAnimation*>(ptr)->QAbstractAnimation::connectNotify(*static_cast<QMetaMethod*>(sign));
} else {
static_cast<QObject*>(ptr)->QObject::connectNotify(*static_cast<QMetaMethod*>(sign));
}
}
void QObject_CustomEvent(void* ptr, void* event)
{
static_cast<QObject*>(ptr)->customEvent(static_cast<QEvent*>(event));
}
void QObject_CustomEventDefault(void* ptr, void* event)
{
if (dynamic_cast<QTranslator*>(static_cast<QObject*>(ptr))) {
static_cast<QTranslator*>(ptr)->QTranslator::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QTimer*>(static_cast<QObject*>(ptr))) {
static_cast<QTimer*>(ptr)->QTimer::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QTimeLine*>(static_cast<QObject*>(ptr))) {
static_cast<QTimeLine*>(ptr)->QTimeLine::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QThreadPool*>(static_cast<QObject*>(ptr))) {
static_cast<QThreadPool*>(ptr)->QThreadPool::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QThread*>(static_cast<QObject*>(ptr))) {
static_cast<QThread*>(ptr)->QThread::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QSocketNotifier*>(static_cast<QObject*>(ptr))) {
static_cast<QSocketNotifier*>(ptr)->QSocketNotifier::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QSharedMemory*>(static_cast<QObject*>(ptr))) {
static_cast<QSharedMemory*>(ptr)->QSharedMemory::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QSettings*>(static_cast<QObject*>(ptr))) {
static_cast<QSettings*>(ptr)->QSettings::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QPluginLoader*>(static_cast<QObject*>(ptr))) {
static_cast<QPluginLoader*>(ptr)->QPluginLoader::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QObjectCleanupHandler*>(static_cast<QObject*>(ptr))) {
static_cast<QObjectCleanupHandler*>(ptr)->QObjectCleanupHandler::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QMimeData*>(static_cast<QObject*>(ptr))) {
static_cast<QMimeData*>(ptr)->QMimeData::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QLibrary*>(static_cast<QObject*>(ptr))) {
static_cast<QLibrary*>(ptr)->QLibrary::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QItemSelectionModel*>(static_cast<QObject*>(ptr))) {
static_cast<QItemSelectionModel*>(ptr)->QItemSelectionModel::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QFutureWatcherBase*>(static_cast<QObject*>(ptr))) {
static_cast<QFutureWatcherBase*>(ptr)->QFutureWatcherBase::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QFileSystemWatcher*>(static_cast<QObject*>(ptr))) {
static_cast<QFileSystemWatcher*>(ptr)->QFileSystemWatcher::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QFileSelector*>(static_cast<QObject*>(ptr))) {
static_cast<QFileSelector*>(ptr)->QFileSelector::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QCoreApplication*>(static_cast<QObject*>(ptr))) {
static_cast<QCoreApplication*>(ptr)->QCoreApplication::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
static_cast<QProcess*>(ptr)->QProcess::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
static_cast<QSaveFile*>(ptr)->QSaveFile::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
static_cast<QFile*>(ptr)->QFile::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
static_cast<QFileDevice*>(ptr)->QFileDevice::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
static_cast<QBuffer*>(ptr)->QBuffer::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QIODevice*>(static_cast<QObject*>(ptr))) {
static_cast<QIODevice*>(ptr)->QIODevice::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QSignalTransition*>(static_cast<QObject*>(ptr))) {
static_cast<QSignalTransition*>(ptr)->QSignalTransition::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QEventTransition*>(static_cast<QObject*>(ptr))) {
static_cast<QEventTransition*>(ptr)->QEventTransition::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QAbstractTransition*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractTransition*>(ptr)->QAbstractTransition::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QStateMachine*>(static_cast<QObject*>(ptr))) {
static_cast<QStateMachine*>(ptr)->QStateMachine::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QState*>(static_cast<QObject*>(ptr))) {
static_cast<QState*>(ptr)->QState::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QHistoryState*>(static_cast<QObject*>(ptr))) {
static_cast<QHistoryState*>(ptr)->QHistoryState::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QFinalState*>(static_cast<QObject*>(ptr))) {
static_cast<QFinalState*>(ptr)->QFinalState::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QAbstractState*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractState*>(ptr)->QAbstractState::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QStringListModel*>(ptr)->QStringListModel::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QAbstractItemModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QAbstractEventDispatcher*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractEventDispatcher*>(ptr)->QAbstractEventDispatcher::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QEventLoop*>(static_cast<QObject*>(ptr))) {
static_cast<QEventLoop*>(ptr)->QEventLoop::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QVariantAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QPauseAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QAnimationGroup*>(ptr)->QAnimationGroup::customEvent(static_cast<QEvent*>(event));
} else if (dynamic_cast<QAbstractAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractAnimation*>(ptr)->QAbstractAnimation::customEvent(static_cast<QEvent*>(event));
} else {
static_cast<QObject*>(ptr)->QObject::customEvent(static_cast<QEvent*>(event));
}
}
void QObject_DeleteLater(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QObject*>(ptr), "deleteLater");
}
void QObject_DeleteLaterDefault(void* ptr)
{
if (dynamic_cast<QTranslator*>(static_cast<QObject*>(ptr))) {
static_cast<QTranslator*>(ptr)->QTranslator::deleteLater();
} else if (dynamic_cast<QTimer*>(static_cast<QObject*>(ptr))) {
static_cast<QTimer*>(ptr)->QTimer::deleteLater();
} else if (dynamic_cast<QTimeLine*>(static_cast<QObject*>(ptr))) {
static_cast<QTimeLine*>(ptr)->QTimeLine::deleteLater();
} else if (dynamic_cast<QThreadPool*>(static_cast<QObject*>(ptr))) {
static_cast<QThreadPool*>(ptr)->QThreadPool::deleteLater();
} else if (dynamic_cast<QThread*>(static_cast<QObject*>(ptr))) {
static_cast<QThread*>(ptr)->QThread::deleteLater();
} else if (dynamic_cast<QSocketNotifier*>(static_cast<QObject*>(ptr))) {
static_cast<QSocketNotifier*>(ptr)->QSocketNotifier::deleteLater();
} else if (dynamic_cast<QSharedMemory*>(static_cast<QObject*>(ptr))) {
static_cast<QSharedMemory*>(ptr)->QSharedMemory::deleteLater();
} else if (dynamic_cast<QSettings*>(static_cast<QObject*>(ptr))) {
static_cast<QSettings*>(ptr)->QSettings::deleteLater();
} else if (dynamic_cast<QPluginLoader*>(static_cast<QObject*>(ptr))) {
static_cast<QPluginLoader*>(ptr)->QPluginLoader::deleteLater();
} else if (dynamic_cast<QObjectCleanupHandler*>(static_cast<QObject*>(ptr))) {
static_cast<QObjectCleanupHandler*>(ptr)->QObjectCleanupHandler::deleteLater();
} else if (dynamic_cast<QMimeData*>(static_cast<QObject*>(ptr))) {
static_cast<QMimeData*>(ptr)->QMimeData::deleteLater();
} else if (dynamic_cast<QLibrary*>(static_cast<QObject*>(ptr))) {
static_cast<QLibrary*>(ptr)->QLibrary::deleteLater();
} else if (dynamic_cast<QItemSelectionModel*>(static_cast<QObject*>(ptr))) {
static_cast<QItemSelectionModel*>(ptr)->QItemSelectionModel::deleteLater();
} else if (dynamic_cast<QFutureWatcherBase*>(static_cast<QObject*>(ptr))) {
static_cast<QFutureWatcherBase*>(ptr)->QFutureWatcherBase::deleteLater();
} else if (dynamic_cast<QFileSystemWatcher*>(static_cast<QObject*>(ptr))) {
static_cast<QFileSystemWatcher*>(ptr)->QFileSystemWatcher::deleteLater();
} else if (dynamic_cast<QFileSelector*>(static_cast<QObject*>(ptr))) {
static_cast<QFileSelector*>(ptr)->QFileSelector::deleteLater();
} else if (dynamic_cast<QCoreApplication*>(static_cast<QObject*>(ptr))) {
static_cast<QCoreApplication*>(ptr)->QCoreApplication::deleteLater();
} else if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
static_cast<QProcess*>(ptr)->QProcess::deleteLater();
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
static_cast<QSaveFile*>(ptr)->QSaveFile::deleteLater();
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::deleteLater();
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
static_cast<QFile*>(ptr)->QFile::deleteLater();
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
static_cast<QFileDevice*>(ptr)->QFileDevice::deleteLater();
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
static_cast<QBuffer*>(ptr)->QBuffer::deleteLater();
} else if (dynamic_cast<QIODevice*>(static_cast<QObject*>(ptr))) {
static_cast<QIODevice*>(ptr)->QIODevice::deleteLater();
} else if (dynamic_cast<QSignalTransition*>(static_cast<QObject*>(ptr))) {
static_cast<QSignalTransition*>(ptr)->QSignalTransition::deleteLater();
} else if (dynamic_cast<QEventTransition*>(static_cast<QObject*>(ptr))) {
static_cast<QEventTransition*>(ptr)->QEventTransition::deleteLater();
} else if (dynamic_cast<QAbstractTransition*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractTransition*>(ptr)->QAbstractTransition::deleteLater();
} else if (dynamic_cast<QStateMachine*>(static_cast<QObject*>(ptr))) {
static_cast<QStateMachine*>(ptr)->QStateMachine::deleteLater();
} else if (dynamic_cast<QState*>(static_cast<QObject*>(ptr))) {
static_cast<QState*>(ptr)->QState::deleteLater();
} else if (dynamic_cast<QHistoryState*>(static_cast<QObject*>(ptr))) {
static_cast<QHistoryState*>(ptr)->QHistoryState::deleteLater();
} else if (dynamic_cast<QFinalState*>(static_cast<QObject*>(ptr))) {
static_cast<QFinalState*>(ptr)->QFinalState::deleteLater();
} else if (dynamic_cast<QAbstractState*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractState*>(ptr)->QAbstractState::deleteLater();
} else if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::deleteLater();
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::deleteLater();
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::deleteLater();
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::deleteLater();
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::deleteLater();
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QStringListModel*>(ptr)->QStringListModel::deleteLater();
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::deleteLater();
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::deleteLater();
} else if (dynamic_cast<QAbstractItemModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::deleteLater();
} else if (dynamic_cast<QAbstractEventDispatcher*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractEventDispatcher*>(ptr)->QAbstractEventDispatcher::deleteLater();
} else if (dynamic_cast<QEventLoop*>(static_cast<QObject*>(ptr))) {
static_cast<QEventLoop*>(ptr)->QEventLoop::deleteLater();
} else if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::deleteLater();
} else if (dynamic_cast<QVariantAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::deleteLater();
} else if (dynamic_cast<QPauseAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::deleteLater();
} else if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::deleteLater();
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::deleteLater();
} else if (dynamic_cast<QAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QAnimationGroup*>(ptr)->QAnimationGroup::deleteLater();
} else if (dynamic_cast<QAbstractAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractAnimation*>(ptr)->QAbstractAnimation::deleteLater();
} else {
static_cast<QObject*>(ptr)->QObject::deleteLater();
}
}
void QObject_ConnectDestroyed(void* ptr, long long t)
{
QObject::connect(static_cast<QObject*>(ptr), static_cast<void (QObject::*)(QObject *)>(&QObject::destroyed), static_cast<MyQObject*>(ptr), static_cast<void (MyQObject::*)(QObject *)>(&MyQObject::Signal_Destroyed), static_cast<Qt::ConnectionType>(t));
}
void QObject_DisconnectDestroyed(void* ptr)
{
QObject::disconnect(static_cast<QObject*>(ptr), static_cast<void (QObject::*)(QObject *)>(&QObject::destroyed), static_cast<MyQObject*>(ptr), static_cast<void (MyQObject::*)(QObject *)>(&MyQObject::Signal_Destroyed));
}
void QObject_Destroyed(void* ptr, void* obj)
{
static_cast<QObject*>(ptr)->destroyed(static_cast<QObject*>(obj));
}
char QObject_QObject_Disconnect(void* sender, char* sign, void* receiver, char* method)
{
return QObject::disconnect(static_cast<QObject*>(sender), const_cast<const char*>(sign), static_cast<QObject*>(receiver), const_cast<const char*>(method));
}
char QObject_QObject_Disconnect2(void* sender, void* sign, void* receiver, void* method)
{
return QObject::disconnect(static_cast<QObject*>(sender), *static_cast<QMetaMethod*>(sign), static_cast<QObject*>(receiver), *static_cast<QMetaMethod*>(method));
}
char QObject_Disconnect3(void* ptr, char* sign, void* receiver, char* method)
{
return static_cast<QObject*>(ptr)->disconnect(const_cast<const char*>(sign), static_cast<QObject*>(receiver), const_cast<const char*>(method));
}
char QObject_Disconnect4(void* ptr, void* receiver, char* method)
{
return static_cast<QObject*>(ptr)->disconnect(static_cast<QObject*>(receiver), const_cast<const char*>(method));
}
void QObject_DisconnectNotify(void* ptr, void* sign)
{
static_cast<QObject*>(ptr)->disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
void QObject_DisconnectNotifyDefault(void* ptr, void* sign)
{
if (dynamic_cast<QTranslator*>(static_cast<QObject*>(ptr))) {
static_cast<QTranslator*>(ptr)->QTranslator::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QTimer*>(static_cast<QObject*>(ptr))) {
static_cast<QTimer*>(ptr)->QTimer::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QTimeLine*>(static_cast<QObject*>(ptr))) {
static_cast<QTimeLine*>(ptr)->QTimeLine::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QThreadPool*>(static_cast<QObject*>(ptr))) {
static_cast<QThreadPool*>(ptr)->QThreadPool::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QThread*>(static_cast<QObject*>(ptr))) {
static_cast<QThread*>(ptr)->QThread::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QSocketNotifier*>(static_cast<QObject*>(ptr))) {
static_cast<QSocketNotifier*>(ptr)->QSocketNotifier::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QSharedMemory*>(static_cast<QObject*>(ptr))) {
static_cast<QSharedMemory*>(ptr)->QSharedMemory::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QSettings*>(static_cast<QObject*>(ptr))) {
static_cast<QSettings*>(ptr)->QSettings::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QPluginLoader*>(static_cast<QObject*>(ptr))) {
static_cast<QPluginLoader*>(ptr)->QPluginLoader::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QObjectCleanupHandler*>(static_cast<QObject*>(ptr))) {
static_cast<QObjectCleanupHandler*>(ptr)->QObjectCleanupHandler::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QMimeData*>(static_cast<QObject*>(ptr))) {
static_cast<QMimeData*>(ptr)->QMimeData::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QLibrary*>(static_cast<QObject*>(ptr))) {
static_cast<QLibrary*>(ptr)->QLibrary::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QItemSelectionModel*>(static_cast<QObject*>(ptr))) {
static_cast<QItemSelectionModel*>(ptr)->QItemSelectionModel::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QFutureWatcherBase*>(static_cast<QObject*>(ptr))) {
static_cast<QFutureWatcherBase*>(ptr)->QFutureWatcherBase::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QFileSystemWatcher*>(static_cast<QObject*>(ptr))) {
static_cast<QFileSystemWatcher*>(ptr)->QFileSystemWatcher::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QFileSelector*>(static_cast<QObject*>(ptr))) {
static_cast<QFileSelector*>(ptr)->QFileSelector::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QCoreApplication*>(static_cast<QObject*>(ptr))) {
static_cast<QCoreApplication*>(ptr)->QCoreApplication::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
static_cast<QProcess*>(ptr)->QProcess::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
static_cast<QSaveFile*>(ptr)->QSaveFile::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
static_cast<QFile*>(ptr)->QFile::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
static_cast<QFileDevice*>(ptr)->QFileDevice::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
static_cast<QBuffer*>(ptr)->QBuffer::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QIODevice*>(static_cast<QObject*>(ptr))) {
static_cast<QIODevice*>(ptr)->QIODevice::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QSignalTransition*>(static_cast<QObject*>(ptr))) {
static_cast<QSignalTransition*>(ptr)->QSignalTransition::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QEventTransition*>(static_cast<QObject*>(ptr))) {
static_cast<QEventTransition*>(ptr)->QEventTransition::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QAbstractTransition*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractTransition*>(ptr)->QAbstractTransition::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QStateMachine*>(static_cast<QObject*>(ptr))) {
static_cast<QStateMachine*>(ptr)->QStateMachine::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QState*>(static_cast<QObject*>(ptr))) {
static_cast<QState*>(ptr)->QState::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QHistoryState*>(static_cast<QObject*>(ptr))) {
static_cast<QHistoryState*>(ptr)->QHistoryState::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QFinalState*>(static_cast<QObject*>(ptr))) {
static_cast<QFinalState*>(ptr)->QFinalState::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QAbstractState*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractState*>(ptr)->QAbstractState::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QStringListModel*>(ptr)->QStringListModel::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QAbstractItemModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QAbstractEventDispatcher*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractEventDispatcher*>(ptr)->QAbstractEventDispatcher::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QEventLoop*>(static_cast<QObject*>(ptr))) {
static_cast<QEventLoop*>(ptr)->QEventLoop::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QVariantAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QPauseAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QAnimationGroup*>(ptr)->QAnimationGroup::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else if (dynamic_cast<QAbstractAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractAnimation*>(ptr)->QAbstractAnimation::disconnectNotify(*static_cast<QMetaMethod*>(sign));
} else {
static_cast<QObject*>(ptr)->QObject::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
}
void QObject_DumpObjectInfo(void* ptr)
{
static_cast<QObject*>(ptr)->dumpObjectInfo();
}
void QObject_DumpObjectTree(void* ptr)
{
static_cast<QObject*>(ptr)->dumpObjectTree();
}
struct QtCore_PackedList QObject_DynamicPropertyNames(void* ptr)
{
return ({ QList<QByteArray>* tmpValue9188e5 = new QList<QByteArray>(static_cast<QObject*>(ptr)->dynamicPropertyNames()); QtCore_PackedList { tmpValue9188e5, tmpValue9188e5->size() }; });
}
char QObject_Event(void* ptr, void* e)
{
return static_cast<QObject*>(ptr)->event(static_cast<QEvent*>(e));
}
char QObject_EventDefault(void* ptr, void* e)
{
if (dynamic_cast<QTranslator*>(static_cast<QObject*>(ptr))) {
return static_cast<QTranslator*>(ptr)->QTranslator::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QTimer*>(static_cast<QObject*>(ptr))) {
return static_cast<QTimer*>(ptr)->QTimer::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QTimeLine*>(static_cast<QObject*>(ptr))) {
return static_cast<QTimeLine*>(ptr)->QTimeLine::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QThreadPool*>(static_cast<QObject*>(ptr))) {
return static_cast<QThreadPool*>(ptr)->QThreadPool::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QThread*>(static_cast<QObject*>(ptr))) {
return static_cast<QThread*>(ptr)->QThread::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QSocketNotifier*>(static_cast<QObject*>(ptr))) {
return static_cast<QSocketNotifier*>(ptr)->QSocketNotifier::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QSharedMemory*>(static_cast<QObject*>(ptr))) {
return static_cast<QSharedMemory*>(ptr)->QSharedMemory::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QSettings*>(static_cast<QObject*>(ptr))) {
return static_cast<QSettings*>(ptr)->QSettings::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QPluginLoader*>(static_cast<QObject*>(ptr))) {
return static_cast<QPluginLoader*>(ptr)->QPluginLoader::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QObjectCleanupHandler*>(static_cast<QObject*>(ptr))) {
return static_cast<QObjectCleanupHandler*>(ptr)->QObjectCleanupHandler::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QMimeData*>(static_cast<QObject*>(ptr))) {
return static_cast<QMimeData*>(ptr)->QMimeData::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QLibrary*>(static_cast<QObject*>(ptr))) {
return static_cast<QLibrary*>(ptr)->QLibrary::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QItemSelectionModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QItemSelectionModel*>(ptr)->QItemSelectionModel::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QFutureWatcherBase*>(static_cast<QObject*>(ptr))) {
return static_cast<QFutureWatcherBase*>(ptr)->QFutureWatcherBase::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QFileSystemWatcher*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileSystemWatcher*>(ptr)->QFileSystemWatcher::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QFileSelector*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileSelector*>(ptr)->QFileSelector::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QCoreApplication*>(static_cast<QObject*>(ptr))) {
return static_cast<QCoreApplication*>(ptr)->QCoreApplication::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
return static_cast<QProcess*>(ptr)->QProcess::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileDevice*>(ptr)->QFileDevice::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
return static_cast<QBuffer*>(ptr)->QBuffer::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QIODevice*>(static_cast<QObject*>(ptr))) {
return static_cast<QIODevice*>(ptr)->QIODevice::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QSignalTransition*>(static_cast<QObject*>(ptr))) {
return static_cast<QSignalTransition*>(ptr)->QSignalTransition::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QEventTransition*>(static_cast<QObject*>(ptr))) {
return static_cast<QEventTransition*>(ptr)->QEventTransition::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QAbstractTransition*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTransition*>(ptr)->QAbstractTransition::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QStateMachine*>(static_cast<QObject*>(ptr))) {
return static_cast<QStateMachine*>(ptr)->QStateMachine::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QState*>(static_cast<QObject*>(ptr))) {
return static_cast<QState*>(ptr)->QState::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QHistoryState*>(static_cast<QObject*>(ptr))) {
return static_cast<QHistoryState*>(ptr)->QHistoryState::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QFinalState*>(static_cast<QObject*>(ptr))) {
return static_cast<QFinalState*>(ptr)->QFinalState::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QAbstractState*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractState*>(ptr)->QAbstractState::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QAbstractItemModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QAbstractEventDispatcher*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractEventDispatcher*>(ptr)->QAbstractEventDispatcher::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QEventLoop*>(static_cast<QObject*>(ptr))) {
return static_cast<QEventLoop*>(ptr)->QEventLoop::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
return static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QVariantAnimation*>(static_cast<QObject*>(ptr))) {
return static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QPauseAnimation*>(static_cast<QObject*>(ptr))) {
return static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
return static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
return static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QAnimationGroup*>(static_cast<QObject*>(ptr))) {
return static_cast<QAnimationGroup*>(ptr)->QAnimationGroup::event(static_cast<QEvent*>(e));
} else if (dynamic_cast<QAbstractAnimation*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractAnimation*>(ptr)->QAbstractAnimation::event(static_cast<QEvent*>(e));
} else {
return static_cast<QObject*>(ptr)->QObject::event(static_cast<QEvent*>(e));
}
}
char QObject_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QObject*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
char QObject_EventFilterDefault(void* ptr, void* watched, void* event)
{
if (dynamic_cast<QTranslator*>(static_cast<QObject*>(ptr))) {
return static_cast<QTranslator*>(ptr)->QTranslator::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QTimer*>(static_cast<QObject*>(ptr))) {
return static_cast<QTimer*>(ptr)->QTimer::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QTimeLine*>(static_cast<QObject*>(ptr))) {
return static_cast<QTimeLine*>(ptr)->QTimeLine::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QThreadPool*>(static_cast<QObject*>(ptr))) {
return static_cast<QThreadPool*>(ptr)->QThreadPool::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QThread*>(static_cast<QObject*>(ptr))) {
return static_cast<QThread*>(ptr)->QThread::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QSocketNotifier*>(static_cast<QObject*>(ptr))) {
return static_cast<QSocketNotifier*>(ptr)->QSocketNotifier::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QSharedMemory*>(static_cast<QObject*>(ptr))) {
return static_cast<QSharedMemory*>(ptr)->QSharedMemory::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QSettings*>(static_cast<QObject*>(ptr))) {
return static_cast<QSettings*>(ptr)->QSettings::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPluginLoader*>(static_cast<QObject*>(ptr))) {
return static_cast<QPluginLoader*>(ptr)->QPluginLoader::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QObjectCleanupHandler*>(static_cast<QObject*>(ptr))) {
return static_cast<QObjectCleanupHandler*>(ptr)->QObjectCleanupHandler::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QMimeData*>(static_cast<QObject*>(ptr))) {
return static_cast<QMimeData*>(ptr)->QMimeData::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QLibrary*>(static_cast<QObject*>(ptr))) {
return static_cast<QLibrary*>(ptr)->QLibrary::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QItemSelectionModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QItemSelectionModel*>(ptr)->QItemSelectionModel::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QFutureWatcherBase*>(static_cast<QObject*>(ptr))) {
return static_cast<QFutureWatcherBase*>(ptr)->QFutureWatcherBase::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QFileSystemWatcher*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileSystemWatcher*>(ptr)->QFileSystemWatcher::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QFileSelector*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileSelector*>(ptr)->QFileSelector::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QCoreApplication*>(static_cast<QObject*>(ptr))) {
return static_cast<QCoreApplication*>(ptr)->QCoreApplication::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
return static_cast<QProcess*>(ptr)->QProcess::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QSaveFile*>(ptr)->QSaveFile::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return static_cast<QFile*>(ptr)->QFile::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
return static_cast<QFileDevice*>(ptr)->QFileDevice::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
return static_cast<QBuffer*>(ptr)->QBuffer::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QIODevice*>(static_cast<QObject*>(ptr))) {
return static_cast<QIODevice*>(ptr)->QIODevice::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QSignalTransition*>(static_cast<QObject*>(ptr))) {
return static_cast<QSignalTransition*>(ptr)->QSignalTransition::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QEventTransition*>(static_cast<QObject*>(ptr))) {
return static_cast<QEventTransition*>(ptr)->QEventTransition::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QAbstractTransition*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTransition*>(ptr)->QAbstractTransition::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QStateMachine*>(static_cast<QObject*>(ptr))) {
return static_cast<QStateMachine*>(ptr)->QStateMachine::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QState*>(static_cast<QObject*>(ptr))) {
return static_cast<QState*>(ptr)->QState::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QHistoryState*>(static_cast<QObject*>(ptr))) {
return static_cast<QHistoryState*>(ptr)->QHistoryState::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QFinalState*>(static_cast<QObject*>(ptr))) {
return static_cast<QFinalState*>(ptr)->QFinalState::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QAbstractState*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractState*>(ptr)->QAbstractState::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QStringListModel*>(ptr)->QStringListModel::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QAbstractItemModel*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QAbstractEventDispatcher*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractEventDispatcher*>(ptr)->QAbstractEventDispatcher::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QEventLoop*>(static_cast<QObject*>(ptr))) {
return static_cast<QEventLoop*>(ptr)->QEventLoop::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
return static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QVariantAnimation*>(static_cast<QObject*>(ptr))) {
return static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QPauseAnimation*>(static_cast<QObject*>(ptr))) {
return static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
return static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
return static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QAnimationGroup*>(static_cast<QObject*>(ptr))) {
return static_cast<QAnimationGroup*>(ptr)->QAnimationGroup::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else if (dynamic_cast<QAbstractAnimation*>(static_cast<QObject*>(ptr))) {
return static_cast<QAbstractAnimation*>(ptr)->QAbstractAnimation::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
} else {
return static_cast<QObject*>(ptr)->QObject::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
}
void* QObject_FindChild(void* ptr, struct QtCore_PackedString name, long long options)
{
return static_cast<QObject*>(ptr)->findChild<QObject*>(QString::fromUtf8(name.data, name.len), static_cast<Qt::FindChildOption>(options));
}
struct QtCore_PackedList QObject_FindChildren(void* ptr, struct QtCore_PackedString name, long long options)
{
return ({ QList<QObject*>* tmpValue03dce3 = new QList<QObject*>(static_cast<QObject*>(ptr)->findChildren<QObject*>(QString::fromUtf8(name.data, name.len), static_cast<Qt::FindChildOption>(options))); QtCore_PackedList { tmpValue03dce3, tmpValue03dce3->size() }; });
}
struct QtCore_PackedList QObject_FindChildren3(void* ptr, void* re, long long options)
{
return ({ QList<QObject*>* tmpValuec8bf88 = new QList<QObject*>(static_cast<QObject*>(ptr)->findChildren<QObject*>(*static_cast<QRegularExpression*>(re), static_cast<Qt::FindChildOption>(options))); QtCore_PackedList { tmpValuec8bf88, tmpValuec8bf88->size() }; });
}
char QObject_Inherits(void* ptr, char* className)
{
return static_cast<QObject*>(ptr)->inherits(const_cast<const char*>(className));
}
void QObject_InstallEventFilter(void* ptr, void* filterObj)
{
static_cast<QObject*>(ptr)->installEventFilter(static_cast<QObject*>(filterObj));
}
char QObject_IsSignalConnected(void* ptr, void* sign)
{
return static_cast<QObject*>(ptr)->isSignalConnected(*static_cast<QMetaMethod*>(sign));
}
char QObject_IsWidgetType(void* ptr)
{
return static_cast<QObject*>(ptr)->isWidgetType();
}
char QObject_IsWindowType(void* ptr)
{
return static_cast<QObject*>(ptr)->isWindowType();
}
void QObject_KillTimer(void* ptr, int id)
{
static_cast<QObject*>(ptr)->killTimer(id);
}
void* QObject_MetaObject(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QObject*>(ptr)->metaObject());
}
void* QObject_MetaObjectDefault(void* ptr)
{
if (dynamic_cast<QTranslator*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QTranslator*>(ptr)->QTranslator::metaObject());
} else if (dynamic_cast<QTimer*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QTimer*>(ptr)->QTimer::metaObject());
} else if (dynamic_cast<QTimeLine*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QTimeLine*>(ptr)->QTimeLine::metaObject());
} else if (dynamic_cast<QThreadPool*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QThreadPool*>(ptr)->QThreadPool::metaObject());
} else if (dynamic_cast<QThread*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QThread*>(ptr)->QThread::metaObject());
} else if (dynamic_cast<QSocketNotifier*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QSocketNotifier*>(ptr)->QSocketNotifier::metaObject());
} else if (dynamic_cast<QSharedMemory*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QSharedMemory*>(ptr)->QSharedMemory::metaObject());
} else if (dynamic_cast<QSettings*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QSettings*>(ptr)->QSettings::metaObject());
} else if (dynamic_cast<QPluginLoader*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QPluginLoader*>(ptr)->QPluginLoader::metaObject());
} else if (dynamic_cast<QObjectCleanupHandler*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QObjectCleanupHandler*>(ptr)->QObjectCleanupHandler::metaObject());
} else if (dynamic_cast<QMimeData*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QMimeData*>(ptr)->QMimeData::metaObject());
} else if (dynamic_cast<QLibrary*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QLibrary*>(ptr)->QLibrary::metaObject());
} else if (dynamic_cast<QItemSelectionModel*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QItemSelectionModel*>(ptr)->QItemSelectionModel::metaObject());
} else if (dynamic_cast<QFutureWatcherBase*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QFutureWatcherBase*>(ptr)->QFutureWatcherBase::metaObject());
} else if (dynamic_cast<QFileSystemWatcher*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QFileSystemWatcher*>(ptr)->QFileSystemWatcher::metaObject());
} else if (dynamic_cast<QFileSelector*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QFileSelector*>(ptr)->QFileSelector::metaObject());
} else if (dynamic_cast<QCoreApplication*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QCoreApplication*>(ptr)->QCoreApplication::metaObject());
} else if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QProcess*>(ptr)->QProcess::metaObject());
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QSaveFile*>(ptr)->QSaveFile::metaObject());
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::metaObject());
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QFile*>(ptr)->QFile::metaObject());
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QFileDevice*>(ptr)->QFileDevice::metaObject());
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QBuffer*>(ptr)->QBuffer::metaObject());
} else if (dynamic_cast<QIODevice*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QIODevice*>(ptr)->QIODevice::metaObject());
} else if (dynamic_cast<QSignalTransition*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QSignalTransition*>(ptr)->QSignalTransition::metaObject());
} else if (dynamic_cast<QEventTransition*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QEventTransition*>(ptr)->QEventTransition::metaObject());
} else if (dynamic_cast<QAbstractTransition*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QAbstractTransition*>(ptr)->QAbstractTransition::metaObject());
} else if (dynamic_cast<QStateMachine*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QStateMachine*>(ptr)->QStateMachine::metaObject());
} else if (dynamic_cast<QState*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QState*>(ptr)->QState::metaObject());
} else if (dynamic_cast<QHistoryState*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QHistoryState*>(ptr)->QHistoryState::metaObject());
} else if (dynamic_cast<QFinalState*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QFinalState*>(ptr)->QFinalState::metaObject());
} else if (dynamic_cast<QAbstractState*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QAbstractState*>(ptr)->QAbstractState::metaObject());
} else if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::metaObject());
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::metaObject());
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::metaObject());
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::metaObject());
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::metaObject());
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QStringListModel*>(ptr)->QStringListModel::metaObject());
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::metaObject());
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::metaObject());
} else if (dynamic_cast<QAbstractItemModel*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::metaObject());
} else if (dynamic_cast<QAbstractEventDispatcher*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QAbstractEventDispatcher*>(ptr)->QAbstractEventDispatcher::metaObject());
} else if (dynamic_cast<QEventLoop*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QEventLoop*>(ptr)->QEventLoop::metaObject());
} else if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::metaObject());
} else if (dynamic_cast<QVariantAnimation*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::metaObject());
} else if (dynamic_cast<QPauseAnimation*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::metaObject());
} else if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::metaObject());
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::metaObject());
} else if (dynamic_cast<QAnimationGroup*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QAnimationGroup*>(ptr)->QAnimationGroup::metaObject());
} else if (dynamic_cast<QAbstractAnimation*>(static_cast<QObject*>(ptr))) {
return const_cast<QMetaObject*>(static_cast<QAbstractAnimation*>(ptr)->QAbstractAnimation::metaObject());
} else {
return const_cast<QMetaObject*>(static_cast<QObject*>(ptr)->QObject::metaObject());
}
}
void QObject_MoveToThread(void* ptr, void* targetThread)
{
static_cast<QObject*>(ptr)->moveToThread(static_cast<QThread*>(targetThread));
}
struct QtCore_PackedString QObject_ObjectName(void* ptr)
{
return ({ QByteArray* te77be1 = new QByteArray(static_cast<QObject*>(ptr)->objectName().toUtf8()); QtCore_PackedString { const_cast<char*>(te77be1->prepend("WHITESPACE").constData()+10), te77be1->size()-10, te77be1 }; });
}
void QObject_ConnectObjectNameChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QObject*>(ptr), &QObject::objectNameChanged, static_cast<MyQObject*>(ptr), static_cast<void (MyQObject::*)(const QString &)>(&MyQObject::Signal_ObjectNameChanged), static_cast<Qt::ConnectionType>(t));
}
void QObject_DisconnectObjectNameChanged(void* ptr)
{
QObject::disconnect(static_cast<QObject*>(ptr), &QObject::objectNameChanged, static_cast<MyQObject*>(ptr), static_cast<void (MyQObject::*)(const QString &)>(&MyQObject::Signal_ObjectNameChanged));
}
void* QObject_Parent(void* ptr)
{
return static_cast<QObject*>(ptr)->parent();
}
void* QObject_Property(void* ptr, char* name)
{
return new QVariant(static_cast<QObject*>(ptr)->property(const_cast<const char*>(name)));
}
int QObject_Receivers(void* ptr, char* sign)
{
return static_cast<QObject*>(ptr)->receivers(const_cast<const char*>(sign));
}
void QObject_RemoveEventFilter(void* ptr, void* obj)
{
static_cast<QObject*>(ptr)->removeEventFilter(static_cast<QObject*>(obj));
}
void* QObject_Sender(void* ptr)
{
return static_cast<QObject*>(ptr)->sender();
}
int QObject_SenderSignalIndex(void* ptr)
{
return static_cast<QObject*>(ptr)->senderSignalIndex();
}
void QObject_SetObjectName(void* ptr, struct QtCore_PackedString name)
{
static_cast<QObject*>(ptr)->setObjectName(QString::fromUtf8(name.data, name.len));
}
void QObject_SetParent(void* ptr, void* parent)
{
static_cast<QObject*>(ptr)->setParent(static_cast<QObject*>(parent));
}
char QObject_SetProperty(void* ptr, char* name, void* value)
{
return static_cast<QObject*>(ptr)->setProperty(const_cast<const char*>(name), *static_cast<QVariant*>(value));
}
char QObject_SignalsBlocked(void* ptr)
{
return static_cast<QObject*>(ptr)->signalsBlocked();
}
int QObject_StartTimer(void* ptr, int interval, long long timerType)
{
return static_cast<QObject*>(ptr)->startTimer(interval, static_cast<Qt::TimerType>(timerType));
}
void* QObject_Thread(void* ptr)
{
return static_cast<QObject*>(ptr)->thread();
}
void QObject_TimerEvent(void* ptr, void* event)
{
static_cast<QObject*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}
void QObject_TimerEventDefault(void* ptr, void* event)
{
if (dynamic_cast<QTranslator*>(static_cast<QObject*>(ptr))) {
static_cast<QTranslator*>(ptr)->QTranslator::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QTimer*>(static_cast<QObject*>(ptr))) {
static_cast<QTimer*>(ptr)->QTimer::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QTimeLine*>(static_cast<QObject*>(ptr))) {
static_cast<QTimeLine*>(ptr)->QTimeLine::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QThreadPool*>(static_cast<QObject*>(ptr))) {
static_cast<QThreadPool*>(ptr)->QThreadPool::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QThread*>(static_cast<QObject*>(ptr))) {
static_cast<QThread*>(ptr)->QThread::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QSocketNotifier*>(static_cast<QObject*>(ptr))) {
static_cast<QSocketNotifier*>(ptr)->QSocketNotifier::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QSharedMemory*>(static_cast<QObject*>(ptr))) {
static_cast<QSharedMemory*>(ptr)->QSharedMemory::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QSettings*>(static_cast<QObject*>(ptr))) {
static_cast<QSettings*>(ptr)->QSettings::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QPluginLoader*>(static_cast<QObject*>(ptr))) {
static_cast<QPluginLoader*>(ptr)->QPluginLoader::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QObjectCleanupHandler*>(static_cast<QObject*>(ptr))) {
static_cast<QObjectCleanupHandler*>(ptr)->QObjectCleanupHandler::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QMimeData*>(static_cast<QObject*>(ptr))) {
static_cast<QMimeData*>(ptr)->QMimeData::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QLibrary*>(static_cast<QObject*>(ptr))) {
static_cast<QLibrary*>(ptr)->QLibrary::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QItemSelectionModel*>(static_cast<QObject*>(ptr))) {
static_cast<QItemSelectionModel*>(ptr)->QItemSelectionModel::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QFutureWatcherBase*>(static_cast<QObject*>(ptr))) {
static_cast<QFutureWatcherBase*>(ptr)->QFutureWatcherBase::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QFileSystemWatcher*>(static_cast<QObject*>(ptr))) {
static_cast<QFileSystemWatcher*>(ptr)->QFileSystemWatcher::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QFileSelector*>(static_cast<QObject*>(ptr))) {
static_cast<QFileSelector*>(ptr)->QFileSelector::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QCoreApplication*>(static_cast<QObject*>(ptr))) {
static_cast<QCoreApplication*>(ptr)->QCoreApplication::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QProcess*>(static_cast<QObject*>(ptr))) {
static_cast<QProcess*>(ptr)->QProcess::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QSaveFile*>(static_cast<QObject*>(ptr))) {
static_cast<QSaveFile*>(ptr)->QSaveFile::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QTemporaryFile*>(static_cast<QObject*>(ptr))) {
static_cast<QTemporaryFile*>(ptr)->QTemporaryFile::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QFile*>(static_cast<QObject*>(ptr))) {
static_cast<QFile*>(ptr)->QFile::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QFileDevice*>(static_cast<QObject*>(ptr))) {
static_cast<QFileDevice*>(ptr)->QFileDevice::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QBuffer*>(static_cast<QObject*>(ptr))) {
static_cast<QBuffer*>(ptr)->QBuffer::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QIODevice*>(static_cast<QObject*>(ptr))) {
static_cast<QIODevice*>(ptr)->QIODevice::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QSignalTransition*>(static_cast<QObject*>(ptr))) {
static_cast<QSignalTransition*>(ptr)->QSignalTransition::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QEventTransition*>(static_cast<QObject*>(ptr))) {
static_cast<QEventTransition*>(ptr)->QEventTransition::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QAbstractTransition*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractTransition*>(ptr)->QAbstractTransition::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QStateMachine*>(static_cast<QObject*>(ptr))) {
static_cast<QStateMachine*>(ptr)->QStateMachine::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QState*>(static_cast<QObject*>(ptr))) {
static_cast<QState*>(ptr)->QState::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QHistoryState*>(static_cast<QObject*>(ptr))) {
static_cast<QHistoryState*>(ptr)->QHistoryState::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QFinalState*>(static_cast<QObject*>(ptr))) {
static_cast<QFinalState*>(ptr)->QFinalState::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QAbstractState*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractState*>(ptr)->QAbstractState::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QConcatenateTablesProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QConcatenateTablesProxyModel*>(ptr)->QConcatenateTablesProxyModel::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QTransposeProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QSortFilterProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QIdentityProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QIdentityProxyModel*>(ptr)->QIdentityProxyModel::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QAbstractProxyModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractProxyModel*>(ptr)->QAbstractProxyModel::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QStringListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QStringListModel*>(ptr)->QStringListModel::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QAbstractListModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractListModel*>(ptr)->QAbstractListModel::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QAbstractTableModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractTableModel*>(ptr)->QAbstractTableModel::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QAbstractItemModel*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractItemModel*>(ptr)->QAbstractItemModel::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QAbstractEventDispatcher*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractEventDispatcher*>(ptr)->QAbstractEventDispatcher::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QEventLoop*>(static_cast<QObject*>(ptr))) {
static_cast<QEventLoop*>(ptr)->QEventLoop::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QVariantAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QPauseAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QSequentialAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QParallelAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QAnimationGroup*>(static_cast<QObject*>(ptr))) {
static_cast<QAnimationGroup*>(ptr)->QAnimationGroup::timerEvent(static_cast<QTimerEvent*>(event));
} else if (dynamic_cast<QAbstractAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QAbstractAnimation*>(ptr)->QAbstractAnimation::timerEvent(static_cast<QTimerEvent*>(event));
} else {
static_cast<QObject*>(ptr)->QObject::timerEvent(static_cast<QTimerEvent*>(event));
}
}
struct QtCore_PackedString QObject_QObject_Tr(char* sourceText, char* disambiguation, int n)
{
return ({ QByteArray* te5b32b = new QByteArray(QObject::tr(const_cast<const char*>(sourceText), const_cast<const char*>(disambiguation), n).toUtf8()); QtCore_PackedString { const_cast<char*>(te5b32b->prepend("WHITESPACE").constData()+10), te5b32b->size()-10, te5b32b }; });
}
void QObject_DestroyQObject(void* ptr)
{
static_cast<QObject*>(ptr)->~QObject();
}
void QObject_DestroyQObjectDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QObject_InvokeMethod(void* ptr, char* name, void* arg)
{
QVariant returnArg;
if (arg)
QMetaObject::invokeMethod(static_cast<QObject*>(ptr), const_cast<const char*>(name), Q_RETURN_ARG(QVariant, returnArg), Q_ARG(QVariant, *static_cast<QVariant*>(arg)));
else
QMetaObject::invokeMethod(static_cast<QObject*>(ptr), const_cast<const char*>(name), Q_RETURN_ARG(QVariant, returnArg));
return new QVariant(returnArg);
}
void* QObject_ToVariant(void* ptr)
{
return new QVariant(QVariant::fromValue(static_cast<QObject*>(ptr)));
}
void* QObject___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QObject___children_setList(void* ptr, void* i)
{
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
void* QObject___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
void* QObject___dynamicPropertyNames_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QObject___dynamicPropertyNames_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QObject___dynamicPropertyNames_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QObject___findChildren_atList(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QObject___findChildren_setList(void* ptr, void* i)
{
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
void* QObject___findChildren_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QObject___findChildren_atList2(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QObject___findChildren_setList2(void* ptr, void* i)
{
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
void* QObject___findChildren_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
void* QObject___findChildren_atList3(void* ptr, int i)
{
return ({QObject* tmp = static_cast<QList<QObject*>*>(ptr)->at(i); if (i == static_cast<QList<QObject*>*>(ptr)->size()-1) { static_cast<QList<QObject*>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QObject___findChildren_setList3(void* ptr, void* i)
{
static_cast<QList<QObject*>*>(ptr)->append(static_cast<QObject*>(i));
}
void* QObject___findChildren_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject*>();
}
class MyQObjectCleanupHandler: public QObjectCleanupHandler
{
public:
MyQObjectCleanupHandler() : QObjectCleanupHandler() {QObjectCleanupHandler_QObjectCleanupHandler_QRegisterMetaType();};
~MyQObjectCleanupHandler() { callbackQObjectCleanupHandler_DestroyQObjectCleanupHandler(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QObjectCleanupHandler*)
Q_DECLARE_METATYPE(MyQObjectCleanupHandler*)
int QObjectCleanupHandler_QObjectCleanupHandler_QRegisterMetaType(){qRegisterMetaType<QObjectCleanupHandler*>(); return qRegisterMetaType<MyQObjectCleanupHandler*>();}
void* QObjectCleanupHandler_NewQObjectCleanupHandler()
{
return new MyQObjectCleanupHandler();
}
void* QObjectCleanupHandler_Add(void* ptr, void* object)
{
return static_cast<QObjectCleanupHandler*>(ptr)->add(static_cast<QObject*>(object));
}
void QObjectCleanupHandler_Clear(void* ptr)
{
static_cast<QObjectCleanupHandler*>(ptr)->clear();
}
char QObjectCleanupHandler_IsEmpty(void* ptr)
{
return static_cast<QObjectCleanupHandler*>(ptr)->isEmpty();
}
void QObjectCleanupHandler_Remove(void* ptr, void* object)
{
static_cast<QObjectCleanupHandler*>(ptr)->remove(static_cast<QObject*>(object));
}
void QObjectCleanupHandler_DestroyQObjectCleanupHandler(void* ptr)
{
static_cast<QObjectCleanupHandler*>(ptr)->~QObjectCleanupHandler();
}
void QObjectCleanupHandler_DestroyQObjectCleanupHandlerDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QObjectCleanupHandler___cleanupObjects_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QObjectCleanupHandler___cleanupObjects_setList(void* ptr, void* i)
{
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
void* QObjectCleanupHandler___cleanupObjects_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
void* QObjectCleanupHandler___setCleanupObjects__atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QObjectCleanupHandler___setCleanupObjects__setList(void* ptr, void* i)
{
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
void* QObjectCleanupHandler___setCleanupObjects__newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
void* QObjectData___children_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QObjectData___children_setList(void* ptr, void* i)
{
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
void* QObjectData___children_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
void* QObjectData___setChildren__atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QObjectData___setChildren__setList(void* ptr, void* i)
{
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
void* QObjectData___setChildren__newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
Q_DECLARE_METATYPE(QOperatingSystemVersion*)
void* QOperatingSystemVersion_NewQOperatingSystemVersion2(long long osType, int vmajor, int vminor, int vmicro)
{
return new QOperatingSystemVersion(static_cast<QOperatingSystemVersion::OSType>(osType), vmajor, vminor, vmicro);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_Current()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::current());
}
long long QOperatingSystemVersion_QOperatingSystemVersion_CurrentType()
{
return QOperatingSystemVersion::currentType();
}
int QOperatingSystemVersion_MajorVersion(void* ptr)
{
return static_cast<QOperatingSystemVersion*>(ptr)->majorVersion();
}
int QOperatingSystemVersion_MicroVersion(void* ptr)
{
return static_cast<QOperatingSystemVersion*>(ptr)->microVersion();
}
int QOperatingSystemVersion_MinorVersion(void* ptr)
{
return static_cast<QOperatingSystemVersion*>(ptr)->minorVersion();
}
struct QtCore_PackedString QOperatingSystemVersion_Name(void* ptr)
{
return ({ QByteArray* t3696c4 = new QByteArray(static_cast<QOperatingSystemVersion*>(ptr)->name().toUtf8()); QtCore_PackedString { const_cast<char*>(t3696c4->prepend("WHITESPACE").constData()+10), t3696c4->size()-10, t3696c4 }; });
}
int QOperatingSystemVersion_SegmentCount(void* ptr)
{
return static_cast<QOperatingSystemVersion*>(ptr)->segmentCount();
}
long long QOperatingSystemVersion_Type(void* ptr)
{
return static_cast<QOperatingSystemVersion*>(ptr)->type();
}
void* QOperatingSystemVersion_QOperatingSystemVersion_Windows7()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::Windows7);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_Windows8()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::Windows8);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_Windows8_1()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::Windows8_1);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_Windows10()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::Windows10);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_OSXMavericks()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::OSXMavericks);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_OSXYosemite()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::OSXYosemite);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_OSXElCapitan()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::OSXElCapitan);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_MacOSSierra()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::MacOSSierra);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_MacOSHighSierra()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::MacOSHighSierra);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_MacOSMojave()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::MacOSMojave);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_AndroidJellyBean()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::AndroidJellyBean);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_AndroidJellyBean_MR1()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::AndroidJellyBean_MR1);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_AndroidJellyBean_MR2()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::AndroidJellyBean_MR2);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_AndroidKitKat()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::AndroidKitKat);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_AndroidLollipop()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::AndroidLollipop);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_AndroidLollipop_MR1()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::AndroidLollipop_MR1);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_AndroidMarshmallow()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::AndroidMarshmallow);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_AndroidNougat()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::AndroidNougat);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_AndroidNougat_MR1()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::AndroidNougat_MR1);
}
void* QOperatingSystemVersion_QOperatingSystemVersion_AndroidOreo()
{
return new QOperatingSystemVersion(QOperatingSystemVersion::AndroidOreo);
}
void* QOperatingSystemVersion_NewQOperatingSystemVersion(void* other)
{
return new QOperatingSystemVersion(*static_cast<QOperatingSystemVersion*>(other));
}
class MyQParallelAnimationGroup: public QParallelAnimationGroup
{
public:
MyQParallelAnimationGroup(QObject *parent = Q_NULLPTR) : QParallelAnimationGroup(parent) {QParallelAnimationGroup_QParallelAnimationGroup_QRegisterMetaType();};
int duration() const { return callbackQParallelAnimationGroup_Duration(const_cast<void*>(static_cast<const void*>(this))); };
bool event(QEvent * event) { return callbackQObject_Event(this, event) != 0; };
void updateCurrentTime(int currentTime) { callbackQParallelAnimationGroup_UpdateCurrentTime(this, currentTime); };
void updateDirection(QAbstractAnimation::Direction direction) { callbackQAbstractAnimation_UpdateDirection(this, direction); };
void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { callbackQAbstractAnimation_UpdateState(this, newState, oldState); };
~MyQParallelAnimationGroup() { callbackQParallelAnimationGroup_DestroyQParallelAnimationGroup(this); };
void Signal_CurrentLoopChanged(int currentLoop) { callbackQAbstractAnimation_CurrentLoopChanged(this, currentLoop); };
void Signal_DirectionChanged(QAbstractAnimation::Direction newDirection) { callbackQAbstractAnimation_DirectionChanged(this, newDirection); };
void Signal_Finished() { callbackQAbstractAnimation_Finished(this); };
void pause() { callbackQAbstractAnimation_Pause(this); };
void resume() { callbackQAbstractAnimation_Resume(this); };
void setCurrentTime(int msecs) { callbackQAbstractAnimation_SetCurrentTime(this, msecs); };
void setPaused(bool paused) { callbackQAbstractAnimation_SetPaused(this, paused); };
void start(QAbstractAnimation::DeletionPolicy policy) { callbackQAbstractAnimation_Start(this, policy); };
void Signal_StateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { callbackQAbstractAnimation_StateChanged(this, newState, oldState); };
void stop() { callbackQAbstractAnimation_Stop(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QParallelAnimationGroup*)
Q_DECLARE_METATYPE(MyQParallelAnimationGroup*)
int QParallelAnimationGroup_QParallelAnimationGroup_QRegisterMetaType(){qRegisterMetaType<QParallelAnimationGroup*>(); return qRegisterMetaType<MyQParallelAnimationGroup*>();}
void* QParallelAnimationGroup_NewQParallelAnimationGroup(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQParallelAnimationGroup(static_cast<QWindow*>(parent));
} else {
return new MyQParallelAnimationGroup(static_cast<QObject*>(parent));
}
}
int QParallelAnimationGroup_Duration(void* ptr)
{
return static_cast<QParallelAnimationGroup*>(ptr)->duration();
}
int QParallelAnimationGroup_DurationDefault(void* ptr)
{
return static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::duration();
}
void QParallelAnimationGroup_UpdateCurrentTime(void* ptr, int currentTime)
{
static_cast<QParallelAnimationGroup*>(ptr)->updateCurrentTime(currentTime);
}
void QParallelAnimationGroup_UpdateCurrentTimeDefault(void* ptr, int currentTime)
{
static_cast<QParallelAnimationGroup*>(ptr)->QParallelAnimationGroup::updateCurrentTime(currentTime);
}
void QParallelAnimationGroup_DestroyQParallelAnimationGroup(void* ptr)
{
static_cast<QParallelAnimationGroup*>(ptr)->~QParallelAnimationGroup();
}
void QParallelAnimationGroup_DestroyQParallelAnimationGroupDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQPauseAnimation: public QPauseAnimation
{
public:
MyQPauseAnimation(QObject *parent = Q_NULLPTR) : QPauseAnimation(parent) {QPauseAnimation_QPauseAnimation_QRegisterMetaType();};
MyQPauseAnimation(int msecs, QObject *parent = Q_NULLPTR) : QPauseAnimation(msecs, parent) {QPauseAnimation_QPauseAnimation_QRegisterMetaType();};
int duration() const { return callbackQPauseAnimation_Duration(const_cast<void*>(static_cast<const void*>(this))); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
void updateCurrentTime(int vin) { callbackQPauseAnimation_UpdateCurrentTime(this, vin); };
~MyQPauseAnimation() { callbackQPauseAnimation_DestroyQPauseAnimation(this); };
void Signal_CurrentLoopChanged(int currentLoop) { callbackQAbstractAnimation_CurrentLoopChanged(this, currentLoop); };
void Signal_DirectionChanged(QAbstractAnimation::Direction newDirection) { callbackQAbstractAnimation_DirectionChanged(this, newDirection); };
void Signal_Finished() { callbackQAbstractAnimation_Finished(this); };
void pause() { callbackQAbstractAnimation_Pause(this); };
void resume() { callbackQAbstractAnimation_Resume(this); };
void setCurrentTime(int msecs) { callbackQAbstractAnimation_SetCurrentTime(this, msecs); };
void setPaused(bool paused) { callbackQAbstractAnimation_SetPaused(this, paused); };
void start(QAbstractAnimation::DeletionPolicy policy) { callbackQAbstractAnimation_Start(this, policy); };
void Signal_StateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { callbackQAbstractAnimation_StateChanged(this, newState, oldState); };
void stop() { callbackQAbstractAnimation_Stop(this); };
void updateDirection(QAbstractAnimation::Direction direction) { callbackQAbstractAnimation_UpdateDirection(this, direction); };
void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { callbackQAbstractAnimation_UpdateState(this, newState, oldState); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QPauseAnimation*)
Q_DECLARE_METATYPE(MyQPauseAnimation*)
int QPauseAnimation_QPauseAnimation_QRegisterMetaType(){qRegisterMetaType<QPauseAnimation*>(); return qRegisterMetaType<MyQPauseAnimation*>();}
void* QPauseAnimation_NewQPauseAnimation(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(static_cast<QWindow*>(parent));
} else {
return new MyQPauseAnimation(static_cast<QObject*>(parent));
}
}
void* QPauseAnimation_NewQPauseAnimation2(int msecs, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQPauseAnimation(msecs, static_cast<QWindow*>(parent));
} else {
return new MyQPauseAnimation(msecs, static_cast<QObject*>(parent));
}
}
int QPauseAnimation_Duration(void* ptr)
{
return static_cast<QPauseAnimation*>(ptr)->duration();
}
int QPauseAnimation_DurationDefault(void* ptr)
{
return static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::duration();
}
void QPauseAnimation_SetDuration(void* ptr, int msecs)
{
static_cast<QPauseAnimation*>(ptr)->setDuration(msecs);
}
void QPauseAnimation_UpdateCurrentTime(void* ptr, int vin)
{
static_cast<QPauseAnimation*>(ptr)->updateCurrentTime(vin);
}
void QPauseAnimation_UpdateCurrentTimeDefault(void* ptr, int vin)
{
static_cast<QPauseAnimation*>(ptr)->QPauseAnimation::updateCurrentTime(vin);
}
void QPauseAnimation_DestroyQPauseAnimation(void* ptr)
{
static_cast<QPauseAnimation*>(ptr)->~QPauseAnimation();
}
void QPauseAnimation_DestroyQPauseAnimationDefault(void* ptr)
{
Q_UNUSED(ptr);
}
Q_DECLARE_METATYPE(QPersistentModelIndex*)
void* QPersistentModelIndex_NewQPersistentModelIndex2(void* index)
{
return new QPersistentModelIndex(*static_cast<QModelIndex*>(index));
}
void* QPersistentModelIndex_NewQPersistentModelIndex3(void* other)
{
return new QPersistentModelIndex(*static_cast<QPersistentModelIndex*>(other));
}
void* QPersistentModelIndex_NewQPersistentModelIndex4(void* other)
{
return new QPersistentModelIndex(*static_cast<QPersistentModelIndex*>(other));
}
int QPersistentModelIndex_Column(void* ptr)
{
return static_cast<QPersistentModelIndex*>(ptr)->column();
}
void* QPersistentModelIndex_Data(void* ptr, int role)
{
return new QVariant(static_cast<QPersistentModelIndex*>(ptr)->data(role));
}
long long QPersistentModelIndex_Flags(void* ptr)
{
return static_cast<QPersistentModelIndex*>(ptr)->flags();
}
char QPersistentModelIndex_IsValid(void* ptr)
{
return static_cast<QPersistentModelIndex*>(ptr)->isValid();
}
void* QPersistentModelIndex_Model(void* ptr)
{
return const_cast<QAbstractItemModel*>(static_cast<QPersistentModelIndex*>(ptr)->model());
}
void* QPersistentModelIndex_Parent(void* ptr)
{
return new QModelIndex(static_cast<QPersistentModelIndex*>(ptr)->parent());
}
int QPersistentModelIndex_Row(void* ptr)
{
return static_cast<QPersistentModelIndex*>(ptr)->row();
}
void* QPersistentModelIndex_Sibling(void* ptr, int row, int column)
{
return new QModelIndex(static_cast<QPersistentModelIndex*>(ptr)->sibling(row, column));
}
void QPersistentModelIndex_Swap(void* ptr, void* other)
{
static_cast<QPersistentModelIndex*>(ptr)->swap(*static_cast<QPersistentModelIndex*>(other));
}
class MyQPluginLoader: public QPluginLoader
{
public:
MyQPluginLoader(QObject *parent = Q_NULLPTR) : QPluginLoader(parent) {QPluginLoader_QPluginLoader_QRegisterMetaType();};
MyQPluginLoader(const QString &fileName, QObject *parent = Q_NULLPTR) : QPluginLoader(fileName, parent) {QPluginLoader_QPluginLoader_QRegisterMetaType();};
~MyQPluginLoader() { callbackQPluginLoader_DestroyQPluginLoader(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QPluginLoader*)
Q_DECLARE_METATYPE(MyQPluginLoader*)
int QPluginLoader_QPluginLoader_QRegisterMetaType(){qRegisterMetaType<QPluginLoader*>(); return qRegisterMetaType<MyQPluginLoader*>();}
void* QPluginLoader_NewQPluginLoader(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(static_cast<QWindow*>(parent));
} else {
return new MyQPluginLoader(static_cast<QObject*>(parent));
}
}
void* QPluginLoader_NewQPluginLoader2(struct QtCore_PackedString fileName, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QWindow*>(parent));
} else {
return new MyQPluginLoader(QString::fromUtf8(fileName.data, fileName.len), static_cast<QObject*>(parent));
}
}
struct QtCore_PackedString QPluginLoader_ErrorString(void* ptr)
{
return ({ QByteArray* tc09de6 = new QByteArray(static_cast<QPluginLoader*>(ptr)->errorString().toUtf8()); QtCore_PackedString { const_cast<char*>(tc09de6->prepend("WHITESPACE").constData()+10), tc09de6->size()-10, tc09de6 }; });
}
struct QtCore_PackedString QPluginLoader_FileName(void* ptr)
{
return ({ QByteArray* t54ffa7 = new QByteArray(static_cast<QPluginLoader*>(ptr)->fileName().toUtf8()); QtCore_PackedString { const_cast<char*>(t54ffa7->prepend("WHITESPACE").constData()+10), t54ffa7->size()-10, t54ffa7 }; });
}
void* QPluginLoader_Instance(void* ptr)
{
return static_cast<QPluginLoader*>(ptr)->instance();
}
char QPluginLoader_IsLoaded(void* ptr)
{
return static_cast<QPluginLoader*>(ptr)->isLoaded();
}
char QPluginLoader_Load(void* ptr)
{
return static_cast<QPluginLoader*>(ptr)->load();
}
long long QPluginLoader_LoadHints(void* ptr)
{
return static_cast<QPluginLoader*>(ptr)->loadHints();
}
void* QPluginLoader_MetaData(void* ptr)
{
return new QJsonObject(static_cast<QPluginLoader*>(ptr)->metaData());
}
void QPluginLoader_SetFileName(void* ptr, struct QtCore_PackedString fileName)
{
static_cast<QPluginLoader*>(ptr)->setFileName(QString::fromUtf8(fileName.data, fileName.len));
}
void QPluginLoader_SetLoadHints(void* ptr, long long loadHints)
{
static_cast<QPluginLoader*>(ptr)->setLoadHints(static_cast<QLibrary::LoadHint>(loadHints));
}
struct QtCore_PackedList QPluginLoader_QPluginLoader_StaticInstances()
{
return ({ QList<QObject *>* tmpValue529eec = new QList<QObject *>(QPluginLoader::staticInstances()); QtCore_PackedList { tmpValue529eec, tmpValue529eec->size() }; });
}
char QPluginLoader_Unload(void* ptr)
{
return static_cast<QPluginLoader*>(ptr)->unload();
}
void QPluginLoader_DestroyQPluginLoader(void* ptr)
{
static_cast<QPluginLoader*>(ptr)->~QPluginLoader();
}
void QPluginLoader_DestroyQPluginLoaderDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QPluginLoader___staticInstances_atList(void* ptr, int i)
{
return ({QObject * tmp = static_cast<QList<QObject *>*>(ptr)->at(i); if (i == static_cast<QList<QObject *>*>(ptr)->size()-1) { static_cast<QList<QObject *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QPluginLoader___staticInstances_setList(void* ptr, void* i)
{
static_cast<QList<QObject *>*>(ptr)->append(static_cast<QObject*>(i));
}
void* QPluginLoader___staticInstances_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QObject *>();
}
void QPluginLoader___staticPlugins_setList(void* ptr, void* i)
{
static_cast<QVector<QStaticPlugin>*>(ptr)->append(*static_cast<QStaticPlugin*>(i));
}
void* QPluginLoader___staticPlugins_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QStaticPlugin>();
}
Q_DECLARE_METATYPE(QPoint)
Q_DECLARE_METATYPE(QPoint*)
void* QPoint_NewQPoint()
{
return new QPoint();
}
void* QPoint_NewQPoint2(int xpos, int ypos)
{
return new QPoint(xpos, ypos);
}
int QPoint_QPoint_DotProduct(void* p1, void* p2)
{
return QPoint::dotProduct(*static_cast<QPoint*>(p1), *static_cast<QPoint*>(p2));
}
char QPoint_IsNull(void* ptr)
{
return static_cast<QPoint*>(ptr)->isNull();
}
int QPoint_ManhattanLength(void* ptr)
{
return static_cast<QPoint*>(ptr)->manhattanLength();
}
int QPoint_Rx(void* ptr)
{
return static_cast<QPoint*>(ptr)->rx();
}
int QPoint_Ry(void* ptr)
{
return static_cast<QPoint*>(ptr)->ry();
}
void QPoint_SetX(void* ptr, int x)
{
static_cast<QPoint*>(ptr)->setX(x);
}
void QPoint_SetY(void* ptr, int y)
{
static_cast<QPoint*>(ptr)->setY(y);
}
int QPoint_X(void* ptr)
{
return static_cast<QPoint*>(ptr)->x();
}
int QPoint_Y(void* ptr)
{
return static_cast<QPoint*>(ptr)->y();
}
Q_DECLARE_METATYPE(QPointF)
Q_DECLARE_METATYPE(QPointF*)
void* QPointF_NewQPointF()
{
return new QPointF();
}
void* QPointF_NewQPointF2(void* point)
{
return new QPointF(*static_cast<QPoint*>(point));
}
void* QPointF_NewQPointF3(double xpos, double ypos)
{
return new QPointF(xpos, ypos);
}
double QPointF_QPointF_DotProduct(void* p1, void* p2)
{
return QPointF::dotProduct(*static_cast<QPointF*>(p1), *static_cast<QPointF*>(p2));
}
char QPointF_IsNull(void* ptr)
{
return static_cast<QPointF*>(ptr)->isNull();
}
double QPointF_ManhattanLength(void* ptr)
{
return static_cast<QPointF*>(ptr)->manhattanLength();
}
double QPointF_Rx(void* ptr)
{
return static_cast<QPointF*>(ptr)->rx();
}
double QPointF_Ry(void* ptr)
{
return static_cast<QPointF*>(ptr)->ry();
}
void QPointF_SetX(void* ptr, double x)
{
static_cast<QPointF*>(ptr)->setX(x);
}
void QPointF_SetY(void* ptr, double y)
{
static_cast<QPointF*>(ptr)->setY(y);
}
void* QPointF_ToPoint(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QPointF*>(ptr)->toPoint(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
double QPointF_X(void* ptr)
{
return static_cast<QPointF*>(ptr)->x();
}
double QPointF_Y(void* ptr)
{
return static_cast<QPointF*>(ptr)->y();
}
class MyQProcess: public QProcess
{
public:
MyQProcess(QObject *parent = Q_NULLPTR) : QProcess(parent) {QProcess_QProcess_QRegisterMetaType();};
bool atEnd() const { return callbackQIODevice_AtEnd(const_cast<void*>(static_cast<const void*>(this))) != 0; };
qint64 bytesAvailable() const { return callbackQIODevice_BytesAvailable(const_cast<void*>(static_cast<const void*>(this))); };
qint64 bytesToWrite() const { return callbackQIODevice_BytesToWrite(const_cast<void*>(static_cast<const void*>(this))); };
bool canReadLine() const { return callbackQIODevice_CanReadLine(const_cast<void*>(static_cast<const void*>(this))) != 0; };
void close() { callbackQIODevice_Close(this); };
void Signal_ErrorOccurred(QProcess::ProcessError error) { callbackQProcess_ErrorOccurred(this, error); };
void Signal_Finished(int exitCode, QProcess::ExitStatus exitStatus) { callbackQProcess_Finished(this, exitCode, exitStatus); };
bool isSequential() const { return callbackQIODevice_IsSequential(const_cast<void*>(static_cast<const void*>(this))) != 0; };
void kill() { callbackQProcess_Kill(this); };
bool open(QIODevice::OpenMode mode) { return callbackQIODevice_Open(this, mode) != 0; };
qint64 readData(char * data, qint64 maxlen) { QtCore_PackedString dataPacked = { data, maxlen, NULL };return callbackQProcess_ReadData(this, dataPacked, maxlen); };
void Signal_ReadyReadStandardError() { callbackQProcess_ReadyReadStandardError(this); };
void Signal_ReadyReadStandardOutput() { callbackQProcess_ReadyReadStandardOutput(this); };
void setupChildProcess() { callbackQProcess_SetupChildProcess(this); };
void Signal_Started() { callbackQProcess_Started(this); };
void Signal_StateChanged(QProcess::ProcessState newState) { callbackQProcess_StateChanged(this, newState); };
void terminate() { callbackQProcess_Terminate(this); };
bool waitForBytesWritten(int msecs) { return callbackQIODevice_WaitForBytesWritten(this, msecs) != 0; };
bool waitForReadyRead(int msecs) { return callbackQIODevice_WaitForReadyRead(this, msecs) != 0; };
qint64 writeData(const char * data, qint64 l) { QtCore_PackedString dataPacked = { const_cast<char*>(data), l, NULL };return callbackQProcess_WriteData(this, dataPacked, l); };
~MyQProcess() { callbackQProcess_DestroyQProcess(this); };
void Signal_AboutToClose() { callbackQIODevice_AboutToClose(this); };
void Signal_BytesWritten(qint64 bytes) { callbackQIODevice_BytesWritten(this, bytes); };
void Signal_ChannelBytesWritten(int channel, qint64 bytes) { callbackQIODevice_ChannelBytesWritten(this, channel, bytes); };
void Signal_ChannelReadyRead(int channel) { callbackQIODevice_ChannelReadyRead(this, channel); };
qint64 pos() const { return callbackQIODevice_Pos(const_cast<void*>(static_cast<const void*>(this))); };
void Signal_ReadChannelFinished() { callbackQIODevice_ReadChannelFinished(this); };
qint64 readLineData(char * data, qint64 maxSize) { QtCore_PackedString dataPacked = { data, maxSize, NULL };return callbackQIODevice_ReadLineData(this, dataPacked, maxSize); };
void Signal_ReadyRead() { callbackQIODevice_ReadyRead(this); };
bool reset() { return callbackQIODevice_Reset(this) != 0; };
bool seek(qint64 pos) { return callbackQIODevice_Seek(this, pos) != 0; };
qint64 size() const { return callbackQIODevice_Size(const_cast<void*>(static_cast<const void*>(this))); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QProcess*)
Q_DECLARE_METATYPE(MyQProcess*)
int QProcess_QProcess_QRegisterMetaType(){qRegisterMetaType<QProcess*>(); return qRegisterMetaType<MyQProcess*>();}
void* QProcess_NewQProcess(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQProcess(static_cast<QWindow*>(parent));
} else {
return new MyQProcess(static_cast<QObject*>(parent));
}
}
struct QtCore_PackedString QProcess_Arguments(void* ptr)
{
return ({ QByteArray* tab219c = new QByteArray(static_cast<QProcess*>(ptr)->arguments().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tab219c->prepend("WHITESPACE").constData()+10), tab219c->size()-10, tab219c }; });
}
void QProcess_CloseReadChannel(void* ptr, long long channel)
{
static_cast<QProcess*>(ptr)->closeReadChannel(static_cast<QProcess::ProcessChannel>(channel));
}
void QProcess_CloseWriteChannel(void* ptr)
{
static_cast<QProcess*>(ptr)->closeWriteChannel();
}
long long QProcess_Error(void* ptr)
{
return static_cast<QProcess*>(ptr)->error();
}
void QProcess_ConnectErrorOccurred(void* ptr, long long t)
{
qRegisterMetaType<QProcess::ProcessError>();
QObject::connect(static_cast<QProcess*>(ptr), static_cast<void (QProcess::*)(QProcess::ProcessError)>(&QProcess::errorOccurred), static_cast<MyQProcess*>(ptr), static_cast<void (MyQProcess::*)(QProcess::ProcessError)>(&MyQProcess::Signal_ErrorOccurred), static_cast<Qt::ConnectionType>(t));
}
void QProcess_DisconnectErrorOccurred(void* ptr)
{
QObject::disconnect(static_cast<QProcess*>(ptr), static_cast<void (QProcess::*)(QProcess::ProcessError)>(&QProcess::errorOccurred), static_cast<MyQProcess*>(ptr), static_cast<void (MyQProcess::*)(QProcess::ProcessError)>(&MyQProcess::Signal_ErrorOccurred));
}
void QProcess_ErrorOccurred(void* ptr, long long error)
{
static_cast<QProcess*>(ptr)->errorOccurred(static_cast<QProcess::ProcessError>(error));
}
int QProcess_QProcess_Execute(struct QtCore_PackedString program, struct QtCore_PackedString arguments)
{
return QProcess::execute(QString::fromUtf8(program.data, program.len), QString::fromUtf8(arguments.data, arguments.len).split("¡¦!", QString::SkipEmptyParts));
}
int QProcess_QProcess_Execute2(struct QtCore_PackedString command)
{
return QProcess::execute(QString::fromUtf8(command.data, command.len));
}
int QProcess_ExitCode(void* ptr)
{
return static_cast<QProcess*>(ptr)->exitCode();
}
long long QProcess_ExitStatus(void* ptr)
{
return static_cast<QProcess*>(ptr)->exitStatus();
}
void QProcess_ConnectFinished(void* ptr, long long t)
{
qRegisterMetaType<QProcess::ExitStatus>();
QObject::connect(static_cast<QProcess*>(ptr), static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished), static_cast<MyQProcess*>(ptr), static_cast<void (MyQProcess::*)(int, QProcess::ExitStatus)>(&MyQProcess::Signal_Finished), static_cast<Qt::ConnectionType>(t));
}
void QProcess_DisconnectFinished(void* ptr)
{
QObject::disconnect(static_cast<QProcess*>(ptr), static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished), static_cast<MyQProcess*>(ptr), static_cast<void (MyQProcess::*)(int, QProcess::ExitStatus)>(&MyQProcess::Signal_Finished));
}
void QProcess_Finished(void* ptr, int exitCode, long long exitStatus)
{
static_cast<QProcess*>(ptr)->finished(exitCode, static_cast<QProcess::ExitStatus>(exitStatus));
}
long long QProcess_InputChannelMode(void* ptr)
{
return static_cast<QProcess*>(ptr)->inputChannelMode();
}
void QProcess_Kill(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QProcess*>(ptr), "kill");
}
void QProcess_KillDefault(void* ptr)
{
static_cast<QProcess*>(ptr)->QProcess::kill();
}
struct QtCore_PackedString QProcess_NativeArguments(void* ptr)
{
#ifdef Q_OS_WIN
return ({ QByteArray* t56488a = new QByteArray(static_cast<QProcess*>(ptr)->nativeArguments().toUtf8()); QtCore_PackedString { const_cast<char*>(t56488a->prepend("WHITESPACE").constData()+10), t56488a->size()-10, t56488a }; });
#else
return QtCore_PackedString {};
#endif
}
struct QtCore_PackedString QProcess_QProcess_NullDevice()
{
return ({ QByteArray* td290b2 = new QByteArray(QProcess::nullDevice().toUtf8()); QtCore_PackedString { const_cast<char*>(td290b2->prepend("WHITESPACE").constData()+10), td290b2->size()-10, td290b2 }; });
}
long long QProcess_ProcessChannelMode(void* ptr)
{
return static_cast<QProcess*>(ptr)->processChannelMode();
}
void* QProcess_ProcessEnvironment(void* ptr)
{
return new QProcessEnvironment(static_cast<QProcess*>(ptr)->processEnvironment());
}
long long QProcess_ProcessId(void* ptr)
{
return static_cast<QProcess*>(ptr)->processId();
}
struct QtCore_PackedString QProcess_Program(void* ptr)
{
return ({ QByteArray* t5d7bda = new QByteArray(static_cast<QProcess*>(ptr)->program().toUtf8()); QtCore_PackedString { const_cast<char*>(t5d7bda->prepend("WHITESPACE").constData()+10), t5d7bda->size()-10, t5d7bda }; });
}
void* QProcess_ReadAllStandardError(void* ptr)
{
return new QByteArray(static_cast<QProcess*>(ptr)->readAllStandardError());
}
void* QProcess_ReadAllStandardOutput(void* ptr)
{
return new QByteArray(static_cast<QProcess*>(ptr)->readAllStandardOutput());
}
long long QProcess_ReadChannel(void* ptr)
{
return static_cast<QProcess*>(ptr)->readChannel();
}
long long QProcess_ReadData(void* ptr, char* data, long long maxlen)
{
return static_cast<QProcess*>(ptr)->readData(data, maxlen);
}
long long QProcess_ReadDataDefault(void* ptr, char* data, long long maxlen)
{
return static_cast<QProcess*>(ptr)->QProcess::readData(data, maxlen);
}
void QProcess_ConnectReadyReadStandardError(void* ptr, long long t)
{
QObject::connect(static_cast<QProcess*>(ptr), &QProcess::readyReadStandardError, static_cast<MyQProcess*>(ptr), static_cast<void (MyQProcess::*)()>(&MyQProcess::Signal_ReadyReadStandardError), static_cast<Qt::ConnectionType>(t));
}
void QProcess_DisconnectReadyReadStandardError(void* ptr)
{
QObject::disconnect(static_cast<QProcess*>(ptr), &QProcess::readyReadStandardError, static_cast<MyQProcess*>(ptr), static_cast<void (MyQProcess::*)()>(&MyQProcess::Signal_ReadyReadStandardError));
}
void QProcess_ConnectReadyReadStandardOutput(void* ptr, long long t)
{
QObject::connect(static_cast<QProcess*>(ptr), &QProcess::readyReadStandardOutput, static_cast<MyQProcess*>(ptr), static_cast<void (MyQProcess::*)()>(&MyQProcess::Signal_ReadyReadStandardOutput), static_cast<Qt::ConnectionType>(t));
}
void QProcess_DisconnectReadyReadStandardOutput(void* ptr)
{
QObject::disconnect(static_cast<QProcess*>(ptr), &QProcess::readyReadStandardOutput, static_cast<MyQProcess*>(ptr), static_cast<void (MyQProcess::*)()>(&MyQProcess::Signal_ReadyReadStandardOutput));
}
void QProcess_SetArguments(void* ptr, struct QtCore_PackedString arguments)
{
static_cast<QProcess*>(ptr)->setArguments(QString::fromUtf8(arguments.data, arguments.len).split("¡¦!", QString::SkipEmptyParts));
}
void QProcess_SetInputChannelMode(void* ptr, long long mode)
{
static_cast<QProcess*>(ptr)->setInputChannelMode(static_cast<QProcess::InputChannelMode>(mode));
}
void QProcess_SetNativeArguments(void* ptr, struct QtCore_PackedString arguments)
{
#ifdef Q_OS_WIN
static_cast<QProcess*>(ptr)->setNativeArguments(QString::fromUtf8(arguments.data, arguments.len));
#endif
}
void QProcess_SetProcessChannelMode(void* ptr, long long mode)
{
static_cast<QProcess*>(ptr)->setProcessChannelMode(static_cast<QProcess::ProcessChannelMode>(mode));
}
void QProcess_SetProcessEnvironment(void* ptr, void* environment)
{
static_cast<QProcess*>(ptr)->setProcessEnvironment(*static_cast<QProcessEnvironment*>(environment));
}
void QProcess_SetProcessState(void* ptr, long long state)
{
static_cast<QProcess*>(ptr)->setProcessState(static_cast<QProcess::ProcessState>(state));
}
void QProcess_SetProgram(void* ptr, struct QtCore_PackedString program)
{
static_cast<QProcess*>(ptr)->setProgram(QString::fromUtf8(program.data, program.len));
}
void QProcess_SetReadChannel(void* ptr, long long channel)
{
static_cast<QProcess*>(ptr)->setReadChannel(static_cast<QProcess::ProcessChannel>(channel));
}
void QProcess_SetStandardErrorFile(void* ptr, struct QtCore_PackedString fileName, long long mode)
{
static_cast<QProcess*>(ptr)->setStandardErrorFile(QString::fromUtf8(fileName.data, fileName.len), static_cast<QIODevice::OpenModeFlag>(mode));
}
void QProcess_SetStandardInputFile(void* ptr, struct QtCore_PackedString fileName)
{
static_cast<QProcess*>(ptr)->setStandardInputFile(QString::fromUtf8(fileName.data, fileName.len));
}
void QProcess_SetStandardOutputFile(void* ptr, struct QtCore_PackedString fileName, long long mode)
{
static_cast<QProcess*>(ptr)->setStandardOutputFile(QString::fromUtf8(fileName.data, fileName.len), static_cast<QIODevice::OpenModeFlag>(mode));
}
void QProcess_SetStandardOutputProcess(void* ptr, void* destination)
{
static_cast<QProcess*>(ptr)->setStandardOutputProcess(static_cast<QProcess*>(destination));
}
void QProcess_SetWorkingDirectory(void* ptr, struct QtCore_PackedString dir)
{
static_cast<QProcess*>(ptr)->setWorkingDirectory(QString::fromUtf8(dir.data, dir.len));
}
void QProcess_SetupChildProcess(void* ptr)
{
static_cast<QProcess*>(ptr)->setupChildProcess();
}
void QProcess_SetupChildProcessDefault(void* ptr)
{
static_cast<QProcess*>(ptr)->QProcess::setupChildProcess();
}
void QProcess_Start(void* ptr, struct QtCore_PackedString program, struct QtCore_PackedString arguments, long long mode)
{
static_cast<QProcess*>(ptr)->start(QString::fromUtf8(program.data, program.len), QString::fromUtf8(arguments.data, arguments.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QIODevice::OpenModeFlag>(mode));
}
void QProcess_Start2(void* ptr, struct QtCore_PackedString command, long long mode)
{
static_cast<QProcess*>(ptr)->start(QString::fromUtf8(command.data, command.len), static_cast<QIODevice::OpenModeFlag>(mode));
}
void QProcess_Start3(void* ptr, long long mode)
{
static_cast<QProcess*>(ptr)->start(static_cast<QIODevice::OpenModeFlag>(mode));
}
char QProcess_StartDetached(void* ptr, long long pid)
{
return static_cast<QProcess*>(ptr)->startDetached(&pid);
}
char QProcess_QProcess_StartDetached2(struct QtCore_PackedString program, struct QtCore_PackedString arguments, struct QtCore_PackedString workingDirectory, long long pid)
{
return QProcess::startDetached(QString::fromUtf8(program.data, program.len), QString::fromUtf8(arguments.data, arguments.len).split("¡¦!", QString::SkipEmptyParts), QString::fromUtf8(workingDirectory.data, workingDirectory.len), &pid);
}
char QProcess_QProcess_StartDetached3(struct QtCore_PackedString command)
{
return QProcess::startDetached(QString::fromUtf8(command.data, command.len));
}
void QProcess_ConnectStarted(void* ptr, long long t)
{
QObject::connect(static_cast<QProcess*>(ptr), &QProcess::started, static_cast<MyQProcess*>(ptr), static_cast<void (MyQProcess::*)()>(&MyQProcess::Signal_Started), static_cast<Qt::ConnectionType>(t));
}
void QProcess_DisconnectStarted(void* ptr)
{
QObject::disconnect(static_cast<QProcess*>(ptr), &QProcess::started, static_cast<MyQProcess*>(ptr), static_cast<void (MyQProcess::*)()>(&MyQProcess::Signal_Started));
}
long long QProcess_State(void* ptr)
{
return static_cast<QProcess*>(ptr)->state();
}
void QProcess_ConnectStateChanged(void* ptr, long long t)
{
qRegisterMetaType<QProcess::ProcessState>();
QObject::connect(static_cast<QProcess*>(ptr), &QProcess::stateChanged, static_cast<MyQProcess*>(ptr), static_cast<void (MyQProcess::*)(QProcess::ProcessState)>(&MyQProcess::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}
void QProcess_DisconnectStateChanged(void* ptr)
{
QObject::disconnect(static_cast<QProcess*>(ptr), &QProcess::stateChanged, static_cast<MyQProcess*>(ptr), static_cast<void (MyQProcess::*)(QProcess::ProcessState)>(&MyQProcess::Signal_StateChanged));
}
struct QtCore_PackedString QProcess_QProcess_SystemEnvironment()
{
return ({ QByteArray* td5ad45 = new QByteArray(QProcess::systemEnvironment().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(td5ad45->prepend("WHITESPACE").constData()+10), td5ad45->size()-10, td5ad45 }; });
}
void QProcess_Terminate(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QProcess*>(ptr), "terminate");
}
void QProcess_TerminateDefault(void* ptr)
{
static_cast<QProcess*>(ptr)->QProcess::terminate();
}
char QProcess_WaitForFinished(void* ptr, int msecs)
{
return static_cast<QProcess*>(ptr)->waitForFinished(msecs);
}
char QProcess_WaitForStarted(void* ptr, int msecs)
{
return static_cast<QProcess*>(ptr)->waitForStarted(msecs);
}
struct QtCore_PackedString QProcess_WorkingDirectory(void* ptr)
{
return ({ QByteArray* t55a1e5 = new QByteArray(static_cast<QProcess*>(ptr)->workingDirectory().toUtf8()); QtCore_PackedString { const_cast<char*>(t55a1e5->prepend("WHITESPACE").constData()+10), t55a1e5->size()-10, t55a1e5 }; });
}
long long QProcess_WriteData(void* ptr, char* data, long long l)
{
return static_cast<QProcess*>(ptr)->writeData(const_cast<const char*>(data), l);
}
long long QProcess_WriteDataDefault(void* ptr, char* data, long long l)
{
return static_cast<QProcess*>(ptr)->QProcess::writeData(const_cast<const char*>(data), l);
}
void QProcess_DestroyQProcess(void* ptr)
{
static_cast<QProcess*>(ptr)->~QProcess();
}
void QProcess_DestroyQProcessDefault(void* ptr)
{
Q_UNUSED(ptr);
}
Q_DECLARE_METATYPE(QProcessEnvironment)
Q_DECLARE_METATYPE(QProcessEnvironment*)
void* QProcessEnvironment_NewQProcessEnvironment()
{
return new QProcessEnvironment();
}
void* QProcessEnvironment_NewQProcessEnvironment2(void* other)
{
return new QProcessEnvironment(*static_cast<QProcessEnvironment*>(other));
}
void QProcessEnvironment_Clear(void* ptr)
{
static_cast<QProcessEnvironment*>(ptr)->clear();
}
char QProcessEnvironment_Contains(void* ptr, struct QtCore_PackedString name)
{
return static_cast<QProcessEnvironment*>(ptr)->contains(QString::fromUtf8(name.data, name.len));
}
void QProcessEnvironment_Insert(void* ptr, struct QtCore_PackedString name, struct QtCore_PackedString value)
{
static_cast<QProcessEnvironment*>(ptr)->insert(QString::fromUtf8(name.data, name.len), QString::fromUtf8(value.data, value.len));
}
void QProcessEnvironment_Insert2(void* ptr, void* e)
{
static_cast<QProcessEnvironment*>(ptr)->insert(*static_cast<QProcessEnvironment*>(e));
}
char QProcessEnvironment_IsEmpty(void* ptr)
{
return static_cast<QProcessEnvironment*>(ptr)->isEmpty();
}
struct QtCore_PackedString QProcessEnvironment_Keys(void* ptr)
{
return ({ QByteArray* tf1d987 = new QByteArray(static_cast<QProcessEnvironment*>(ptr)->keys().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tf1d987->prepend("WHITESPACE").constData()+10), tf1d987->size()-10, tf1d987 }; });
}
void QProcessEnvironment_Remove(void* ptr, struct QtCore_PackedString name)
{
static_cast<QProcessEnvironment*>(ptr)->remove(QString::fromUtf8(name.data, name.len));
}
void QProcessEnvironment_Swap(void* ptr, void* other)
{
static_cast<QProcessEnvironment*>(ptr)->swap(*static_cast<QProcessEnvironment*>(other));
}
void* QProcessEnvironment_QProcessEnvironment_SystemEnvironment()
{
return new QProcessEnvironment(QProcessEnvironment::systemEnvironment());
}
struct QtCore_PackedString QProcessEnvironment_ToStringList(void* ptr)
{
return ({ QByteArray* tf595c1 = new QByteArray(static_cast<QProcessEnvironment*>(ptr)->toStringList().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tf595c1->prepend("WHITESPACE").constData()+10), tf595c1->size()-10, tf595c1 }; });
}
struct QtCore_PackedString QProcessEnvironment_Value(void* ptr, struct QtCore_PackedString name, struct QtCore_PackedString defaultValue)
{
return ({ QByteArray* t6b2311 = new QByteArray(static_cast<QProcessEnvironment*>(ptr)->value(QString::fromUtf8(name.data, name.len), QString::fromUtf8(defaultValue.data, defaultValue.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t6b2311->prepend("WHITESPACE").constData()+10), t6b2311->size()-10, t6b2311 }; });
}
void QProcessEnvironment_DestroyQProcessEnvironment(void* ptr)
{
static_cast<QProcessEnvironment*>(ptr)->~QProcessEnvironment();
}
class MyQPropertyAnimation: public QPropertyAnimation
{
public:
MyQPropertyAnimation(QObject *parent = Q_NULLPTR) : QPropertyAnimation(parent) {QPropertyAnimation_QPropertyAnimation_QRegisterMetaType();};
MyQPropertyAnimation(QObject *target, const QByteArray &propertyName, QObject *parent = Q_NULLPTR) : QPropertyAnimation(target, propertyName, parent) {QPropertyAnimation_QPropertyAnimation_QRegisterMetaType();};
bool event(QEvent * event) { return callbackQObject_Event(this, event) != 0; };
void updateCurrentValue(const QVariant & value) { callbackQVariantAnimation_UpdateCurrentValue(this, const_cast<QVariant*>(&value)); };
void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { callbackQAbstractAnimation_UpdateState(this, newState, oldState); };
~MyQPropertyAnimation() { callbackQPropertyAnimation_DestroyQPropertyAnimation(this); };
int duration() const { return callbackQVariantAnimation_Duration(const_cast<void*>(static_cast<const void*>(this))); };
QVariant interpolated(const QVariant & from, const QVariant & to, qreal progress) const { return *static_cast<QVariant*>(callbackQVariantAnimation_Interpolated(const_cast<void*>(static_cast<const void*>(this)), const_cast<QVariant*>(&from), const_cast<QVariant*>(&to), progress)); };
void updateCurrentTime(int vin) { callbackQVariantAnimation_UpdateCurrentTime(this, vin); };
void Signal_ValueChanged(const QVariant & value) { callbackQVariantAnimation_ValueChanged(this, const_cast<QVariant*>(&value)); };
void Signal_CurrentLoopChanged(int currentLoop) { callbackQAbstractAnimation_CurrentLoopChanged(this, currentLoop); };
void Signal_DirectionChanged(QAbstractAnimation::Direction newDirection) { callbackQAbstractAnimation_DirectionChanged(this, newDirection); };
void Signal_Finished() { callbackQAbstractAnimation_Finished(this); };
void pause() { callbackQAbstractAnimation_Pause(this); };
void resume() { callbackQAbstractAnimation_Resume(this); };
void setCurrentTime(int msecs) { callbackQAbstractAnimation_SetCurrentTime(this, msecs); };
void setPaused(bool paused) { callbackQAbstractAnimation_SetPaused(this, paused); };
void start(QAbstractAnimation::DeletionPolicy policy) { callbackQAbstractAnimation_Start(this, policy); };
void Signal_StateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { callbackQAbstractAnimation_StateChanged(this, newState, oldState); };
void stop() { callbackQAbstractAnimation_Stop(this); };
void updateDirection(QAbstractAnimation::Direction direction) { callbackQAbstractAnimation_UpdateDirection(this, direction); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QPropertyAnimation*)
Q_DECLARE_METATYPE(MyQPropertyAnimation*)
int QPropertyAnimation_QPropertyAnimation_QRegisterMetaType(){qRegisterMetaType<QPropertyAnimation*>(); return qRegisterMetaType<MyQPropertyAnimation*>();}
void* QPropertyAnimation_NewQPropertyAnimation(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQPropertyAnimation(static_cast<QWindow*>(parent));
} else {
return new MyQPropertyAnimation(static_cast<QObject*>(parent));
}
}
void* QPropertyAnimation_NewQPropertyAnimation2(void* target, void* propertyName, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QAudioSystemPlugin*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QCameraImageCapture*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QDBusPendingCallWatcher*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QExtensionFactory*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QExtensionManager*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QGraphicsObject*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QGraphicsWidget*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QLayout*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QMediaPlaylist*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QMediaRecorder*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QMediaServiceProviderPlugin*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QOffscreenSurface*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QPaintDeviceWindow*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QPdfWriter*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QQuickItem*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QRadioData*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QRemoteObjectPendingCallWatcher*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QScriptExtensionPlugin*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QWidget*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(target))) {
return new MyQPropertyAnimation(static_cast<QWindow*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
} else {
return new MyQPropertyAnimation(static_cast<QObject*>(target), *static_cast<QByteArray*>(propertyName), static_cast<QObject*>(parent));
}
}
void* QPropertyAnimation_PropertyName(void* ptr)
{
return new QByteArray(static_cast<QPropertyAnimation*>(ptr)->propertyName());
}
void QPropertyAnimation_SetPropertyName(void* ptr, void* propertyName)
{
static_cast<QPropertyAnimation*>(ptr)->setPropertyName(*static_cast<QByteArray*>(propertyName));
}
void QPropertyAnimation_SetTargetObject(void* ptr, void* target)
{
static_cast<QPropertyAnimation*>(ptr)->setTargetObject(static_cast<QObject*>(target));
}
void* QPropertyAnimation_TargetObject(void* ptr)
{
return static_cast<QPropertyAnimation*>(ptr)->targetObject();
}
void QPropertyAnimation_DestroyQPropertyAnimation(void* ptr)
{
static_cast<QPropertyAnimation*>(ptr)->~QPropertyAnimation();
}
void QPropertyAnimation_DestroyQPropertyAnimationDefault(void* ptr)
{
Q_UNUSED(ptr);
}
Q_DECLARE_METATYPE(QRandomGenerator*)
void* QRandomGenerator_NewQRandomGenerator(unsigned int seedValue)
{
return new QRandomGenerator(seedValue);
}
void* QRandomGenerator_NewQRandomGenerator5(unsigned int begin, unsigned int end)
{
return new QRandomGenerator(const_cast<const quint32*>(&begin), const_cast<const quint32*>(&end));
}
void* QRandomGenerator_NewQRandomGenerator6(void* other)
{
return new QRandomGenerator(*static_cast<QRandomGenerator*>(other));
}
double QRandomGenerator_Bounded(void* ptr, double highest)
{
return static_cast<QRandomGenerator*>(ptr)->bounded(highest);
}
unsigned int QRandomGenerator_Bounded2(void* ptr, unsigned int highest)
{
return static_cast<QRandomGenerator*>(ptr)->bounded(highest);
}
int QRandomGenerator_Bounded3(void* ptr, int highest)
{
return static_cast<QRandomGenerator*>(ptr)->bounded(highest);
}
unsigned int QRandomGenerator_Bounded4(void* ptr, unsigned int lowest, unsigned int highest)
{
return static_cast<QRandomGenerator*>(ptr)->bounded(lowest, highest);
}
int QRandomGenerator_Bounded5(void* ptr, int lowest, int highest)
{
return static_cast<QRandomGenerator*>(ptr)->bounded(lowest, highest);
}
void QRandomGenerator_Discard(void* ptr, unsigned long long z)
{
static_cast<QRandomGenerator*>(ptr)->discard(z);
}
unsigned int QRandomGenerator_Generate(void* ptr)
{
return static_cast<QRandomGenerator*>(ptr)->generate();
}
unsigned long long QRandomGenerator_Generate64(void* ptr)
{
return static_cast<QRandomGenerator*>(ptr)->generate64();
}
double QRandomGenerator_GenerateDouble(void* ptr)
{
return static_cast<QRandomGenerator*>(ptr)->generateDouble();
}
void* QRandomGenerator_QRandomGenerator_Global()
{
return QRandomGenerator::global();
}
void* QRandomGenerator_QRandomGenerator_SecurelySeeded()
{
return new QRandomGenerator(QRandomGenerator::securelySeeded());
}
void QRandomGenerator_Seed(void* ptr, unsigned int seed)
{
static_cast<QRandomGenerator*>(ptr)->seed(seed);
}
void* QRandomGenerator_QRandomGenerator_System()
{
return QRandomGenerator::system();
}
unsigned long long QRandomGenerator64_Generate(void* ptr)
{
return static_cast<QRandomGenerator64*>(ptr)->generate();
}
Q_DECLARE_METATYPE(QReadLocker*)
void* QReadLocker_NewQReadLocker(void* lock)
{
return new QReadLocker(static_cast<QReadWriteLock*>(lock));
}
void* QReadLocker_ReadWriteLock(void* ptr)
{
return static_cast<QReadLocker*>(ptr)->readWriteLock();
}
void QReadLocker_Relock(void* ptr)
{
static_cast<QReadLocker*>(ptr)->relock();
}
void QReadLocker_Unlock(void* ptr)
{
static_cast<QReadLocker*>(ptr)->unlock();
}
void QReadLocker_DestroyQReadLocker(void* ptr)
{
static_cast<QReadLocker*>(ptr)->~QReadLocker();
}
Q_DECLARE_METATYPE(QReadWriteLock*)
void* QReadWriteLock_NewQReadWriteLock(long long recursionMode)
{
return new QReadWriteLock(static_cast<QReadWriteLock::RecursionMode>(recursionMode));
}
void QReadWriteLock_LockForRead(void* ptr)
{
static_cast<QReadWriteLock*>(ptr)->lockForRead();
}
void QReadWriteLock_LockForWrite(void* ptr)
{
static_cast<QReadWriteLock*>(ptr)->lockForWrite();
}
char QReadWriteLock_TryLockForRead(void* ptr)
{
return static_cast<QReadWriteLock*>(ptr)->tryLockForRead();
}
char QReadWriteLock_TryLockForRead2(void* ptr, int timeout)
{
return static_cast<QReadWriteLock*>(ptr)->tryLockForRead(timeout);
}
char QReadWriteLock_TryLockForWrite(void* ptr)
{
return static_cast<QReadWriteLock*>(ptr)->tryLockForWrite();
}
char QReadWriteLock_TryLockForWrite2(void* ptr, int timeout)
{
return static_cast<QReadWriteLock*>(ptr)->tryLockForWrite(timeout);
}
void QReadWriteLock_Unlock(void* ptr)
{
static_cast<QReadWriteLock*>(ptr)->unlock();
}
void QReadWriteLock_DestroyQReadWriteLock(void* ptr)
{
static_cast<QReadWriteLock*>(ptr)->~QReadWriteLock();
}
Q_DECLARE_METATYPE(QRect)
Q_DECLARE_METATYPE(QRect*)
void* QRect_NewQRect()
{
return new QRect();
}
void* QRect_NewQRect2(void* topLeft, void* bottomRight)
{
return new QRect(*static_cast<QPoint*>(topLeft), *static_cast<QPoint*>(bottomRight));
}
void* QRect_NewQRect3(void* topLeft, void* size)
{
return new QRect(*static_cast<QPoint*>(topLeft), *static_cast<QSize*>(size));
}
void* QRect_NewQRect4(int x, int y, int width, int height)
{
return new QRect(x, y, width, height);
}
void QRect_Adjust(void* ptr, int dx1, int dy1, int dx2, int dy2)
{
static_cast<QRect*>(ptr)->adjust(dx1, dy1, dx2, dy2);
}
void* QRect_Adjusted(void* ptr, int dx1, int dy1, int dx2, int dy2)
{
return ({ QRect tmpValue = static_cast<QRect*>(ptr)->adjusted(dx1, dy1, dx2, dy2); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
int QRect_Bottom(void* ptr)
{
return static_cast<QRect*>(ptr)->bottom();
}
void* QRect_BottomLeft(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QRect*>(ptr)->bottomLeft(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QRect_BottomRight(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QRect*>(ptr)->bottomRight(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QRect_Center(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QRect*>(ptr)->center(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
char QRect_Contains(void* ptr, void* point, char proper)
{
return static_cast<QRect*>(ptr)->contains(*static_cast<QPoint*>(point), proper != 0);
}
char QRect_Contains2(void* ptr, void* rectangle, char proper)
{
return static_cast<QRect*>(ptr)->contains(*static_cast<QRect*>(rectangle), proper != 0);
}
char QRect_Contains3(void* ptr, int x, int y)
{
return static_cast<QRect*>(ptr)->contains(x, y);
}
char QRect_Contains4(void* ptr, int x, int y, char proper)
{
return static_cast<QRect*>(ptr)->contains(x, y, proper != 0);
}
void QRect_GetCoords(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QRect*>(ptr)->getCoords(&x1, &y1, &x2, &y2);
}
void QRect_GetRect(void* ptr, int x, int y, int width, int height)
{
static_cast<QRect*>(ptr)->getRect(&x, &y, &width, &height);
}
int QRect_Height(void* ptr)
{
return static_cast<QRect*>(ptr)->height();
}
void* QRect_Intersected(void* ptr, void* rectangle)
{
return ({ QRect tmpValue = static_cast<QRect*>(ptr)->intersected(*static_cast<QRect*>(rectangle)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
char QRect_Intersects(void* ptr, void* rectangle)
{
return static_cast<QRect*>(ptr)->intersects(*static_cast<QRect*>(rectangle));
}
char QRect_IsEmpty(void* ptr)
{
return static_cast<QRect*>(ptr)->isEmpty();
}
char QRect_IsNull(void* ptr)
{
return static_cast<QRect*>(ptr)->isNull();
}
char QRect_IsValid(void* ptr)
{
return static_cast<QRect*>(ptr)->isValid();
}
int QRect_Left(void* ptr)
{
return static_cast<QRect*>(ptr)->left();
}
void* QRect_MarginsAdded(void* ptr, void* margins)
{
return ({ QRect tmpValue = static_cast<QRect*>(ptr)->marginsAdded(*static_cast<QMargins*>(margins)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QRect_MarginsRemoved(void* ptr, void* margins)
{
return ({ QRect tmpValue = static_cast<QRect*>(ptr)->marginsRemoved(*static_cast<QMargins*>(margins)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void QRect_MoveBottom(void* ptr, int y)
{
static_cast<QRect*>(ptr)->moveBottom(y);
}
void QRect_MoveBottomLeft(void* ptr, void* position)
{
static_cast<QRect*>(ptr)->moveBottomLeft(*static_cast<QPoint*>(position));
}
void QRect_MoveBottomRight(void* ptr, void* position)
{
static_cast<QRect*>(ptr)->moveBottomRight(*static_cast<QPoint*>(position));
}
void QRect_MoveCenter(void* ptr, void* position)
{
static_cast<QRect*>(ptr)->moveCenter(*static_cast<QPoint*>(position));
}
void QRect_MoveLeft(void* ptr, int x)
{
static_cast<QRect*>(ptr)->moveLeft(x);
}
void QRect_MoveRight(void* ptr, int x)
{
static_cast<QRect*>(ptr)->moveRight(x);
}
void QRect_MoveTo(void* ptr, int x, int y)
{
static_cast<QRect*>(ptr)->moveTo(x, y);
}
void QRect_MoveTo2(void* ptr, void* position)
{
static_cast<QRect*>(ptr)->moveTo(*static_cast<QPoint*>(position));
}
void QRect_MoveTop(void* ptr, int y)
{
static_cast<QRect*>(ptr)->moveTop(y);
}
void QRect_MoveTopLeft(void* ptr, void* position)
{
static_cast<QRect*>(ptr)->moveTopLeft(*static_cast<QPoint*>(position));
}
void QRect_MoveTopRight(void* ptr, void* position)
{
static_cast<QRect*>(ptr)->moveTopRight(*static_cast<QPoint*>(position));
}
void* QRect_Normalized(void* ptr)
{
return ({ QRect tmpValue = static_cast<QRect*>(ptr)->normalized(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
int QRect_Right(void* ptr)
{
return static_cast<QRect*>(ptr)->right();
}
void QRect_SetBottom(void* ptr, int y)
{
static_cast<QRect*>(ptr)->setBottom(y);
}
void QRect_SetBottomLeft(void* ptr, void* position)
{
static_cast<QRect*>(ptr)->setBottomLeft(*static_cast<QPoint*>(position));
}
void QRect_SetBottomRight(void* ptr, void* position)
{
static_cast<QRect*>(ptr)->setBottomRight(*static_cast<QPoint*>(position));
}
void QRect_SetCoords(void* ptr, int x1, int y1, int x2, int y2)
{
static_cast<QRect*>(ptr)->setCoords(x1, y1, x2, y2);
}
void QRect_SetHeight(void* ptr, int height)
{
static_cast<QRect*>(ptr)->setHeight(height);
}
void QRect_SetLeft(void* ptr, int x)
{
static_cast<QRect*>(ptr)->setLeft(x);
}
void QRect_SetRect(void* ptr, int x, int y, int width, int height)
{
static_cast<QRect*>(ptr)->setRect(x, y, width, height);
}
void QRect_SetRight(void* ptr, int x)
{
static_cast<QRect*>(ptr)->setRight(x);
}
void QRect_SetSize(void* ptr, void* size)
{
static_cast<QRect*>(ptr)->setSize(*static_cast<QSize*>(size));
}
void QRect_SetTop(void* ptr, int y)
{
static_cast<QRect*>(ptr)->setTop(y);
}
void QRect_SetTopLeft(void* ptr, void* position)
{
static_cast<QRect*>(ptr)->setTopLeft(*static_cast<QPoint*>(position));
}
void QRect_SetTopRight(void* ptr, void* position)
{
static_cast<QRect*>(ptr)->setTopRight(*static_cast<QPoint*>(position));
}
void QRect_SetWidth(void* ptr, int width)
{
static_cast<QRect*>(ptr)->setWidth(width);
}
void QRect_SetX(void* ptr, int x)
{
static_cast<QRect*>(ptr)->setX(x);
}
void QRect_SetY(void* ptr, int y)
{
static_cast<QRect*>(ptr)->setY(y);
}
void* QRect_Size(void* ptr)
{
return ({ QSize tmpValue = static_cast<QRect*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
}
int QRect_Top(void* ptr)
{
return static_cast<QRect*>(ptr)->top();
}
void* QRect_TopLeft(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QRect*>(ptr)->topLeft(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QRect_TopRight(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QRect*>(ptr)->topRight(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void QRect_Translate(void* ptr, int dx, int dy)
{
static_cast<QRect*>(ptr)->translate(dx, dy);
}
void QRect_Translate2(void* ptr, void* offset)
{
static_cast<QRect*>(ptr)->translate(*static_cast<QPoint*>(offset));
}
void* QRect_Translated(void* ptr, int dx, int dy)
{
return ({ QRect tmpValue = static_cast<QRect*>(ptr)->translated(dx, dy); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QRect_Translated2(void* ptr, void* offset)
{
return ({ QRect tmpValue = static_cast<QRect*>(ptr)->translated(*static_cast<QPoint*>(offset)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QRect_Transposed(void* ptr)
{
return ({ QRect tmpValue = static_cast<QRect*>(ptr)->transposed(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QRect_United(void* ptr, void* rectangle)
{
return ({ QRect tmpValue = static_cast<QRect*>(ptr)->united(*static_cast<QRect*>(rectangle)); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
int QRect_Width(void* ptr)
{
return static_cast<QRect*>(ptr)->width();
}
int QRect_X(void* ptr)
{
return static_cast<QRect*>(ptr)->x();
}
int QRect_Y(void* ptr)
{
return static_cast<QRect*>(ptr)->y();
}
Q_DECLARE_METATYPE(QRectF)
Q_DECLARE_METATYPE(QRectF*)
void* QRectF_NewQRectF()
{
return new QRectF();
}
void* QRectF_NewQRectF2(void* topLeft, void* size)
{
return new QRectF(*static_cast<QPointF*>(topLeft), *static_cast<QSizeF*>(size));
}
void* QRectF_NewQRectF3(void* topLeft, void* bottomRight)
{
return new QRectF(*static_cast<QPointF*>(topLeft), *static_cast<QPointF*>(bottomRight));
}
void* QRectF_NewQRectF4(double x, double y, double width, double height)
{
return new QRectF(x, y, width, height);
}
void* QRectF_NewQRectF5(void* rectangle)
{
return new QRectF(*static_cast<QRect*>(rectangle));
}
void QRectF_Adjust(void* ptr, double dx1, double dy1, double dx2, double dy2)
{
static_cast<QRectF*>(ptr)->adjust(dx1, dy1, dx2, dy2);
}
void* QRectF_Adjusted(void* ptr, double dx1, double dy1, double dx2, double dy2)
{
return ({ QRectF tmpValue = static_cast<QRectF*>(ptr)->adjusted(dx1, dy1, dx2, dy2); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
double QRectF_Bottom(void* ptr)
{
return static_cast<QRectF*>(ptr)->bottom();
}
void* QRectF_BottomLeft(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QRectF*>(ptr)->bottomLeft(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QRectF_BottomRight(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QRectF*>(ptr)->bottomRight(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QRectF_Center(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QRectF*>(ptr)->center(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
char QRectF_Contains(void* ptr, void* point)
{
return static_cast<QRectF*>(ptr)->contains(*static_cast<QPointF*>(point));
}
char QRectF_Contains2(void* ptr, void* rectangle)
{
return static_cast<QRectF*>(ptr)->contains(*static_cast<QRectF*>(rectangle));
}
char QRectF_Contains3(void* ptr, double x, double y)
{
return static_cast<QRectF*>(ptr)->contains(x, y);
}
void QRectF_GetCoords(void* ptr, double x1, double y1, double x2, double y2)
{
static_cast<QRectF*>(ptr)->getCoords(&x1, &y1, &x2, &y2);
}
void QRectF_GetRect(void* ptr, double x, double y, double width, double height)
{
static_cast<QRectF*>(ptr)->getRect(&x, &y, &width, &height);
}
double QRectF_Height(void* ptr)
{
return static_cast<QRectF*>(ptr)->height();
}
void* QRectF_Intersected(void* ptr, void* rectangle)
{
return ({ QRectF tmpValue = static_cast<QRectF*>(ptr)->intersected(*static_cast<QRectF*>(rectangle)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
char QRectF_Intersects(void* ptr, void* rectangle)
{
return static_cast<QRectF*>(ptr)->intersects(*static_cast<QRectF*>(rectangle));
}
char QRectF_IsEmpty(void* ptr)
{
return static_cast<QRectF*>(ptr)->isEmpty();
}
char QRectF_IsNull(void* ptr)
{
return static_cast<QRectF*>(ptr)->isNull();
}
char QRectF_IsValid(void* ptr)
{
return static_cast<QRectF*>(ptr)->isValid();
}
double QRectF_Left(void* ptr)
{
return static_cast<QRectF*>(ptr)->left();
}
void* QRectF_MarginsAdded(void* ptr, void* margins)
{
return ({ QRectF tmpValue = static_cast<QRectF*>(ptr)->marginsAdded(*static_cast<QMarginsF*>(margins)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QRectF_MarginsRemoved(void* ptr, void* margins)
{
return ({ QRectF tmpValue = static_cast<QRectF*>(ptr)->marginsRemoved(*static_cast<QMarginsF*>(margins)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void QRectF_MoveBottom(void* ptr, double y)
{
static_cast<QRectF*>(ptr)->moveBottom(y);
}
void QRectF_MoveBottomLeft(void* ptr, void* position)
{
static_cast<QRectF*>(ptr)->moveBottomLeft(*static_cast<QPointF*>(position));
}
void QRectF_MoveBottomRight(void* ptr, void* position)
{
static_cast<QRectF*>(ptr)->moveBottomRight(*static_cast<QPointF*>(position));
}
void QRectF_MoveCenter(void* ptr, void* position)
{
static_cast<QRectF*>(ptr)->moveCenter(*static_cast<QPointF*>(position));
}
void QRectF_MoveLeft(void* ptr, double x)
{
static_cast<QRectF*>(ptr)->moveLeft(x);
}
void QRectF_MoveRight(void* ptr, double x)
{
static_cast<QRectF*>(ptr)->moveRight(x);
}
void QRectF_MoveTo(void* ptr, double x, double y)
{
static_cast<QRectF*>(ptr)->moveTo(x, y);
}
void QRectF_MoveTo2(void* ptr, void* position)
{
static_cast<QRectF*>(ptr)->moveTo(*static_cast<QPointF*>(position));
}
void QRectF_MoveTop(void* ptr, double y)
{
static_cast<QRectF*>(ptr)->moveTop(y);
}
void QRectF_MoveTopLeft(void* ptr, void* position)
{
static_cast<QRectF*>(ptr)->moveTopLeft(*static_cast<QPointF*>(position));
}
void QRectF_MoveTopRight(void* ptr, void* position)
{
static_cast<QRectF*>(ptr)->moveTopRight(*static_cast<QPointF*>(position));
}
void* QRectF_Normalized(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QRectF*>(ptr)->normalized(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
double QRectF_Right(void* ptr)
{
return static_cast<QRectF*>(ptr)->right();
}
void QRectF_SetBottom(void* ptr, double y)
{
static_cast<QRectF*>(ptr)->setBottom(y);
}
void QRectF_SetBottomLeft(void* ptr, void* position)
{
static_cast<QRectF*>(ptr)->setBottomLeft(*static_cast<QPointF*>(position));
}
void QRectF_SetBottomRight(void* ptr, void* position)
{
static_cast<QRectF*>(ptr)->setBottomRight(*static_cast<QPointF*>(position));
}
void QRectF_SetCoords(void* ptr, double x1, double y1, double x2, double y2)
{
static_cast<QRectF*>(ptr)->setCoords(x1, y1, x2, y2);
}
void QRectF_SetHeight(void* ptr, double height)
{
static_cast<QRectF*>(ptr)->setHeight(height);
}
void QRectF_SetLeft(void* ptr, double x)
{
static_cast<QRectF*>(ptr)->setLeft(x);
}
void QRectF_SetRect(void* ptr, double x, double y, double width, double height)
{
static_cast<QRectF*>(ptr)->setRect(x, y, width, height);
}
void QRectF_SetRight(void* ptr, double x)
{
static_cast<QRectF*>(ptr)->setRight(x);
}
void QRectF_SetSize(void* ptr, void* size)
{
static_cast<QRectF*>(ptr)->setSize(*static_cast<QSizeF*>(size));
}
void QRectF_SetTop(void* ptr, double y)
{
static_cast<QRectF*>(ptr)->setTop(y);
}
void QRectF_SetTopLeft(void* ptr, void* position)
{
static_cast<QRectF*>(ptr)->setTopLeft(*static_cast<QPointF*>(position));
}
void QRectF_SetTopRight(void* ptr, void* position)
{
static_cast<QRectF*>(ptr)->setTopRight(*static_cast<QPointF*>(position));
}
void QRectF_SetWidth(void* ptr, double width)
{
static_cast<QRectF*>(ptr)->setWidth(width);
}
void QRectF_SetX(void* ptr, double x)
{
static_cast<QRectF*>(ptr)->setX(x);
}
void QRectF_SetY(void* ptr, double y)
{
static_cast<QRectF*>(ptr)->setY(y);
}
void* QRectF_Size(void* ptr)
{
return ({ QSizeF tmpValue = static_cast<QRectF*>(ptr)->size(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
void* QRectF_ToAlignedRect(void* ptr)
{
return ({ QRect tmpValue = static_cast<QRectF*>(ptr)->toAlignedRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QRectF_ToRect(void* ptr)
{
return ({ QRect tmpValue = static_cast<QRectF*>(ptr)->toRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
double QRectF_Top(void* ptr)
{
return static_cast<QRectF*>(ptr)->top();
}
void* QRectF_TopLeft(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QRectF*>(ptr)->topLeft(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void* QRectF_TopRight(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QRectF*>(ptr)->topRight(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
void QRectF_Translate(void* ptr, double dx, double dy)
{
static_cast<QRectF*>(ptr)->translate(dx, dy);
}
void QRectF_Translate2(void* ptr, void* offset)
{
static_cast<QRectF*>(ptr)->translate(*static_cast<QPointF*>(offset));
}
void* QRectF_Translated(void* ptr, double dx, double dy)
{
return ({ QRectF tmpValue = static_cast<QRectF*>(ptr)->translated(dx, dy); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QRectF_Translated2(void* ptr, void* offset)
{
return ({ QRectF tmpValue = static_cast<QRectF*>(ptr)->translated(*static_cast<QPointF*>(offset)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QRectF_Transposed(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QRectF*>(ptr)->transposed(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QRectF_United(void* ptr, void* rectangle)
{
return ({ QRectF tmpValue = static_cast<QRectF*>(ptr)->united(*static_cast<QRectF*>(rectangle)); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
double QRectF_Width(void* ptr)
{
return static_cast<QRectF*>(ptr)->width();
}
double QRectF_X(void* ptr)
{
return static_cast<QRectF*>(ptr)->x();
}
double QRectF_Y(void* ptr)
{
return static_cast<QRectF*>(ptr)->y();
}
Q_DECLARE_METATYPE(QRegExp)
Q_DECLARE_METATYPE(QRegExp*)
void* QRegExp_NewQRegExp()
{
return new QRegExp();
}
void* QRegExp_NewQRegExp2(struct QtCore_PackedString pattern, long long cs, long long syntax)
{
return new QRegExp(QString::fromUtf8(pattern.data, pattern.len), static_cast<Qt::CaseSensitivity>(cs), static_cast<QRegExp::PatternSyntax>(syntax));
}
void* QRegExp_NewQRegExp3(void* rx)
{
return new QRegExp(*static_cast<QRegExp*>(rx));
}
struct QtCore_PackedString QRegExp_Cap(void* ptr, int nth)
{
return ({ QByteArray* t6327b9 = new QByteArray(static_cast<QRegExp*>(ptr)->cap(nth).toUtf8()); QtCore_PackedString { const_cast<char*>(t6327b9->prepend("WHITESPACE").constData()+10), t6327b9->size()-10, t6327b9 }; });
}
int QRegExp_CaptureCount(void* ptr)
{
return static_cast<QRegExp*>(ptr)->captureCount();
}
struct QtCore_PackedString QRegExp_CapturedTexts(void* ptr)
{
return ({ QByteArray* t69e4cf = new QByteArray(static_cast<QRegExp*>(ptr)->capturedTexts().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t69e4cf->prepend("WHITESPACE").constData()+10), t69e4cf->size()-10, t69e4cf }; });
}
long long QRegExp_CaseSensitivity(void* ptr)
{
return static_cast<QRegExp*>(ptr)->caseSensitivity();
}
struct QtCore_PackedString QRegExp_ErrorString(void* ptr)
{
return ({ QByteArray* t53d00c = new QByteArray(static_cast<QRegExp*>(ptr)->errorString().toUtf8()); QtCore_PackedString { const_cast<char*>(t53d00c->prepend("WHITESPACE").constData()+10), t53d00c->size()-10, t53d00c }; });
}
struct QtCore_PackedString QRegExp_QRegExp_Escape(struct QtCore_PackedString str)
{
return ({ QByteArray* tf416e0 = new QByteArray(QRegExp::escape(QString::fromUtf8(str.data, str.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(tf416e0->prepend("WHITESPACE").constData()+10), tf416e0->size()-10, tf416e0 }; });
}
char QRegExp_ExactMatch(void* ptr, struct QtCore_PackedString str)
{
return static_cast<QRegExp*>(ptr)->exactMatch(QString::fromUtf8(str.data, str.len));
}
int QRegExp_IndexIn(void* ptr, struct QtCore_PackedString str, int offset, long long caretMode)
{
return static_cast<QRegExp*>(ptr)->indexIn(QString::fromUtf8(str.data, str.len), offset, static_cast<QRegExp::CaretMode>(caretMode));
}
char QRegExp_IsEmpty(void* ptr)
{
return static_cast<QRegExp*>(ptr)->isEmpty();
}
char QRegExp_IsMinimal(void* ptr)
{
return static_cast<QRegExp*>(ptr)->isMinimal();
}
char QRegExp_IsValid(void* ptr)
{
return static_cast<QRegExp*>(ptr)->isValid();
}
int QRegExp_LastIndexIn(void* ptr, struct QtCore_PackedString str, int offset, long long caretMode)
{
return static_cast<QRegExp*>(ptr)->lastIndexIn(QString::fromUtf8(str.data, str.len), offset, static_cast<QRegExp::CaretMode>(caretMode));
}
int QRegExp_MatchedLength(void* ptr)
{
return static_cast<QRegExp*>(ptr)->matchedLength();
}
struct QtCore_PackedString QRegExp_Pattern(void* ptr)
{
return ({ QByteArray* t70b801 = new QByteArray(static_cast<QRegExp*>(ptr)->pattern().toUtf8()); QtCore_PackedString { const_cast<char*>(t70b801->prepend("WHITESPACE").constData()+10), t70b801->size()-10, t70b801 }; });
}
long long QRegExp_PatternSyntax(void* ptr)
{
return static_cast<QRegExp*>(ptr)->patternSyntax();
}
int QRegExp_Pos(void* ptr, int nth)
{
return static_cast<QRegExp*>(ptr)->pos(nth);
}
void QRegExp_SetCaseSensitivity(void* ptr, long long cs)
{
static_cast<QRegExp*>(ptr)->setCaseSensitivity(static_cast<Qt::CaseSensitivity>(cs));
}
void QRegExp_SetMinimal(void* ptr, char minimal)
{
static_cast<QRegExp*>(ptr)->setMinimal(minimal != 0);
}
void QRegExp_SetPattern(void* ptr, struct QtCore_PackedString pattern)
{
static_cast<QRegExp*>(ptr)->setPattern(QString::fromUtf8(pattern.data, pattern.len));
}
void QRegExp_SetPatternSyntax(void* ptr, long long syntax)
{
static_cast<QRegExp*>(ptr)->setPatternSyntax(static_cast<QRegExp::PatternSyntax>(syntax));
}
void QRegExp_Swap(void* ptr, void* other)
{
static_cast<QRegExp*>(ptr)->swap(*static_cast<QRegExp*>(other));
}
void QRegExp_DestroyQRegExp(void* ptr)
{
static_cast<QRegExp*>(ptr)->~QRegExp();
}
Q_DECLARE_METATYPE(QRegularExpression)
Q_DECLARE_METATYPE(QRegularExpression*)
void* QRegularExpression_NewQRegularExpression()
{
return new QRegularExpression();
}
void* QRegularExpression_NewQRegularExpression2(struct QtCore_PackedString pattern, long long options)
{
return new QRegularExpression(QString::fromUtf8(pattern.data, pattern.len), static_cast<QRegularExpression::PatternOption>(options));
}
void* QRegularExpression_NewQRegularExpression3(void* re)
{
return new QRegularExpression(*static_cast<QRegularExpression*>(re));
}
struct QtCore_PackedString QRegularExpression_QRegularExpression_AnchoredPattern(struct QtCore_PackedString expression)
{
return ({ QByteArray* t32c726 = new QByteArray(QRegularExpression::anchoredPattern(QString::fromUtf8(expression.data, expression.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t32c726->prepend("WHITESPACE").constData()+10), t32c726->size()-10, t32c726 }; });
}
int QRegularExpression_CaptureCount(void* ptr)
{
return static_cast<QRegularExpression*>(ptr)->captureCount();
}
struct QtCore_PackedString QRegularExpression_ErrorString(void* ptr)
{
return ({ QByteArray* t85aa6b = new QByteArray(static_cast<QRegularExpression*>(ptr)->errorString().toUtf8()); QtCore_PackedString { const_cast<char*>(t85aa6b->prepend("WHITESPACE").constData()+10), t85aa6b->size()-10, t85aa6b }; });
}
struct QtCore_PackedString QRegularExpression_QRegularExpression_Escape(struct QtCore_PackedString str)
{
return ({ QByteArray* tf551fc = new QByteArray(QRegularExpression::escape(QString::fromUtf8(str.data, str.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(tf551fc->prepend("WHITESPACE").constData()+10), tf551fc->size()-10, tf551fc }; });
}
void* QRegularExpression_GlobalMatch(void* ptr, struct QtCore_PackedString subject, int offset, long long matchType, long long matchOptions)
{
return new QRegularExpressionMatchIterator(static_cast<QRegularExpression*>(ptr)->globalMatch(QString::fromUtf8(subject.data, subject.len), offset, static_cast<QRegularExpression::MatchType>(matchType), static_cast<QRegularExpression::MatchOption>(matchOptions)));
}
void* QRegularExpression_GlobalMatch2(void* ptr, void* subjectRef, int offset, long long matchType, long long matchOptions)
{
return new QRegularExpressionMatchIterator(static_cast<QRegularExpression*>(ptr)->globalMatch(*static_cast<QStringRef*>(subjectRef), offset, static_cast<QRegularExpression::MatchType>(matchType), static_cast<QRegularExpression::MatchOption>(matchOptions)));
}
char QRegularExpression_IsValid(void* ptr)
{
return static_cast<QRegularExpression*>(ptr)->isValid();
}
void* QRegularExpression_Match(void* ptr, struct QtCore_PackedString subject, int offset, long long matchType, long long matchOptions)
{
return new QRegularExpressionMatch(static_cast<QRegularExpression*>(ptr)->match(QString::fromUtf8(subject.data, subject.len), offset, static_cast<QRegularExpression::MatchType>(matchType), static_cast<QRegularExpression::MatchOption>(matchOptions)));
}
void* QRegularExpression_Match2(void* ptr, void* subjectRef, int offset, long long matchType, long long matchOptions)
{
return new QRegularExpressionMatch(static_cast<QRegularExpression*>(ptr)->match(*static_cast<QStringRef*>(subjectRef), offset, static_cast<QRegularExpression::MatchType>(matchType), static_cast<QRegularExpression::MatchOption>(matchOptions)));
}
struct QtCore_PackedString QRegularExpression_NamedCaptureGroups(void* ptr)
{
return ({ QByteArray* t5a80a4 = new QByteArray(static_cast<QRegularExpression*>(ptr)->namedCaptureGroups().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t5a80a4->prepend("WHITESPACE").constData()+10), t5a80a4->size()-10, t5a80a4 }; });
}
void QRegularExpression_Optimize(void* ptr)
{
static_cast<QRegularExpression*>(ptr)->optimize();
}
struct QtCore_PackedString QRegularExpression_Pattern(void* ptr)
{
return ({ QByteArray* t585ea0 = new QByteArray(static_cast<QRegularExpression*>(ptr)->pattern().toUtf8()); QtCore_PackedString { const_cast<char*>(t585ea0->prepend("WHITESPACE").constData()+10), t585ea0->size()-10, t585ea0 }; });
}
int QRegularExpression_PatternErrorOffset(void* ptr)
{
return static_cast<QRegularExpression*>(ptr)->patternErrorOffset();
}
long long QRegularExpression_PatternOptions(void* ptr)
{
return static_cast<QRegularExpression*>(ptr)->patternOptions();
}
void QRegularExpression_SetPattern(void* ptr, struct QtCore_PackedString pattern)
{
static_cast<QRegularExpression*>(ptr)->setPattern(QString::fromUtf8(pattern.data, pattern.len));
}
void QRegularExpression_SetPatternOptions(void* ptr, long long options)
{
static_cast<QRegularExpression*>(ptr)->setPatternOptions(static_cast<QRegularExpression::PatternOption>(options));
}
void QRegularExpression_Swap(void* ptr, void* other)
{
static_cast<QRegularExpression*>(ptr)->swap(*static_cast<QRegularExpression*>(other));
}
struct QtCore_PackedString QRegularExpression_QRegularExpression_WildcardToRegularExpression(struct QtCore_PackedString pattern)
{
return ({ QByteArray* ta3cf94 = new QByteArray(QRegularExpression::wildcardToRegularExpression(QString::fromUtf8(pattern.data, pattern.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(ta3cf94->prepend("WHITESPACE").constData()+10), ta3cf94->size()-10, ta3cf94 }; });
}
void QRegularExpression_DestroyQRegularExpression(void* ptr)
{
static_cast<QRegularExpression*>(ptr)->~QRegularExpression();
}
Q_DECLARE_METATYPE(QRegularExpressionMatch)
Q_DECLARE_METATYPE(QRegularExpressionMatch*)
void* QRegularExpressionMatch_NewQRegularExpressionMatch()
{
return new QRegularExpressionMatch();
}
void* QRegularExpressionMatch_NewQRegularExpressionMatch2(void* match)
{
return new QRegularExpressionMatch(*static_cast<QRegularExpressionMatch*>(match));
}
struct QtCore_PackedString QRegularExpressionMatch_Captured(void* ptr, int nth)
{
return ({ QByteArray* t5bb134 = new QByteArray(static_cast<QRegularExpressionMatch*>(ptr)->captured(nth).toUtf8()); QtCore_PackedString { const_cast<char*>(t5bb134->prepend("WHITESPACE").constData()+10), t5bb134->size()-10, t5bb134 }; });
}
struct QtCore_PackedString QRegularExpressionMatch_Captured2(void* ptr, struct QtCore_PackedString name)
{
return ({ QByteArray* te09a4d = new QByteArray(static_cast<QRegularExpressionMatch*>(ptr)->captured(QString::fromUtf8(name.data, name.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(te09a4d->prepend("WHITESPACE").constData()+10), te09a4d->size()-10, te09a4d }; });
}
struct QtCore_PackedString QRegularExpressionMatch_Captured3(void* ptr, void* name)
{
return ({ QByteArray* t0ab4af = new QByteArray(static_cast<QRegularExpressionMatch*>(ptr)->captured(*static_cast<QStringView*>(name)).toUtf8()); QtCore_PackedString { const_cast<char*>(t0ab4af->prepend("WHITESPACE").constData()+10), t0ab4af->size()-10, t0ab4af }; });
}
int QRegularExpressionMatch_CapturedEnd(void* ptr, int nth)
{
return static_cast<QRegularExpressionMatch*>(ptr)->capturedEnd(nth);
}
int QRegularExpressionMatch_CapturedEnd2(void* ptr, struct QtCore_PackedString name)
{
return static_cast<QRegularExpressionMatch*>(ptr)->capturedEnd(QString::fromUtf8(name.data, name.len));
}
int QRegularExpressionMatch_CapturedEnd3(void* ptr, void* name)
{
return static_cast<QRegularExpressionMatch*>(ptr)->capturedEnd(*static_cast<QStringView*>(name));
}
int QRegularExpressionMatch_CapturedLength(void* ptr, int nth)
{
return static_cast<QRegularExpressionMatch*>(ptr)->capturedLength(nth);
}
int QRegularExpressionMatch_CapturedLength2(void* ptr, struct QtCore_PackedString name)
{
return static_cast<QRegularExpressionMatch*>(ptr)->capturedLength(QString::fromUtf8(name.data, name.len));
}
int QRegularExpressionMatch_CapturedLength3(void* ptr, void* name)
{
return static_cast<QRegularExpressionMatch*>(ptr)->capturedLength(*static_cast<QStringView*>(name));
}
void* QRegularExpressionMatch_CapturedRef(void* ptr, int nth)
{
return new QStringRef(static_cast<QRegularExpressionMatch*>(ptr)->capturedRef(nth));
}
void* QRegularExpressionMatch_CapturedRef2(void* ptr, struct QtCore_PackedString name)
{
return new QStringRef(static_cast<QRegularExpressionMatch*>(ptr)->capturedRef(QString::fromUtf8(name.data, name.len)));
}
void* QRegularExpressionMatch_CapturedRef3(void* ptr, void* name)
{
return new QStringRef(static_cast<QRegularExpressionMatch*>(ptr)->capturedRef(*static_cast<QStringView*>(name)));
}
int QRegularExpressionMatch_CapturedStart(void* ptr, int nth)
{
return static_cast<QRegularExpressionMatch*>(ptr)->capturedStart(nth);
}
int QRegularExpressionMatch_CapturedStart2(void* ptr, struct QtCore_PackedString name)
{
return static_cast<QRegularExpressionMatch*>(ptr)->capturedStart(QString::fromUtf8(name.data, name.len));
}
int QRegularExpressionMatch_CapturedStart3(void* ptr, void* name)
{
return static_cast<QRegularExpressionMatch*>(ptr)->capturedStart(*static_cast<QStringView*>(name));
}
struct QtCore_PackedString QRegularExpressionMatch_CapturedTexts(void* ptr)
{
return ({ QByteArray* t75c0a9 = new QByteArray(static_cast<QRegularExpressionMatch*>(ptr)->capturedTexts().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t75c0a9->prepend("WHITESPACE").constData()+10), t75c0a9->size()-10, t75c0a9 }; });
}
void* QRegularExpressionMatch_CapturedView(void* ptr, int nth)
{
return new QStringView(static_cast<QRegularExpressionMatch*>(ptr)->capturedView(nth));
}
void* QRegularExpressionMatch_CapturedView2(void* ptr, void* name)
{
return new QStringView(static_cast<QRegularExpressionMatch*>(ptr)->capturedView(*static_cast<QStringView*>(name)));
}
char QRegularExpressionMatch_HasMatch(void* ptr)
{
return static_cast<QRegularExpressionMatch*>(ptr)->hasMatch();
}
char QRegularExpressionMatch_HasPartialMatch(void* ptr)
{
return static_cast<QRegularExpressionMatch*>(ptr)->hasPartialMatch();
}
char QRegularExpressionMatch_IsValid(void* ptr)
{
return static_cast<QRegularExpressionMatch*>(ptr)->isValid();
}
int QRegularExpressionMatch_LastCapturedIndex(void* ptr)
{
return static_cast<QRegularExpressionMatch*>(ptr)->lastCapturedIndex();
}
long long QRegularExpressionMatch_MatchOptions(void* ptr)
{
return static_cast<QRegularExpressionMatch*>(ptr)->matchOptions();
}
long long QRegularExpressionMatch_MatchType(void* ptr)
{
return static_cast<QRegularExpressionMatch*>(ptr)->matchType();
}
void* QRegularExpressionMatch_RegularExpression(void* ptr)
{
return new QRegularExpression(static_cast<QRegularExpressionMatch*>(ptr)->regularExpression());
}
void QRegularExpressionMatch_Swap(void* ptr, void* other)
{
static_cast<QRegularExpressionMatch*>(ptr)->swap(*static_cast<QRegularExpressionMatch*>(other));
}
void QRegularExpressionMatch_DestroyQRegularExpressionMatch(void* ptr)
{
static_cast<QRegularExpressionMatch*>(ptr)->~QRegularExpressionMatch();
}
Q_DECLARE_METATYPE(QResource*)
void* QResource_NewQResource(struct QtCore_PackedString file, void* locale)
{
return new QResource(QString::fromUtf8(file.data, file.len), *static_cast<QLocale*>(locale));
}
struct QtCore_PackedString QResource_AbsoluteFilePath(void* ptr)
{
return ({ QByteArray* t1066ec = new QByteArray(static_cast<QResource*>(ptr)->absoluteFilePath().toUtf8()); QtCore_PackedString { const_cast<char*>(t1066ec->prepend("WHITESPACE").constData()+10), t1066ec->size()-10, t1066ec }; });
}
struct QtCore_PackedString QResource_Children(void* ptr)
{
return ({ QByteArray* t6aef35 = new QByteArray(static_cast<QResource*>(ptr)->children().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t6aef35->prepend("WHITESPACE").constData()+10), t6aef35->size()-10, t6aef35 }; });
}
long long QResource_CompressionAlgorithm(void* ptr)
{
return static_cast<QResource*>(ptr)->compressionAlgorithm();
}
struct QtCore_PackedString QResource_Data(void* ptr)
{
return ({ char* t4b0f0d = static_cast<char*>(static_cast<void*>(const_cast<uchar*>(static_cast<QResource*>(ptr)->data()))); QtCore_PackedString { t4b0f0d, -1, NULL }; });
}
struct QtCore_PackedString QResource_FileName(void* ptr)
{
return ({ QByteArray* t28de69 = new QByteArray(static_cast<QResource*>(ptr)->fileName().toUtf8()); QtCore_PackedString { const_cast<char*>(t28de69->prepend("WHITESPACE").constData()+10), t28de69->size()-10, t28de69 }; });
}
char QResource_IsCompressed(void* ptr)
{
return static_cast<QResource*>(ptr)->isCompressed();
}
char QResource_IsDir(void* ptr)
{
return static_cast<QResource*>(ptr)->isDir();
}
char QResource_IsFile(void* ptr)
{
return static_cast<QResource*>(ptr)->isFile();
}
char QResource_IsValid(void* ptr)
{
return static_cast<QResource*>(ptr)->isValid();
}
void* QResource_LastModified(void* ptr)
{
return new QDateTime(static_cast<QResource*>(ptr)->lastModified());
}
void* QResource_Locale(void* ptr)
{
return new QLocale(static_cast<QResource*>(ptr)->locale());
}
char QResource_QResource_RegisterResource(struct QtCore_PackedString rccFileName, struct QtCore_PackedString mapRoot)
{
return QResource::registerResource(QString::fromUtf8(rccFileName.data, rccFileName.len), QString::fromUtf8(mapRoot.data, mapRoot.len));
}
char QResource_QResource_RegisterResource2(char* rccData, struct QtCore_PackedString mapRoot)
{
return QResource::registerResource(const_cast<const uchar*>(static_cast<uchar*>(static_cast<void*>(rccData))), QString::fromUtf8(mapRoot.data, mapRoot.len));
}
void QResource_SetFileName(void* ptr, struct QtCore_PackedString file)
{
static_cast<QResource*>(ptr)->setFileName(QString::fromUtf8(file.data, file.len));
}
void QResource_SetLocale(void* ptr, void* locale)
{
static_cast<QResource*>(ptr)->setLocale(*static_cast<QLocale*>(locale));
}
long long QResource_Size(void* ptr)
{
return static_cast<QResource*>(ptr)->size();
}
char QResource_QResource_UnregisterResource(struct QtCore_PackedString rccFileName, struct QtCore_PackedString mapRoot)
{
return QResource::unregisterResource(QString::fromUtf8(rccFileName.data, rccFileName.len), QString::fromUtf8(mapRoot.data, mapRoot.len));
}
char QResource_QResource_UnregisterResource2(char* rccData, struct QtCore_PackedString mapRoot)
{
return QResource::unregisterResource(const_cast<const uchar*>(static_cast<uchar*>(static_cast<void*>(rccData))), QString::fromUtf8(mapRoot.data, mapRoot.len));
}
void QResource_DestroyQResource(void* ptr)
{
static_cast<QResource*>(ptr)->~QResource();
}
class MyQRunnable: public QRunnable
{
public:
MyQRunnable() : QRunnable() {QRunnable_QRunnable_QRegisterMetaType();};
void run() { callbackQRunnable_Run(this); };
~MyQRunnable() { callbackQRunnable_DestroyQRunnable(this); };
};
Q_DECLARE_METATYPE(QRunnable*)
Q_DECLARE_METATYPE(MyQRunnable*)
int QRunnable_QRunnable_QRegisterMetaType(){qRegisterMetaType<QRunnable*>(); return qRegisterMetaType<MyQRunnable*>();}
void* QRunnable_NewQRunnable()
{
return new MyQRunnable();
}
char QRunnable_AutoDelete(void* ptr)
{
return static_cast<QRunnable*>(ptr)->autoDelete();
}
void QRunnable_Run(void* ptr)
{
static_cast<QRunnable*>(ptr)->run();
}
void QRunnable_SetAutoDelete(void* ptr, char autoDelete)
{
static_cast<QRunnable*>(ptr)->setAutoDelete(autoDelete != 0);
}
void QRunnable_DestroyQRunnable(void* ptr)
{
static_cast<QRunnable*>(ptr)->~QRunnable();
}
void QRunnable_DestroyQRunnableDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQSaveFile: public QSaveFile
{
public:
MyQSaveFile(const QString &name) : QSaveFile(name) {QSaveFile_QSaveFile_QRegisterMetaType();};
MyQSaveFile(QObject *parent = Q_NULLPTR) : QSaveFile(parent) {QSaveFile_QSaveFile_QRegisterMetaType();};
MyQSaveFile(const QString &name, QObject *parent) : QSaveFile(name, parent) {QSaveFile_QSaveFile_QRegisterMetaType();};
QString fileName() const { return ({ QtCore_PackedString tempVal = callbackQFileDevice_FileName(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
bool open(QIODevice::OpenMode mode) { return callbackQIODevice_Open(this, mode) != 0; };
qint64 writeData(const char * data, qint64 l) { QtCore_PackedString dataPacked = { const_cast<char*>(data), l, NULL };return callbackQFileDevice_WriteData(this, dataPacked, l); };
~MyQSaveFile() { callbackQSaveFile_DestroyQSaveFile(this); };
bool atEnd() const { return callbackQIODevice_AtEnd(const_cast<void*>(static_cast<const void*>(this))) != 0; };
void close() { callbackQIODevice_Close(this); };
bool isSequential() const { return callbackQIODevice_IsSequential(const_cast<void*>(static_cast<const void*>(this))) != 0; };
QFileDevice::Permissions permissions() const { return static_cast<QFileDevice::Permission>(callbackQFileDevice_Permissions(const_cast<void*>(static_cast<const void*>(this)))); };
qint64 pos() const { return callbackQIODevice_Pos(const_cast<void*>(static_cast<const void*>(this))); };
qint64 readData(char * data, qint64 l) { QtCore_PackedString dataPacked = { data, l, NULL };return callbackQFileDevice_ReadData(this, dataPacked, l); };
qint64 readLineData(char * data, qint64 maxlen) { QtCore_PackedString dataPacked = { data, maxlen, NULL };return callbackQIODevice_ReadLineData(this, dataPacked, maxlen); };
bool resize(qint64 sz) { return callbackQFileDevice_Resize(this, sz) != 0; };
bool seek(qint64 pos) { return callbackQIODevice_Seek(this, pos) != 0; };
bool setPermissions(QFileDevice::Permissions permissions) { return callbackQFileDevice_SetPermissions(this, permissions) != 0; };
qint64 size() const { return callbackQIODevice_Size(const_cast<void*>(static_cast<const void*>(this))); };
void Signal_AboutToClose() { callbackQIODevice_AboutToClose(this); };
qint64 bytesAvailable() const { return callbackQIODevice_BytesAvailable(const_cast<void*>(static_cast<const void*>(this))); };
qint64 bytesToWrite() const { return callbackQIODevice_BytesToWrite(const_cast<void*>(static_cast<const void*>(this))); };
void Signal_BytesWritten(qint64 bytes) { callbackQIODevice_BytesWritten(this, bytes); };
bool canReadLine() const { return callbackQIODevice_CanReadLine(const_cast<void*>(static_cast<const void*>(this))) != 0; };
void Signal_ChannelBytesWritten(int channel, qint64 bytes) { callbackQIODevice_ChannelBytesWritten(this, channel, bytes); };
void Signal_ChannelReadyRead(int channel) { callbackQIODevice_ChannelReadyRead(this, channel); };
void Signal_ReadChannelFinished() { callbackQIODevice_ReadChannelFinished(this); };
void Signal_ReadyRead() { callbackQIODevice_ReadyRead(this); };
bool reset() { return callbackQIODevice_Reset(this) != 0; };
bool waitForBytesWritten(int msecs) { return callbackQIODevice_WaitForBytesWritten(this, msecs) != 0; };
bool waitForReadyRead(int msecs) { return callbackQIODevice_WaitForReadyRead(this, msecs) != 0; };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QSaveFile*)
Q_DECLARE_METATYPE(MyQSaveFile*)
int QSaveFile_QSaveFile_QRegisterMetaType(){qRegisterMetaType<QSaveFile*>(); return qRegisterMetaType<MyQSaveFile*>();}
void* QSaveFile_NewQSaveFile(struct QtCore_PackedString name)
{
return new MyQSaveFile(QString::fromUtf8(name.data, name.len));
}
void* QSaveFile_NewQSaveFile2(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(static_cast<QWindow*>(parent));
} else {
return new MyQSaveFile(static_cast<QObject*>(parent));
}
}
void* QSaveFile_NewQSaveFile3(struct QtCore_PackedString name, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QWindow*>(parent));
} else {
return new MyQSaveFile(QString::fromUtf8(name.data, name.len), static_cast<QObject*>(parent));
}
}
void QSaveFile_CancelWriting(void* ptr)
{
static_cast<QSaveFile*>(ptr)->cancelWriting();
}
char QSaveFile_Commit(void* ptr)
{
return static_cast<QSaveFile*>(ptr)->commit();
}
char QSaveFile_DirectWriteFallback(void* ptr)
{
return static_cast<QSaveFile*>(ptr)->directWriteFallback();
}
void QSaveFile_SetDirectWriteFallback(void* ptr, char enabled)
{
static_cast<QSaveFile*>(ptr)->setDirectWriteFallback(enabled != 0);
}
void QSaveFile_SetFileName(void* ptr, struct QtCore_PackedString name)
{
static_cast<QSaveFile*>(ptr)->setFileName(QString::fromUtf8(name.data, name.len));
}
void QSaveFile_DestroyQSaveFile(void* ptr)
{
static_cast<QSaveFile*>(ptr)->~QSaveFile();
}
void QSaveFile_DestroyQSaveFileDefault(void* ptr)
{
Q_UNUSED(ptr);
}
Q_DECLARE_METATYPE(QSemaphore*)
void* QSemaphore_NewQSemaphore(int n)
{
return new QSemaphore(n);
}
void QSemaphore_Acquire(void* ptr, int n)
{
static_cast<QSemaphore*>(ptr)->acquire(n);
}
int QSemaphore_Available(void* ptr)
{
return static_cast<QSemaphore*>(ptr)->available();
}
void QSemaphore_Release(void* ptr, int n)
{
static_cast<QSemaphore*>(ptr)->release(n);
}
char QSemaphore_TryAcquire(void* ptr, int n)
{
return static_cast<QSemaphore*>(ptr)->tryAcquire(n);
}
char QSemaphore_TryAcquire2(void* ptr, int n, int timeout)
{
return static_cast<QSemaphore*>(ptr)->tryAcquire(n, timeout);
}
void QSemaphore_DestroyQSemaphore(void* ptr)
{
static_cast<QSemaphore*>(ptr)->~QSemaphore();
}
Q_DECLARE_METATYPE(QSemaphoreReleaser*)
void* QSemaphoreReleaser_NewQSemaphoreReleaser()
{
return new QSemaphoreReleaser();
}
void* QSemaphoreReleaser_NewQSemaphoreReleaser2(void* sem, int n)
{
return new QSemaphoreReleaser(*static_cast<QSemaphore*>(sem), n);
}
void* QSemaphoreReleaser_NewQSemaphoreReleaser3(void* sem, int n)
{
return new QSemaphoreReleaser(static_cast<QSemaphore*>(sem), n);
}
void* QSemaphoreReleaser_Cancel(void* ptr)
{
return static_cast<QSemaphoreReleaser*>(ptr)->cancel();
}
void* QSemaphoreReleaser_Semaphore(void* ptr)
{
return static_cast<QSemaphoreReleaser*>(ptr)->semaphore();
}
void QSemaphoreReleaser_Swap(void* ptr, void* other)
{
static_cast<QSemaphoreReleaser*>(ptr)->swap(*static_cast<QSemaphoreReleaser*>(other));
}
void QSemaphoreReleaser_DestroyQSemaphoreReleaser(void* ptr)
{
static_cast<QSemaphoreReleaser*>(ptr)->~QSemaphoreReleaser();
}
class MyQSequentialAnimationGroup: public QSequentialAnimationGroup
{
public:
MyQSequentialAnimationGroup(QObject *parent = Q_NULLPTR) : QSequentialAnimationGroup(parent) {QSequentialAnimationGroup_QSequentialAnimationGroup_QRegisterMetaType();};
void Signal_CurrentAnimationChanged(QAbstractAnimation * current) { callbackQSequentialAnimationGroup_CurrentAnimationChanged(this, current); };
int duration() const { return callbackQSequentialAnimationGroup_Duration(const_cast<void*>(static_cast<const void*>(this))); };
bool event(QEvent * event) { return callbackQObject_Event(this, event) != 0; };
void updateCurrentTime(int currentTime) { callbackQSequentialAnimationGroup_UpdateCurrentTime(this, currentTime); };
void updateDirection(QAbstractAnimation::Direction direction) { callbackQAbstractAnimation_UpdateDirection(this, direction); };
void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { callbackQAbstractAnimation_UpdateState(this, newState, oldState); };
~MyQSequentialAnimationGroup() { callbackQSequentialAnimationGroup_DestroyQSequentialAnimationGroup(this); };
void Signal_CurrentLoopChanged(int currentLoop) { callbackQAbstractAnimation_CurrentLoopChanged(this, currentLoop); };
void Signal_DirectionChanged(QAbstractAnimation::Direction newDirection) { callbackQAbstractAnimation_DirectionChanged(this, newDirection); };
void Signal_Finished() { callbackQAbstractAnimation_Finished(this); };
void pause() { callbackQAbstractAnimation_Pause(this); };
void resume() { callbackQAbstractAnimation_Resume(this); };
void setCurrentTime(int msecs) { callbackQAbstractAnimation_SetCurrentTime(this, msecs); };
void setPaused(bool paused) { callbackQAbstractAnimation_SetPaused(this, paused); };
void start(QAbstractAnimation::DeletionPolicy policy) { callbackQAbstractAnimation_Start(this, policy); };
void Signal_StateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { callbackQAbstractAnimation_StateChanged(this, newState, oldState); };
void stop() { callbackQAbstractAnimation_Stop(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QSequentialAnimationGroup*)
Q_DECLARE_METATYPE(MyQSequentialAnimationGroup*)
int QSequentialAnimationGroup_QSequentialAnimationGroup_QRegisterMetaType(){qRegisterMetaType<QSequentialAnimationGroup*>(); return qRegisterMetaType<MyQSequentialAnimationGroup*>();}
void* QSequentialAnimationGroup_NewQSequentialAnimationGroup(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQSequentialAnimationGroup(static_cast<QWindow*>(parent));
} else {
return new MyQSequentialAnimationGroup(static_cast<QObject*>(parent));
}
}
void* QSequentialAnimationGroup_AddPause(void* ptr, int msecs)
{
return static_cast<QSequentialAnimationGroup*>(ptr)->addPause(msecs);
}
void* QSequentialAnimationGroup_CurrentAnimation(void* ptr)
{
return static_cast<QSequentialAnimationGroup*>(ptr)->currentAnimation();
}
void QSequentialAnimationGroup_ConnectCurrentAnimationChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QSequentialAnimationGroup*>(ptr), static_cast<void (QSequentialAnimationGroup::*)(QAbstractAnimation *)>(&QSequentialAnimationGroup::currentAnimationChanged), static_cast<MyQSequentialAnimationGroup*>(ptr), static_cast<void (MyQSequentialAnimationGroup::*)(QAbstractAnimation *)>(&MyQSequentialAnimationGroup::Signal_CurrentAnimationChanged), static_cast<Qt::ConnectionType>(t));
}
void QSequentialAnimationGroup_DisconnectCurrentAnimationChanged(void* ptr)
{
QObject::disconnect(static_cast<QSequentialAnimationGroup*>(ptr), static_cast<void (QSequentialAnimationGroup::*)(QAbstractAnimation *)>(&QSequentialAnimationGroup::currentAnimationChanged), static_cast<MyQSequentialAnimationGroup*>(ptr), static_cast<void (MyQSequentialAnimationGroup::*)(QAbstractAnimation *)>(&MyQSequentialAnimationGroup::Signal_CurrentAnimationChanged));
}
void QSequentialAnimationGroup_CurrentAnimationChanged(void* ptr, void* current)
{
static_cast<QSequentialAnimationGroup*>(ptr)->currentAnimationChanged(static_cast<QAbstractAnimation*>(current));
}
int QSequentialAnimationGroup_Duration(void* ptr)
{
return static_cast<QSequentialAnimationGroup*>(ptr)->duration();
}
int QSequentialAnimationGroup_DurationDefault(void* ptr)
{
return static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::duration();
}
void* QSequentialAnimationGroup_InsertPause(void* ptr, int index, int msecs)
{
return static_cast<QSequentialAnimationGroup*>(ptr)->insertPause(index, msecs);
}
void QSequentialAnimationGroup_UpdateCurrentTime(void* ptr, int currentTime)
{
static_cast<QSequentialAnimationGroup*>(ptr)->updateCurrentTime(currentTime);
}
void QSequentialAnimationGroup_UpdateCurrentTimeDefault(void* ptr, int currentTime)
{
static_cast<QSequentialAnimationGroup*>(ptr)->QSequentialAnimationGroup::updateCurrentTime(currentTime);
}
void QSequentialAnimationGroup_DestroyQSequentialAnimationGroup(void* ptr)
{
static_cast<QSequentialAnimationGroup*>(ptr)->~QSequentialAnimationGroup();
}
void QSequentialAnimationGroup_DestroyQSequentialAnimationGroupDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QSequentialIterable_At(void* ptr, int idx)
{
return new QVariant(static_cast<QSequentialIterable*>(ptr)->at(idx));
}
char QSequentialIterable_CanReverseIterate(void* ptr)
{
return static_cast<QSequentialIterable*>(ptr)->canReverseIterate();
}
int QSequentialIterable_Size(void* ptr)
{
return static_cast<QSequentialIterable*>(ptr)->size();
}
class MyQSettings: public QSettings
{
public:
MyQSettings(const QString &organization, const QString &application = QString(), QObject *parent = Q_NULLPTR) : QSettings(organization, application, parent) {QSettings_QSettings_QRegisterMetaType();};
MyQSettings(QSettings::Scope scope, const QString &organization, const QString &application = QString(), QObject *parent = Q_NULLPTR) : QSettings(scope, organization, application, parent) {QSettings_QSettings_QRegisterMetaType();};
MyQSettings(QSettings::Format format, QSettings::Scope scope, const QString &organization, const QString &application = QString(), QObject *parent = Q_NULLPTR) : QSettings(format, scope, organization, application, parent) {QSettings_QSettings_QRegisterMetaType();};
MyQSettings(const QString &fileName, QSettings::Format format, QObject *parent = Q_NULLPTR) : QSettings(fileName, format, parent) {QSettings_QSettings_QRegisterMetaType();};
MyQSettings(QObject *parent = Q_NULLPTR) : QSettings(parent) {QSettings_QSettings_QRegisterMetaType();};
MyQSettings(QSettings::Scope scope, QObject *parent = Q_NULLPTR) : QSettings(scope, parent) {QSettings_QSettings_QRegisterMetaType();};
bool event(QEvent * event) { return callbackQObject_Event(this, event) != 0; };
~MyQSettings() { callbackQSettings_DestroyQSettings(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QSettings*)
Q_DECLARE_METATYPE(MyQSettings*)
int QSettings_QSettings_QRegisterMetaType(){qRegisterMetaType<QSettings*>(); return qRegisterMetaType<MyQSettings*>();}
void* QSettings_NewQSettings(struct QtCore_PackedString organization, struct QtCore_PackedString application, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QWindow*>(parent));
} else {
return new MyQSettings(QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QObject*>(parent));
}
}
void* QSettings_NewQSettings2(long long scope, struct QtCore_PackedString organization, struct QtCore_PackedString application, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QWindow*>(parent));
} else {
return new MyQSettings(static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QObject*>(parent));
}
}
void* QSettings_NewQSettings3(long long format, long long scope, struct QtCore_PackedString organization, struct QtCore_PackedString application, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QWindow*>(parent));
} else {
return new MyQSettings(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(organization.data, organization.len), QString::fromUtf8(application.data, application.len), static_cast<QObject*>(parent));
}
}
void* QSettings_NewQSettings4(struct QtCore_PackedString fileName, long long format, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QWindow*>(parent));
} else {
return new MyQSettings(QString::fromUtf8(fileName.data, fileName.len), static_cast<QSettings::Format>(format), static_cast<QObject*>(parent));
}
}
void* QSettings_NewQSettings5(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QWindow*>(parent));
} else {
return new MyQSettings(static_cast<QObject*>(parent));
}
}
void* QSettings_NewQSettings6(long long scope, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QWindow*>(parent));
} else {
return new MyQSettings(static_cast<QSettings::Scope>(scope), static_cast<QObject*>(parent));
}
}
struct QtCore_PackedString QSettings_AllKeys(void* ptr)
{
return ({ QByteArray* t39d6f3 = new QByteArray(static_cast<QSettings*>(ptr)->allKeys().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t39d6f3->prepend("WHITESPACE").constData()+10), t39d6f3->size()-10, t39d6f3 }; });
}
struct QtCore_PackedString QSettings_ApplicationName(void* ptr)
{
return ({ QByteArray* tbe59f0 = new QByteArray(static_cast<QSettings*>(ptr)->applicationName().toUtf8()); QtCore_PackedString { const_cast<char*>(tbe59f0->prepend("WHITESPACE").constData()+10), tbe59f0->size()-10, tbe59f0 }; });
}
void QSettings_BeginGroup(void* ptr, struct QtCore_PackedString prefix)
{
static_cast<QSettings*>(ptr)->beginGroup(QString::fromUtf8(prefix.data, prefix.len));
}
int QSettings_BeginReadArray(void* ptr, struct QtCore_PackedString prefix)
{
return static_cast<QSettings*>(ptr)->beginReadArray(QString::fromUtf8(prefix.data, prefix.len));
}
void QSettings_BeginWriteArray(void* ptr, struct QtCore_PackedString prefix, int size)
{
static_cast<QSettings*>(ptr)->beginWriteArray(QString::fromUtf8(prefix.data, prefix.len), size);
}
struct QtCore_PackedString QSettings_ChildGroups(void* ptr)
{
return ({ QByteArray* t85b658 = new QByteArray(static_cast<QSettings*>(ptr)->childGroups().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t85b658->prepend("WHITESPACE").constData()+10), t85b658->size()-10, t85b658 }; });
}
struct QtCore_PackedString QSettings_ChildKeys(void* ptr)
{
return ({ QByteArray* t28840d = new QByteArray(static_cast<QSettings*>(ptr)->childKeys().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t28840d->prepend("WHITESPACE").constData()+10), t28840d->size()-10, t28840d }; });
}
void QSettings_Clear(void* ptr)
{
static_cast<QSettings*>(ptr)->clear();
}
char QSettings_Contains(void* ptr, struct QtCore_PackedString key)
{
return static_cast<QSettings*>(ptr)->contains(QString::fromUtf8(key.data, key.len));
}
long long QSettings_QSettings_DefaultFormat()
{
return QSettings::defaultFormat();
}
void QSettings_EndArray(void* ptr)
{
static_cast<QSettings*>(ptr)->endArray();
}
void QSettings_EndGroup(void* ptr)
{
static_cast<QSettings*>(ptr)->endGroup();
}
char QSettings_FallbacksEnabled(void* ptr)
{
return static_cast<QSettings*>(ptr)->fallbacksEnabled();
}
struct QtCore_PackedString QSettings_FileName(void* ptr)
{
return ({ QByteArray* tb2013f = new QByteArray(static_cast<QSettings*>(ptr)->fileName().toUtf8()); QtCore_PackedString { const_cast<char*>(tb2013f->prepend("WHITESPACE").constData()+10), tb2013f->size()-10, tb2013f }; });
}
long long QSettings_Format(void* ptr)
{
return static_cast<QSettings*>(ptr)->format();
}
struct QtCore_PackedString QSettings_Group(void* ptr)
{
return ({ QByteArray* t8d2697 = new QByteArray(static_cast<QSettings*>(ptr)->group().toUtf8()); QtCore_PackedString { const_cast<char*>(t8d2697->prepend("WHITESPACE").constData()+10), t8d2697->size()-10, t8d2697 }; });
}
void* QSettings_IniCodec(void* ptr)
{
return static_cast<QSettings*>(ptr)->iniCodec();
}
char QSettings_IsAtomicSyncRequired(void* ptr)
{
return static_cast<QSettings*>(ptr)->isAtomicSyncRequired();
}
char QSettings_IsWritable(void* ptr)
{
return static_cast<QSettings*>(ptr)->isWritable();
}
struct QtCore_PackedString QSettings_OrganizationName(void* ptr)
{
return ({ QByteArray* t43251f = new QByteArray(static_cast<QSettings*>(ptr)->organizationName().toUtf8()); QtCore_PackedString { const_cast<char*>(t43251f->prepend("WHITESPACE").constData()+10), t43251f->size()-10, t43251f }; });
}
void QSettings_Remove(void* ptr, struct QtCore_PackedString key)
{
static_cast<QSettings*>(ptr)->remove(QString::fromUtf8(key.data, key.len));
}
long long QSettings_Scope(void* ptr)
{
return static_cast<QSettings*>(ptr)->scope();
}
void QSettings_SetArrayIndex(void* ptr, int i)
{
static_cast<QSettings*>(ptr)->setArrayIndex(i);
}
void QSettings_SetAtomicSyncRequired(void* ptr, char enable)
{
static_cast<QSettings*>(ptr)->setAtomicSyncRequired(enable != 0);
}
void QSettings_QSettings_SetDefaultFormat(long long format)
{
QSettings::setDefaultFormat(static_cast<QSettings::Format>(format));
}
void QSettings_SetFallbacksEnabled(void* ptr, char b)
{
static_cast<QSettings*>(ptr)->setFallbacksEnabled(b != 0);
}
void QSettings_SetIniCodec(void* ptr, void* codec)
{
static_cast<QSettings*>(ptr)->setIniCodec(static_cast<QTextCodec*>(codec));
}
void QSettings_SetIniCodec2(void* ptr, char* codecName)
{
static_cast<QSettings*>(ptr)->setIniCodec(const_cast<const char*>(codecName));
}
void QSettings_QSettings_SetPath(long long format, long long scope, struct QtCore_PackedString path)
{
QSettings::setPath(static_cast<QSettings::Format>(format), static_cast<QSettings::Scope>(scope), QString::fromUtf8(path.data, path.len));
}
void QSettings_SetValue(void* ptr, struct QtCore_PackedString key, void* value)
{
static_cast<QSettings*>(ptr)->setValue(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(value));
}
long long QSettings_Status(void* ptr)
{
return static_cast<QSettings*>(ptr)->status();
}
void QSettings_Sync(void* ptr)
{
static_cast<QSettings*>(ptr)->sync();
}
void* QSettings_Value(void* ptr, struct QtCore_PackedString key, void* defaultValue)
{
return new QVariant(static_cast<QSettings*>(ptr)->value(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(defaultValue)));
}
void QSettings_DestroyQSettings(void* ptr)
{
static_cast<QSettings*>(ptr)->~QSettings();
}
void QSettings_DestroyQSettingsDefault(void* ptr)
{
Q_UNUSED(ptr);
}
Q_DECLARE_METATYPE(QSharedData)
Q_DECLARE_METATYPE(QSharedData*)
void* QSharedData_NewQSharedData()
{
return new QSharedData();
}
void* QSharedData_NewQSharedData2(void* vqs)
{
return new QSharedData(*static_cast<QSharedData*>(vqs));
}
class MyQSharedMemory: public QSharedMemory
{
public:
MyQSharedMemory(const QString &key, QObject *parent = Q_NULLPTR) : QSharedMemory(key, parent) {QSharedMemory_QSharedMemory_QRegisterMetaType();};
MyQSharedMemory(QObject *parent = Q_NULLPTR) : QSharedMemory(parent) {QSharedMemory_QSharedMemory_QRegisterMetaType();};
~MyQSharedMemory() { callbackQSharedMemory_DestroyQSharedMemory(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QSharedMemory*)
Q_DECLARE_METATYPE(MyQSharedMemory*)
int QSharedMemory_QSharedMemory_QRegisterMetaType(){qRegisterMetaType<QSharedMemory*>(); return qRegisterMetaType<MyQSharedMemory*>();}
void* QSharedMemory_NewQSharedMemory(struct QtCore_PackedString key, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QWindow*>(parent));
} else {
return new MyQSharedMemory(QString::fromUtf8(key.data, key.len), static_cast<QObject*>(parent));
}
}
void* QSharedMemory_NewQSharedMemory2(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQSharedMemory(static_cast<QWindow*>(parent));
} else {
return new MyQSharedMemory(static_cast<QObject*>(parent));
}
}
char QSharedMemory_Attach(void* ptr, long long mode)
{
return static_cast<QSharedMemory*>(ptr)->attach(static_cast<QSharedMemory::AccessMode>(mode));
}
void* QSharedMemory_ConstData(void* ptr)
{
return const_cast<void*>(static_cast<QSharedMemory*>(ptr)->constData());
}
char QSharedMemory_Create(void* ptr, int size, long long mode)
{
return static_cast<QSharedMemory*>(ptr)->create(size, static_cast<QSharedMemory::AccessMode>(mode));
}
void* QSharedMemory_Data(void* ptr)
{
return static_cast<QSharedMemory*>(ptr)->data();
}
void* QSharedMemory_Data2(void* ptr)
{
return const_cast<void*>(static_cast<QSharedMemory*>(ptr)->data());
}
char QSharedMemory_Detach(void* ptr)
{
return static_cast<QSharedMemory*>(ptr)->detach();
}
long long QSharedMemory_Error(void* ptr)
{
return static_cast<QSharedMemory*>(ptr)->error();
}
struct QtCore_PackedString QSharedMemory_ErrorString(void* ptr)
{
return ({ QByteArray* t1fb547 = new QByteArray(static_cast<QSharedMemory*>(ptr)->errorString().toUtf8()); QtCore_PackedString { const_cast<char*>(t1fb547->prepend("WHITESPACE").constData()+10), t1fb547->size()-10, t1fb547 }; });
}
char QSharedMemory_IsAttached(void* ptr)
{
return static_cast<QSharedMemory*>(ptr)->isAttached();
}
struct QtCore_PackedString QSharedMemory_Key(void* ptr)
{
return ({ QByteArray* t0bb3c9 = new QByteArray(static_cast<QSharedMemory*>(ptr)->key().toUtf8()); QtCore_PackedString { const_cast<char*>(t0bb3c9->prepend("WHITESPACE").constData()+10), t0bb3c9->size()-10, t0bb3c9 }; });
}
char QSharedMemory_Lock(void* ptr)
{
return static_cast<QSharedMemory*>(ptr)->lock();
}
struct QtCore_PackedString QSharedMemory_NativeKey(void* ptr)
{
return ({ QByteArray* t971b81 = new QByteArray(static_cast<QSharedMemory*>(ptr)->nativeKey().toUtf8()); QtCore_PackedString { const_cast<char*>(t971b81->prepend("WHITESPACE").constData()+10), t971b81->size()-10, t971b81 }; });
}
void QSharedMemory_SetKey(void* ptr, struct QtCore_PackedString key)
{
static_cast<QSharedMemory*>(ptr)->setKey(QString::fromUtf8(key.data, key.len));
}
void QSharedMemory_SetNativeKey(void* ptr, struct QtCore_PackedString key)
{
static_cast<QSharedMemory*>(ptr)->setNativeKey(QString::fromUtf8(key.data, key.len));
}
int QSharedMemory_Size(void* ptr)
{
return static_cast<QSharedMemory*>(ptr)->size();
}
char QSharedMemory_Unlock(void* ptr)
{
return static_cast<QSharedMemory*>(ptr)->unlock();
}
void QSharedMemory_DestroyQSharedMemory(void* ptr)
{
static_cast<QSharedMemory*>(ptr)->~QSharedMemory();
}
void QSharedMemory_DestroyQSharedMemoryDefault(void* ptr)
{
Q_UNUSED(ptr);
}
Q_DECLARE_METATYPE(QSignalBlocker*)
void* QSignalBlocker_NewQSignalBlocker(void* object)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QAudioSystemPlugin*>(object));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QCameraImageCapture*>(object));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QDBusPendingCallWatcher*>(object));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QExtensionFactory*>(object));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QExtensionManager*>(object));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QGraphicsObject*>(object));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QGraphicsWidget*>(object));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QLayout*>(object));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QMediaPlaylist*>(object));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QMediaRecorder*>(object));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QMediaServiceProviderPlugin*>(object));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QOffscreenSurface*>(object));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QPaintDeviceWindow*>(object));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QPdfWriter*>(object));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QQuickItem*>(object));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QRadioData*>(object));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QRemoteObjectPendingCallWatcher*>(object));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QScriptExtensionPlugin*>(object));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QWidget*>(object));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(static_cast<QWindow*>(object));
} else {
return new QSignalBlocker(static_cast<QObject*>(object));
}
}
void* QSignalBlocker_NewQSignalBlocker2(void* object)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QAudioSystemPlugin*>(object));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QCameraImageCapture*>(object));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QDBusPendingCallWatcher*>(object));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QExtensionFactory*>(object));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QExtensionManager*>(object));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QGraphicsObject*>(object));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QGraphicsWidget*>(object));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QLayout*>(object));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QMediaPlaylist*>(object));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QMediaRecorder*>(object));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QMediaServiceProviderPlugin*>(object));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QOffscreenSurface*>(object));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QPaintDeviceWindow*>(object));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QPdfWriter*>(object));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QQuickItem*>(object));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QRadioData*>(object));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QRemoteObjectPendingCallWatcher*>(object));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QScriptExtensionPlugin*>(object));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QWidget*>(object));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(object))) {
return new QSignalBlocker(*static_cast<QWindow*>(object));
} else {
return new QSignalBlocker(*static_cast<QObject*>(object));
}
}
void QSignalBlocker_Reblock(void* ptr)
{
static_cast<QSignalBlocker*>(ptr)->reblock();
}
void QSignalBlocker_Unblock(void* ptr)
{
static_cast<QSignalBlocker*>(ptr)->unblock();
}
void QSignalBlocker_DestroyQSignalBlocker(void* ptr)
{
static_cast<QSignalBlocker*>(ptr)->~QSignalBlocker();
}
class MyQSignalTransition: public QSignalTransition
{
public:
MyQSignalTransition(QState *sourceState = Q_NULLPTR) : QSignalTransition(sourceState) {QSignalTransition_QSignalTransition_QRegisterMetaType();};
MyQSignalTransition(const QObject *sender, const char *sign, QState *sourceState = Q_NULLPTR) : QSignalTransition(sender, sign, sourceState) {QSignalTransition_QSignalTransition_QRegisterMetaType();};
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventTest(QEvent * event) { return callbackQSignalTransition_EventTest(this, event) != 0; };
void onTransition(QEvent * event) { callbackQSignalTransition_OnTransition(this, event); };
void Signal_SenderObjectChanged() { callbackQSignalTransition_SenderObjectChanged(this); };
void Signal_SignalChanged() { callbackQSignalTransition_SignalChanged(this); };
~MyQSignalTransition() { callbackQSignalTransition_DestroyQSignalTransition(this); };
void Signal_TargetStateChanged() { callbackQAbstractTransition_TargetStateChanged(this); };
void Signal_TargetStatesChanged() { callbackQAbstractTransition_TargetStatesChanged(this); };
void Signal_Triggered() { callbackQAbstractTransition_Triggered(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QSignalTransition*)
Q_DECLARE_METATYPE(MyQSignalTransition*)
int QSignalTransition_QSignalTransition_QRegisterMetaType(){qRegisterMetaType<QSignalTransition*>(); return qRegisterMetaType<MyQSignalTransition*>();}
void* QSignalTransition_NewQSignalTransition(void* sourceState)
{
return new MyQSignalTransition(static_cast<QState*>(sourceState));
}
void* QSignalTransition_NewQSignalTransition2(void* sender, char* sign, void* sourceState)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QAudioSystemPlugin*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QCameraImageCapture*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QDBusPendingCallWatcher*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QExtensionFactory*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QExtensionManager*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QGraphicsObject*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QGraphicsWidget*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QLayout*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QMediaPlaylist*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QMediaRecorder*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QMediaServiceProviderPlugin*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QOffscreenSurface*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QPaintDeviceWindow*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QPdfWriter*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QQuickItem*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QRadioData*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QRemoteObjectPendingCallWatcher*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QScriptExtensionPlugin*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QWidget*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(sender))) {
return new MyQSignalTransition(static_cast<QWindow*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
} else {
return new MyQSignalTransition(static_cast<QObject*>(sender), const_cast<const char*>(sign), static_cast<QState*>(sourceState));
}
}
char QSignalTransition_EventTest(void* ptr, void* event)
{
return static_cast<QSignalTransition*>(ptr)->eventTest(static_cast<QEvent*>(event));
}
char QSignalTransition_EventTestDefault(void* ptr, void* event)
{
return static_cast<QSignalTransition*>(ptr)->QSignalTransition::eventTest(static_cast<QEvent*>(event));
}
void QSignalTransition_OnTransition(void* ptr, void* event)
{
static_cast<QSignalTransition*>(ptr)->onTransition(static_cast<QEvent*>(event));
}
void QSignalTransition_OnTransitionDefault(void* ptr, void* event)
{
static_cast<QSignalTransition*>(ptr)->QSignalTransition::onTransition(static_cast<QEvent*>(event));
}
void* QSignalTransition_SenderObject(void* ptr)
{
return static_cast<QSignalTransition*>(ptr)->senderObject();
}
void QSignalTransition_ConnectSenderObjectChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QSignalTransition*>(ptr), &QSignalTransition::senderObjectChanged, static_cast<MyQSignalTransition*>(ptr), static_cast<void (MyQSignalTransition::*)()>(&MyQSignalTransition::Signal_SenderObjectChanged), static_cast<Qt::ConnectionType>(t));
}
void QSignalTransition_DisconnectSenderObjectChanged(void* ptr)
{
QObject::disconnect(static_cast<QSignalTransition*>(ptr), &QSignalTransition::senderObjectChanged, static_cast<MyQSignalTransition*>(ptr), static_cast<void (MyQSignalTransition::*)()>(&MyQSignalTransition::Signal_SenderObjectChanged));
}
void QSignalTransition_SetSenderObject(void* ptr, void* sender)
{
static_cast<QSignalTransition*>(ptr)->setSenderObject(static_cast<QObject*>(sender));
}
void QSignalTransition_SetSignal(void* ptr, void* sign)
{
static_cast<QSignalTransition*>(ptr)->setSignal(*static_cast<QByteArray*>(sign));
}
void* QSignalTransition_Signal(void* ptr)
{
return new QByteArray(static_cast<QSignalTransition*>(ptr)->signal());
}
void QSignalTransition_ConnectSignalChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QSignalTransition*>(ptr), &QSignalTransition::signalChanged, static_cast<MyQSignalTransition*>(ptr), static_cast<void (MyQSignalTransition::*)()>(&MyQSignalTransition::Signal_SignalChanged), static_cast<Qt::ConnectionType>(t));
}
void QSignalTransition_DisconnectSignalChanged(void* ptr)
{
QObject::disconnect(static_cast<QSignalTransition*>(ptr), &QSignalTransition::signalChanged, static_cast<MyQSignalTransition*>(ptr), static_cast<void (MyQSignalTransition::*)()>(&MyQSignalTransition::Signal_SignalChanged));
}
void QSignalTransition_DestroyQSignalTransition(void* ptr)
{
static_cast<QSignalTransition*>(ptr)->~QSignalTransition();
}
void QSignalTransition_DestroyQSignalTransitionDefault(void* ptr)
{
Q_UNUSED(ptr);
}
Q_DECLARE_METATYPE(QSize)
Q_DECLARE_METATYPE(QSize*)
void* QSize_NewQSize()
{
return new QSize();
}
void* QSize_NewQSize2(int width, int height)
{
return new QSize(width, height);
}
void* QSize_BoundedTo(void* ptr, void* otherSize)
{
return ({ QSize tmpValue = static_cast<QSize*>(ptr)->boundedTo(*static_cast<QSize*>(otherSize)); new QSize(tmpValue.width(), tmpValue.height()); });
}
void* QSize_ExpandedTo(void* ptr, void* otherSize)
{
return ({ QSize tmpValue = static_cast<QSize*>(ptr)->expandedTo(*static_cast<QSize*>(otherSize)); new QSize(tmpValue.width(), tmpValue.height()); });
}
int QSize_Height(void* ptr)
{
return static_cast<QSize*>(ptr)->height();
}
char QSize_IsEmpty(void* ptr)
{
return static_cast<QSize*>(ptr)->isEmpty();
}
char QSize_IsNull(void* ptr)
{
return static_cast<QSize*>(ptr)->isNull();
}
char QSize_IsValid(void* ptr)
{
return static_cast<QSize*>(ptr)->isValid();
}
int QSize_Rheight(void* ptr)
{
return static_cast<QSize*>(ptr)->rheight();
}
int QSize_Rwidth(void* ptr)
{
return static_cast<QSize*>(ptr)->rwidth();
}
void QSize_Scale(void* ptr, int width, int height, long long mode)
{
static_cast<QSize*>(ptr)->scale(width, height, static_cast<Qt::AspectRatioMode>(mode));
}
void QSize_Scale2(void* ptr, void* size, long long mode)
{
static_cast<QSize*>(ptr)->scale(*static_cast<QSize*>(size), static_cast<Qt::AspectRatioMode>(mode));
}
void* QSize_Scaled(void* ptr, int width, int height, long long mode)
{
return ({ QSize tmpValue = static_cast<QSize*>(ptr)->scaled(width, height, static_cast<Qt::AspectRatioMode>(mode)); new QSize(tmpValue.width(), tmpValue.height()); });
}
void* QSize_Scaled2(void* ptr, void* s, long long mode)
{
return ({ QSize tmpValue = static_cast<QSize*>(ptr)->scaled(*static_cast<QSize*>(s), static_cast<Qt::AspectRatioMode>(mode)); new QSize(tmpValue.width(), tmpValue.height()); });
}
void QSize_SetHeight(void* ptr, int height)
{
static_cast<QSize*>(ptr)->setHeight(height);
}
void QSize_SetWidth(void* ptr, int width)
{
static_cast<QSize*>(ptr)->setWidth(width);
}
void QSize_Transpose(void* ptr)
{
static_cast<QSize*>(ptr)->transpose();
}
void* QSize_Transposed(void* ptr)
{
return ({ QSize tmpValue = static_cast<QSize*>(ptr)->transposed(); new QSize(tmpValue.width(), tmpValue.height()); });
}
int QSize_Width(void* ptr)
{
return static_cast<QSize*>(ptr)->width();
}
Q_DECLARE_METATYPE(QSizeF)
Q_DECLARE_METATYPE(QSizeF*)
void* QSizeF_NewQSizeF()
{
return new QSizeF();
}
void* QSizeF_NewQSizeF2(void* size)
{
return new QSizeF(*static_cast<QSize*>(size));
}
void* QSizeF_NewQSizeF3(double width, double height)
{
return new QSizeF(width, height);
}
void* QSizeF_BoundedTo(void* ptr, void* otherSize)
{
return ({ QSizeF tmpValue = static_cast<QSizeF*>(ptr)->boundedTo(*static_cast<QSizeF*>(otherSize)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
void* QSizeF_ExpandedTo(void* ptr, void* otherSize)
{
return ({ QSizeF tmpValue = static_cast<QSizeF*>(ptr)->expandedTo(*static_cast<QSizeF*>(otherSize)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
double QSizeF_Height(void* ptr)
{
return static_cast<QSizeF*>(ptr)->height();
}
char QSizeF_IsEmpty(void* ptr)
{
return static_cast<QSizeF*>(ptr)->isEmpty();
}
char QSizeF_IsNull(void* ptr)
{
return static_cast<QSizeF*>(ptr)->isNull();
}
char QSizeF_IsValid(void* ptr)
{
return static_cast<QSizeF*>(ptr)->isValid();
}
double QSizeF_Rheight(void* ptr)
{
return static_cast<QSizeF*>(ptr)->rheight();
}
double QSizeF_Rwidth(void* ptr)
{
return static_cast<QSizeF*>(ptr)->rwidth();
}
void QSizeF_Scale(void* ptr, double width, double height, long long mode)
{
static_cast<QSizeF*>(ptr)->scale(width, height, static_cast<Qt::AspectRatioMode>(mode));
}
void QSizeF_Scale2(void* ptr, void* size, long long mode)
{
static_cast<QSizeF*>(ptr)->scale(*static_cast<QSizeF*>(size), static_cast<Qt::AspectRatioMode>(mode));
}
void* QSizeF_Scaled(void* ptr, double width, double height, long long mode)
{
return ({ QSizeF tmpValue = static_cast<QSizeF*>(ptr)->scaled(width, height, static_cast<Qt::AspectRatioMode>(mode)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
void* QSizeF_Scaled2(void* ptr, void* s, long long mode)
{
return ({ QSizeF tmpValue = static_cast<QSizeF*>(ptr)->scaled(*static_cast<QSizeF*>(s), static_cast<Qt::AspectRatioMode>(mode)); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
void QSizeF_SetHeight(void* ptr, double height)
{
static_cast<QSizeF*>(ptr)->setHeight(height);
}
void QSizeF_SetWidth(void* ptr, double width)
{
static_cast<QSizeF*>(ptr)->setWidth(width);
}
void* QSizeF_ToSize(void* ptr)
{
return ({ QSize tmpValue = static_cast<QSizeF*>(ptr)->toSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}
void QSizeF_Transpose(void* ptr)
{
static_cast<QSizeF*>(ptr)->transpose();
}
void* QSizeF_Transposed(void* ptr)
{
return ({ QSizeF tmpValue = static_cast<QSizeF*>(ptr)->transposed(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
double QSizeF_Width(void* ptr)
{
return static_cast<QSizeF*>(ptr)->width();
}
class MyQSocketNotifier: public QSocketNotifier
{
public:
void Signal_Activated(int socket) { callbackQSocketNotifier_Activated(this, socket); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
void setEnabled(bool enable) { callbackQSocketNotifier_SetEnabled(this, enable); };
~MyQSocketNotifier() { callbackQSocketNotifier_DestroyQSocketNotifier(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QSocketNotifier*)
Q_DECLARE_METATYPE(MyQSocketNotifier*)
int QSocketNotifier_QSocketNotifier_QRegisterMetaType(){qRegisterMetaType<QSocketNotifier*>(); return qRegisterMetaType<MyQSocketNotifier*>();}
void QSocketNotifier_ConnectActivated(void* ptr, long long t)
{
QObject::connect(static_cast<QSocketNotifier*>(ptr), &QSocketNotifier::activated, static_cast<MyQSocketNotifier*>(ptr), static_cast<void (MyQSocketNotifier::*)(int)>(&MyQSocketNotifier::Signal_Activated), static_cast<Qt::ConnectionType>(t));
}
void QSocketNotifier_DisconnectActivated(void* ptr)
{
QObject::disconnect(static_cast<QSocketNotifier*>(ptr), &QSocketNotifier::activated, static_cast<MyQSocketNotifier*>(ptr), static_cast<void (MyQSocketNotifier::*)(int)>(&MyQSocketNotifier::Signal_Activated));
}
char QSocketNotifier_IsEnabled(void* ptr)
{
return static_cast<QSocketNotifier*>(ptr)->isEnabled();
}
void QSocketNotifier_SetEnabled(void* ptr, char enable)
{
QMetaObject::invokeMethod(static_cast<QSocketNotifier*>(ptr), "setEnabled", Q_ARG(bool, enable != 0));
}
void QSocketNotifier_SetEnabledDefault(void* ptr, char enable)
{
static_cast<QSocketNotifier*>(ptr)->QSocketNotifier::setEnabled(enable != 0);
}
long long QSocketNotifier_Type(void* ptr)
{
return static_cast<QSocketNotifier*>(ptr)->type();
}
void QSocketNotifier_DestroyQSocketNotifier(void* ptr)
{
static_cast<QSocketNotifier*>(ptr)->~QSocketNotifier();
}
void QSocketNotifier_DestroyQSocketNotifierDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQSortFilterProxyModel: public QSortFilterProxyModel
{
public:
MyQSortFilterProxyModel(QObject *parent = Q_NULLPTR) : QSortFilterProxyModel(parent) {QSortFilterProxyModel_QSortFilterProxyModel_QRegisterMetaType();};
QModelIndex buddy(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Buddy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool canFetchMore(const QModelIndex & parent) const { return callbackQAbstractItemModel_CanFetchMore(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
int columnCount(const QModelIndex & parent) const { return callbackQSortFilterProxyModel_ColumnCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
QVariant data(const QModelIndex & index, int role) const { return *static_cast<QVariant*>(callbackQAbstractProxyModel_Data(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), role)); };
bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQAbstractItemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
void fetchMore(const QModelIndex & parent) { callbackQAbstractItemModel_FetchMore(this, const_cast<QModelIndex*>(&parent)); };
bool filterAcceptsColumn(int source_column, const QModelIndex & source_parent) const { return callbackQSortFilterProxyModel_FilterAcceptsColumn(const_cast<void*>(static_cast<const void*>(this)), source_column, const_cast<QModelIndex*>(&source_parent)) != 0; };
bool filterAcceptsRow(int source_row, const QModelIndex & source_parent) const { return callbackQSortFilterProxyModel_FilterAcceptsRow(const_cast<void*>(static_cast<const void*>(this)), source_row, const_cast<QModelIndex*>(&source_parent)) != 0; };
Qt::ItemFlags flags(const QModelIndex & index) const { return static_cast<Qt::ItemFlag>(callbackQAbstractItemModel_Flags(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool hasChildren(const QModelIndex & parent) const { return callbackQAbstractItemModel_HasChildren(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
QVariant headerData(int section, Qt::Orientation orientation, int role) const { return *static_cast<QVariant*>(callbackQAbstractItemModel_HeaderData(const_cast<void*>(static_cast<const void*>(this)), section, orientation, role)); };
QModelIndex index(int row, int column, const QModelIndex & parent) const { return *static_cast<QModelIndex*>(callbackQSortFilterProxyModel_Index(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&parent))); };
bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
void invalidate() { callbackQSortFilterProxyModel_Invalidate(this); };
bool lessThan(const QModelIndex & source_left, const QModelIndex & source_right) const { return callbackQSortFilterProxyModel_LessThan(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&source_left), const_cast<QModelIndex*>(&source_right)) != 0; };
QModelIndex mapFromSource(const QModelIndex & sourceIndex) const { return *static_cast<QModelIndex*>(callbackQSortFilterProxyModel_MapFromSource(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&sourceIndex))); };
QItemSelection mapSelectionFromSource(const QItemSelection & sourceSelection) const { return *static_cast<QItemSelection*>(callbackQAbstractProxyModel_MapSelectionFromSource(const_cast<void*>(static_cast<const void*>(this)), const_cast<QItemSelection*>(&sourceSelection))); };
QItemSelection mapSelectionToSource(const QItemSelection & proxySelection) const { return *static_cast<QItemSelection*>(callbackQAbstractProxyModel_MapSelectionToSource(const_cast<void*>(static_cast<const void*>(this)), const_cast<QItemSelection*>(&proxySelection))); };
QModelIndex mapToSource(const QModelIndex & proxyIndex) const { return *static_cast<QModelIndex*>(callbackQSortFilterProxyModel_MapToSource(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&proxyIndex))); };
QList<QModelIndex> match(const QModelIndex & start, int role, const QVariant & value, int hits, Qt::MatchFlags flags) const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemModel_Match(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&start), role, const_cast<QVariant*>(&value), hits, flags)); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
QMimeData * mimeData(const QModelIndexList & indexes) const { return static_cast<QMimeData*>(callbackQAbstractItemModel_MimeData(const_cast<void*>(static_cast<const void*>(this)), ({ QList<QModelIndex>* tmpValuee0adf2 = new QList<QModelIndex>(indexes); QtCore_PackedList { tmpValuee0adf2, tmpValuee0adf2->size() }; }))); };
QStringList mimeTypes() const { return ({ QtCore_PackedString tempVal = callbackQAbstractItemModel_MimeTypes(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
QModelIndex parent(const QModelIndex & child) const { return *static_cast<QModelIndex*>(callbackQSortFilterProxyModel_Parent(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&child))); };
bool removeColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool removeRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
int rowCount(const QModelIndex & parent) const { return callbackQSortFilterProxyModel_RowCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
bool setData(const QModelIndex & index, const QVariant & value, int role) { return callbackQAbstractItemModel_SetData(this, const_cast<QModelIndex*>(&index), const_cast<QVariant*>(&value), role) != 0; };
void setFilterFixedString(const QString & pattern) { QByteArray* t91cc2e = new QByteArray(pattern.toUtf8()); QtCore_PackedString patternPacked = { const_cast<char*>(t91cc2e->prepend("WHITESPACE").constData()+10), t91cc2e->size()-10, t91cc2e };callbackQSortFilterProxyModel_SetFilterFixedString(this, patternPacked); };
void setFilterRegExp(const QRegExp & regExp) { callbackQSortFilterProxyModel_SetFilterRegExp(this, const_cast<QRegExp*>(&regExp)); };
void setFilterRegExp(const QString & pattern) { QByteArray* t91cc2e = new QByteArray(pattern.toUtf8()); QtCore_PackedString patternPacked = { const_cast<char*>(t91cc2e->prepend("WHITESPACE").constData()+10), t91cc2e->size()-10, t91cc2e };callbackQSortFilterProxyModel_SetFilterRegExp2(this, patternPacked); };
void setFilterRegularExpression(const QString & pattern) { QByteArray* t91cc2e = new QByteArray(pattern.toUtf8()); QtCore_PackedString patternPacked = { const_cast<char*>(t91cc2e->prepend("WHITESPACE").constData()+10), t91cc2e->size()-10, t91cc2e };callbackQSortFilterProxyModel_SetFilterRegularExpression(this, patternPacked); };
void setFilterRegularExpression(const QRegularExpression & regularExpression) { callbackQSortFilterProxyModel_SetFilterRegularExpression2(this, const_cast<QRegularExpression*>(&regularExpression)); };
void setFilterWildcard(const QString & pattern) { QByteArray* t91cc2e = new QByteArray(pattern.toUtf8()); QtCore_PackedString patternPacked = { const_cast<char*>(t91cc2e->prepend("WHITESPACE").constData()+10), t91cc2e->size()-10, t91cc2e };callbackQSortFilterProxyModel_SetFilterWildcard(this, patternPacked); };
bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQAbstractItemModel_SetHeaderData(this, section, orientation, const_cast<QVariant*>(&value), role) != 0; };
void setSourceModel(QAbstractItemModel * sourceModel) { callbackQAbstractProxyModel_SetSourceModel(this, sourceModel); };
QModelIndex sibling(int row, int column, const QModelIndex & idx) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Sibling(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&idx))); };
void sort(int column, Qt::SortOrder order) { callbackQAbstractItemModel_Sort(this, column, order); };
QSize span(const QModelIndex & index) const { return *static_cast<QSize*>(callbackQAbstractItemModel_Span(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQAbstractItemModel_SupportedDropActions(const_cast<void*>(static_cast<const void*>(this)))); };
~MyQSortFilterProxyModel() { callbackQSortFilterProxyModel_DestroyQSortFilterProxyModel(this); };
bool canDropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) const { return callbackQAbstractItemModel_CanDropMimeData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
QMap<int, QVariant> itemData(const QModelIndex & proxyIndex) const { return ({ QMap<int, QVariant>* tmpP = static_cast<QMap<int, QVariant>*>(callbackQAbstractItemModel_ItemData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&proxyIndex))); QMap<int, QVariant> tmpV = *tmpP; tmpP->~QMap(); free(tmpP); tmpV; }); };
void resetInternalData() { callbackQAbstractItemModel_ResetInternalData(this); };
void revert() { callbackQAbstractProxyModel_Revert(this); };
bool setItemData(const QModelIndex & index, const QMap<int, QVariant> & roles) { return callbackQAbstractItemModel_SetItemData(this, const_cast<QModelIndex*>(&index), ({ QMap<int, QVariant>* tmpValue037c88 = new QMap<int, QVariant>(roles); QtCore_PackedList { tmpValue037c88, tmpValue037c88->size() }; })) != 0; };
void Signal_SourceModelChanged() { callbackQAbstractProxyModel_SourceModelChanged(this); };
bool submit() { return callbackQAbstractProxyModel_Submit(this) != 0; };
Qt::DropActions supportedDragActions() const { return static_cast<Qt::DropAction>(callbackQAbstractItemModel_SupportedDragActions(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ColumnsAboutToBeInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationColumn) { callbackQAbstractItemModel_ColumnsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationColumn); };
void Signal_ColumnsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int column) { callbackQAbstractItemModel_ColumnsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), column); };
void Signal_ColumnsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_DataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQAbstractItemModel_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtCore_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
void Signal_HeaderDataChanged(Qt::Orientation orientation, int first, int last) { callbackQAbstractItemModel_HeaderDataChanged(this, orientation, first, last); };
void Signal_LayoutAboutToBeChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQAbstractItemModel_LayoutAboutToBeChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtCore_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
void Signal_LayoutChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQAbstractItemModel_LayoutChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtCore_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
void Signal_ModelAboutToBeReset() { callbackQAbstractItemModel_ModelAboutToBeReset(this); };
void Signal_ModelReset() { callbackQAbstractItemModel_ModelReset(this); };
bool moveColumns(const QModelIndex & sourceParent, int sourceColumn, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQAbstractItemModel_MoveColumns(this, const_cast<QModelIndex*>(&sourceParent), sourceColumn, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
bool moveRows(const QModelIndex & sourceParent, int sourceRow, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQAbstractItemModel_MoveRows(this, const_cast<QModelIndex*>(&sourceParent), sourceRow, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
QHash<int, QByteArray> roleNames() const { return ({ QHash<int, QByteArray>* tmpP = static_cast<QHash<int, QByteArray>*>(callbackQAbstractItemModel_RoleNames(const_cast<void*>(static_cast<const void*>(this)))); QHash<int, QByteArray> tmpV = *tmpP; tmpP->~QHash(); free(tmpP); tmpV; }); };
void Signal_RowsAboutToBeInserted(const QModelIndex & parent, int start, int end) { callbackQAbstractItemModel_RowsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
void Signal_RowsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationRow) { callbackQAbstractItemModel_RowsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationRow); };
void Signal_RowsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int row) { callbackQAbstractItemModel_RowsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), row); };
void Signal_RowsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QSortFilterProxyModel*)
Q_DECLARE_METATYPE(MyQSortFilterProxyModel*)
int QSortFilterProxyModel_QSortFilterProxyModel_QRegisterMetaType(){qRegisterMetaType<QSortFilterProxyModel*>(); return qRegisterMetaType<MyQSortFilterProxyModel*>();}
void* QSortFilterProxyModel_NewQSortFilterProxyModel(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQSortFilterProxyModel(static_cast<QWindow*>(parent));
} else {
return new MyQSortFilterProxyModel(static_cast<QObject*>(parent));
}
}
int QSortFilterProxyModel_ColumnCount(void* ptr, void* parent)
{
return static_cast<QSortFilterProxyModel*>(ptr)->columnCount(*static_cast<QModelIndex*>(parent));
}
int QSortFilterProxyModel_ColumnCountDefault(void* ptr, void* parent)
{
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::columnCount(*static_cast<QModelIndex*>(parent));
}
char QSortFilterProxyModel_DynamicSortFilter(void* ptr)
{
return static_cast<QSortFilterProxyModel*>(ptr)->dynamicSortFilter();
}
char QSortFilterProxyModel_FilterAcceptsColumn(void* ptr, int source_column, void* source_parent)
{
return static_cast<QSortFilterProxyModel*>(ptr)->filterAcceptsColumn(source_column, *static_cast<QModelIndex*>(source_parent));
}
char QSortFilterProxyModel_FilterAcceptsColumnDefault(void* ptr, int source_column, void* source_parent)
{
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::filterAcceptsColumn(source_column, *static_cast<QModelIndex*>(source_parent));
}
char QSortFilterProxyModel_FilterAcceptsRow(void* ptr, int source_row, void* source_parent)
{
return static_cast<QSortFilterProxyModel*>(ptr)->filterAcceptsRow(source_row, *static_cast<QModelIndex*>(source_parent));
}
char QSortFilterProxyModel_FilterAcceptsRowDefault(void* ptr, int source_row, void* source_parent)
{
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::filterAcceptsRow(source_row, *static_cast<QModelIndex*>(source_parent));
}
long long QSortFilterProxyModel_FilterCaseSensitivity(void* ptr)
{
return static_cast<QSortFilterProxyModel*>(ptr)->filterCaseSensitivity();
}
int QSortFilterProxyModel_FilterKeyColumn(void* ptr)
{
return static_cast<QSortFilterProxyModel*>(ptr)->filterKeyColumn();
}
void* QSortFilterProxyModel_FilterRegExp(void* ptr)
{
return new QRegExp(static_cast<QSortFilterProxyModel*>(ptr)->filterRegExp());
}
void* QSortFilterProxyModel_FilterRegularExpression(void* ptr)
{
return new QRegularExpression(static_cast<QSortFilterProxyModel*>(ptr)->filterRegularExpression());
}
int QSortFilterProxyModel_FilterRole(void* ptr)
{
return static_cast<QSortFilterProxyModel*>(ptr)->filterRole();
}
void* QSortFilterProxyModel_Index(void* ptr, int row, int column, void* parent)
{
return new QModelIndex(static_cast<QSortFilterProxyModel*>(ptr)->index(row, column, *static_cast<QModelIndex*>(parent)));
}
void* QSortFilterProxyModel_IndexDefault(void* ptr, int row, int column, void* parent)
{
return new QModelIndex(static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::index(row, column, *static_cast<QModelIndex*>(parent)));
}
void QSortFilterProxyModel_Invalidate(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QSortFilterProxyModel*>(ptr), "invalidate");
}
void QSortFilterProxyModel_InvalidateDefault(void* ptr)
{
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::invalidate();
}
void QSortFilterProxyModel_InvalidateFilter(void* ptr)
{
static_cast<QSortFilterProxyModel*>(ptr)->invalidateFilter();
}
char QSortFilterProxyModel_IsRecursiveFilteringEnabled(void* ptr)
{
return static_cast<QSortFilterProxyModel*>(ptr)->isRecursiveFilteringEnabled();
}
char QSortFilterProxyModel_IsSortLocaleAware(void* ptr)
{
return static_cast<QSortFilterProxyModel*>(ptr)->isSortLocaleAware();
}
char QSortFilterProxyModel_LessThan(void* ptr, void* source_left, void* source_right)
{
return static_cast<QSortFilterProxyModel*>(ptr)->lessThan(*static_cast<QModelIndex*>(source_left), *static_cast<QModelIndex*>(source_right));
}
char QSortFilterProxyModel_LessThanDefault(void* ptr, void* source_left, void* source_right)
{
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::lessThan(*static_cast<QModelIndex*>(source_left), *static_cast<QModelIndex*>(source_right));
}
void* QSortFilterProxyModel_MapFromSource(void* ptr, void* sourceIndex)
{
return new QModelIndex(static_cast<QSortFilterProxyModel*>(ptr)->mapFromSource(*static_cast<QModelIndex*>(sourceIndex)));
}
void* QSortFilterProxyModel_MapFromSourceDefault(void* ptr, void* sourceIndex)
{
return new QModelIndex(static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::mapFromSource(*static_cast<QModelIndex*>(sourceIndex)));
}
void* QSortFilterProxyModel_MapToSource(void* ptr, void* proxyIndex)
{
return new QModelIndex(static_cast<QSortFilterProxyModel*>(ptr)->mapToSource(*static_cast<QModelIndex*>(proxyIndex)));
}
void* QSortFilterProxyModel_MapToSourceDefault(void* ptr, void* proxyIndex)
{
return new QModelIndex(static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::mapToSource(*static_cast<QModelIndex*>(proxyIndex)));
}
void* QSortFilterProxyModel_Parent(void* ptr, void* child)
{
return new QModelIndex(static_cast<QSortFilterProxyModel*>(ptr)->parent(*static_cast<QModelIndex*>(child)));
}
void* QSortFilterProxyModel_ParentDefault(void* ptr, void* child)
{
return new QModelIndex(static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::parent(*static_cast<QModelIndex*>(child)));
}
int QSortFilterProxyModel_RowCount(void* ptr, void* parent)
{
return static_cast<QSortFilterProxyModel*>(ptr)->rowCount(*static_cast<QModelIndex*>(parent));
}
int QSortFilterProxyModel_RowCountDefault(void* ptr, void* parent)
{
return static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::rowCount(*static_cast<QModelIndex*>(parent));
}
void QSortFilterProxyModel_SetDynamicSortFilter(void* ptr, char enable)
{
static_cast<QSortFilterProxyModel*>(ptr)->setDynamicSortFilter(enable != 0);
}
void QSortFilterProxyModel_SetFilterCaseSensitivity(void* ptr, long long cs)
{
static_cast<QSortFilterProxyModel*>(ptr)->setFilterCaseSensitivity(static_cast<Qt::CaseSensitivity>(cs));
}
void QSortFilterProxyModel_SetFilterFixedString(void* ptr, struct QtCore_PackedString pattern)
{
QMetaObject::invokeMethod(static_cast<QSortFilterProxyModel*>(ptr), "setFilterFixedString", Q_ARG(const QString, QString::fromUtf8(pattern.data, pattern.len)));
}
void QSortFilterProxyModel_SetFilterFixedStringDefault(void* ptr, struct QtCore_PackedString pattern)
{
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::setFilterFixedString(QString::fromUtf8(pattern.data, pattern.len));
}
void QSortFilterProxyModel_SetFilterKeyColumn(void* ptr, int column)
{
static_cast<QSortFilterProxyModel*>(ptr)->setFilterKeyColumn(column);
}
void QSortFilterProxyModel_SetFilterRegExp(void* ptr, void* regExp)
{
QMetaObject::invokeMethod(static_cast<QSortFilterProxyModel*>(ptr), "setFilterRegExp", Q_ARG(const QRegExp, *static_cast<QRegExp*>(regExp)));
}
void QSortFilterProxyModel_SetFilterRegExpDefault(void* ptr, void* regExp)
{
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::setFilterRegExp(*static_cast<QRegExp*>(regExp));
}
void QSortFilterProxyModel_SetFilterRegExp2(void* ptr, struct QtCore_PackedString pattern)
{
QMetaObject::invokeMethod(static_cast<QSortFilterProxyModel*>(ptr), "setFilterRegExp", Q_ARG(const QString, QString::fromUtf8(pattern.data, pattern.len)));
}
void QSortFilterProxyModel_SetFilterRegExp2Default(void* ptr, struct QtCore_PackedString pattern)
{
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::setFilterRegExp(QString::fromUtf8(pattern.data, pattern.len));
}
void QSortFilterProxyModel_SetFilterRegularExpression(void* ptr, struct QtCore_PackedString pattern)
{
QMetaObject::invokeMethod(static_cast<QSortFilterProxyModel*>(ptr), "setFilterRegularExpression", Q_ARG(const QString, QString::fromUtf8(pattern.data, pattern.len)));
}
void QSortFilterProxyModel_SetFilterRegularExpressionDefault(void* ptr, struct QtCore_PackedString pattern)
{
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::setFilterRegularExpression(QString::fromUtf8(pattern.data, pattern.len));
}
void QSortFilterProxyModel_SetFilterRegularExpression2(void* ptr, void* regularExpression)
{
QMetaObject::invokeMethod(static_cast<QSortFilterProxyModel*>(ptr), "setFilterRegularExpression", Q_ARG(const QRegularExpression, *static_cast<QRegularExpression*>(regularExpression)));
}
void QSortFilterProxyModel_SetFilterRegularExpression2Default(void* ptr, void* regularExpression)
{
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::setFilterRegularExpression(*static_cast<QRegularExpression*>(regularExpression));
}
void QSortFilterProxyModel_SetFilterRole(void* ptr, int role)
{
static_cast<QSortFilterProxyModel*>(ptr)->setFilterRole(role);
}
void QSortFilterProxyModel_SetFilterWildcard(void* ptr, struct QtCore_PackedString pattern)
{
QMetaObject::invokeMethod(static_cast<QSortFilterProxyModel*>(ptr), "setFilterWildcard", Q_ARG(const QString, QString::fromUtf8(pattern.data, pattern.len)));
}
void QSortFilterProxyModel_SetFilterWildcardDefault(void* ptr, struct QtCore_PackedString pattern)
{
static_cast<QSortFilterProxyModel*>(ptr)->QSortFilterProxyModel::setFilterWildcard(QString::fromUtf8(pattern.data, pattern.len));
}
void QSortFilterProxyModel_SetRecursiveFilteringEnabled(void* ptr, char recursive)
{
static_cast<QSortFilterProxyModel*>(ptr)->setRecursiveFilteringEnabled(recursive != 0);
}
void QSortFilterProxyModel_SetSortCaseSensitivity(void* ptr, long long cs)
{
static_cast<QSortFilterProxyModel*>(ptr)->setSortCaseSensitivity(static_cast<Qt::CaseSensitivity>(cs));
}
void QSortFilterProxyModel_SetSortLocaleAware(void* ptr, char on)
{
static_cast<QSortFilterProxyModel*>(ptr)->setSortLocaleAware(on != 0);
}
void QSortFilterProxyModel_SetSortRole(void* ptr, int role)
{
static_cast<QSortFilterProxyModel*>(ptr)->setSortRole(role);
}
long long QSortFilterProxyModel_SortCaseSensitivity(void* ptr)
{
return static_cast<QSortFilterProxyModel*>(ptr)->sortCaseSensitivity();
}
int QSortFilterProxyModel_SortColumn(void* ptr)
{
return static_cast<QSortFilterProxyModel*>(ptr)->sortColumn();
}
long long QSortFilterProxyModel_SortOrder(void* ptr)
{
return static_cast<QSortFilterProxyModel*>(ptr)->sortOrder();
}
int QSortFilterProxyModel_SortRole(void* ptr)
{
return static_cast<QSortFilterProxyModel*>(ptr)->sortRole();
}
void QSortFilterProxyModel_DestroyQSortFilterProxyModel(void* ptr)
{
static_cast<QSortFilterProxyModel*>(ptr)->~QSortFilterProxyModel();
}
void QSortFilterProxyModel_DestroyQSortFilterProxyModelDefault(void* ptr)
{
Q_UNUSED(ptr);
}
struct QtCore_PackedString QStandardPaths_QStandardPaths_DisplayName(long long ty)
{
return ({ QByteArray* t0e52e2 = new QByteArray(QStandardPaths::displayName(static_cast<QStandardPaths::StandardLocation>(ty)).toUtf8()); QtCore_PackedString { const_cast<char*>(t0e52e2->prepend("WHITESPACE").constData()+10), t0e52e2->size()-10, t0e52e2 }; });
}
struct QtCore_PackedString QStandardPaths_QStandardPaths_FindExecutable(struct QtCore_PackedString executableName, struct QtCore_PackedString paths)
{
return ({ QByteArray* t2ef25b = new QByteArray(QStandardPaths::findExecutable(QString::fromUtf8(executableName.data, executableName.len), QString::fromUtf8(paths.data, paths.len).split("¡¦!", QString::SkipEmptyParts)).toUtf8()); QtCore_PackedString { const_cast<char*>(t2ef25b->prepend("WHITESPACE").constData()+10), t2ef25b->size()-10, t2ef25b }; });
}
struct QtCore_PackedString QStandardPaths_QStandardPaths_Locate(long long ty, struct QtCore_PackedString fileName, long long options)
{
return ({ QByteArray* t1c6d77 = new QByteArray(QStandardPaths::locate(static_cast<QStandardPaths::StandardLocation>(ty), QString::fromUtf8(fileName.data, fileName.len), static_cast<QStandardPaths::LocateOption>(options)).toUtf8()); QtCore_PackedString { const_cast<char*>(t1c6d77->prepend("WHITESPACE").constData()+10), t1c6d77->size()-10, t1c6d77 }; });
}
struct QtCore_PackedString QStandardPaths_QStandardPaths_LocateAll(long long ty, struct QtCore_PackedString fileName, long long options)
{
return ({ QByteArray* t84546e = new QByteArray(QStandardPaths::locateAll(static_cast<QStandardPaths::StandardLocation>(ty), QString::fromUtf8(fileName.data, fileName.len), static_cast<QStandardPaths::LocateOption>(options)).join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t84546e->prepend("WHITESPACE").constData()+10), t84546e->size()-10, t84546e }; });
}
void QStandardPaths_QStandardPaths_SetTestModeEnabled(char testMode)
{
QStandardPaths::setTestModeEnabled(testMode != 0);
}
struct QtCore_PackedString QStandardPaths_QStandardPaths_StandardLocations(long long ty)
{
return ({ QByteArray* t70622a = new QByteArray(QStandardPaths::standardLocations(static_cast<QStandardPaths::StandardLocation>(ty)).join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t70622a->prepend("WHITESPACE").constData()+10), t70622a->size()-10, t70622a }; });
}
struct QtCore_PackedString QStandardPaths_QStandardPaths_WritableLocation(long long ty)
{
return ({ QByteArray* t06b5c0 = new QByteArray(QStandardPaths::writableLocation(static_cast<QStandardPaths::StandardLocation>(ty)).toUtf8()); QtCore_PackedString { const_cast<char*>(t06b5c0->prepend("WHITESPACE").constData()+10), t06b5c0->size()-10, t06b5c0 }; });
}
class MyQState: public QState
{
public:
MyQState(QState *parent = Q_NULLPTR) : QState(parent) {QState_QState_QRegisterMetaType();};
MyQState(QState::ChildMode childMode, QState *parent = Q_NULLPTR) : QState(childMode, parent) {QState_QState_QRegisterMetaType();};
void Signal_ChildModeChanged() { callbackQState_ChildModeChanged(this); };
void Signal_ErrorStateChanged() { callbackQState_ErrorStateChanged(this); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
void Signal_Finished() { callbackQState_Finished(this); };
void Signal_InitialStateChanged() { callbackQState_InitialStateChanged(this); };
void onEntry(QEvent * event) { callbackQState_OnEntry(this, event); };
void onExit(QEvent * event) { callbackQState_OnExit(this, event); };
void Signal_PropertiesAssigned() { callbackQState_PropertiesAssigned(this); };
~MyQState() { callbackQState_DestroyQState(this); };
void Signal_ActiveChanged(bool active) { callbackQAbstractState_ActiveChanged(this, active); };
void Signal_Entered() { callbackQAbstractState_Entered(this); };
void Signal_Exited() { callbackQAbstractState_Exited(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QState*)
Q_DECLARE_METATYPE(MyQState*)
int QState_QState_QRegisterMetaType(){qRegisterMetaType<QState*>(); return qRegisterMetaType<MyQState*>();}
void* QState_NewQState(void* parent)
{
return new MyQState(static_cast<QState*>(parent));
}
void* QState_NewQState2(long long childMode, void* parent)
{
return new MyQState(static_cast<QState::ChildMode>(childMode), static_cast<QState*>(parent));
}
void QState_AddTransition(void* ptr, void* transition)
{
static_cast<QState*>(ptr)->addTransition(static_cast<QAbstractTransition*>(transition));
}
void* QState_AddTransition2(void* ptr, void* sender, char* sign, void* target)
{
return static_cast<QState*>(ptr)->addTransition(static_cast<QObject*>(sender), const_cast<const char*>(sign), static_cast<QAbstractState*>(target));
}
void* QState_AddTransition4(void* ptr, void* target)
{
return static_cast<QState*>(ptr)->addTransition(static_cast<QAbstractState*>(target));
}
void QState_AssignProperty(void* ptr, void* object, char* name, void* value)
{
static_cast<QState*>(ptr)->assignProperty(static_cast<QObject*>(object), const_cast<const char*>(name), *static_cast<QVariant*>(value));
}
long long QState_ChildMode(void* ptr)
{
return static_cast<QState*>(ptr)->childMode();
}
void QState_ConnectChildModeChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QState*>(ptr), &QState::childModeChanged, static_cast<MyQState*>(ptr), static_cast<void (MyQState::*)()>(&MyQState::Signal_ChildModeChanged), static_cast<Qt::ConnectionType>(t));
}
void QState_DisconnectChildModeChanged(void* ptr)
{
QObject::disconnect(static_cast<QState*>(ptr), &QState::childModeChanged, static_cast<MyQState*>(ptr), static_cast<void (MyQState::*)()>(&MyQState::Signal_ChildModeChanged));
}
void* QState_ErrorState(void* ptr)
{
return static_cast<QState*>(ptr)->errorState();
}
void QState_ConnectErrorStateChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QState*>(ptr), &QState::errorStateChanged, static_cast<MyQState*>(ptr), static_cast<void (MyQState::*)()>(&MyQState::Signal_ErrorStateChanged), static_cast<Qt::ConnectionType>(t));
}
void QState_DisconnectErrorStateChanged(void* ptr)
{
QObject::disconnect(static_cast<QState*>(ptr), &QState::errorStateChanged, static_cast<MyQState*>(ptr), static_cast<void (MyQState::*)()>(&MyQState::Signal_ErrorStateChanged));
}
void QState_ConnectFinished(void* ptr, long long t)
{
QObject::connect(static_cast<QState*>(ptr), &QState::finished, static_cast<MyQState*>(ptr), static_cast<void (MyQState::*)()>(&MyQState::Signal_Finished), static_cast<Qt::ConnectionType>(t));
}
void QState_DisconnectFinished(void* ptr)
{
QObject::disconnect(static_cast<QState*>(ptr), &QState::finished, static_cast<MyQState*>(ptr), static_cast<void (MyQState::*)()>(&MyQState::Signal_Finished));
}
void* QState_InitialState(void* ptr)
{
return static_cast<QState*>(ptr)->initialState();
}
void QState_ConnectInitialStateChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QState*>(ptr), &QState::initialStateChanged, static_cast<MyQState*>(ptr), static_cast<void (MyQState::*)()>(&MyQState::Signal_InitialStateChanged), static_cast<Qt::ConnectionType>(t));
}
void QState_DisconnectInitialStateChanged(void* ptr)
{
QObject::disconnect(static_cast<QState*>(ptr), &QState::initialStateChanged, static_cast<MyQState*>(ptr), static_cast<void (MyQState::*)()>(&MyQState::Signal_InitialStateChanged));
}
void QState_OnEntry(void* ptr, void* event)
{
static_cast<QState*>(ptr)->onEntry(static_cast<QEvent*>(event));
}
void QState_OnEntryDefault(void* ptr, void* event)
{
if (dynamic_cast<QStateMachine*>(static_cast<QObject*>(ptr))) {
static_cast<QStateMachine*>(ptr)->QStateMachine::onEntry(static_cast<QEvent*>(event));
} else {
static_cast<QState*>(ptr)->QState::onEntry(static_cast<QEvent*>(event));
}
}
void QState_OnExit(void* ptr, void* event)
{
static_cast<QState*>(ptr)->onExit(static_cast<QEvent*>(event));
}
void QState_OnExitDefault(void* ptr, void* event)
{
if (dynamic_cast<QStateMachine*>(static_cast<QObject*>(ptr))) {
static_cast<QStateMachine*>(ptr)->QStateMachine::onExit(static_cast<QEvent*>(event));
} else {
static_cast<QState*>(ptr)->QState::onExit(static_cast<QEvent*>(event));
}
}
void QState_ConnectPropertiesAssigned(void* ptr, long long t)
{
QObject::connect(static_cast<QState*>(ptr), &QState::propertiesAssigned, static_cast<MyQState*>(ptr), static_cast<void (MyQState::*)()>(&MyQState::Signal_PropertiesAssigned), static_cast<Qt::ConnectionType>(t));
}
void QState_DisconnectPropertiesAssigned(void* ptr)
{
QObject::disconnect(static_cast<QState*>(ptr), &QState::propertiesAssigned, static_cast<MyQState*>(ptr), static_cast<void (MyQState::*)()>(&MyQState::Signal_PropertiesAssigned));
}
void QState_RemoveTransition(void* ptr, void* transition)
{
static_cast<QState*>(ptr)->removeTransition(static_cast<QAbstractTransition*>(transition));
}
void QState_SetChildMode(void* ptr, long long mode)
{
static_cast<QState*>(ptr)->setChildMode(static_cast<QState::ChildMode>(mode));
}
void QState_SetErrorState(void* ptr, void* state)
{
static_cast<QState*>(ptr)->setErrorState(static_cast<QAbstractState*>(state));
}
void QState_SetInitialState(void* ptr, void* state)
{
static_cast<QState*>(ptr)->setInitialState(static_cast<QAbstractState*>(state));
}
struct QtCore_PackedList QState_Transitions(void* ptr)
{
return ({ QList<QAbstractTransition *>* tmpValue720ea7 = new QList<QAbstractTransition *>(static_cast<QState*>(ptr)->transitions()); QtCore_PackedList { tmpValue720ea7, tmpValue720ea7->size() }; });
}
void QState_DestroyQState(void* ptr)
{
static_cast<QState*>(ptr)->~QState();
}
void QState_DestroyQStateDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QState___transitions_atList(void* ptr, int i)
{
return ({QAbstractTransition * tmp = static_cast<QList<QAbstractTransition *>*>(ptr)->at(i); if (i == static_cast<QList<QAbstractTransition *>*>(ptr)->size()-1) { static_cast<QList<QAbstractTransition *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QState___transitions_setList(void* ptr, void* i)
{
static_cast<QList<QAbstractTransition *>*>(ptr)->append(static_cast<QAbstractTransition*>(i));
}
void* QState___transitions_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QAbstractTransition *>();
}
class MyQStateMachine: public QStateMachine
{
public:
MyQStateMachine(QObject *parent = Q_NULLPTR) : QStateMachine(parent) {QStateMachine_QStateMachine_QRegisterMetaType();};
MyQStateMachine(QState::ChildMode childMode, QObject *parent = Q_NULLPTR) : QStateMachine(childMode, parent) {QStateMachine_QStateMachine_QRegisterMetaType();};
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
void onEntry(QEvent * event) { callbackQState_OnEntry(this, event); };
void onExit(QEvent * event) { callbackQState_OnExit(this, event); };
void Signal_RunningChanged(bool running) { callbackQStateMachine_RunningChanged(this, running); };
void setRunning(bool running) { callbackQStateMachine_SetRunning(this, running); };
void start() { callbackQStateMachine_Start(this); };
void Signal_Started() { callbackQStateMachine_Started(this); };
void stop() { callbackQStateMachine_Stop(this); };
void Signal_Stopped() { callbackQStateMachine_Stopped(this); };
~MyQStateMachine() { callbackQStateMachine_DestroyQStateMachine(this); };
void Signal_ChildModeChanged() { callbackQState_ChildModeChanged(this); };
void Signal_ErrorStateChanged() { callbackQState_ErrorStateChanged(this); };
void Signal_Finished() { callbackQState_Finished(this); };
void Signal_InitialStateChanged() { callbackQState_InitialStateChanged(this); };
void Signal_PropertiesAssigned() { callbackQState_PropertiesAssigned(this); };
void Signal_ActiveChanged(bool active) { callbackQAbstractState_ActiveChanged(this, active); };
void Signal_Entered() { callbackQAbstractState_Entered(this); };
void Signal_Exited() { callbackQAbstractState_Exited(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QStateMachine*)
Q_DECLARE_METATYPE(MyQStateMachine*)
int QStateMachine_QStateMachine_QRegisterMetaType(){qRegisterMetaType<QStateMachine*>(); return qRegisterMetaType<MyQStateMachine*>();}
void* QStateMachine_NewQStateMachine(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QWindow*>(parent));
} else {
return new MyQStateMachine(static_cast<QObject*>(parent));
}
}
void* QStateMachine_NewQStateMachine2(long long childMode, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QWindow*>(parent));
} else {
return new MyQStateMachine(static_cast<QState::ChildMode>(childMode), static_cast<QObject*>(parent));
}
}
void QStateMachine_AddDefaultAnimation(void* ptr, void* animation)
{
static_cast<QStateMachine*>(ptr)->addDefaultAnimation(static_cast<QAbstractAnimation*>(animation));
}
void QStateMachine_AddState(void* ptr, void* state)
{
static_cast<QStateMachine*>(ptr)->addState(static_cast<QAbstractState*>(state));
}
char QStateMachine_CancelDelayedEvent(void* ptr, int id)
{
return static_cast<QStateMachine*>(ptr)->cancelDelayedEvent(id);
}
void QStateMachine_ClearError(void* ptr)
{
static_cast<QStateMachine*>(ptr)->clearError();
}
struct QtCore_PackedList QStateMachine_DefaultAnimations(void* ptr)
{
return ({ QList<QAbstractAnimation *>* tmpValue99eefa = new QList<QAbstractAnimation *>(static_cast<QStateMachine*>(ptr)->defaultAnimations()); QtCore_PackedList { tmpValue99eefa, tmpValue99eefa->size() }; });
}
long long QStateMachine_Error(void* ptr)
{
return static_cast<QStateMachine*>(ptr)->error();
}
struct QtCore_PackedString QStateMachine_ErrorString(void* ptr)
{
return ({ QByteArray* tb4aee6 = new QByteArray(static_cast<QStateMachine*>(ptr)->errorString().toUtf8()); QtCore_PackedString { const_cast<char*>(tb4aee6->prepend("WHITESPACE").constData()+10), tb4aee6->size()-10, tb4aee6 }; });
}
long long QStateMachine_GlobalRestorePolicy(void* ptr)
{
return static_cast<QStateMachine*>(ptr)->globalRestorePolicy();
}
char QStateMachine_IsAnimated(void* ptr)
{
return static_cast<QStateMachine*>(ptr)->isAnimated();
}
char QStateMachine_IsRunning(void* ptr)
{
return static_cast<QStateMachine*>(ptr)->isRunning();
}
int QStateMachine_PostDelayedEvent(void* ptr, void* event, int delay)
{
return static_cast<QStateMachine*>(ptr)->postDelayedEvent(static_cast<QEvent*>(event), delay);
}
void QStateMachine_PostEvent(void* ptr, void* event, long long priority)
{
static_cast<QStateMachine*>(ptr)->postEvent(static_cast<QEvent*>(event), static_cast<QStateMachine::EventPriority>(priority));
}
void QStateMachine_RemoveDefaultAnimation(void* ptr, void* animation)
{
static_cast<QStateMachine*>(ptr)->removeDefaultAnimation(static_cast<QAbstractAnimation*>(animation));
}
void QStateMachine_RemoveState(void* ptr, void* state)
{
static_cast<QStateMachine*>(ptr)->removeState(static_cast<QAbstractState*>(state));
}
void QStateMachine_ConnectRunningChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QStateMachine*>(ptr), static_cast<void (QStateMachine::*)(bool)>(&QStateMachine::runningChanged), static_cast<MyQStateMachine*>(ptr), static_cast<void (MyQStateMachine::*)(bool)>(&MyQStateMachine::Signal_RunningChanged), static_cast<Qt::ConnectionType>(t));
}
void QStateMachine_DisconnectRunningChanged(void* ptr)
{
QObject::disconnect(static_cast<QStateMachine*>(ptr), static_cast<void (QStateMachine::*)(bool)>(&QStateMachine::runningChanged), static_cast<MyQStateMachine*>(ptr), static_cast<void (MyQStateMachine::*)(bool)>(&MyQStateMachine::Signal_RunningChanged));
}
void QStateMachine_RunningChanged(void* ptr, char running)
{
static_cast<QStateMachine*>(ptr)->runningChanged(running != 0);
}
void QStateMachine_SetAnimated(void* ptr, char enabled)
{
static_cast<QStateMachine*>(ptr)->setAnimated(enabled != 0);
}
void QStateMachine_SetGlobalRestorePolicy(void* ptr, long long restorePolicy)
{
static_cast<QStateMachine*>(ptr)->setGlobalRestorePolicy(static_cast<QState::RestorePolicy>(restorePolicy));
}
void QStateMachine_SetRunning(void* ptr, char running)
{
QMetaObject::invokeMethod(static_cast<QStateMachine*>(ptr), "setRunning", Q_ARG(bool, running != 0));
}
void QStateMachine_SetRunningDefault(void* ptr, char running)
{
static_cast<QStateMachine*>(ptr)->QStateMachine::setRunning(running != 0);
}
void QStateMachine_Start(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QStateMachine*>(ptr), "start");
}
void QStateMachine_StartDefault(void* ptr)
{
static_cast<QStateMachine*>(ptr)->QStateMachine::start();
}
void QStateMachine_ConnectStarted(void* ptr, long long t)
{
QObject::connect(static_cast<QStateMachine*>(ptr), &QStateMachine::started, static_cast<MyQStateMachine*>(ptr), static_cast<void (MyQStateMachine::*)()>(&MyQStateMachine::Signal_Started), static_cast<Qt::ConnectionType>(t));
}
void QStateMachine_DisconnectStarted(void* ptr)
{
QObject::disconnect(static_cast<QStateMachine*>(ptr), &QStateMachine::started, static_cast<MyQStateMachine*>(ptr), static_cast<void (MyQStateMachine::*)()>(&MyQStateMachine::Signal_Started));
}
void QStateMachine_Stop(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QStateMachine*>(ptr), "stop");
}
void QStateMachine_StopDefault(void* ptr)
{
static_cast<QStateMachine*>(ptr)->QStateMachine::stop();
}
void QStateMachine_ConnectStopped(void* ptr, long long t)
{
QObject::connect(static_cast<QStateMachine*>(ptr), &QStateMachine::stopped, static_cast<MyQStateMachine*>(ptr), static_cast<void (MyQStateMachine::*)()>(&MyQStateMachine::Signal_Stopped), static_cast<Qt::ConnectionType>(t));
}
void QStateMachine_DisconnectStopped(void* ptr)
{
QObject::disconnect(static_cast<QStateMachine*>(ptr), &QStateMachine::stopped, static_cast<MyQStateMachine*>(ptr), static_cast<void (MyQStateMachine::*)()>(&MyQStateMachine::Signal_Stopped));
}
void QStateMachine_DestroyQStateMachine(void* ptr)
{
static_cast<QStateMachine*>(ptr)->~QStateMachine();
}
void QStateMachine_DestroyQStateMachineDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QStateMachine___defaultAnimations_atList(void* ptr, int i)
{
return ({QAbstractAnimation * tmp = static_cast<QList<QAbstractAnimation *>*>(ptr)->at(i); if (i == static_cast<QList<QAbstractAnimation *>*>(ptr)->size()-1) { static_cast<QList<QAbstractAnimation *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QStateMachine___defaultAnimations_setList(void* ptr, void* i)
{
static_cast<QList<QAbstractAnimation *>*>(ptr)->append(static_cast<QAbstractAnimation*>(i));
}
void* QStateMachine___defaultAnimations_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QAbstractAnimation *>();
}
void* QStaticPlugin_Instance(void* ptr)
{
return static_cast<QStaticPlugin*>(ptr)->instance();
}
void* QStaticPlugin_MetaData(void* ptr)
{
return new QJsonObject(static_cast<QStaticPlugin*>(ptr)->metaData());
}
struct QtCore_PackedString QStaticPlugin_RawMetaData(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QStaticPlugin*>(ptr)->rawMetaData()), -1, NULL };
}
Q_DECLARE_METATYPE(QStorageInfo*)
void* QStorageInfo_NewQStorageInfo()
{
return new QStorageInfo();
}
void* QStorageInfo_NewQStorageInfo2(struct QtCore_PackedString path)
{
return new QStorageInfo(QString::fromUtf8(path.data, path.len));
}
void* QStorageInfo_NewQStorageInfo3(void* dir)
{
return new QStorageInfo(*static_cast<QDir*>(dir));
}
void* QStorageInfo_NewQStorageInfo4(void* other)
{
return new QStorageInfo(*static_cast<QStorageInfo*>(other));
}
int QStorageInfo_BlockSize(void* ptr)
{
return static_cast<QStorageInfo*>(ptr)->blockSize();
}
long long QStorageInfo_BytesAvailable(void* ptr)
{
return static_cast<QStorageInfo*>(ptr)->bytesAvailable();
}
long long QStorageInfo_BytesFree(void* ptr)
{
return static_cast<QStorageInfo*>(ptr)->bytesFree();
}
long long QStorageInfo_BytesTotal(void* ptr)
{
return static_cast<QStorageInfo*>(ptr)->bytesTotal();
}
void* QStorageInfo_Device(void* ptr)
{
return new QByteArray(static_cast<QStorageInfo*>(ptr)->device());
}
struct QtCore_PackedString QStorageInfo_DisplayName(void* ptr)
{
return ({ QByteArray* t7b3b54 = new QByteArray(static_cast<QStorageInfo*>(ptr)->displayName().toUtf8()); QtCore_PackedString { const_cast<char*>(t7b3b54->prepend("WHITESPACE").constData()+10), t7b3b54->size()-10, t7b3b54 }; });
}
void* QStorageInfo_FileSystemType(void* ptr)
{
return new QByteArray(static_cast<QStorageInfo*>(ptr)->fileSystemType());
}
char QStorageInfo_IsReadOnly(void* ptr)
{
return static_cast<QStorageInfo*>(ptr)->isReadOnly();
}
char QStorageInfo_IsReady(void* ptr)
{
return static_cast<QStorageInfo*>(ptr)->isReady();
}
char QStorageInfo_IsRoot(void* ptr)
{
return static_cast<QStorageInfo*>(ptr)->isRoot();
}
char QStorageInfo_IsValid(void* ptr)
{
return static_cast<QStorageInfo*>(ptr)->isValid();
}
struct QtCore_PackedList QStorageInfo_QStorageInfo_MountedVolumes()
{
return ({ QList<QStorageInfo>* tmpValuec2da3c = new QList<QStorageInfo>(QStorageInfo::mountedVolumes()); QtCore_PackedList { tmpValuec2da3c, tmpValuec2da3c->size() }; });
}
struct QtCore_PackedString QStorageInfo_Name(void* ptr)
{
return ({ QByteArray* t4fa869 = new QByteArray(static_cast<QStorageInfo*>(ptr)->name().toUtf8()); QtCore_PackedString { const_cast<char*>(t4fa869->prepend("WHITESPACE").constData()+10), t4fa869->size()-10, t4fa869 }; });
}
void QStorageInfo_Refresh(void* ptr)
{
static_cast<QStorageInfo*>(ptr)->refresh();
}
void* QStorageInfo_QStorageInfo_Root()
{
return new QStorageInfo(QStorageInfo::root());
}
struct QtCore_PackedString QStorageInfo_RootPath(void* ptr)
{
return ({ QByteArray* t0ec510 = new QByteArray(static_cast<QStorageInfo*>(ptr)->rootPath().toUtf8()); QtCore_PackedString { const_cast<char*>(t0ec510->prepend("WHITESPACE").constData()+10), t0ec510->size()-10, t0ec510 }; });
}
void QStorageInfo_SetPath(void* ptr, struct QtCore_PackedString path)
{
static_cast<QStorageInfo*>(ptr)->setPath(QString::fromUtf8(path.data, path.len));
}
void* QStorageInfo_Subvolume(void* ptr)
{
return new QByteArray(static_cast<QStorageInfo*>(ptr)->subvolume());
}
void QStorageInfo_Swap(void* ptr, void* other)
{
static_cast<QStorageInfo*>(ptr)->swap(*static_cast<QStorageInfo*>(other));
}
void QStorageInfo_DestroyQStorageInfo(void* ptr)
{
static_cast<QStorageInfo*>(ptr)->~QStorageInfo();
}
void* QStorageInfo___mountedVolumes_atList(void* ptr, int i)
{
return new QStorageInfo(({QStorageInfo tmp = static_cast<QList<QStorageInfo>*>(ptr)->at(i); if (i == static_cast<QList<QStorageInfo>*>(ptr)->size()-1) { static_cast<QList<QStorageInfo>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QStorageInfo___mountedVolumes_setList(void* ptr, void* i)
{
static_cast<QList<QStorageInfo>*>(ptr)->append(*static_cast<QStorageInfo*>(i));
}
void* QStorageInfo___mountedVolumes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QStorageInfo>();
}
class MyQStringListModel: public QStringListModel
{
public:
MyQStringListModel(QObject *parent = Q_NULLPTR) : QStringListModel(parent) {QStringListModel_QStringListModel_QRegisterMetaType();};
MyQStringListModel(const QStringList &strin, QObject *parent = Q_NULLPTR) : QStringListModel(strin, parent) {QStringListModel_QStringListModel_QRegisterMetaType();};
QVariant data(const QModelIndex & index, int role) const { return *static_cast<QVariant*>(callbackQStringListModel_Data(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index), role)); };
Qt::ItemFlags flags(const QModelIndex & index) const { return static_cast<Qt::ItemFlag>(callbackQAbstractItemModel_Flags(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
QMap<int, QVariant> itemData(const QModelIndex & index) const { return ({ QMap<int, QVariant>* tmpP = static_cast<QMap<int, QVariant>*>(callbackQAbstractItemModel_ItemData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); QMap<int, QVariant> tmpV = *tmpP; tmpP->~QMap(); free(tmpP); tmpV; }); };
bool moveRows(const QModelIndex & sourceParent, int sourceRow, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQAbstractItemModel_MoveRows(this, const_cast<QModelIndex*>(&sourceParent), sourceRow, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
bool removeRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
int rowCount(const QModelIndex & parent) const { return callbackQStringListModel_RowCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
bool setData(const QModelIndex & index, const QVariant & value, int role) { return callbackQAbstractItemModel_SetData(this, const_cast<QModelIndex*>(&index), const_cast<QVariant*>(&value), role) != 0; };
bool setItemData(const QModelIndex & index, const QMap<int, QVariant> & roles) { return callbackQAbstractItemModel_SetItemData(this, const_cast<QModelIndex*>(&index), ({ QMap<int, QVariant>* tmpValue037c88 = new QMap<int, QVariant>(roles); QtCore_PackedList { tmpValue037c88, tmpValue037c88->size() }; })) != 0; };
QModelIndex sibling(int row, int column, const QModelIndex & idx) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Sibling(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&idx))); };
void sort(int column, Qt::SortOrder order) { callbackQAbstractItemModel_Sort(this, column, order); };
Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQAbstractItemModel_SupportedDropActions(const_cast<void*>(static_cast<const void*>(this)))); };
bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQAbstractItemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
QModelIndex index(int row, int column, const QModelIndex & parent) const { return *static_cast<QModelIndex*>(callbackQAbstractListModel_Index(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&parent))); };
QModelIndex buddy(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Buddy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool canDropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) const { return callbackQAbstractItemModel_CanDropMimeData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
bool canFetchMore(const QModelIndex & parent) const { return callbackQAbstractItemModel_CanFetchMore(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
int columnCount(const QModelIndex & parent) const { return callbackQAbstractListModel_ColumnCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
void Signal_ColumnsAboutToBeInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationColumn) { callbackQAbstractItemModel_ColumnsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationColumn); };
void Signal_ColumnsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int column) { callbackQAbstractItemModel_ColumnsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), column); };
void Signal_ColumnsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_DataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQAbstractItemModel_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtCore_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
void fetchMore(const QModelIndex & parent) { callbackQAbstractItemModel_FetchMore(this, const_cast<QModelIndex*>(&parent)); };
bool hasChildren(const QModelIndex & parent) const { return callbackQAbstractItemModel_HasChildren(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
QVariant headerData(int section, Qt::Orientation orientation, int role) const { return *static_cast<QVariant*>(callbackQAbstractItemModel_HeaderData(const_cast<void*>(static_cast<const void*>(this)), section, orientation, role)); };
void Signal_HeaderDataChanged(Qt::Orientation orientation, int first, int last) { callbackQAbstractItemModel_HeaderDataChanged(this, orientation, first, last); };
bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
void Signal_LayoutAboutToBeChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQAbstractItemModel_LayoutAboutToBeChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtCore_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
void Signal_LayoutChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQAbstractItemModel_LayoutChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtCore_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
QList<QModelIndex> match(const QModelIndex & start, int role, const QVariant & value, int hits, Qt::MatchFlags flags) const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemModel_Match(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&start), role, const_cast<QVariant*>(&value), hits, flags)); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
QMimeData * mimeData(const QModelIndexList & indexes) const { return static_cast<QMimeData*>(callbackQAbstractItemModel_MimeData(const_cast<void*>(static_cast<const void*>(this)), ({ QList<QModelIndex>* tmpValuee0adf2 = new QList<QModelIndex>(indexes); QtCore_PackedList { tmpValuee0adf2, tmpValuee0adf2->size() }; }))); };
QStringList mimeTypes() const { return ({ QtCore_PackedString tempVal = callbackQAbstractItemModel_MimeTypes(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
void Signal_ModelAboutToBeReset() { callbackQAbstractItemModel_ModelAboutToBeReset(this); };
void Signal_ModelReset() { callbackQAbstractItemModel_ModelReset(this); };
bool moveColumns(const QModelIndex & sourceParent, int sourceColumn, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQAbstractItemModel_MoveColumns(this, const_cast<QModelIndex*>(&sourceParent), sourceColumn, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
QModelIndex parent(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQAbstractListModel_Parent(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool removeColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
void resetInternalData() { callbackQAbstractItemModel_ResetInternalData(this); };
void revert() { callbackQAbstractItemModel_Revert(this); };
QHash<int, QByteArray> roleNames() const { return ({ QHash<int, QByteArray>* tmpP = static_cast<QHash<int, QByteArray>*>(callbackQAbstractItemModel_RoleNames(const_cast<void*>(static_cast<const void*>(this)))); QHash<int, QByteArray> tmpV = *tmpP; tmpP->~QHash(); free(tmpP); tmpV; }); };
void Signal_RowsAboutToBeInserted(const QModelIndex & parent, int start, int end) { callbackQAbstractItemModel_RowsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
void Signal_RowsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationRow) { callbackQAbstractItemModel_RowsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationRow); };
void Signal_RowsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int row) { callbackQAbstractItemModel_RowsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), row); };
void Signal_RowsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQAbstractItemModel_SetHeaderData(this, section, orientation, const_cast<QVariant*>(&value), role) != 0; };
QSize span(const QModelIndex & index) const { return *static_cast<QSize*>(callbackQAbstractItemModel_Span(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool submit() { return callbackQAbstractItemModel_Submit(this) != 0; };
Qt::DropActions supportedDragActions() const { return static_cast<Qt::DropAction>(callbackQAbstractItemModel_SupportedDragActions(const_cast<void*>(static_cast<const void*>(this)))); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QStringListModel*)
Q_DECLARE_METATYPE(MyQStringListModel*)
int QStringListModel_QStringListModel_QRegisterMetaType(){qRegisterMetaType<QStringListModel*>(); return qRegisterMetaType<MyQStringListModel*>();}
void* QStringListModel_NewQStringListModel(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(static_cast<QWindow*>(parent));
} else {
return new MyQStringListModel(static_cast<QObject*>(parent));
}
}
void* QStringListModel_NewQStringListModel2(struct QtCore_PackedString strin, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QWindow*>(parent));
} else {
return new MyQStringListModel(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QObject*>(parent));
}
}
void* QStringListModel_Data(void* ptr, void* index, int role)
{
return new QVariant(static_cast<QStringListModel*>(ptr)->data(*static_cast<QModelIndex*>(index), role));
}
void* QStringListModel_DataDefault(void* ptr, void* index, int role)
{
return new QVariant(static_cast<QStringListModel*>(ptr)->QStringListModel::data(*static_cast<QModelIndex*>(index), role));
}
int QStringListModel_RowCount(void* ptr, void* parent)
{
return static_cast<QStringListModel*>(ptr)->rowCount(*static_cast<QModelIndex*>(parent));
}
int QStringListModel_RowCountDefault(void* ptr, void* parent)
{
return static_cast<QStringListModel*>(ptr)->QStringListModel::rowCount(*static_cast<QModelIndex*>(parent));
}
void QStringListModel_SetStringList(void* ptr, struct QtCore_PackedString strin)
{
static_cast<QStringListModel*>(ptr)->setStringList(QString::fromUtf8(strin.data, strin.len).split("¡¦!", QString::SkipEmptyParts));
}
struct QtCore_PackedString QStringListModel_StringList(void* ptr)
{
return ({ QByteArray* t02c9ed = new QByteArray(static_cast<QStringListModel*>(ptr)->stringList().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t02c9ed->prepend("WHITESPACE").constData()+10), t02c9ed->size()-10, t02c9ed }; });
}
Q_DECLARE_METATYPE(QStringMatcher)
Q_DECLARE_METATYPE(QStringMatcher*)
void* QStringMatcher_NewQStringMatcher()
{
return new QStringMatcher();
}
void* QStringMatcher_NewQStringMatcher2(struct QtCore_PackedString pattern, long long cs)
{
return new QStringMatcher(QString::fromUtf8(pattern.data, pattern.len), static_cast<Qt::CaseSensitivity>(cs));
}
void* QStringMatcher_NewQStringMatcher3(void* uc, int length, long long cs)
{
return new QStringMatcher(static_cast<QChar*>(uc), length, static_cast<Qt::CaseSensitivity>(cs));
}
void* QStringMatcher_NewQStringMatcher4(void* other)
{
return new QStringMatcher(*static_cast<QStringMatcher*>(other));
}
long long QStringMatcher_CaseSensitivity(void* ptr)
{
return static_cast<QStringMatcher*>(ptr)->caseSensitivity();
}
int QStringMatcher_IndexIn(void* ptr, struct QtCore_PackedString str, int from)
{
return static_cast<QStringMatcher*>(ptr)->indexIn(QString::fromUtf8(str.data, str.len), from);
}
int QStringMatcher_IndexIn2(void* ptr, void* str, int length, int from)
{
return static_cast<QStringMatcher*>(ptr)->indexIn(static_cast<QChar*>(str), length, from);
}
struct QtCore_PackedString QStringMatcher_Pattern(void* ptr)
{
return ({ QByteArray* ta9f593 = new QByteArray(static_cast<QStringMatcher*>(ptr)->pattern().toUtf8()); QtCore_PackedString { const_cast<char*>(ta9f593->prepend("WHITESPACE").constData()+10), ta9f593->size()-10, ta9f593 }; });
}
void QStringMatcher_SetCaseSensitivity(void* ptr, long long cs)
{
static_cast<QStringMatcher*>(ptr)->setCaseSensitivity(static_cast<Qt::CaseSensitivity>(cs));
}
void QStringMatcher_SetPattern(void* ptr, struct QtCore_PackedString pattern)
{
static_cast<QStringMatcher*>(ptr)->setPattern(QString::fromUtf8(pattern.data, pattern.len));
}
void QStringMatcher_DestroyQStringMatcher(void* ptr)
{
static_cast<QStringMatcher*>(ptr)->~QStringMatcher();
}
Q_DECLARE_METATYPE(QStringRef)
Q_DECLARE_METATYPE(QStringRef*)
void* QStringRef_NewQStringRef()
{
return new QStringRef();
}
void* QStringRef_NewQStringRef2(struct QtCore_PackedString stri, int position, int length)
{
return new QStringRef(new QString(QString::fromUtf8(stri.data, stri.len)), position, length);
}
void* QStringRef_NewQStringRef3(struct QtCore_PackedString stri)
{
return new QStringRef(new QString(QString::fromUtf8(stri.data, stri.len)));
}
void* QStringRef_NewQStringRef4(void* other)
{
return new QStringRef(*static_cast<QStringRef*>(other));
}
void* QStringRef_AppendTo(void* ptr, struct QtCore_PackedString stri)
{
return new QStringRef(static_cast<QStringRef*>(ptr)->appendTo(new QString(QString::fromUtf8(stri.data, stri.len))));
}
void* QStringRef_At(void* ptr, int position)
{
return new QChar(static_cast<QStringRef*>(ptr)->at(position));
}
void* QStringRef_Back(void* ptr)
{
return new QChar(static_cast<QStringRef*>(ptr)->back());
}
void QStringRef_Chop(void* ptr, int n)
{
static_cast<QStringRef*>(ptr)->chop(n);
}
void* QStringRef_Chopped(void* ptr, int l)
{
return new QStringRef(static_cast<QStringRef*>(ptr)->chopped(l));
}
void QStringRef_Clear(void* ptr)
{
static_cast<QStringRef*>(ptr)->clear();
}
int QStringRef_QStringRef_Compare(void* s1, struct QtCore_PackedString s2, long long cs)
{
return QStringRef::compare(*static_cast<QStringRef*>(s1), QString::fromUtf8(s2.data, s2.len), static_cast<Qt::CaseSensitivity>(cs));
}
int QStringRef_Compare2(void* ptr, struct QtCore_PackedString other, long long cs)
{
return static_cast<QStringRef*>(ptr)->compare(QString::fromUtf8(other.data, other.len), static_cast<Qt::CaseSensitivity>(cs));
}
int QStringRef_Compare3(void* ptr, void* other, long long cs)
{
return static_cast<QStringRef*>(ptr)->compare(*static_cast<QStringRef*>(other), static_cast<Qt::CaseSensitivity>(cs));
}
int QStringRef_Compare4(void* ptr, void* other, long long cs)
{
return static_cast<QStringRef*>(ptr)->compare(*static_cast<QLatin1String*>(other), static_cast<Qt::CaseSensitivity>(cs));
}
int QStringRef_Compare5(void* ptr, void* other, long long cs)
{
return static_cast<QStringRef*>(ptr)->compare(*static_cast<QByteArray*>(other), static_cast<Qt::CaseSensitivity>(cs));
}
int QStringRef_QStringRef_Compare6(void* s1, void* s2, long long cs)
{
return QStringRef::compare(*static_cast<QStringRef*>(s1), *static_cast<QStringRef*>(s2), static_cast<Qt::CaseSensitivity>(cs));
}
int QStringRef_QStringRef_Compare7(void* s1, void* s2, long long cs)
{
return QStringRef::compare(*static_cast<QStringRef*>(s1), *static_cast<QLatin1String*>(s2), static_cast<Qt::CaseSensitivity>(cs));
}
void* QStringRef_ConstData(void* ptr)
{
return const_cast<QChar*>(static_cast<QStringRef*>(ptr)->constData());
}
char QStringRef_Contains(void* ptr, struct QtCore_PackedString str, long long cs)
{
return static_cast<QStringRef*>(ptr)->contains(QString::fromUtf8(str.data, str.len), static_cast<Qt::CaseSensitivity>(cs));
}
char QStringRef_Contains2(void* ptr, void* ch, long long cs)
{
return static_cast<QStringRef*>(ptr)->contains(*static_cast<QChar*>(ch), static_cast<Qt::CaseSensitivity>(cs));
}
char QStringRef_Contains3(void* ptr, void* str, long long cs)
{
return static_cast<QStringRef*>(ptr)->contains(*static_cast<QLatin1String*>(str), static_cast<Qt::CaseSensitivity>(cs));
}
char QStringRef_Contains4(void* ptr, void* str, long long cs)
{
return static_cast<QStringRef*>(ptr)->contains(*static_cast<QStringRef*>(str), static_cast<Qt::CaseSensitivity>(cs));
}
int QStringRef_Count(void* ptr)
{
return static_cast<QStringRef*>(ptr)->count();
}
int QStringRef_Count2(void* ptr, struct QtCore_PackedString str, long long cs)
{
return static_cast<QStringRef*>(ptr)->count(QString::fromUtf8(str.data, str.len), static_cast<Qt::CaseSensitivity>(cs));
}
int QStringRef_Count3(void* ptr, void* ch, long long cs)
{
return static_cast<QStringRef*>(ptr)->count(*static_cast<QChar*>(ch), static_cast<Qt::CaseSensitivity>(cs));
}
int QStringRef_Count4(void* ptr, void* str, long long cs)
{
return static_cast<QStringRef*>(ptr)->count(*static_cast<QStringRef*>(str), static_cast<Qt::CaseSensitivity>(cs));
}
void* QStringRef_Data(void* ptr)
{
return const_cast<QChar*>(static_cast<QStringRef*>(ptr)->data());
}
char QStringRef_EndsWith(void* ptr, struct QtCore_PackedString str, long long cs)
{
return static_cast<QStringRef*>(ptr)->endsWith(QString::fromUtf8(str.data, str.len), static_cast<Qt::CaseSensitivity>(cs));
}
char QStringRef_EndsWith2(void* ptr, void* str, long long cs)
{
return static_cast<QStringRef*>(ptr)->endsWith(*static_cast<QStringView*>(str), static_cast<Qt::CaseSensitivity>(cs));
}
char QStringRef_EndsWith3(void* ptr, void* str, long long cs)
{
return static_cast<QStringRef*>(ptr)->endsWith(*static_cast<QLatin1String*>(str), static_cast<Qt::CaseSensitivity>(cs));
}
char QStringRef_EndsWith4(void* ptr, void* ch, long long cs)
{
return static_cast<QStringRef*>(ptr)->endsWith(*static_cast<QChar*>(ch), static_cast<Qt::CaseSensitivity>(cs));
}
char QStringRef_EndsWith5(void* ptr, void* str, long long cs)
{
return static_cast<QStringRef*>(ptr)->endsWith(*static_cast<QStringRef*>(str), static_cast<Qt::CaseSensitivity>(cs));
}
void* QStringRef_Front(void* ptr)
{
return new QChar(static_cast<QStringRef*>(ptr)->front());
}
int QStringRef_IndexOf(void* ptr, struct QtCore_PackedString str, int from, long long cs)
{
return static_cast<QStringRef*>(ptr)->indexOf(QString::fromUtf8(str.data, str.len), from, static_cast<Qt::CaseSensitivity>(cs));
}
int QStringRef_IndexOf2(void* ptr, void* ch, int from, long long cs)
{
return static_cast<QStringRef*>(ptr)->indexOf(*static_cast<QChar*>(ch), from, static_cast<Qt::CaseSensitivity>(cs));
}
int QStringRef_IndexOf3(void* ptr, void* str, int from, long long cs)
{
return static_cast<QStringRef*>(ptr)->indexOf(*static_cast<QLatin1String*>(str), from, static_cast<Qt::CaseSensitivity>(cs));
}
int QStringRef_IndexOf4(void* ptr, void* str, int from, long long cs)
{
return static_cast<QStringRef*>(ptr)->indexOf(*static_cast<QStringRef*>(str), from, static_cast<Qt::CaseSensitivity>(cs));
}
char QStringRef_IsEmpty(void* ptr)
{
return static_cast<QStringRef*>(ptr)->isEmpty();
}
char QStringRef_IsNull(void* ptr)
{
return static_cast<QStringRef*>(ptr)->isNull();
}
char QStringRef_IsRightToLeft(void* ptr)
{
return static_cast<QStringRef*>(ptr)->isRightToLeft();
}
int QStringRef_LastIndexOf(void* ptr, struct QtCore_PackedString str, int from, long long cs)
{
return static_cast<QStringRef*>(ptr)->lastIndexOf(QString::fromUtf8(str.data, str.len), from, static_cast<Qt::CaseSensitivity>(cs));
}
int QStringRef_LastIndexOf2(void* ptr, void* ch, int from, long long cs)
{
return static_cast<QStringRef*>(ptr)->lastIndexOf(*static_cast<QChar*>(ch), from, static_cast<Qt::CaseSensitivity>(cs));
}
int QStringRef_LastIndexOf3(void* ptr, void* str, int from, long long cs)
{
return static_cast<QStringRef*>(ptr)->lastIndexOf(*static_cast<QLatin1String*>(str), from, static_cast<Qt::CaseSensitivity>(cs));
}
int QStringRef_LastIndexOf4(void* ptr, void* str, int from, long long cs)
{
return static_cast<QStringRef*>(ptr)->lastIndexOf(*static_cast<QStringRef*>(str), from, static_cast<Qt::CaseSensitivity>(cs));
}
void* QStringRef_Left(void* ptr, int n)
{
return new QStringRef(static_cast<QStringRef*>(ptr)->left(n));
}
int QStringRef_Length(void* ptr)
{
return static_cast<QStringRef*>(ptr)->length();
}
int QStringRef_QStringRef_LocaleAwareCompare(void* s1, struct QtCore_PackedString s2)
{
return QStringRef::localeAwareCompare(*static_cast<QStringRef*>(s1), QString::fromUtf8(s2.data, s2.len));
}
int QStringRef_LocaleAwareCompare2(void* ptr, struct QtCore_PackedString other)
{
return static_cast<QStringRef*>(ptr)->localeAwareCompare(QString::fromUtf8(other.data, other.len));
}
int QStringRef_LocaleAwareCompare3(void* ptr, void* other)
{
return static_cast<QStringRef*>(ptr)->localeAwareCompare(*static_cast<QStringRef*>(other));
}
int QStringRef_QStringRef_LocaleAwareCompare4(void* s1, void* s2)
{
return QStringRef::localeAwareCompare(*static_cast<QStringRef*>(s1), *static_cast<QStringRef*>(s2));
}
void* QStringRef_Mid(void* ptr, int position, int n)
{
return new QStringRef(static_cast<QStringRef*>(ptr)->mid(position, n));
}
int QStringRef_Position(void* ptr)
{
return static_cast<QStringRef*>(ptr)->position();
}
void* QStringRef_Right(void* ptr, int n)
{
return new QStringRef(static_cast<QStringRef*>(ptr)->right(n));
}
int QStringRef_Size(void* ptr)
{
return static_cast<QStringRef*>(ptr)->size();
}
struct QtCore_PackedList QStringRef_Split(void* ptr, struct QtCore_PackedString sep, long long behavior, long long cs)
{
return ({ QVector<QStringRef>* tmpValued1bf8d = new QVector<QStringRef>(static_cast<QStringRef*>(ptr)->split(QString::fromUtf8(sep.data, sep.len), static_cast<QString::SplitBehavior>(behavior), static_cast<Qt::CaseSensitivity>(cs))); QtCore_PackedList { tmpValued1bf8d, tmpValued1bf8d->size() }; });
}
struct QtCore_PackedList QStringRef_Split2(void* ptr, void* sep, long long behavior, long long cs)
{
return ({ QVector<QStringRef>* tmpValue643751 = new QVector<QStringRef>(static_cast<QStringRef*>(ptr)->split(*static_cast<QChar*>(sep), static_cast<QString::SplitBehavior>(behavior), static_cast<Qt::CaseSensitivity>(cs))); QtCore_PackedList { tmpValue643751, tmpValue643751->size() }; });
}
char QStringRef_StartsWith(void* ptr, struct QtCore_PackedString str, long long cs)
{
return static_cast<QStringRef*>(ptr)->startsWith(QString::fromUtf8(str.data, str.len), static_cast<Qt::CaseSensitivity>(cs));
}
char QStringRef_StartsWith2(void* ptr, void* str, long long cs)
{
return static_cast<QStringRef*>(ptr)->startsWith(*static_cast<QStringView*>(str), static_cast<Qt::CaseSensitivity>(cs));
}
char QStringRef_StartsWith3(void* ptr, void* str, long long cs)
{
return static_cast<QStringRef*>(ptr)->startsWith(*static_cast<QLatin1String*>(str), static_cast<Qt::CaseSensitivity>(cs));
}
char QStringRef_StartsWith4(void* ptr, void* ch, long long cs)
{
return static_cast<QStringRef*>(ptr)->startsWith(*static_cast<QChar*>(ch), static_cast<Qt::CaseSensitivity>(cs));
}
char QStringRef_StartsWith5(void* ptr, void* str, long long cs)
{
return static_cast<QStringRef*>(ptr)->startsWith(*static_cast<QStringRef*>(str), static_cast<Qt::CaseSensitivity>(cs));
}
struct QtCore_PackedString QStringRef_String(void* ptr)
{
return ({ QByteArray* t75a779 = new QByteArray(static_cast<QStringRef*>(ptr)->string()->toUtf8()); QtCore_PackedString { const_cast<char*>(t75a779->prepend("WHITESPACE").constData()+10), t75a779->size()-10, t75a779 }; });
}
double QStringRef_ToDouble(void* ptr, char* ok)
{
return static_cast<QStringRef*>(ptr)->toDouble(reinterpret_cast<bool*>(ok));
}
float QStringRef_ToFloat(void* ptr, char* ok)
{
return static_cast<QStringRef*>(ptr)->toFloat(reinterpret_cast<bool*>(ok));
}
int QStringRef_ToInt(void* ptr, char* ok, int base)
{
return static_cast<QStringRef*>(ptr)->toInt(reinterpret_cast<bool*>(ok), base);
}
void* QStringRef_ToLatin1(void* ptr)
{
return new QByteArray(static_cast<QStringRef*>(ptr)->toLatin1());
}
void* QStringRef_ToLocal8Bit(void* ptr)
{
return new QByteArray(static_cast<QStringRef*>(ptr)->toLocal8Bit());
}
long QStringRef_ToLong(void* ptr, char* ok, int base)
{
return static_cast<QStringRef*>(ptr)->toLong(reinterpret_cast<bool*>(ok), base);
}
long long QStringRef_ToLongLong(void* ptr, char* ok, int base)
{
return static_cast<QStringRef*>(ptr)->toLongLong(reinterpret_cast<bool*>(ok), base);
}
short QStringRef_ToShort(void* ptr, char* ok, int base)
{
return static_cast<QStringRef*>(ptr)->toShort(reinterpret_cast<bool*>(ok), base);
}
struct QtCore_PackedString QStringRef_ToString(void* ptr)
{
return ({ QByteArray* t336448 = new QByteArray(static_cast<QStringRef*>(ptr)->toString().toUtf8()); QtCore_PackedString { const_cast<char*>(t336448->prepend("WHITESPACE").constData()+10), t336448->size()-10, t336448 }; });
}
unsigned int QStringRef_ToUInt(void* ptr, char* ok, int base)
{
return static_cast<QStringRef*>(ptr)->toUInt(reinterpret_cast<bool*>(ok), base);
}
unsigned long QStringRef_ToULong(void* ptr, char* ok, int base)
{
return static_cast<QStringRef*>(ptr)->toULong(reinterpret_cast<bool*>(ok), base);
}
unsigned long long QStringRef_ToULongLong(void* ptr, char* ok, int base)
{
return static_cast<QStringRef*>(ptr)->toULongLong(reinterpret_cast<bool*>(ok), base);
}
unsigned short QStringRef_ToUShort(void* ptr, char* ok, int base)
{
return static_cast<QStringRef*>(ptr)->toUShort(reinterpret_cast<bool*>(ok), base);
}
struct QtCore_PackedList QStringRef_ToUcs4(void* ptr)
{
return ({ QVector<uint>* tmpValue6487a2 = new QVector<uint>(static_cast<QStringRef*>(ptr)->toUcs4()); QtCore_PackedList { tmpValue6487a2, tmpValue6487a2->size() }; });
}
void* QStringRef_ToUtf8(void* ptr)
{
return new QByteArray(static_cast<QStringRef*>(ptr)->toUtf8());
}
void* QStringRef_Trimmed(void* ptr)
{
return new QStringRef(static_cast<QStringRef*>(ptr)->trimmed());
}
void QStringRef_Truncate(void* ptr, int position)
{
static_cast<QStringRef*>(ptr)->truncate(position);
}
void* QStringRef_Unicode(void* ptr)
{
return const_cast<QChar*>(static_cast<QStringRef*>(ptr)->unicode());
}
void QStringRef_DestroyQStringRef(void* ptr)
{
static_cast<QStringRef*>(ptr)->~QStringRef();
}
void* QStringRef___split_atList(void* ptr, int i)
{
return new QStringRef(({QStringRef tmp = static_cast<QVector<QStringRef>*>(ptr)->at(i); if (i == static_cast<QVector<QStringRef>*>(ptr)->size()-1) { static_cast<QVector<QStringRef>*>(ptr)->~QVector(); free(ptr); }; tmp; }));
}
void QStringRef___split_setList(void* ptr, void* i)
{
static_cast<QVector<QStringRef>*>(ptr)->append(*static_cast<QStringRef*>(i));
}
void* QStringRef___split_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QStringRef>();
}
void* QStringRef___split_atList2(void* ptr, int i)
{
return new QStringRef(({QStringRef tmp = static_cast<QVector<QStringRef>*>(ptr)->at(i); if (i == static_cast<QVector<QStringRef>*>(ptr)->size()-1) { static_cast<QVector<QStringRef>*>(ptr)->~QVector(); free(ptr); }; tmp; }));
}
void QStringRef___split_setList2(void* ptr, void* i)
{
static_cast<QVector<QStringRef>*>(ptr)->append(*static_cast<QStringRef*>(i));
}
void* QStringRef___split_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QStringRef>();
}
unsigned int QStringRef___toUcs4_atList(void* ptr, int i)
{
return ({uint tmp = static_cast<QVector<uint>*>(ptr)->at(i); if (i == static_cast<QVector<uint>*>(ptr)->size()-1) { static_cast<QVector<uint>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QStringRef___toUcs4_setList(void* ptr, unsigned int i)
{
static_cast<QVector<uint>*>(ptr)->append(i);
}
void* QStringRef___toUcs4_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<uint>();
}
Q_DECLARE_METATYPE(QStringView)
Q_DECLARE_METATYPE(QStringView*)
void* QStringView_NewQStringView()
{
return new QStringView();
}
void* QStringView_NewQStringView7(struct QtCore_PackedString str)
{
return new QStringView(QString::fromUtf8(str.data, str.len));
}
void* QStringView_NewQStringView8(void* str)
{
return new QStringView(*static_cast<QStringRef*>(str));
}
void* QStringView_Back(void* ptr)
{
return new QChar(static_cast<QStringView*>(ptr)->back());
}
int QStringView_Compare(void* ptr, void* other, long long cs)
{
return static_cast<QStringView*>(ptr)->compare(*static_cast<QStringView*>(other), static_cast<Qt::CaseSensitivity>(cs));
}
char QStringView_Empty(void* ptr)
{
return static_cast<QStringView*>(ptr)->empty();
}
char QStringView_EndsWith(void* ptr, void* str, long long cs)
{
return static_cast<QStringView*>(ptr)->endsWith(*static_cast<QStringView*>(str), static_cast<Qt::CaseSensitivity>(cs));
}
char QStringView_EndsWith2(void* ptr, void* l1, long long cs)
{
return static_cast<QStringView*>(ptr)->endsWith(*static_cast<QLatin1String*>(l1), static_cast<Qt::CaseSensitivity>(cs));
}
char QStringView_EndsWith3(void* ptr, void* ch)
{
return static_cast<QStringView*>(ptr)->endsWith(*static_cast<QChar*>(ch));
}
char QStringView_EndsWith4(void* ptr, void* ch, long long cs)
{
return static_cast<QStringView*>(ptr)->endsWith(*static_cast<QChar*>(ch), static_cast<Qt::CaseSensitivity>(cs));
}
void* QStringView_First(void* ptr)
{
return new QChar(static_cast<QStringView*>(ptr)->first());
}
void* QStringView_Front(void* ptr)
{
return new QChar(static_cast<QStringView*>(ptr)->front());
}
char QStringView_IsEmpty(void* ptr)
{
return static_cast<QStringView*>(ptr)->isEmpty();
}
char QStringView_IsNull(void* ptr)
{
return static_cast<QStringView*>(ptr)->isNull();
}
char QStringView_IsRightToLeft(void* ptr)
{
return static_cast<QStringView*>(ptr)->isRightToLeft();
}
void* QStringView_Last(void* ptr)
{
return new QChar(static_cast<QStringView*>(ptr)->last());
}
int QStringView_Length(void* ptr)
{
return static_cast<QStringView*>(ptr)->length();
}
char QStringView_StartsWith(void* ptr, void* str, long long cs)
{
return static_cast<QStringView*>(ptr)->startsWith(*static_cast<QStringView*>(str), static_cast<Qt::CaseSensitivity>(cs));
}
char QStringView_StartsWith2(void* ptr, void* l1, long long cs)
{
return static_cast<QStringView*>(ptr)->startsWith(*static_cast<QLatin1String*>(l1), static_cast<Qt::CaseSensitivity>(cs));
}
char QStringView_StartsWith3(void* ptr, void* ch)
{
return static_cast<QStringView*>(ptr)->startsWith(*static_cast<QChar*>(ch));
}
char QStringView_StartsWith4(void* ptr, void* ch, long long cs)
{
return static_cast<QStringView*>(ptr)->startsWith(*static_cast<QChar*>(ch), static_cast<Qt::CaseSensitivity>(cs));
}
void* QStringView_ToLatin1(void* ptr)
{
return new QByteArray(static_cast<QStringView*>(ptr)->toLatin1());
}
void* QStringView_ToLocal8Bit(void* ptr)
{
return new QByteArray(static_cast<QStringView*>(ptr)->toLocal8Bit());
}
struct QtCore_PackedString QStringView_ToString(void* ptr)
{
return ({ QByteArray* t401ff3 = new QByteArray(static_cast<QStringView*>(ptr)->toString().toUtf8()); QtCore_PackedString { const_cast<char*>(t401ff3->prepend("WHITESPACE").constData()+10), t401ff3->size()-10, t401ff3 }; });
}
struct QtCore_PackedList QStringView_ToUcs4(void* ptr)
{
return ({ QVector<uint>* tmpValue713c7b = new QVector<uint>(static_cast<QStringView*>(ptr)->toUcs4()); QtCore_PackedList { tmpValue713c7b, tmpValue713c7b->size() }; });
}
void* QStringView_ToUtf8(void* ptr)
{
return new QByteArray(static_cast<QStringView*>(ptr)->toUtf8());
}
void* QStringView_Trimmed(void* ptr)
{
return new QStringView(static_cast<QStringView*>(ptr)->trimmed());
}
unsigned int QStringView___convertToUcs4_atList(void* ptr, int i)
{
return ({uint tmp = static_cast<QVector<uint>*>(ptr)->at(i); if (i == static_cast<QVector<uint>*>(ptr)->size()-1) { static_cast<QVector<uint>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QStringView___convertToUcs4_setList(void* ptr, unsigned int i)
{
static_cast<QVector<uint>*>(ptr)->append(i);
}
void* QStringView___convertToUcs4_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<uint>();
}
unsigned int QStringView___toUcs4_atList(void* ptr, int i)
{
return ({uint tmp = static_cast<QVector<uint>*>(ptr)->at(i); if (i == static_cast<QVector<uint>*>(ptr)->size()-1) { static_cast<QVector<uint>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QStringView___toUcs4_setList(void* ptr, unsigned int i)
{
static_cast<QVector<uint>*>(ptr)->append(i);
}
void* QStringView___toUcs4_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<uint>();
}
int QSysInfo_WordSize_Type()
{
return QSysInfo::WordSize;
}
void* QSysInfo_QSysInfo_BootUniqueId()
{
return new QByteArray(QSysInfo::bootUniqueId());
}
struct QtCore_PackedString QSysInfo_QSysInfo_BuildAbi()
{
return ({ QByteArray* t231d28 = new QByteArray(QSysInfo::buildAbi().toUtf8()); QtCore_PackedString { const_cast<char*>(t231d28->prepend("WHITESPACE").constData()+10), t231d28->size()-10, t231d28 }; });
}
struct QtCore_PackedString QSysInfo_QSysInfo_BuildCpuArchitecture()
{
return ({ QByteArray* t3eb43d = new QByteArray(QSysInfo::buildCpuArchitecture().toUtf8()); QtCore_PackedString { const_cast<char*>(t3eb43d->prepend("WHITESPACE").constData()+10), t3eb43d->size()-10, t3eb43d }; });
}
struct QtCore_PackedString QSysInfo_QSysInfo_CurrentCpuArchitecture()
{
return ({ QByteArray* t58cec8 = new QByteArray(QSysInfo::currentCpuArchitecture().toUtf8()); QtCore_PackedString { const_cast<char*>(t58cec8->prepend("WHITESPACE").constData()+10), t58cec8->size()-10, t58cec8 }; });
}
struct QtCore_PackedString QSysInfo_QSysInfo_KernelType()
{
return ({ QByteArray* t17bcdb = new QByteArray(QSysInfo::kernelType().toUtf8()); QtCore_PackedString { const_cast<char*>(t17bcdb->prepend("WHITESPACE").constData()+10), t17bcdb->size()-10, t17bcdb }; });
}
struct QtCore_PackedString QSysInfo_QSysInfo_KernelVersion()
{
return ({ QByteArray* t25443e = new QByteArray(QSysInfo::kernelVersion().toUtf8()); QtCore_PackedString { const_cast<char*>(t25443e->prepend("WHITESPACE").constData()+10), t25443e->size()-10, t25443e }; });
}
struct QtCore_PackedString QSysInfo_QSysInfo_MachineHostName()
{
return ({ QByteArray* t05046f = new QByteArray(QSysInfo::machineHostName().toUtf8()); QtCore_PackedString { const_cast<char*>(t05046f->prepend("WHITESPACE").constData()+10), t05046f->size()-10, t05046f }; });
}
void* QSysInfo_QSysInfo_MachineUniqueId()
{
return new QByteArray(QSysInfo::machineUniqueId());
}
struct QtCore_PackedString QSysInfo_QSysInfo_PrettyProductName()
{
return ({ QByteArray* t377223 = new QByteArray(QSysInfo::prettyProductName().toUtf8()); QtCore_PackedString { const_cast<char*>(t377223->prepend("WHITESPACE").constData()+10), t377223->size()-10, t377223 }; });
}
struct QtCore_PackedString QSysInfo_QSysInfo_ProductType()
{
return ({ QByteArray* t2dc849 = new QByteArray(QSysInfo::productType().toUtf8()); QtCore_PackedString { const_cast<char*>(t2dc849->prepend("WHITESPACE").constData()+10), t2dc849->size()-10, t2dc849 }; });
}
struct QtCore_PackedString QSysInfo_QSysInfo_ProductVersion()
{
return ({ QByteArray* tf9eb38 = new QByteArray(QSysInfo::productVersion().toUtf8()); QtCore_PackedString { const_cast<char*>(tf9eb38->prepend("WHITESPACE").constData()+10), tf9eb38->size()-10, tf9eb38 }; });
}
Q_DECLARE_METATYPE(QSystemSemaphore*)
void* QSystemSemaphore_NewQSystemSemaphore(struct QtCore_PackedString key, int initialValue, long long mode)
{
return new QSystemSemaphore(QString::fromUtf8(key.data, key.len), initialValue, static_cast<QSystemSemaphore::AccessMode>(mode));
}
char QSystemSemaphore_Acquire(void* ptr)
{
return static_cast<QSystemSemaphore*>(ptr)->acquire();
}
long long QSystemSemaphore_Error(void* ptr)
{
return static_cast<QSystemSemaphore*>(ptr)->error();
}
struct QtCore_PackedString QSystemSemaphore_ErrorString(void* ptr)
{
return ({ QByteArray* te02386 = new QByteArray(static_cast<QSystemSemaphore*>(ptr)->errorString().toUtf8()); QtCore_PackedString { const_cast<char*>(te02386->prepend("WHITESPACE").constData()+10), te02386->size()-10, te02386 }; });
}
struct QtCore_PackedString QSystemSemaphore_Key(void* ptr)
{
return ({ QByteArray* tdbcddf = new QByteArray(static_cast<QSystemSemaphore*>(ptr)->key().toUtf8()); QtCore_PackedString { const_cast<char*>(tdbcddf->prepend("WHITESPACE").constData()+10), tdbcddf->size()-10, tdbcddf }; });
}
char QSystemSemaphore_Release(void* ptr, int n)
{
return static_cast<QSystemSemaphore*>(ptr)->release(n);
}
void QSystemSemaphore_SetKey(void* ptr, struct QtCore_PackedString key, int initialValue, long long mode)
{
static_cast<QSystemSemaphore*>(ptr)->setKey(QString::fromUtf8(key.data, key.len), initialValue, static_cast<QSystemSemaphore::AccessMode>(mode));
}
void QSystemSemaphore_DestroyQSystemSemaphore(void* ptr)
{
static_cast<QSystemSemaphore*>(ptr)->~QSystemSemaphore();
}
Q_DECLARE_METATYPE(QTemporaryDir*)
void* QTemporaryDir_NewQTemporaryDir()
{
return new QTemporaryDir();
}
void* QTemporaryDir_NewQTemporaryDir2(struct QtCore_PackedString templatePath)
{
return new QTemporaryDir(QString::fromUtf8(templatePath.data, templatePath.len));
}
char QTemporaryDir_AutoRemove(void* ptr)
{
return static_cast<QTemporaryDir*>(ptr)->autoRemove();
}
struct QtCore_PackedString QTemporaryDir_ErrorString(void* ptr)
{
return ({ QByteArray* t501345 = new QByteArray(static_cast<QTemporaryDir*>(ptr)->errorString().toUtf8()); QtCore_PackedString { const_cast<char*>(t501345->prepend("WHITESPACE").constData()+10), t501345->size()-10, t501345 }; });
}
struct QtCore_PackedString QTemporaryDir_FilePath(void* ptr, struct QtCore_PackedString fileName)
{
return ({ QByteArray* ted61dd = new QByteArray(static_cast<QTemporaryDir*>(ptr)->filePath(QString::fromUtf8(fileName.data, fileName.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(ted61dd->prepend("WHITESPACE").constData()+10), ted61dd->size()-10, ted61dd }; });
}
char QTemporaryDir_IsValid(void* ptr)
{
return static_cast<QTemporaryDir*>(ptr)->isValid();
}
struct QtCore_PackedString QTemporaryDir_Path(void* ptr)
{
return ({ QByteArray* tec09d2 = new QByteArray(static_cast<QTemporaryDir*>(ptr)->path().toUtf8()); QtCore_PackedString { const_cast<char*>(tec09d2->prepend("WHITESPACE").constData()+10), tec09d2->size()-10, tec09d2 }; });
}
char QTemporaryDir_Remove(void* ptr)
{
return static_cast<QTemporaryDir*>(ptr)->remove();
}
void QTemporaryDir_SetAutoRemove(void* ptr, char b)
{
static_cast<QTemporaryDir*>(ptr)->setAutoRemove(b != 0);
}
void QTemporaryDir_DestroyQTemporaryDir(void* ptr)
{
static_cast<QTemporaryDir*>(ptr)->~QTemporaryDir();
}
class MyQTemporaryFile: public QTemporaryFile
{
public:
MyQTemporaryFile() : QTemporaryFile() {QTemporaryFile_QTemporaryFile_QRegisterMetaType();};
MyQTemporaryFile(const QString &templateName) : QTemporaryFile(templateName) {QTemporaryFile_QTemporaryFile_QRegisterMetaType();};
MyQTemporaryFile(QObject *parent) : QTemporaryFile(parent) {QTemporaryFile_QTemporaryFile_QRegisterMetaType();};
MyQTemporaryFile(const QString &templateName, QObject *parent) : QTemporaryFile(templateName, parent) {QTemporaryFile_QTemporaryFile_QRegisterMetaType();};
QString fileName() const { return ({ QtCore_PackedString tempVal = callbackQFileDevice_FileName(const_cast<void*>(static_cast<const void*>(this))); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
~MyQTemporaryFile() { callbackQTemporaryFile_DestroyQTemporaryFile(this); };
QFileDevice::Permissions permissions() const { return static_cast<QFileDevice::Permission>(callbackQFileDevice_Permissions(const_cast<void*>(static_cast<const void*>(this)))); };
bool resize(qint64 sz) { return callbackQFileDevice_Resize(this, sz) != 0; };
bool setPermissions(QFileDevice::Permissions permissions) { return callbackQFileDevice_SetPermissions(this, permissions) != 0; };
qint64 size() const { return callbackQIODevice_Size(const_cast<void*>(static_cast<const void*>(this))); };
bool atEnd() const { return callbackQIODevice_AtEnd(const_cast<void*>(static_cast<const void*>(this))) != 0; };
void close() { callbackQIODevice_Close(this); };
bool isSequential() const { return callbackQIODevice_IsSequential(const_cast<void*>(static_cast<const void*>(this))) != 0; };
qint64 pos() const { return callbackQIODevice_Pos(const_cast<void*>(static_cast<const void*>(this))); };
qint64 readData(char * data, qint64 l) { QtCore_PackedString dataPacked = { data, l, NULL };return callbackQFileDevice_ReadData(this, dataPacked, l); };
qint64 readLineData(char * data, qint64 maxlen) { QtCore_PackedString dataPacked = { data, maxlen, NULL };return callbackQIODevice_ReadLineData(this, dataPacked, maxlen); };
bool seek(qint64 pos) { return callbackQIODevice_Seek(this, pos) != 0; };
qint64 writeData(const char * data, qint64 l) { QtCore_PackedString dataPacked = { const_cast<char*>(data), l, NULL };return callbackQFileDevice_WriteData(this, dataPacked, l); };
void Signal_AboutToClose() { callbackQIODevice_AboutToClose(this); };
qint64 bytesAvailable() const { return callbackQIODevice_BytesAvailable(const_cast<void*>(static_cast<const void*>(this))); };
qint64 bytesToWrite() const { return callbackQIODevice_BytesToWrite(const_cast<void*>(static_cast<const void*>(this))); };
void Signal_BytesWritten(qint64 bytes) { callbackQIODevice_BytesWritten(this, bytes); };
bool canReadLine() const { return callbackQIODevice_CanReadLine(const_cast<void*>(static_cast<const void*>(this))) != 0; };
void Signal_ChannelBytesWritten(int channel, qint64 bytes) { callbackQIODevice_ChannelBytesWritten(this, channel, bytes); };
void Signal_ChannelReadyRead(int channel) { callbackQIODevice_ChannelReadyRead(this, channel); };
void Signal_ReadChannelFinished() { callbackQIODevice_ReadChannelFinished(this); };
void Signal_ReadyRead() { callbackQIODevice_ReadyRead(this); };
bool reset() { return callbackQIODevice_Reset(this) != 0; };
bool waitForBytesWritten(int msecs) { return callbackQIODevice_WaitForBytesWritten(this, msecs) != 0; };
bool waitForReadyRead(int msecs) { return callbackQIODevice_WaitForReadyRead(this, msecs) != 0; };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QTemporaryFile*)
Q_DECLARE_METATYPE(MyQTemporaryFile*)
int QTemporaryFile_QTemporaryFile_QRegisterMetaType(){qRegisterMetaType<QTemporaryFile*>(); return qRegisterMetaType<MyQTemporaryFile*>();}
void* QTemporaryFile_NewQTemporaryFile()
{
return new MyQTemporaryFile();
}
void* QTemporaryFile_NewQTemporaryFile2(struct QtCore_PackedString templateName)
{
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len));
}
void* QTemporaryFile_NewQTemporaryFile3(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(static_cast<QWindow*>(parent));
} else {
return new MyQTemporaryFile(static_cast<QObject*>(parent));
}
}
void* QTemporaryFile_NewQTemporaryFile4(struct QtCore_PackedString templateName, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QWindow*>(parent));
} else {
return new MyQTemporaryFile(QString::fromUtf8(templateName.data, templateName.len), static_cast<QObject*>(parent));
}
}
char QTemporaryFile_AutoRemove(void* ptr)
{
return static_cast<QTemporaryFile*>(ptr)->autoRemove();
}
void* QTemporaryFile_QTemporaryFile_CreateNativeFile(void* file)
{
return QTemporaryFile::createNativeFile(*static_cast<QFile*>(file));
}
void* QTemporaryFile_QTemporaryFile_CreateNativeFile2(struct QtCore_PackedString fileName)
{
return QTemporaryFile::createNativeFile(QString::fromUtf8(fileName.data, fileName.len));
}
struct QtCore_PackedString QTemporaryFile_FileTemplate(void* ptr)
{
return ({ QByteArray* t23cbd0 = new QByteArray(static_cast<QTemporaryFile*>(ptr)->fileTemplate().toUtf8()); QtCore_PackedString { const_cast<char*>(t23cbd0->prepend("WHITESPACE").constData()+10), t23cbd0->size()-10, t23cbd0 }; });
}
char QTemporaryFile_Open(void* ptr)
{
return static_cast<QTemporaryFile*>(ptr)->open();
}
void QTemporaryFile_SetAutoRemove(void* ptr, char b)
{
static_cast<QTemporaryFile*>(ptr)->setAutoRemove(b != 0);
}
void QTemporaryFile_SetFileTemplate(void* ptr, struct QtCore_PackedString name)
{
static_cast<QTemporaryFile*>(ptr)->setFileTemplate(QString::fromUtf8(name.data, name.len));
}
void QTemporaryFile_DestroyQTemporaryFile(void* ptr)
{
static_cast<QTemporaryFile*>(ptr)->~QTemporaryFile();
}
void QTemporaryFile_DestroyQTemporaryFileDefault(void* ptr)
{
Q_UNUSED(ptr);
}
Q_DECLARE_METATYPE(QTextBoundaryFinder)
Q_DECLARE_METATYPE(QTextBoundaryFinder*)
void* QTextBoundaryFinder_NewQTextBoundaryFinder()
{
return new QTextBoundaryFinder();
}
void* QTextBoundaryFinder_NewQTextBoundaryFinder2(void* other)
{
return new QTextBoundaryFinder(*static_cast<QTextBoundaryFinder*>(other));
}
void* QTextBoundaryFinder_NewQTextBoundaryFinder3(long long ty, struct QtCore_PackedString stri)
{
return new QTextBoundaryFinder(static_cast<QTextBoundaryFinder::BoundaryType>(ty), QString::fromUtf8(stri.data, stri.len));
}
long long QTextBoundaryFinder_BoundaryReasons(void* ptr)
{
return static_cast<QTextBoundaryFinder*>(ptr)->boundaryReasons();
}
char QTextBoundaryFinder_IsAtBoundary(void* ptr)
{
return static_cast<QTextBoundaryFinder*>(ptr)->isAtBoundary();
}
char QTextBoundaryFinder_IsValid(void* ptr)
{
return static_cast<QTextBoundaryFinder*>(ptr)->isValid();
}
int QTextBoundaryFinder_Position(void* ptr)
{
return static_cast<QTextBoundaryFinder*>(ptr)->position();
}
void QTextBoundaryFinder_SetPosition(void* ptr, int position)
{
static_cast<QTextBoundaryFinder*>(ptr)->setPosition(position);
}
struct QtCore_PackedString QTextBoundaryFinder_String(void* ptr)
{
return ({ QByteArray* t2d3858 = new QByteArray(static_cast<QTextBoundaryFinder*>(ptr)->string().toUtf8()); QtCore_PackedString { const_cast<char*>(t2d3858->prepend("WHITESPACE").constData()+10), t2d3858->size()-10, t2d3858 }; });
}
void QTextBoundaryFinder_ToEnd(void* ptr)
{
static_cast<QTextBoundaryFinder*>(ptr)->toEnd();
}
int QTextBoundaryFinder_ToNextBoundary(void* ptr)
{
return static_cast<QTextBoundaryFinder*>(ptr)->toNextBoundary();
}
int QTextBoundaryFinder_ToPreviousBoundary(void* ptr)
{
return static_cast<QTextBoundaryFinder*>(ptr)->toPreviousBoundary();
}
void QTextBoundaryFinder_ToStart(void* ptr)
{
static_cast<QTextBoundaryFinder*>(ptr)->toStart();
}
long long QTextBoundaryFinder_Type(void* ptr)
{
return static_cast<QTextBoundaryFinder*>(ptr)->type();
}
void QTextBoundaryFinder_DestroyQTextBoundaryFinder(void* ptr)
{
static_cast<QTextBoundaryFinder*>(ptr)->~QTextBoundaryFinder();
}
class MyQTextCodec: public QTextCodec
{
public:
QList<QByteArray> aliases() const { return ({ QList<QByteArray>* tmpP = static_cast<QList<QByteArray>*>(callbackQTextCodec_Aliases(const_cast<void*>(static_cast<const void*>(this)))); QList<QByteArray> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
int mibEnum() const { return callbackQTextCodec_MibEnum(const_cast<void*>(static_cast<const void*>(this))); };
QByteArray name() const { return *static_cast<QByteArray*>(callbackQTextCodec_Name(const_cast<void*>(static_cast<const void*>(this)))); };
~MyQTextCodec() { callbackQTextCodec_DestroyQTextCodec(this); };
};
Q_DECLARE_METATYPE(QTextCodec*)
Q_DECLARE_METATYPE(MyQTextCodec*)
int QTextCodec_QTextCodec_QRegisterMetaType(){qRegisterMetaType<QTextCodec*>(); return qRegisterMetaType<MyQTextCodec*>();}
struct QtCore_PackedList QTextCodec_Aliases(void* ptr)
{
return ({ QList<QByteArray>* tmpValueb6774e = new QList<QByteArray>(static_cast<QTextCodec*>(ptr)->aliases()); QtCore_PackedList { tmpValueb6774e, tmpValueb6774e->size() }; });
}
struct QtCore_PackedList QTextCodec_AliasesDefault(void* ptr)
{
return ({ QList<QByteArray>* tmpValuee659dd = new QList<QByteArray>(static_cast<QTextCodec*>(ptr)->QTextCodec::aliases()); QtCore_PackedList { tmpValuee659dd, tmpValuee659dd->size() }; });
}
struct QtCore_PackedList QTextCodec_QTextCodec_AvailableCodecs()
{
return ({ QList<QByteArray>* tmpValue6a90cd = new QList<QByteArray>(QTextCodec::availableCodecs()); QtCore_PackedList { tmpValue6a90cd, tmpValue6a90cd->size() }; });
}
struct QtCore_PackedList QTextCodec_QTextCodec_AvailableMibs()
{
return ({ QList<int>* tmpValuef6e6be = new QList<int>(QTextCodec::availableMibs()); QtCore_PackedList { tmpValuef6e6be, tmpValuef6e6be->size() }; });
}
char QTextCodec_CanEncode(void* ptr, void* ch)
{
return static_cast<QTextCodec*>(ptr)->canEncode(*static_cast<QChar*>(ch));
}
char QTextCodec_CanEncode2(void* ptr, struct QtCore_PackedString s)
{
return static_cast<QTextCodec*>(ptr)->canEncode(QString::fromUtf8(s.data, s.len));
}
char QTextCodec_CanEncode3(void* ptr, void* s)
{
return static_cast<QTextCodec*>(ptr)->canEncode(*static_cast<QStringView*>(s));
}
void* QTextCodec_QTextCodec_CodecForHtml(void* ba, void* defaultCodec)
{
return QTextCodec::codecForHtml(*static_cast<QByteArray*>(ba), static_cast<QTextCodec*>(defaultCodec));
}
void* QTextCodec_QTextCodec_CodecForHtml2(void* ba)
{
return QTextCodec::codecForHtml(*static_cast<QByteArray*>(ba));
}
void* QTextCodec_QTextCodec_CodecForLocale()
{
return QTextCodec::codecForLocale();
}
void* QTextCodec_QTextCodec_CodecForMib(int mib)
{
return QTextCodec::codecForMib(mib);
}
void* QTextCodec_QTextCodec_CodecForName(void* name)
{
return QTextCodec::codecForName(*static_cast<QByteArray*>(name));
}
void* QTextCodec_QTextCodec_CodecForName2(char* name)
{
return QTextCodec::codecForName(const_cast<const char*>(name));
}
void* QTextCodec_QTextCodec_CodecForUtfText(void* ba, void* defaultCodec)
{
return QTextCodec::codecForUtfText(*static_cast<QByteArray*>(ba), static_cast<QTextCodec*>(defaultCodec));
}
void* QTextCodec_QTextCodec_CodecForUtfText2(void* ba)
{
return QTextCodec::codecForUtfText(*static_cast<QByteArray*>(ba));
}
void* QTextCodec_FromUnicode(void* ptr, struct QtCore_PackedString str)
{
return new QByteArray(static_cast<QTextCodec*>(ptr)->fromUnicode(QString::fromUtf8(str.data, str.len)));
}
void* QTextCodec_FromUnicode2(void* ptr, void* str)
{
return new QByteArray(static_cast<QTextCodec*>(ptr)->fromUnicode(*static_cast<QStringView*>(str)));
}
void* QTextCodec_MakeDecoder(void* ptr, long long flags)
{
return static_cast<QTextCodec*>(ptr)->makeDecoder(static_cast<QTextCodec::ConversionFlag>(flags));
}
void* QTextCodec_MakeEncoder(void* ptr, long long flags)
{
return static_cast<QTextCodec*>(ptr)->makeEncoder(static_cast<QTextCodec::ConversionFlag>(flags));
}
int QTextCodec_MibEnum(void* ptr)
{
return static_cast<QTextCodec*>(ptr)->mibEnum();
}
void* QTextCodec_Name(void* ptr)
{
return new QByteArray(static_cast<QTextCodec*>(ptr)->name());
}
void QTextCodec_QTextCodec_SetCodecForLocale(void* c)
{
QTextCodec::setCodecForLocale(static_cast<QTextCodec*>(c));
}
struct QtCore_PackedString QTextCodec_ToUnicode(void* ptr, void* a)
{
return ({ QByteArray* te3183b = new QByteArray(static_cast<QTextCodec*>(ptr)->toUnicode(*static_cast<QByteArray*>(a)).toUtf8()); QtCore_PackedString { const_cast<char*>(te3183b->prepend("WHITESPACE").constData()+10), te3183b->size()-10, te3183b }; });
}
struct QtCore_PackedString QTextCodec_ToUnicode2(void* ptr, char* chars)
{
return ({ QByteArray* t6b92b5 = new QByteArray(static_cast<QTextCodec*>(ptr)->toUnicode(const_cast<const char*>(chars)).toUtf8()); QtCore_PackedString { const_cast<char*>(t6b92b5->prepend("WHITESPACE").constData()+10), t6b92b5->size()-10, t6b92b5 }; });
}
void QTextCodec_DestroyQTextCodec(void* ptr)
{
static_cast<QTextCodec*>(ptr)->~QTextCodec();
}
void QTextCodec_DestroyQTextCodecDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QTextCodec___aliases_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QTextCodec___aliases_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QTextCodec___aliases_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QTextCodec___availableCodecs_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QTextCodec___availableCodecs_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QTextCodec___availableCodecs_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
int QTextCodec___availableMibs_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QList<int>*>(ptr)->at(i); if (i == static_cast<QList<int>*>(ptr)->size()-1) { static_cast<QList<int>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QTextCodec___availableMibs_setList(void* ptr, int i)
{
static_cast<QList<int>*>(ptr)->append(i);
}
void* QTextCodec___availableMibs_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<int>();
}
Q_DECLARE_METATYPE(QTextDecoder*)
void* QTextDecoder_NewQTextDecoder2(void* codec)
{
return new QTextDecoder(static_cast<QTextCodec*>(codec));
}
void* QTextDecoder_NewQTextDecoder3(void* codec, long long flags)
{
return new QTextDecoder(static_cast<QTextCodec*>(codec), static_cast<QTextCodec::ConversionFlag>(flags));
}
struct QtCore_PackedString QTextDecoder_ToUnicode(void* ptr, char* chars, int l)
{
return ({ QByteArray* t9f8601 = new QByteArray(static_cast<QTextDecoder*>(ptr)->toUnicode(const_cast<const char*>(chars), l).toUtf8()); QtCore_PackedString { const_cast<char*>(t9f8601->prepend("WHITESPACE").constData()+10), t9f8601->size()-10, t9f8601 }; });
}
struct QtCore_PackedString QTextDecoder_ToUnicode2(void* ptr, void* ba)
{
return ({ QByteArray* t597c34 = new QByteArray(static_cast<QTextDecoder*>(ptr)->toUnicode(*static_cast<QByteArray*>(ba)).toUtf8()); QtCore_PackedString { const_cast<char*>(t597c34->prepend("WHITESPACE").constData()+10), t597c34->size()-10, t597c34 }; });
}
void QTextDecoder_ToUnicode3(void* ptr, struct QtCore_PackedString target, char* chars, int l)
{
static_cast<QTextDecoder*>(ptr)->toUnicode(new QString(QString::fromUtf8(target.data, target.len)), const_cast<const char*>(chars), l);
}
void QTextDecoder_DestroyQTextDecoder(void* ptr)
{
static_cast<QTextDecoder*>(ptr)->~QTextDecoder();
}
Q_DECLARE_METATYPE(QTextEncoder*)
void* QTextEncoder_NewQTextEncoder2(void* codec)
{
return new QTextEncoder(static_cast<QTextCodec*>(codec));
}
void* QTextEncoder_NewQTextEncoder3(void* codec, long long flags)
{
return new QTextEncoder(static_cast<QTextCodec*>(codec), static_cast<QTextCodec::ConversionFlag>(flags));
}
void* QTextEncoder_FromUnicode(void* ptr, struct QtCore_PackedString str)
{
return new QByteArray(static_cast<QTextEncoder*>(ptr)->fromUnicode(QString::fromUtf8(str.data, str.len)));
}
void* QTextEncoder_FromUnicode2(void* ptr, void* str)
{
return new QByteArray(static_cast<QTextEncoder*>(ptr)->fromUnicode(*static_cast<QStringView*>(str)));
}
void* QTextEncoder_FromUnicode3(void* ptr, void* uc, int l)
{
return new QByteArray(static_cast<QTextEncoder*>(ptr)->fromUnicode(static_cast<QChar*>(uc), l));
}
void QTextEncoder_DestroyQTextEncoder(void* ptr)
{
static_cast<QTextEncoder*>(ptr)->~QTextEncoder();
}
class MyQTextStream: public QTextStream
{
public:
MyQTextStream() : QTextStream() {QTextStream_QTextStream_QRegisterMetaType();};
MyQTextStream(QIODevice *device) : QTextStream(device) {QTextStream_QTextStream_QRegisterMetaType();};
MyQTextStream(QString *stri, QIODevice::OpenMode openMode = QIODevice::ReadWrite) : QTextStream(stri, openMode) {QTextStream_QTextStream_QRegisterMetaType();};
MyQTextStream(QByteArray *array, QIODevice::OpenMode openMode = QIODevice::ReadWrite) : QTextStream(array, openMode) {QTextStream_QTextStream_QRegisterMetaType();};
MyQTextStream(const QByteArray &array, QIODevice::OpenMode openMode = QIODevice::ReadOnly) : QTextStream(array, openMode) {QTextStream_QTextStream_QRegisterMetaType();};
~MyQTextStream() { callbackQTextStream_DestroyQTextStream(this); };
};
Q_DECLARE_METATYPE(QTextStream*)
Q_DECLARE_METATYPE(MyQTextStream*)
int QTextStream_QTextStream_QRegisterMetaType(){qRegisterMetaType<QTextStream*>(); return qRegisterMetaType<MyQTextStream*>();}
void* QTextStream_NewQTextStream()
{
return new MyQTextStream();
}
void* QTextStream_NewQTextStream2(void* device)
{
return new MyQTextStream(static_cast<QIODevice*>(device));
}
void* QTextStream_NewQTextStream4(struct QtCore_PackedString stri, long long openMode)
{
return new MyQTextStream(new QString(QString::fromUtf8(stri.data, stri.len)), static_cast<QIODevice::OpenModeFlag>(openMode));
}
void* QTextStream_NewQTextStream5(void* array, long long openMode)
{
return new MyQTextStream(static_cast<QByteArray*>(array), static_cast<QIODevice::OpenModeFlag>(openMode));
}
void* QTextStream_NewQTextStream6(void* array, long long openMode)
{
return new MyQTextStream(*static_cast<QByteArray*>(array), static_cast<QIODevice::OpenModeFlag>(openMode));
}
char QTextStream_AtEnd(void* ptr)
{
return static_cast<QTextStream*>(ptr)->atEnd();
}
char QTextStream_AutoDetectUnicode(void* ptr)
{
return static_cast<QTextStream*>(ptr)->autoDetectUnicode();
}
void* QTextStream_Codec(void* ptr)
{
return static_cast<QTextStream*>(ptr)->codec();
}
void* QTextStream_Device(void* ptr)
{
return static_cast<QTextStream*>(ptr)->device();
}
long long QTextStream_FieldAlignment(void* ptr)
{
return static_cast<QTextStream*>(ptr)->fieldAlignment();
}
int QTextStream_FieldWidth(void* ptr)
{
return static_cast<QTextStream*>(ptr)->fieldWidth();
}
void QTextStream_Flush(void* ptr)
{
static_cast<QTextStream*>(ptr)->flush();
}
char QTextStream_GenerateByteOrderMark(void* ptr)
{
return static_cast<QTextStream*>(ptr)->generateByteOrderMark();
}
int QTextStream_IntegerBase(void* ptr)
{
return static_cast<QTextStream*>(ptr)->integerBase();
}
void* QTextStream_Locale(void* ptr)
{
return new QLocale(static_cast<QTextStream*>(ptr)->locale());
}
long long QTextStream_NumberFlags(void* ptr)
{
return static_cast<QTextStream*>(ptr)->numberFlags();
}
void* QTextStream_PadChar(void* ptr)
{
return new QChar(static_cast<QTextStream*>(ptr)->padChar());
}
long long QTextStream_Pos(void* ptr)
{
return static_cast<QTextStream*>(ptr)->pos();
}
struct QtCore_PackedString QTextStream_Read(void* ptr, long long maxlen)
{
return ({ QByteArray* t1ba29b = new QByteArray(static_cast<QTextStream*>(ptr)->read(maxlen).toUtf8()); QtCore_PackedString { const_cast<char*>(t1ba29b->prepend("WHITESPACE").constData()+10), t1ba29b->size()-10, t1ba29b }; });
}
struct QtCore_PackedString QTextStream_ReadAll(void* ptr)
{
return ({ QByteArray* t3976a4 = new QByteArray(static_cast<QTextStream*>(ptr)->readAll().toUtf8()); QtCore_PackedString { const_cast<char*>(t3976a4->prepend("WHITESPACE").constData()+10), t3976a4->size()-10, t3976a4 }; });
}
struct QtCore_PackedString QTextStream_ReadLine(void* ptr, long long maxlen)
{
return ({ QByteArray* t7fab2e = new QByteArray(static_cast<QTextStream*>(ptr)->readLine(maxlen).toUtf8()); QtCore_PackedString { const_cast<char*>(t7fab2e->prepend("WHITESPACE").constData()+10), t7fab2e->size()-10, t7fab2e }; });
}
char QTextStream_ReadLineInto(void* ptr, struct QtCore_PackedString line, long long maxlen)
{
return static_cast<QTextStream*>(ptr)->readLineInto(new QString(QString::fromUtf8(line.data, line.len)), maxlen);
}
long long QTextStream_RealNumberNotation(void* ptr)
{
return static_cast<QTextStream*>(ptr)->realNumberNotation();
}
int QTextStream_RealNumberPrecision(void* ptr)
{
return static_cast<QTextStream*>(ptr)->realNumberPrecision();
}
void QTextStream_Reset(void* ptr)
{
static_cast<QTextStream*>(ptr)->reset();
}
void QTextStream_ResetStatus(void* ptr)
{
static_cast<QTextStream*>(ptr)->resetStatus();
}
char QTextStream_Seek(void* ptr, long long pos)
{
return static_cast<QTextStream*>(ptr)->seek(pos);
}
void QTextStream_SetAutoDetectUnicode(void* ptr, char enabled)
{
static_cast<QTextStream*>(ptr)->setAutoDetectUnicode(enabled != 0);
}
void QTextStream_SetCodec(void* ptr, void* codec)
{
static_cast<QTextStream*>(ptr)->setCodec(static_cast<QTextCodec*>(codec));
}
void QTextStream_SetCodec2(void* ptr, char* codecName)
{
static_cast<QTextStream*>(ptr)->setCodec(const_cast<const char*>(codecName));
}
void QTextStream_SetDevice(void* ptr, void* device)
{
static_cast<QTextStream*>(ptr)->setDevice(static_cast<QIODevice*>(device));
}
void QTextStream_SetFieldAlignment(void* ptr, long long mode)
{
static_cast<QTextStream*>(ptr)->setFieldAlignment(static_cast<QTextStream::FieldAlignment>(mode));
}
void QTextStream_SetFieldWidth(void* ptr, int width)
{
static_cast<QTextStream*>(ptr)->setFieldWidth(width);
}
void QTextStream_SetGenerateByteOrderMark(void* ptr, char generate)
{
static_cast<QTextStream*>(ptr)->setGenerateByteOrderMark(generate != 0);
}
void QTextStream_SetIntegerBase(void* ptr, int base)
{
static_cast<QTextStream*>(ptr)->setIntegerBase(base);
}
void QTextStream_SetLocale(void* ptr, void* locale)
{
static_cast<QTextStream*>(ptr)->setLocale(*static_cast<QLocale*>(locale));
}
void QTextStream_SetNumberFlags(void* ptr, long long flags)
{
static_cast<QTextStream*>(ptr)->setNumberFlags(static_cast<QTextStream::NumberFlag>(flags));
}
void QTextStream_SetPadChar(void* ptr, void* ch)
{
static_cast<QTextStream*>(ptr)->setPadChar(*static_cast<QChar*>(ch));
}
void QTextStream_SetRealNumberNotation(void* ptr, long long notation)
{
static_cast<QTextStream*>(ptr)->setRealNumberNotation(static_cast<QTextStream::RealNumberNotation>(notation));
}
void QTextStream_SetRealNumberPrecision(void* ptr, int precision)
{
static_cast<QTextStream*>(ptr)->setRealNumberPrecision(precision);
}
void QTextStream_SetStatus(void* ptr, long long status)
{
static_cast<QTextStream*>(ptr)->setStatus(static_cast<QTextStream::Status>(status));
}
void QTextStream_SetString(void* ptr, struct QtCore_PackedString stri, long long openMode)
{
static_cast<QTextStream*>(ptr)->setString(new QString(QString::fromUtf8(stri.data, stri.len)), static_cast<QIODevice::OpenModeFlag>(openMode));
}
void QTextStream_SkipWhiteSpace(void* ptr)
{
static_cast<QTextStream*>(ptr)->skipWhiteSpace();
}
long long QTextStream_Status(void* ptr)
{
return static_cast<QTextStream*>(ptr)->status();
}
struct QtCore_PackedString QTextStream_String(void* ptr)
{
return ({ QByteArray* t586a42 = new QByteArray(static_cast<QTextStream*>(ptr)->string()->toUtf8()); QtCore_PackedString { const_cast<char*>(t586a42->prepend("WHITESPACE").constData()+10), t586a42->size()-10, t586a42 }; });
}
void QTextStream_DestroyQTextStream(void* ptr)
{
static_cast<QTextStream*>(ptr)->~QTextStream();
}
void QTextStream_DestroyQTextStreamDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQThread: public QThread
{
public:
MyQThread(QObject *parent = Q_NULLPTR) : QThread(parent) {QThread_QThread_QRegisterMetaType();};
bool event(QEvent * event) { return callbackQObject_Event(this, event) != 0; };
void Signal_Finished() { callbackQThread_Finished(this); };
void quit() { callbackQThread_Quit(this); };
void run() { callbackQThread_Run(this); };
void start() { callbackQThread_Start(this); };
void Signal_Started() { callbackQThread_Started(this); };
void terminate() { callbackQThread_Terminate(this); };
~MyQThread() { callbackQThread_DestroyQThread(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QThread*)
Q_DECLARE_METATYPE(MyQThread*)
int QThread_QThread_QRegisterMetaType(){qRegisterMetaType<QThread*>(); return qRegisterMetaType<MyQThread*>();}
void* QThread_NewQThread(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQThread(static_cast<QWindow*>(parent));
} else {
return new MyQThread(static_cast<QObject*>(parent));
}
}
void* QThread_QThread_CurrentThread()
{
return QThread::currentThread();
}
void* QThread_EventDispatcher(void* ptr)
{
return static_cast<QThread*>(ptr)->eventDispatcher();
}
int QThread_Exec(void* ptr)
{
return static_cast<QThread*>(ptr)->exec();
}
void QThread_Exit(void* ptr, int returnCode)
{
static_cast<QThread*>(ptr)->exit(returnCode);
}
void QThread_ConnectFinished(void* ptr, long long t)
{
QObject::connect(static_cast<QThread*>(ptr), &QThread::finished, static_cast<MyQThread*>(ptr), static_cast<void (MyQThread::*)()>(&MyQThread::Signal_Finished), static_cast<Qt::ConnectionType>(t));
}
void QThread_DisconnectFinished(void* ptr)
{
QObject::disconnect(static_cast<QThread*>(ptr), &QThread::finished, static_cast<MyQThread*>(ptr), static_cast<void (MyQThread::*)()>(&MyQThread::Signal_Finished));
}
int QThread_QThread_IdealThreadCount()
{
return QThread::idealThreadCount();
}
char QThread_IsFinished(void* ptr)
{
return static_cast<QThread*>(ptr)->isFinished();
}
char QThread_IsInterruptionRequested(void* ptr)
{
return static_cast<QThread*>(ptr)->isInterruptionRequested();
}
char QThread_IsRunning(void* ptr)
{
return static_cast<QThread*>(ptr)->isRunning();
}
int QThread_LoopLevel(void* ptr)
{
return static_cast<QThread*>(ptr)->loopLevel();
}
void QThread_QThread_Msleep(unsigned long msecs)
{
QThread::msleep(msecs);
}
long long QThread_Priority(void* ptr)
{
return static_cast<QThread*>(ptr)->priority();
}
void QThread_Quit(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QThread*>(ptr), "quit");
}
void QThread_QuitDefault(void* ptr)
{
static_cast<QThread*>(ptr)->QThread::quit();
}
void QThread_RequestInterruption(void* ptr)
{
static_cast<QThread*>(ptr)->requestInterruption();
}
void QThread_Run(void* ptr)
{
static_cast<QThread*>(ptr)->run();
}
void QThread_RunDefault(void* ptr)
{
static_cast<QThread*>(ptr)->QThread::run();
}
void QThread_SetEventDispatcher(void* ptr, void* eventDispatcher)
{
static_cast<QThread*>(ptr)->setEventDispatcher(static_cast<QAbstractEventDispatcher*>(eventDispatcher));
}
void QThread_SetPriority(void* ptr, long long priority)
{
static_cast<QThread*>(ptr)->setPriority(static_cast<QThread::Priority>(priority));
}
void QThread_SetStackSize(void* ptr, unsigned int stackSize)
{
static_cast<QThread*>(ptr)->setStackSize(stackSize);
}
void QThread_QThread_SetTerminationEnabled(char enabled)
{
QThread::setTerminationEnabled(enabled != 0);
}
void QThread_QThread_Sleep(unsigned long secs)
{
QThread::sleep(secs);
}
unsigned int QThread_StackSize(void* ptr)
{
return static_cast<QThread*>(ptr)->stackSize();
}
void QThread_Start(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QThread*>(ptr), "start");
}
void QThread_StartDefault(void* ptr)
{
static_cast<QThread*>(ptr)->QThread::start();
}
void QThread_ConnectStarted(void* ptr, long long t)
{
QObject::connect(static_cast<QThread*>(ptr), &QThread::started, static_cast<MyQThread*>(ptr), static_cast<void (MyQThread::*)()>(&MyQThread::Signal_Started), static_cast<Qt::ConnectionType>(t));
}
void QThread_DisconnectStarted(void* ptr)
{
QObject::disconnect(static_cast<QThread*>(ptr), &QThread::started, static_cast<MyQThread*>(ptr), static_cast<void (MyQThread::*)()>(&MyQThread::Signal_Started));
}
void QThread_Terminate(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QThread*>(ptr), "terminate");
}
void QThread_TerminateDefault(void* ptr)
{
static_cast<QThread*>(ptr)->QThread::terminate();
}
void QThread_QThread_Usleep(unsigned long usecs)
{
QThread::usleep(usecs);
}
char QThread_Wait(void* ptr, unsigned long ti)
{
return static_cast<QThread*>(ptr)->wait(ti);
}
void QThread_QThread_YieldCurrentThread()
{
QThread::yieldCurrentThread();
}
void QThread_DestroyQThread(void* ptr)
{
static_cast<QThread*>(ptr)->~QThread();
}
void QThread_DestroyQThreadDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQThreadPool: public QThreadPool
{
public:
MyQThreadPool(QObject *parent = Q_NULLPTR) : QThreadPool(parent) {QThreadPool_QThreadPool_QRegisterMetaType();};
~MyQThreadPool() { callbackQThreadPool_DestroyQThreadPool(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QThreadPool*)
Q_DECLARE_METATYPE(MyQThreadPool*)
int QThreadPool_QThreadPool_QRegisterMetaType(){qRegisterMetaType<QThreadPool*>(); return qRegisterMetaType<MyQThreadPool*>();}
void* QThreadPool_NewQThreadPool(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQThreadPool(static_cast<QWindow*>(parent));
} else {
return new MyQThreadPool(static_cast<QObject*>(parent));
}
}
int QThreadPool_ActiveThreadCount(void* ptr)
{
return static_cast<QThreadPool*>(ptr)->activeThreadCount();
}
void QThreadPool_Clear(void* ptr)
{
static_cast<QThreadPool*>(ptr)->clear();
}
int QThreadPool_ExpiryTimeout(void* ptr)
{
return static_cast<QThreadPool*>(ptr)->expiryTimeout();
}
void* QThreadPool_QThreadPool_GlobalInstance()
{
return QThreadPool::globalInstance();
}
int QThreadPool_MaxThreadCount(void* ptr)
{
return static_cast<QThreadPool*>(ptr)->maxThreadCount();
}
void QThreadPool_ReleaseThread(void* ptr)
{
static_cast<QThreadPool*>(ptr)->releaseThread();
}
void QThreadPool_ReserveThread(void* ptr)
{
static_cast<QThreadPool*>(ptr)->reserveThread();
}
void QThreadPool_SetExpiryTimeout(void* ptr, int expiryTimeout)
{
static_cast<QThreadPool*>(ptr)->setExpiryTimeout(expiryTimeout);
}
void QThreadPool_SetMaxThreadCount(void* ptr, int maxThreadCount)
{
static_cast<QThreadPool*>(ptr)->setMaxThreadCount(maxThreadCount);
}
void QThreadPool_SetStackSize(void* ptr, unsigned int stackSize)
{
static_cast<QThreadPool*>(ptr)->setStackSize(stackSize);
}
unsigned int QThreadPool_StackSize(void* ptr)
{
return static_cast<QThreadPool*>(ptr)->stackSize();
}
void QThreadPool_Start(void* ptr, void* runnable, int priority)
{
static_cast<QThreadPool*>(ptr)->start(static_cast<QRunnable*>(runnable), priority);
}
char QThreadPool_TryStart(void* ptr, void* runnable)
{
return static_cast<QThreadPool*>(ptr)->tryStart(static_cast<QRunnable*>(runnable));
}
char QThreadPool_TryTake(void* ptr, void* runnable)
{
return static_cast<QThreadPool*>(ptr)->tryTake(static_cast<QRunnable*>(runnable));
}
char QThreadPool_WaitForDone(void* ptr, int msecs)
{
return static_cast<QThreadPool*>(ptr)->waitForDone(msecs);
}
void QThreadPool_DestroyQThreadPool(void* ptr)
{
static_cast<QThreadPool*>(ptr)->~QThreadPool();
}
void QThreadPool_DestroyQThreadPoolDefault(void* ptr)
{
Q_UNUSED(ptr);
}
Q_DECLARE_METATYPE(QTime)
Q_DECLARE_METATYPE(QTime*)
void* QTime_NewQTime2()
{
return new QTime();
}
void* QTime_NewQTime3(int h, int m, int s, int ms)
{
return new QTime(h, m, s, ms);
}
void* QTime_AddMSecs(void* ptr, int ms)
{
return new QTime(static_cast<QTime*>(ptr)->addMSecs(ms));
}
void* QTime_AddSecs(void* ptr, int s)
{
return new QTime(static_cast<QTime*>(ptr)->addSecs(s));
}
void* QTime_QTime_CurrentTime()
{
return new QTime(QTime::currentTime());
}
int QTime_Elapsed(void* ptr)
{
return static_cast<QTime*>(ptr)->elapsed();
}
void* QTime_QTime_FromMSecsSinceStartOfDay(int msecs)
{
return new QTime(QTime::fromMSecsSinceStartOfDay(msecs));
}
void* QTime_QTime_FromString(struct QtCore_PackedString stri, long long format)
{
return new QTime(QTime::fromString(QString::fromUtf8(stri.data, stri.len), static_cast<Qt::DateFormat>(format)));
}
void* QTime_QTime_FromString2(struct QtCore_PackedString stri, struct QtCore_PackedString format)
{
return new QTime(QTime::fromString(QString::fromUtf8(stri.data, stri.len), QString::fromUtf8(format.data, format.len)));
}
int QTime_Hour(void* ptr)
{
return static_cast<QTime*>(ptr)->hour();
}
char QTime_IsNull(void* ptr)
{
return static_cast<QTime*>(ptr)->isNull();
}
char QTime_IsValid(void* ptr)
{
return static_cast<QTime*>(ptr)->isValid();
}
char QTime_QTime_IsValid2(int h, int m, int s, int ms)
{
return QTime::isValid(h, m, s, ms);
}
int QTime_Minute(void* ptr)
{
return static_cast<QTime*>(ptr)->minute();
}
int QTime_Msec(void* ptr)
{
return static_cast<QTime*>(ptr)->msec();
}
int QTime_MsecsSinceStartOfDay(void* ptr)
{
return static_cast<QTime*>(ptr)->msecsSinceStartOfDay();
}
int QTime_MsecsTo(void* ptr, void* t)
{
return static_cast<QTime*>(ptr)->msecsTo(*static_cast<QTime*>(t));
}
int QTime_Restart(void* ptr)
{
return static_cast<QTime*>(ptr)->restart();
}
int QTime_Second(void* ptr)
{
return static_cast<QTime*>(ptr)->second();
}
int QTime_SecsTo(void* ptr, void* t)
{
return static_cast<QTime*>(ptr)->secsTo(*static_cast<QTime*>(t));
}
char QTime_SetHMS(void* ptr, int h, int m, int s, int ms)
{
return static_cast<QTime*>(ptr)->setHMS(h, m, s, ms);
}
void QTime_Start(void* ptr)
{
static_cast<QTime*>(ptr)->start();
}
struct QtCore_PackedString QTime_ToString(void* ptr, struct QtCore_PackedString format)
{
return ({ QByteArray* t864fb5 = new QByteArray(static_cast<QTime*>(ptr)->toString(QString::fromUtf8(format.data, format.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t864fb5->prepend("WHITESPACE").constData()+10), t864fb5->size()-10, t864fb5 }; });
}
struct QtCore_PackedString QTime_ToString2(void* ptr, long long format)
{
return ({ QByteArray* tb222d7 = new QByteArray(static_cast<QTime*>(ptr)->toString(static_cast<Qt::DateFormat>(format)).toUtf8()); QtCore_PackedString { const_cast<char*>(tb222d7->prepend("WHITESPACE").constData()+10), tb222d7->size()-10, tb222d7 }; });
}
struct QtCore_PackedString QTime_ToString3(void* ptr, void* format)
{
return ({ QByteArray* t3aabc8 = new QByteArray(static_cast<QTime*>(ptr)->toString(*static_cast<QStringView*>(format)).toUtf8()); QtCore_PackedString { const_cast<char*>(t3aabc8->prepend("WHITESPACE").constData()+10), t3aabc8->size()-10, t3aabc8 }; });
}
class MyQTimeLine: public QTimeLine
{
public:
MyQTimeLine(int duration = 1000, QObject *parent = Q_NULLPTR) : QTimeLine(duration, parent) {QTimeLine_QTimeLine_QRegisterMetaType();};
void Signal_Finished() { callbackQTimeLine_Finished(this); };
void Signal_FrameChanged(int frame) { callbackQTimeLine_FrameChanged(this, frame); };
void resume() { callbackQTimeLine_Resume(this); };
void setCurrentTime(int msec) { callbackQTimeLine_SetCurrentTime(this, msec); };
void setPaused(bool paused) { callbackQTimeLine_SetPaused(this, paused); };
void start() { callbackQTimeLine_Start(this); };
void Signal_StateChanged(QTimeLine::State newState) { callbackQTimeLine_StateChanged(this, newState); };
void stop() { callbackQTimeLine_Stop(this); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
void toggleDirection() { callbackQTimeLine_ToggleDirection(this); };
void Signal_ValueChanged(qreal value) { callbackQTimeLine_ValueChanged(this, value); };
qreal valueForTime(int msec) const { return callbackQTimeLine_ValueForTime(const_cast<void*>(static_cast<const void*>(this)), msec); };
~MyQTimeLine() { callbackQTimeLine_DestroyQTimeLine(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
};
Q_DECLARE_METATYPE(QTimeLine*)
Q_DECLARE_METATYPE(MyQTimeLine*)
int QTimeLine_QTimeLine_QRegisterMetaType(){qRegisterMetaType<QTimeLine*>(); return qRegisterMetaType<MyQTimeLine*>();}
void* QTimeLine_NewQTimeLine(int duration, void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQTimeLine(duration, static_cast<QWindow*>(parent));
} else {
return new MyQTimeLine(duration, static_cast<QObject*>(parent));
}
}
int QTimeLine_CurrentFrame(void* ptr)
{
return static_cast<QTimeLine*>(ptr)->currentFrame();
}
int QTimeLine_CurrentTime(void* ptr)
{
return static_cast<QTimeLine*>(ptr)->currentTime();
}
double QTimeLine_CurrentValue(void* ptr)
{
return static_cast<QTimeLine*>(ptr)->currentValue();
}
long long QTimeLine_CurveShape(void* ptr)
{
return static_cast<QTimeLine*>(ptr)->curveShape();
}
long long QTimeLine_Direction(void* ptr)
{
return static_cast<QTimeLine*>(ptr)->direction();
}
int QTimeLine_Duration(void* ptr)
{
return static_cast<QTimeLine*>(ptr)->duration();
}
void* QTimeLine_EasingCurve(void* ptr)
{
return new QEasingCurve(static_cast<QTimeLine*>(ptr)->easingCurve());
}
int QTimeLine_EndFrame(void* ptr)
{
return static_cast<QTimeLine*>(ptr)->endFrame();
}
void QTimeLine_ConnectFinished(void* ptr, long long t)
{
QObject::connect(static_cast<QTimeLine*>(ptr), &QTimeLine::finished, static_cast<MyQTimeLine*>(ptr), static_cast<void (MyQTimeLine::*)()>(&MyQTimeLine::Signal_Finished), static_cast<Qt::ConnectionType>(t));
}
void QTimeLine_DisconnectFinished(void* ptr)
{
QObject::disconnect(static_cast<QTimeLine*>(ptr), &QTimeLine::finished, static_cast<MyQTimeLine*>(ptr), static_cast<void (MyQTimeLine::*)()>(&MyQTimeLine::Signal_Finished));
}
void QTimeLine_ConnectFrameChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QTimeLine*>(ptr), &QTimeLine::frameChanged, static_cast<MyQTimeLine*>(ptr), static_cast<void (MyQTimeLine::*)(int)>(&MyQTimeLine::Signal_FrameChanged), static_cast<Qt::ConnectionType>(t));
}
void QTimeLine_DisconnectFrameChanged(void* ptr)
{
QObject::disconnect(static_cast<QTimeLine*>(ptr), &QTimeLine::frameChanged, static_cast<MyQTimeLine*>(ptr), static_cast<void (MyQTimeLine::*)(int)>(&MyQTimeLine::Signal_FrameChanged));
}
int QTimeLine_FrameForTime(void* ptr, int msec)
{
return static_cast<QTimeLine*>(ptr)->frameForTime(msec);
}
int QTimeLine_LoopCount(void* ptr)
{
return static_cast<QTimeLine*>(ptr)->loopCount();
}
void QTimeLine_Resume(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QTimeLine*>(ptr), "resume");
}
void QTimeLine_ResumeDefault(void* ptr)
{
static_cast<QTimeLine*>(ptr)->QTimeLine::resume();
}
void QTimeLine_SetCurrentTime(void* ptr, int msec)
{
QMetaObject::invokeMethod(static_cast<QTimeLine*>(ptr), "setCurrentTime", Q_ARG(int, msec));
}
void QTimeLine_SetCurrentTimeDefault(void* ptr, int msec)
{
static_cast<QTimeLine*>(ptr)->QTimeLine::setCurrentTime(msec);
}
void QTimeLine_SetCurveShape(void* ptr, long long shape)
{
static_cast<QTimeLine*>(ptr)->setCurveShape(static_cast<QTimeLine::CurveShape>(shape));
}
void QTimeLine_SetDirection(void* ptr, long long direction)
{
static_cast<QTimeLine*>(ptr)->setDirection(static_cast<QTimeLine::Direction>(direction));
}
void QTimeLine_SetDuration(void* ptr, int duration)
{
static_cast<QTimeLine*>(ptr)->setDuration(duration);
}
void QTimeLine_SetEasingCurve(void* ptr, void* curve)
{
static_cast<QTimeLine*>(ptr)->setEasingCurve(*static_cast<QEasingCurve*>(curve));
}
void QTimeLine_SetEndFrame(void* ptr, int frame)
{
static_cast<QTimeLine*>(ptr)->setEndFrame(frame);
}
void QTimeLine_SetFrameRange(void* ptr, int startFrame, int endFrame)
{
static_cast<QTimeLine*>(ptr)->setFrameRange(startFrame, endFrame);
}
void QTimeLine_SetLoopCount(void* ptr, int count)
{
static_cast<QTimeLine*>(ptr)->setLoopCount(count);
}
void QTimeLine_SetPaused(void* ptr, char paused)
{
QMetaObject::invokeMethod(static_cast<QTimeLine*>(ptr), "setPaused", Q_ARG(bool, paused != 0));
}
void QTimeLine_SetPausedDefault(void* ptr, char paused)
{
static_cast<QTimeLine*>(ptr)->QTimeLine::setPaused(paused != 0);
}
void QTimeLine_SetStartFrame(void* ptr, int frame)
{
static_cast<QTimeLine*>(ptr)->setStartFrame(frame);
}
void QTimeLine_SetUpdateInterval(void* ptr, int interval)
{
static_cast<QTimeLine*>(ptr)->setUpdateInterval(interval);
}
void QTimeLine_Start(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QTimeLine*>(ptr), "start");
}
void QTimeLine_StartDefault(void* ptr)
{
static_cast<QTimeLine*>(ptr)->QTimeLine::start();
}
int QTimeLine_StartFrame(void* ptr)
{
return static_cast<QTimeLine*>(ptr)->startFrame();
}
long long QTimeLine_State(void* ptr)
{
return static_cast<QTimeLine*>(ptr)->state();
}
void QTimeLine_ConnectStateChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QTimeLine*>(ptr), &QTimeLine::stateChanged, static_cast<MyQTimeLine*>(ptr), static_cast<void (MyQTimeLine::*)(QTimeLine::State)>(&MyQTimeLine::Signal_StateChanged), static_cast<Qt::ConnectionType>(t));
}
void QTimeLine_DisconnectStateChanged(void* ptr)
{
QObject::disconnect(static_cast<QTimeLine*>(ptr), &QTimeLine::stateChanged, static_cast<MyQTimeLine*>(ptr), static_cast<void (MyQTimeLine::*)(QTimeLine::State)>(&MyQTimeLine::Signal_StateChanged));
}
void QTimeLine_Stop(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QTimeLine*>(ptr), "stop");
}
void QTimeLine_StopDefault(void* ptr)
{
static_cast<QTimeLine*>(ptr)->QTimeLine::stop();
}
void QTimeLine_ToggleDirection(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QTimeLine*>(ptr), "toggleDirection");
}
void QTimeLine_ToggleDirectionDefault(void* ptr)
{
static_cast<QTimeLine*>(ptr)->QTimeLine::toggleDirection();
}
int QTimeLine_UpdateInterval(void* ptr)
{
return static_cast<QTimeLine*>(ptr)->updateInterval();
}
void QTimeLine_ConnectValueChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QTimeLine*>(ptr), &QTimeLine::valueChanged, static_cast<MyQTimeLine*>(ptr), static_cast<void (MyQTimeLine::*)(qreal)>(&MyQTimeLine::Signal_ValueChanged), static_cast<Qt::ConnectionType>(t));
}
void QTimeLine_DisconnectValueChanged(void* ptr)
{
QObject::disconnect(static_cast<QTimeLine*>(ptr), &QTimeLine::valueChanged, static_cast<MyQTimeLine*>(ptr), static_cast<void (MyQTimeLine::*)(qreal)>(&MyQTimeLine::Signal_ValueChanged));
}
double QTimeLine_ValueForTime(void* ptr, int msec)
{
return static_cast<QTimeLine*>(ptr)->valueForTime(msec);
}
double QTimeLine_ValueForTimeDefault(void* ptr, int msec)
{
return static_cast<QTimeLine*>(ptr)->QTimeLine::valueForTime(msec);
}
void QTimeLine_DestroyQTimeLine(void* ptr)
{
static_cast<QTimeLine*>(ptr)->~QTimeLine();
}
void QTimeLine_DestroyQTimeLineDefault(void* ptr)
{
Q_UNUSED(ptr);
}
Q_DECLARE_METATYPE(QTimeZone)
Q_DECLARE_METATYPE(QTimeZone*)
void* QTimeZone_NewQTimeZone()
{
return new QTimeZone();
}
void* QTimeZone_NewQTimeZone2(void* ianaId)
{
return new QTimeZone(*static_cast<QByteArray*>(ianaId));
}
void* QTimeZone_NewQTimeZone3(int offsetSeconds)
{
return new QTimeZone(offsetSeconds);
}
void* QTimeZone_NewQTimeZone4(void* ianaId, int offsetSeconds, struct QtCore_PackedString name, struct QtCore_PackedString abbreviation, long long country, struct QtCore_PackedString comment)
{
return new QTimeZone(*static_cast<QByteArray*>(ianaId), offsetSeconds, QString::fromUtf8(name.data, name.len), QString::fromUtf8(abbreviation.data, abbreviation.len), static_cast<QLocale::Country>(country), QString::fromUtf8(comment.data, comment.len));
}
void* QTimeZone_NewQTimeZone5(void* other)
{
return new QTimeZone(*static_cast<QTimeZone*>(other));
}
struct QtCore_PackedString QTimeZone_Abbreviation(void* ptr, void* atDateTime)
{
return ({ QByteArray* t82ae84 = new QByteArray(static_cast<QTimeZone*>(ptr)->abbreviation(*static_cast<QDateTime*>(atDateTime)).toUtf8()); QtCore_PackedString { const_cast<char*>(t82ae84->prepend("WHITESPACE").constData()+10), t82ae84->size()-10, t82ae84 }; });
}
struct QtCore_PackedList QTimeZone_QTimeZone_AvailableTimeZoneIds()
{
return ({ QList<QByteArray>* tmpValue9dfc57 = new QList<QByteArray>(QTimeZone::availableTimeZoneIds()); QtCore_PackedList { tmpValue9dfc57, tmpValue9dfc57->size() }; });
}
struct QtCore_PackedList QTimeZone_QTimeZone_AvailableTimeZoneIds2(long long country)
{
return ({ QList<QByteArray>* tmpValueb51557 = new QList<QByteArray>(QTimeZone::availableTimeZoneIds(static_cast<QLocale::Country>(country))); QtCore_PackedList { tmpValueb51557, tmpValueb51557->size() }; });
}
struct QtCore_PackedList QTimeZone_QTimeZone_AvailableTimeZoneIds3(int offsetSeconds)
{
return ({ QList<QByteArray>* tmpValue137a2a = new QList<QByteArray>(QTimeZone::availableTimeZoneIds(offsetSeconds)); QtCore_PackedList { tmpValue137a2a, tmpValue137a2a->size() }; });
}
struct QtCore_PackedString QTimeZone_Comment(void* ptr)
{
return ({ QByteArray* t2b73f6 = new QByteArray(static_cast<QTimeZone*>(ptr)->comment().toUtf8()); QtCore_PackedString { const_cast<char*>(t2b73f6->prepend("WHITESPACE").constData()+10), t2b73f6->size()-10, t2b73f6 }; });
}
long long QTimeZone_Country(void* ptr)
{
return static_cast<QTimeZone*>(ptr)->country();
}
int QTimeZone_DaylightTimeOffset(void* ptr, void* atDateTime)
{
return static_cast<QTimeZone*>(ptr)->daylightTimeOffset(*static_cast<QDateTime*>(atDateTime));
}
struct QtCore_PackedString QTimeZone_DisplayName(void* ptr, void* atDateTime, long long nameType, void* locale)
{
return ({ QByteArray* t168cd9 = new QByteArray(static_cast<QTimeZone*>(ptr)->displayName(*static_cast<QDateTime*>(atDateTime), static_cast<QTimeZone::NameType>(nameType), *static_cast<QLocale*>(locale)).toUtf8()); QtCore_PackedString { const_cast<char*>(t168cd9->prepend("WHITESPACE").constData()+10), t168cd9->size()-10, t168cd9 }; });
}
struct QtCore_PackedString QTimeZone_DisplayName2(void* ptr, long long timeType, long long nameType, void* locale)
{
return ({ QByteArray* tc6cf47 = new QByteArray(static_cast<QTimeZone*>(ptr)->displayName(static_cast<QTimeZone::TimeType>(timeType), static_cast<QTimeZone::NameType>(nameType), *static_cast<QLocale*>(locale)).toUtf8()); QtCore_PackedString { const_cast<char*>(tc6cf47->prepend("WHITESPACE").constData()+10), tc6cf47->size()-10, tc6cf47 }; });
}
char QTimeZone_HasDaylightTime(void* ptr)
{
return static_cast<QTimeZone*>(ptr)->hasDaylightTime();
}
char QTimeZone_HasTransitions(void* ptr)
{
return static_cast<QTimeZone*>(ptr)->hasTransitions();
}
void* QTimeZone_QTimeZone_IanaIdToWindowsId(void* ianaId)
{
return new QByteArray(QTimeZone::ianaIdToWindowsId(*static_cast<QByteArray*>(ianaId)));
}
void* QTimeZone_Id(void* ptr)
{
return new QByteArray(static_cast<QTimeZone*>(ptr)->id());
}
char QTimeZone_IsDaylightTime(void* ptr, void* atDateTime)
{
return static_cast<QTimeZone*>(ptr)->isDaylightTime(*static_cast<QDateTime*>(atDateTime));
}
char QTimeZone_QTimeZone_IsTimeZoneIdAvailable(void* ianaId)
{
return QTimeZone::isTimeZoneIdAvailable(*static_cast<QByteArray*>(ianaId));
}
char QTimeZone_IsValid(void* ptr)
{
return static_cast<QTimeZone*>(ptr)->isValid();
}
int QTimeZone_OffsetFromUtc(void* ptr, void* atDateTime)
{
return static_cast<QTimeZone*>(ptr)->offsetFromUtc(*static_cast<QDateTime*>(atDateTime));
}
int QTimeZone_StandardTimeOffset(void* ptr, void* atDateTime)
{
return static_cast<QTimeZone*>(ptr)->standardTimeOffset(*static_cast<QDateTime*>(atDateTime));
}
void QTimeZone_Swap(void* ptr, void* other)
{
static_cast<QTimeZone*>(ptr)->swap(*static_cast<QTimeZone*>(other));
}
void* QTimeZone_QTimeZone_SystemTimeZone()
{
return new QTimeZone(QTimeZone::systemTimeZone());
}
void* QTimeZone_QTimeZone_SystemTimeZoneId()
{
return new QByteArray(QTimeZone::systemTimeZoneId());
}
void* QTimeZone_QTimeZone_Utc()
{
return new QTimeZone(QTimeZone::utc());
}
void* QTimeZone_QTimeZone_WindowsIdToDefaultIanaId(void* windowsId)
{
return new QByteArray(QTimeZone::windowsIdToDefaultIanaId(*static_cast<QByteArray*>(windowsId)));
}
void* QTimeZone_QTimeZone_WindowsIdToDefaultIanaId2(void* windowsId, long long country)
{
return new QByteArray(QTimeZone::windowsIdToDefaultIanaId(*static_cast<QByteArray*>(windowsId), static_cast<QLocale::Country>(country)));
}
struct QtCore_PackedList QTimeZone_QTimeZone_WindowsIdToIanaIds(void* windowsId)
{
return ({ QList<QByteArray>* tmpValue7576fc = new QList<QByteArray>(QTimeZone::windowsIdToIanaIds(*static_cast<QByteArray*>(windowsId))); QtCore_PackedList { tmpValue7576fc, tmpValue7576fc->size() }; });
}
struct QtCore_PackedList QTimeZone_QTimeZone_WindowsIdToIanaIds2(void* windowsId, long long country)
{
return ({ QList<QByteArray>* tmpValue5be00a = new QList<QByteArray>(QTimeZone::windowsIdToIanaIds(*static_cast<QByteArray*>(windowsId), static_cast<QLocale::Country>(country))); QtCore_PackedList { tmpValue5be00a, tmpValue5be00a->size() }; });
}
void QTimeZone_DestroyQTimeZone(void* ptr)
{
static_cast<QTimeZone*>(ptr)->~QTimeZone();
}
void* QTimeZone___availableTimeZoneIds_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QTimeZone___availableTimeZoneIds_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QTimeZone___availableTimeZoneIds_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QTimeZone___availableTimeZoneIds_atList2(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QTimeZone___availableTimeZoneIds_setList2(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QTimeZone___availableTimeZoneIds_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QTimeZone___availableTimeZoneIds_atList3(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QTimeZone___availableTimeZoneIds_setList3(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QTimeZone___availableTimeZoneIds_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QTimeZone___windowsIdToIanaIds_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QTimeZone___windowsIdToIanaIds_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QTimeZone___windowsIdToIanaIds_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QTimeZone___windowsIdToIanaIds_atList2(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QTimeZone___windowsIdToIanaIds_setList2(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QTimeZone___windowsIdToIanaIds_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
class MyQTimer: public QTimer
{
public:
MyQTimer(QObject *parent = Q_NULLPTR) : QTimer(parent) {QTimer_QTimer_QRegisterMetaType();};
void start(int msec) { callbackQTimer_Start(this, msec); };
void start() { callbackQTimer_Start2(this); };
void stop() { callbackQTimer_Stop(this); };
void Signal_Timeout() { callbackQTimer_Timeout(this); };
void timerEvent(QTimerEvent * e) { callbackQObject_TimerEvent(this, e); };
~MyQTimer() { callbackQTimer_DestroyQTimer(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
};
Q_DECLARE_METATYPE(QTimer*)
Q_DECLARE_METATYPE(MyQTimer*)
int QTimer_QTimer_QRegisterMetaType(){qRegisterMetaType<QTimer*>(); return qRegisterMetaType<MyQTimer*>();}
void* QTimer_NewQTimer(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQTimer(static_cast<QWindow*>(parent));
} else {
return new MyQTimer(static_cast<QObject*>(parent));
}
}
int QTimer_Interval(void* ptr)
{
return static_cast<QTimer*>(ptr)->interval();
}
char QTimer_IsActive(void* ptr)
{
return static_cast<QTimer*>(ptr)->isActive();
}
char QTimer_IsSingleShot(void* ptr)
{
return static_cast<QTimer*>(ptr)->isSingleShot();
}
int QTimer_RemainingTime(void* ptr)
{
return static_cast<QTimer*>(ptr)->remainingTime();
}
void QTimer_SetInterval(void* ptr, int msec)
{
static_cast<QTimer*>(ptr)->setInterval(msec);
}
void QTimer_SetSingleShot(void* ptr, char singleShot)
{
static_cast<QTimer*>(ptr)->setSingleShot(singleShot != 0);
}
void QTimer_SetTimerType(void* ptr, long long atype)
{
static_cast<QTimer*>(ptr)->setTimerType(static_cast<Qt::TimerType>(atype));
}
void QTimer_QTimer_SingleShot(int msec, void* receiver, char* member)
{
QTimer::singleShot(msec, static_cast<QObject*>(receiver), const_cast<const char*>(member));
}
void QTimer_QTimer_SingleShot2(int msec, long long timerType, void* receiver, char* member)
{
QTimer::singleShot(msec, static_cast<Qt::TimerType>(timerType), static_cast<QObject*>(receiver), const_cast<const char*>(member));
}
void QTimer_Start(void* ptr, int msec)
{
QMetaObject::invokeMethod(static_cast<QTimer*>(ptr), "start", Q_ARG(int, msec));
}
void QTimer_StartDefault(void* ptr, int msec)
{
static_cast<QTimer*>(ptr)->QTimer::start(msec);
}
void QTimer_Start2(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QTimer*>(ptr), "start");
}
void QTimer_Start2Default(void* ptr)
{
static_cast<QTimer*>(ptr)->QTimer::start();
}
void QTimer_Stop(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QTimer*>(ptr), "stop");
}
void QTimer_StopDefault(void* ptr)
{
static_cast<QTimer*>(ptr)->QTimer::stop();
}
void QTimer_ConnectTimeout(void* ptr, long long t)
{
QObject::connect(static_cast<QTimer*>(ptr), &QTimer::timeout, static_cast<MyQTimer*>(ptr), static_cast<void (MyQTimer::*)()>(&MyQTimer::Signal_Timeout), static_cast<Qt::ConnectionType>(t));
}
void QTimer_DisconnectTimeout(void* ptr)
{
QObject::disconnect(static_cast<QTimer*>(ptr), &QTimer::timeout, static_cast<MyQTimer*>(ptr), static_cast<void (MyQTimer::*)()>(&MyQTimer::Signal_Timeout));
}
int QTimer_TimerId(void* ptr)
{
return static_cast<QTimer*>(ptr)->timerId();
}
long long QTimer_TimerType(void* ptr)
{
return static_cast<QTimer*>(ptr)->timerType();
}
void QTimer_DestroyQTimer(void* ptr)
{
static_cast<QTimer*>(ptr)->~QTimer();
}
void QTimer_DestroyQTimerDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQTimerEvent: public QTimerEvent
{
public:
MyQTimerEvent(int timerId) : QTimerEvent(timerId) {QTimerEvent_QTimerEvent_QRegisterMetaType();};
};
Q_DECLARE_METATYPE(QTimerEvent*)
Q_DECLARE_METATYPE(MyQTimerEvent*)
int QTimerEvent_QTimerEvent_QRegisterMetaType(){qRegisterMetaType<QTimerEvent*>(); return qRegisterMetaType<MyQTimerEvent*>();}
void* QTimerEvent_NewQTimerEvent(int timerId)
{
return new MyQTimerEvent(timerId);
}
int QTimerEvent_TimerId(void* ptr)
{
return static_cast<QTimerEvent*>(ptr)->timerId();
}
class MyQTranslator: public QTranslator
{
public:
MyQTranslator(QObject *parent = Q_NULLPTR) : QTranslator(parent) {QTranslator_QTranslator_QRegisterMetaType();};
bool isEmpty() const { return callbackQTranslator_IsEmpty(const_cast<void*>(static_cast<const void*>(this))) != 0; };
QString translate(const char * context, const char * sourceText, const char * disambiguation, int n) const { QtCore_PackedString contextPacked = { const_cast<char*>(context), n, NULL };QtCore_PackedString sourceTextPacked = { const_cast<char*>(sourceText), n, NULL };QtCore_PackedString disambiguationPacked = { const_cast<char*>(disambiguation), n, NULL };return ({ QtCore_PackedString tempVal = callbackQTranslator_Translate(const_cast<void*>(static_cast<const void*>(this)), contextPacked, sourceTextPacked, disambiguationPacked, n); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
~MyQTranslator() { callbackQTranslator_DestroyQTranslator(this); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QTranslator*)
Q_DECLARE_METATYPE(MyQTranslator*)
int QTranslator_QTranslator_QRegisterMetaType(){qRegisterMetaType<QTranslator*>(); return qRegisterMetaType<MyQTranslator*>();}
void* QTranslator_NewQTranslator(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQTranslator(static_cast<QWindow*>(parent));
} else {
return new MyQTranslator(static_cast<QObject*>(parent));
}
}
char QTranslator_IsEmpty(void* ptr)
{
return static_cast<QTranslator*>(ptr)->isEmpty();
}
char QTranslator_IsEmptyDefault(void* ptr)
{
return static_cast<QTranslator*>(ptr)->QTranslator::isEmpty();
}
char QTranslator_Load(void* ptr, struct QtCore_PackedString filename, struct QtCore_PackedString directory, struct QtCore_PackedString search_delimiters, struct QtCore_PackedString suffix)
{
return static_cast<QTranslator*>(ptr)->load(QString::fromUtf8(filename.data, filename.len), QString::fromUtf8(directory.data, directory.len), QString::fromUtf8(search_delimiters.data, search_delimiters.len), QString::fromUtf8(suffix.data, suffix.len));
}
char QTranslator_Load2(void* ptr, void* locale, struct QtCore_PackedString filename, struct QtCore_PackedString prefix, struct QtCore_PackedString directory, struct QtCore_PackedString suffix)
{
return static_cast<QTranslator*>(ptr)->load(*static_cast<QLocale*>(locale), QString::fromUtf8(filename.data, filename.len), QString::fromUtf8(prefix.data, prefix.len), QString::fromUtf8(directory.data, directory.len), QString::fromUtf8(suffix.data, suffix.len));
}
char QTranslator_Load3(void* ptr, char* data, int l, struct QtCore_PackedString directory)
{
return static_cast<QTranslator*>(ptr)->load(const_cast<const uchar*>(static_cast<uchar*>(static_cast<void*>(data))), l, QString::fromUtf8(directory.data, directory.len));
}
struct QtCore_PackedString QTranslator_Translate(void* ptr, char* context, char* sourceText, char* disambiguation, int n)
{
return ({ QByteArray* tb6b80e = new QByteArray(static_cast<QTranslator*>(ptr)->translate(const_cast<const char*>(context), const_cast<const char*>(sourceText), const_cast<const char*>(disambiguation), n).toUtf8()); QtCore_PackedString { const_cast<char*>(tb6b80e->prepend("WHITESPACE").constData()+10), tb6b80e->size()-10, tb6b80e }; });
}
struct QtCore_PackedString QTranslator_TranslateDefault(void* ptr, char* context, char* sourceText, char* disambiguation, int n)
{
return ({ QByteArray* t5511a2 = new QByteArray(static_cast<QTranslator*>(ptr)->QTranslator::translate(const_cast<const char*>(context), const_cast<const char*>(sourceText), const_cast<const char*>(disambiguation), n).toUtf8()); QtCore_PackedString { const_cast<char*>(t5511a2->prepend("WHITESPACE").constData()+10), t5511a2->size()-10, t5511a2 }; });
}
void QTranslator_DestroyQTranslator(void* ptr)
{
static_cast<QTranslator*>(ptr)->~QTranslator();
}
void QTranslator_DestroyQTranslatorDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQTransposeProxyModel: public QTransposeProxyModel
{
public:
MyQTransposeProxyModel(QObject *parent = Q_NULLPTR) : QTransposeProxyModel(parent) {QTransposeProxyModel_QTransposeProxyModel_QRegisterMetaType();};
int columnCount(const QModelIndex & parent) const { return callbackQTransposeProxyModel_ColumnCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
QVariant headerData(int section, Qt::Orientation orientation, int role) const { return *static_cast<QVariant*>(callbackQAbstractItemModel_HeaderData(const_cast<void*>(static_cast<const void*>(this)), section, orientation, role)); };
QModelIndex index(int row, int column, const QModelIndex & parent) const { return *static_cast<QModelIndex*>(callbackQTransposeProxyModel_Index(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&parent))); };
bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
QMap<int, QVariant> itemData(const QModelIndex & index) const { return ({ QMap<int, QVariant>* tmpP = static_cast<QMap<int, QVariant>*>(callbackQAbstractItemModel_ItemData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); QMap<int, QVariant> tmpV = *tmpP; tmpP->~QMap(); free(tmpP); tmpV; }); };
QModelIndex mapFromSource(const QModelIndex & sourceIndex) const { return *static_cast<QModelIndex*>(callbackQTransposeProxyModel_MapFromSource(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&sourceIndex))); };
QModelIndex mapToSource(const QModelIndex & proxyIndex) const { return *static_cast<QModelIndex*>(callbackQTransposeProxyModel_MapToSource(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&proxyIndex))); };
bool moveColumns(const QModelIndex & sourceParent, int sourceRow, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQAbstractItemModel_MoveColumns(this, const_cast<QModelIndex*>(&sourceParent), sourceRow, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
bool moveRows(const QModelIndex & sourceParent, int sourceRow, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQAbstractItemModel_MoveRows(this, const_cast<QModelIndex*>(&sourceParent), sourceRow, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
QModelIndex parent(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQTransposeProxyModel_Parent(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool removeColumns(int column, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool removeRows(int row, int count, const QModelIndex & parent) { return callbackQAbstractItemModel_RemoveRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
int rowCount(const QModelIndex & parent) const { return callbackQTransposeProxyModel_RowCount(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)); };
bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQAbstractItemModel_SetHeaderData(this, section, orientation, const_cast<QVariant*>(&value), role) != 0; };
bool setItemData(const QModelIndex & index, const QMap<int, QVariant> & roles) { return callbackQAbstractItemModel_SetItemData(this, const_cast<QModelIndex*>(&index), ({ QMap<int, QVariant>* tmpValue037c88 = new QMap<int, QVariant>(roles); QtCore_PackedList { tmpValue037c88, tmpValue037c88->size() }; })) != 0; };
void setSourceModel(QAbstractItemModel * newSourceModel) { callbackQAbstractProxyModel_SetSourceModel(this, newSourceModel); };
void sort(int column, Qt::SortOrder order) { callbackQAbstractItemModel_Sort(this, column, order); };
QSize span(const QModelIndex & index) const { return *static_cast<QSize*>(callbackQAbstractItemModel_Span(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
~MyQTransposeProxyModel() { callbackQTransposeProxyModel_DestroyQTransposeProxyModel(this); };
QModelIndex buddy(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Buddy(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool canDropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) const { return callbackQAbstractItemModel_CanDropMimeData(const_cast<void*>(static_cast<const void*>(this)), const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
bool canFetchMore(const QModelIndex & parent) const { return callbackQAbstractItemModel_CanFetchMore(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
QVariant data(const QModelIndex & proxyIndex, int role) const { return *static_cast<QVariant*>(callbackQAbstractProxyModel_Data(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&proxyIndex), role)); };
bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQAbstractItemModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
void fetchMore(const QModelIndex & parent) { callbackQAbstractItemModel_FetchMore(this, const_cast<QModelIndex*>(&parent)); };
Qt::ItemFlags flags(const QModelIndex & index) const { return static_cast<Qt::ItemFlag>(callbackQAbstractItemModel_Flags(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&index))); };
bool hasChildren(const QModelIndex & parent) const { return callbackQAbstractItemModel_HasChildren(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&parent)) != 0; };
QItemSelection mapSelectionFromSource(const QItemSelection & sourceSelection) const { return *static_cast<QItemSelection*>(callbackQAbstractProxyModel_MapSelectionFromSource(const_cast<void*>(static_cast<const void*>(this)), const_cast<QItemSelection*>(&sourceSelection))); };
QItemSelection mapSelectionToSource(const QItemSelection & proxySelection) const { return *static_cast<QItemSelection*>(callbackQAbstractProxyModel_MapSelectionToSource(const_cast<void*>(static_cast<const void*>(this)), const_cast<QItemSelection*>(&proxySelection))); };
QMimeData * mimeData(const QModelIndexList & indexes) const { return static_cast<QMimeData*>(callbackQAbstractItemModel_MimeData(const_cast<void*>(static_cast<const void*>(this)), ({ QList<QModelIndex>* tmpValuee0adf2 = new QList<QModelIndex>(indexes); QtCore_PackedList { tmpValuee0adf2, tmpValuee0adf2->size() }; }))); };
QStringList mimeTypes() const { return ({ QtCore_PackedString tempVal = callbackQAbstractItemModel_MimeTypes(const_cast<void*>(static_cast<const void*>(this))); QStringList ret = QString::fromUtf8(tempVal.data, tempVal.len).split("¡¦!", QString::SkipEmptyParts); free(tempVal.data); ret; }); };
void resetInternalData() { callbackQAbstractItemModel_ResetInternalData(this); };
void revert() { callbackQAbstractProxyModel_Revert(this); };
bool setData(const QModelIndex & index, const QVariant & value, int role) { return callbackQAbstractItemModel_SetData(this, const_cast<QModelIndex*>(&index), const_cast<QVariant*>(&value), role) != 0; };
QModelIndex sibling(int row, int column, const QModelIndex & idx) const { return *static_cast<QModelIndex*>(callbackQAbstractItemModel_Sibling(const_cast<void*>(static_cast<const void*>(this)), row, column, const_cast<QModelIndex*>(&idx))); };
void Signal_SourceModelChanged() { callbackQAbstractProxyModel_SourceModelChanged(this); };
bool submit() { return callbackQAbstractProxyModel_Submit(this) != 0; };
Qt::DropActions supportedDragActions() const { return static_cast<Qt::DropAction>(callbackQAbstractItemModel_SupportedDragActions(const_cast<void*>(static_cast<const void*>(this)))); };
Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQAbstractItemModel_SupportedDropActions(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ColumnsAboutToBeInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationColumn) { callbackQAbstractItemModel_ColumnsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationColumn); };
void Signal_ColumnsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_ColumnsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int column) { callbackQAbstractItemModel_ColumnsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), column); };
void Signal_ColumnsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_ColumnsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_DataChanged(const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles) { callbackQAbstractItemModel_DataChanged(this, const_cast<QModelIndex*>(&topLeft), const_cast<QModelIndex*>(&bottomRight), ({ QVector<int>* tmpValue037c88 = new QVector<int>(roles); QtCore_PackedList { tmpValue037c88, tmpValue037c88->size() }; })); };
void Signal_HeaderDataChanged(Qt::Orientation orientation, int first, int last) { callbackQAbstractItemModel_HeaderDataChanged(this, orientation, first, last); };
void Signal_LayoutAboutToBeChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQAbstractItemModel_LayoutAboutToBeChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtCore_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
void Signal_LayoutChanged(const QList<QPersistentModelIndex> & parents, QAbstractItemModel::LayoutChangeHint hint) { callbackQAbstractItemModel_LayoutChanged(this, ({ QList<QPersistentModelIndex>* tmpValuea664f1 = new QList<QPersistentModelIndex>(parents); QtCore_PackedList { tmpValuea664f1, tmpValuea664f1->size() }; }), hint); };
QList<QModelIndex> match(const QModelIndex & start, int role, const QVariant & value, int hits, Qt::MatchFlags flags) const { return ({ QList<QModelIndex>* tmpP = static_cast<QList<QModelIndex>*>(callbackQAbstractItemModel_Match(const_cast<void*>(static_cast<const void*>(this)), const_cast<QModelIndex*>(&start), role, const_cast<QVariant*>(&value), hits, flags)); QList<QModelIndex> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }); };
void Signal_ModelAboutToBeReset() { callbackQAbstractItemModel_ModelAboutToBeReset(this); };
void Signal_ModelReset() { callbackQAbstractItemModel_ModelReset(this); };
QHash<int, QByteArray> roleNames() const { return ({ QHash<int, QByteArray>* tmpP = static_cast<QHash<int, QByteArray>*>(callbackQAbstractItemModel_RoleNames(const_cast<void*>(static_cast<const void*>(this)))); QHash<int, QByteArray> tmpV = *tmpP; tmpP->~QHash(); free(tmpP); tmpV; }); };
void Signal_RowsAboutToBeInserted(const QModelIndex & parent, int start, int end) { callbackQAbstractItemModel_RowsAboutToBeInserted(this, const_cast<QModelIndex*>(&parent), start, end); };
void Signal_RowsAboutToBeMoved(const QModelIndex & sourceParent, int sourceStart, int sourceEnd, const QModelIndex & destinationParent, int destinationRow) { callbackQAbstractItemModel_RowsAboutToBeMoved(this, const_cast<QModelIndex*>(&sourceParent), sourceStart, sourceEnd, const_cast<QModelIndex*>(&destinationParent), destinationRow); };
void Signal_RowsAboutToBeRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsAboutToBeRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsInserted(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsInserted(this, const_cast<QModelIndex*>(&parent), first, last); };
void Signal_RowsMoved(const QModelIndex & parent, int start, int end, const QModelIndex & destination, int row) { callbackQAbstractItemModel_RowsMoved(this, const_cast<QModelIndex*>(&parent), start, end, const_cast<QModelIndex*>(&destination), row); };
void Signal_RowsRemoved(const QModelIndex & parent, int first, int last) { callbackQAbstractItemModel_RowsRemoved(this, const_cast<QModelIndex*>(&parent), first, last); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QTransposeProxyModel*)
Q_DECLARE_METATYPE(MyQTransposeProxyModel*)
int QTransposeProxyModel_QTransposeProxyModel_QRegisterMetaType(){qRegisterMetaType<QTransposeProxyModel*>(); return qRegisterMetaType<MyQTransposeProxyModel*>();}
void* QTransposeProxyModel_NewQTransposeProxyModel2(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQTransposeProxyModel(static_cast<QWindow*>(parent));
} else {
return new MyQTransposeProxyModel(static_cast<QObject*>(parent));
}
}
int QTransposeProxyModel_ColumnCount(void* ptr, void* parent)
{
return static_cast<QTransposeProxyModel*>(ptr)->columnCount(*static_cast<QModelIndex*>(parent));
}
int QTransposeProxyModel_ColumnCountDefault(void* ptr, void* parent)
{
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::columnCount(*static_cast<QModelIndex*>(parent));
}
void* QTransposeProxyModel_Index(void* ptr, int row, int column, void* parent)
{
return new QModelIndex(static_cast<QTransposeProxyModel*>(ptr)->index(row, column, *static_cast<QModelIndex*>(parent)));
}
void* QTransposeProxyModel_IndexDefault(void* ptr, int row, int column, void* parent)
{
return new QModelIndex(static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::index(row, column, *static_cast<QModelIndex*>(parent)));
}
void* QTransposeProxyModel_MapFromSource(void* ptr, void* sourceIndex)
{
return new QModelIndex(static_cast<QTransposeProxyModel*>(ptr)->mapFromSource(*static_cast<QModelIndex*>(sourceIndex)));
}
void* QTransposeProxyModel_MapFromSourceDefault(void* ptr, void* sourceIndex)
{
return new QModelIndex(static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::mapFromSource(*static_cast<QModelIndex*>(sourceIndex)));
}
void* QTransposeProxyModel_MapToSource(void* ptr, void* proxyIndex)
{
return new QModelIndex(static_cast<QTransposeProxyModel*>(ptr)->mapToSource(*static_cast<QModelIndex*>(proxyIndex)));
}
void* QTransposeProxyModel_MapToSourceDefault(void* ptr, void* proxyIndex)
{
return new QModelIndex(static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::mapToSource(*static_cast<QModelIndex*>(proxyIndex)));
}
void* QTransposeProxyModel_Parent(void* ptr, void* index)
{
return new QModelIndex(static_cast<QTransposeProxyModel*>(ptr)->parent(*static_cast<QModelIndex*>(index)));
}
void* QTransposeProxyModel_ParentDefault(void* ptr, void* index)
{
return new QModelIndex(static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::parent(*static_cast<QModelIndex*>(index)));
}
int QTransposeProxyModel_RowCount(void* ptr, void* parent)
{
return static_cast<QTransposeProxyModel*>(ptr)->rowCount(*static_cast<QModelIndex*>(parent));
}
int QTransposeProxyModel_RowCountDefault(void* ptr, void* parent)
{
return static_cast<QTransposeProxyModel*>(ptr)->QTransposeProxyModel::rowCount(*static_cast<QModelIndex*>(parent));
}
void QTransposeProxyModel_DestroyQTransposeProxyModel(void* ptr)
{
static_cast<QTransposeProxyModel*>(ptr)->~QTransposeProxyModel();
}
void QTransposeProxyModel_DestroyQTransposeProxyModelDefault(void* ptr)
{
Q_UNUSED(ptr);
}
class MyQUnhandledException: public QUnhandledException
{
public:
};
Q_DECLARE_METATYPE(QUnhandledException*)
Q_DECLARE_METATYPE(MyQUnhandledException*)
int QUnhandledException_QUnhandledException_QRegisterMetaType(){qRegisterMetaType<QUnhandledException*>(); return qRegisterMetaType<MyQUnhandledException*>();}
Q_DECLARE_METATYPE(QUrl)
Q_DECLARE_METATYPE(QUrl*)
void* QUrl_NewQUrl()
{
return new QUrl();
}
void* QUrl_NewQUrl2(void* other)
{
return new QUrl(*static_cast<QUrl*>(other));
}
void* QUrl_NewQUrl3(struct QtCore_PackedString url, long long parsingMode)
{
return new QUrl(QString::fromUtf8(url.data, url.len), static_cast<QUrl::ParsingMode>(parsingMode));
}
void* QUrl_NewQUrl4(void* other)
{
return new QUrl(*static_cast<QUrl*>(other));
}
void* QUrl_Adjusted(void* ptr, long long options)
{
return new QUrl(static_cast<QUrl*>(ptr)->adjusted(static_cast<QUrl::UrlFormattingOption>(options)));
}
struct QtCore_PackedString QUrl_Authority(void* ptr, long long options)
{
return ({ QByteArray* t5a26fa = new QByteArray(static_cast<QUrl*>(ptr)->authority(static_cast<QUrl::ComponentFormattingOption>(options)).toUtf8()); QtCore_PackedString { const_cast<char*>(t5a26fa->prepend("WHITESPACE").constData()+10), t5a26fa->size()-10, t5a26fa }; });
}
void QUrl_Clear(void* ptr)
{
static_cast<QUrl*>(ptr)->clear();
}
struct QtCore_PackedString QUrl_ErrorString(void* ptr)
{
return ({ QByteArray* t35c6dc = new QByteArray(static_cast<QUrl*>(ptr)->errorString().toUtf8()); QtCore_PackedString { const_cast<char*>(t35c6dc->prepend("WHITESPACE").constData()+10), t35c6dc->size()-10, t35c6dc }; });
}
struct QtCore_PackedString QUrl_FileName(void* ptr, long long options)
{
return ({ QByteArray* t4c468f = new QByteArray(static_cast<QUrl*>(ptr)->fileName(static_cast<QUrl::ComponentFormattingOption>(options)).toUtf8()); QtCore_PackedString { const_cast<char*>(t4c468f->prepend("WHITESPACE").constData()+10), t4c468f->size()-10, t4c468f }; });
}
struct QtCore_PackedString QUrl_Fragment(void* ptr, long long options)
{
return ({ QByteArray* t754185 = new QByteArray(static_cast<QUrl*>(ptr)->fragment(static_cast<QUrl::ComponentFormattingOption>(options)).toUtf8()); QtCore_PackedString { const_cast<char*>(t754185->prepend("WHITESPACE").constData()+10), t754185->size()-10, t754185 }; });
}
struct QtCore_PackedString QUrl_QUrl_FromAce(void* domain)
{
return ({ QByteArray* t0cf8b9 = new QByteArray(QUrl::fromAce(*static_cast<QByteArray*>(domain)).toUtf8()); QtCore_PackedString { const_cast<char*>(t0cf8b9->prepend("WHITESPACE").constData()+10), t0cf8b9->size()-10, t0cf8b9 }; });
}
void* QUrl_QUrl_FromEncoded(void* input, long long parsingMode)
{
return new QUrl(QUrl::fromEncoded(*static_cast<QByteArray*>(input), static_cast<QUrl::ParsingMode>(parsingMode)));
}
void* QUrl_QUrl_FromLocalFile(struct QtCore_PackedString localFile)
{
return new QUrl(QUrl::fromLocalFile(QString::fromUtf8(localFile.data, localFile.len)));
}
struct QtCore_PackedString QUrl_QUrl_FromPercentEncoding(void* input)
{
return ({ QByteArray* t95c42a = new QByteArray(QUrl::fromPercentEncoding(*static_cast<QByteArray*>(input)).toUtf8()); QtCore_PackedString { const_cast<char*>(t95c42a->prepend("WHITESPACE").constData()+10), t95c42a->size()-10, t95c42a }; });
}
struct QtCore_PackedList QUrl_QUrl_FromStringList(struct QtCore_PackedString urls, long long mode)
{
return ({ QList<QUrl>* tmpValue5751dc = new QList<QUrl>(QUrl::fromStringList(QString::fromUtf8(urls.data, urls.len).split("¡¦!", QString::SkipEmptyParts), static_cast<QUrl::ParsingMode>(mode))); QtCore_PackedList { tmpValue5751dc, tmpValue5751dc->size() }; });
}
void* QUrl_QUrl_FromUserInput(struct QtCore_PackedString userInput)
{
return new QUrl(QUrl::fromUserInput(QString::fromUtf8(userInput.data, userInput.len)));
}
void* QUrl_QUrl_FromUserInput2(struct QtCore_PackedString userInput, struct QtCore_PackedString workingDirectory, long long options)
{
return new QUrl(QUrl::fromUserInput(QString::fromUtf8(userInput.data, userInput.len), QString::fromUtf8(workingDirectory.data, workingDirectory.len), static_cast<QUrl::UserInputResolutionOption>(options)));
}
char QUrl_HasFragment(void* ptr)
{
return static_cast<QUrl*>(ptr)->hasFragment();
}
char QUrl_HasQuery(void* ptr)
{
return static_cast<QUrl*>(ptr)->hasQuery();
}
struct QtCore_PackedString QUrl_Host(void* ptr, long long options)
{
return ({ QByteArray* tf93546 = new QByteArray(static_cast<QUrl*>(ptr)->host(static_cast<QUrl::ComponentFormattingOption>(options)).toUtf8()); QtCore_PackedString { const_cast<char*>(tf93546->prepend("WHITESPACE").constData()+10), tf93546->size()-10, tf93546 }; });
}
struct QtCore_PackedString QUrl_QUrl_IdnWhitelist()
{
return ({ QByteArray* t7d801d = new QByteArray(QUrl::idnWhitelist().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(t7d801d->prepend("WHITESPACE").constData()+10), t7d801d->size()-10, t7d801d }; });
}
char QUrl_IsEmpty(void* ptr)
{
return static_cast<QUrl*>(ptr)->isEmpty();
}
char QUrl_IsLocalFile(void* ptr)
{
return static_cast<QUrl*>(ptr)->isLocalFile();
}
char QUrl_IsParentOf(void* ptr, void* childUrl)
{
return static_cast<QUrl*>(ptr)->isParentOf(*static_cast<QUrl*>(childUrl));
}
char QUrl_IsRelative(void* ptr)
{
return static_cast<QUrl*>(ptr)->isRelative();
}
char QUrl_IsValid(void* ptr)
{
return static_cast<QUrl*>(ptr)->isValid();
}
char QUrl_Matches(void* ptr, void* url, long long options)
{
return static_cast<QUrl*>(ptr)->matches(*static_cast<QUrl*>(url), static_cast<QUrl::UrlFormattingOption>(options));
}
struct QtCore_PackedString QUrl_Password(void* ptr, long long options)
{
return ({ QByteArray* t55f068 = new QByteArray(static_cast<QUrl*>(ptr)->password(static_cast<QUrl::ComponentFormattingOption>(options)).toUtf8()); QtCore_PackedString { const_cast<char*>(t55f068->prepend("WHITESPACE").constData()+10), t55f068->size()-10, t55f068 }; });
}
struct QtCore_PackedString QUrl_Path(void* ptr, long long options)
{
return ({ QByteArray* t70ef65 = new QByteArray(static_cast<QUrl*>(ptr)->path(static_cast<QUrl::ComponentFormattingOption>(options)).toUtf8()); QtCore_PackedString { const_cast<char*>(t70ef65->prepend("WHITESPACE").constData()+10), t70ef65->size()-10, t70ef65 }; });
}
int QUrl_Port(void* ptr, int defaultPort)
{
return static_cast<QUrl*>(ptr)->port(defaultPort);
}
struct QtCore_PackedString QUrl_Query(void* ptr, long long options)
{
return ({ QByteArray* t911c73 = new QByteArray(static_cast<QUrl*>(ptr)->query(static_cast<QUrl::ComponentFormattingOption>(options)).toUtf8()); QtCore_PackedString { const_cast<char*>(t911c73->prepend("WHITESPACE").constData()+10), t911c73->size()-10, t911c73 }; });
}
void* QUrl_Resolved(void* ptr, void* relative)
{
return new QUrl(static_cast<QUrl*>(ptr)->resolved(*static_cast<QUrl*>(relative)));
}
struct QtCore_PackedString QUrl_Scheme(void* ptr)
{
return ({ QByteArray* t862954 = new QByteArray(static_cast<QUrl*>(ptr)->scheme().toUtf8()); QtCore_PackedString { const_cast<char*>(t862954->prepend("WHITESPACE").constData()+10), t862954->size()-10, t862954 }; });
}
void QUrl_SetAuthority(void* ptr, struct QtCore_PackedString authority, long long mode)
{
static_cast<QUrl*>(ptr)->setAuthority(QString::fromUtf8(authority.data, authority.len), static_cast<QUrl::ParsingMode>(mode));
}
void QUrl_SetFragment(void* ptr, struct QtCore_PackedString fragment, long long mode)
{
static_cast<QUrl*>(ptr)->setFragment(QString::fromUtf8(fragment.data, fragment.len), static_cast<QUrl::ParsingMode>(mode));
}
void QUrl_SetHost(void* ptr, struct QtCore_PackedString host, long long mode)
{
static_cast<QUrl*>(ptr)->setHost(QString::fromUtf8(host.data, host.len), static_cast<QUrl::ParsingMode>(mode));
}
void QUrl_QUrl_SetIdnWhitelist(struct QtCore_PackedString list)
{
QUrl::setIdnWhitelist(QString::fromUtf8(list.data, list.len).split("¡¦!", QString::SkipEmptyParts));
}
void QUrl_SetPassword(void* ptr, struct QtCore_PackedString password, long long mode)
{
static_cast<QUrl*>(ptr)->setPassword(QString::fromUtf8(password.data, password.len), static_cast<QUrl::ParsingMode>(mode));
}
void QUrl_SetPath(void* ptr, struct QtCore_PackedString path, long long mode)
{
static_cast<QUrl*>(ptr)->setPath(QString::fromUtf8(path.data, path.len), static_cast<QUrl::ParsingMode>(mode));
}
void QUrl_SetPort(void* ptr, int port)
{
static_cast<QUrl*>(ptr)->setPort(port);
}
void QUrl_SetQuery(void* ptr, struct QtCore_PackedString query, long long mode)
{
static_cast<QUrl*>(ptr)->setQuery(QString::fromUtf8(query.data, query.len), static_cast<QUrl::ParsingMode>(mode));
}
void QUrl_SetQuery2(void* ptr, void* query)
{
static_cast<QUrl*>(ptr)->setQuery(*static_cast<QUrlQuery*>(query));
}
void QUrl_SetScheme(void* ptr, struct QtCore_PackedString scheme)
{
static_cast<QUrl*>(ptr)->setScheme(QString::fromUtf8(scheme.data, scheme.len));
}
void QUrl_SetUrl(void* ptr, struct QtCore_PackedString url, long long parsingMode)
{
static_cast<QUrl*>(ptr)->setUrl(QString::fromUtf8(url.data, url.len), static_cast<QUrl::ParsingMode>(parsingMode));
}
void QUrl_SetUserInfo(void* ptr, struct QtCore_PackedString userInfo, long long mode)
{
static_cast<QUrl*>(ptr)->setUserInfo(QString::fromUtf8(userInfo.data, userInfo.len), static_cast<QUrl::ParsingMode>(mode));
}
void QUrl_SetUserName(void* ptr, struct QtCore_PackedString userName, long long mode)
{
static_cast<QUrl*>(ptr)->setUserName(QString::fromUtf8(userName.data, userName.len), static_cast<QUrl::ParsingMode>(mode));
}
void QUrl_Swap(void* ptr, void* other)
{
static_cast<QUrl*>(ptr)->swap(*static_cast<QUrl*>(other));
}
void* QUrl_QUrl_ToAce(struct QtCore_PackedString domain)
{
return new QByteArray(QUrl::toAce(QString::fromUtf8(domain.data, domain.len)));
}
struct QtCore_PackedString QUrl_ToDisplayString(void* ptr, long long options)
{
return ({ QByteArray* tb72fa5 = new QByteArray(static_cast<QUrl*>(ptr)->toDisplayString(static_cast<QUrl::UrlFormattingOption>(options)).toUtf8()); QtCore_PackedString { const_cast<char*>(tb72fa5->prepend("WHITESPACE").constData()+10), tb72fa5->size()-10, tb72fa5 }; });
}
void* QUrl_ToEncoded(void* ptr, long long options)
{
return new QByteArray(static_cast<QUrl*>(ptr)->toEncoded(static_cast<QUrl::UrlFormattingOption>(options)));
}
struct QtCore_PackedString QUrl_ToLocalFile(void* ptr)
{
return ({ QByteArray* tdd5812 = new QByteArray(static_cast<QUrl*>(ptr)->toLocalFile().toUtf8()); QtCore_PackedString { const_cast<char*>(tdd5812->prepend("WHITESPACE").constData()+10), tdd5812->size()-10, tdd5812 }; });
}
void* QUrl_QUrl_ToPercentEncoding(struct QtCore_PackedString input, void* exclude, void* include)
{
return new QByteArray(QUrl::toPercentEncoding(QString::fromUtf8(input.data, input.len), *static_cast<QByteArray*>(exclude), *static_cast<QByteArray*>(include)));
}
struct QtCore_PackedString QUrl_ToString(void* ptr, long long options)
{
return ({ QByteArray* tc0d7b7 = new QByteArray(static_cast<QUrl*>(ptr)->toString(static_cast<QUrl::UrlFormattingOption>(options)).toUtf8()); QtCore_PackedString { const_cast<char*>(tc0d7b7->prepend("WHITESPACE").constData()+10), tc0d7b7->size()-10, tc0d7b7 }; });
}
struct QtCore_PackedString QUrl_QUrl_ToStringList(void* urls, long long options)
{
return ({ QByteArray* tc32440 = new QByteArray(QUrl::toStringList(*static_cast<QList<QUrl>*>(urls), static_cast<QUrl::UrlFormattingOption>(options)).join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tc32440->prepend("WHITESPACE").constData()+10), tc32440->size()-10, tc32440 }; });
}
struct QtCore_PackedString QUrl_TopLevelDomain(void* ptr, long long options)
{
return ({ QByteArray* t06da8f = new QByteArray(static_cast<QUrl*>(ptr)->topLevelDomain(static_cast<QUrl::ComponentFormattingOption>(options)).toUtf8()); QtCore_PackedString { const_cast<char*>(t06da8f->prepend("WHITESPACE").constData()+10), t06da8f->size()-10, t06da8f }; });
}
struct QtCore_PackedString QUrl_Url(void* ptr, long long options)
{
return ({ QByteArray* t2ea726 = new QByteArray(static_cast<QUrl*>(ptr)->url(static_cast<QUrl::UrlFormattingOption>(options)).toUtf8()); QtCore_PackedString { const_cast<char*>(t2ea726->prepend("WHITESPACE").constData()+10), t2ea726->size()-10, t2ea726 }; });
}
struct QtCore_PackedString QUrl_UserInfo(void* ptr, long long options)
{
return ({ QByteArray* tff62a1 = new QByteArray(static_cast<QUrl*>(ptr)->userInfo(static_cast<QUrl::ComponentFormattingOption>(options)).toUtf8()); QtCore_PackedString { const_cast<char*>(tff62a1->prepend("WHITESPACE").constData()+10), tff62a1->size()-10, tff62a1 }; });
}
struct QtCore_PackedString QUrl_UserName(void* ptr, long long options)
{
return ({ QByteArray* tb9c277 = new QByteArray(static_cast<QUrl*>(ptr)->userName(static_cast<QUrl::ComponentFormattingOption>(options)).toUtf8()); QtCore_PackedString { const_cast<char*>(tb9c277->prepend("WHITESPACE").constData()+10), tb9c277->size()-10, tb9c277 }; });
}
void QUrl_DestroyQUrl(void* ptr)
{
static_cast<QUrl*>(ptr)->~QUrl();
}
void* QUrl___allEncodedQueryItemValues_atList(void* ptr, int i)
{
return new QByteArray(({QByteArray tmp = static_cast<QList<QByteArray>*>(ptr)->at(i); if (i == static_cast<QList<QByteArray>*>(ptr)->size()-1) { static_cast<QList<QByteArray>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QUrl___allEncodedQueryItemValues_setList(void* ptr, void* i)
{
static_cast<QList<QByteArray>*>(ptr)->append(*static_cast<QByteArray*>(i));
}
void* QUrl___allEncodedQueryItemValues_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QByteArray>();
}
void* QUrl___fromStringList_atList(void* ptr, int i)
{
return new QUrl(({QUrl tmp = static_cast<QList<QUrl>*>(ptr)->at(i); if (i == static_cast<QList<QUrl>*>(ptr)->size()-1) { static_cast<QList<QUrl>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QUrl___fromStringList_setList(void* ptr, void* i)
{
static_cast<QList<QUrl>*>(ptr)->append(*static_cast<QUrl*>(i));
}
void* QUrl___fromStringList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QUrl>();
}
void* QUrl___toStringList_urls_atList(void* ptr, int i)
{
return new QUrl(({QUrl tmp = static_cast<QList<QUrl>*>(ptr)->at(i); if (i == static_cast<QList<QUrl>*>(ptr)->size()-1) { static_cast<QList<QUrl>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QUrl___toStringList_urls_setList(void* ptr, void* i)
{
static_cast<QList<QUrl>*>(ptr)->append(*static_cast<QUrl*>(i));
}
void* QUrl___toStringList_urls_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QUrl>();
}
Q_DECLARE_METATYPE(QUrlQuery)
Q_DECLARE_METATYPE(QUrlQuery*)
void* QUrlQuery_NewQUrlQuery()
{
return new QUrlQuery();
}
void* QUrlQuery_NewQUrlQuery2(void* url)
{
return new QUrlQuery(*static_cast<QUrl*>(url));
}
void* QUrlQuery_NewQUrlQuery3(struct QtCore_PackedString queryString)
{
return new QUrlQuery(QString::fromUtf8(queryString.data, queryString.len));
}
void* QUrlQuery_NewQUrlQuery5(void* other)
{
return new QUrlQuery(*static_cast<QUrlQuery*>(other));
}
void QUrlQuery_AddQueryItem(void* ptr, struct QtCore_PackedString key, struct QtCore_PackedString value)
{
static_cast<QUrlQuery*>(ptr)->addQueryItem(QString::fromUtf8(key.data, key.len), QString::fromUtf8(value.data, value.len));
}
struct QtCore_PackedString QUrlQuery_AllQueryItemValues(void* ptr, struct QtCore_PackedString key, long long encoding)
{
return ({ QByteArray* tad6e07 = new QByteArray(static_cast<QUrlQuery*>(ptr)->allQueryItemValues(QString::fromUtf8(key.data, key.len), static_cast<QUrl::ComponentFormattingOption>(encoding)).join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tad6e07->prepend("WHITESPACE").constData()+10), tad6e07->size()-10, tad6e07 }; });
}
void QUrlQuery_Clear(void* ptr)
{
static_cast<QUrlQuery*>(ptr)->clear();
}
void* QUrlQuery_QUrlQuery_DefaultQueryPairDelimiter()
{
return new QChar(QUrlQuery::defaultQueryPairDelimiter());
}
void* QUrlQuery_QUrlQuery_DefaultQueryValueDelimiter()
{
return new QChar(QUrlQuery::defaultQueryValueDelimiter());
}
char QUrlQuery_HasQueryItem(void* ptr, struct QtCore_PackedString key)
{
return static_cast<QUrlQuery*>(ptr)->hasQueryItem(QString::fromUtf8(key.data, key.len));
}
char QUrlQuery_IsEmpty(void* ptr)
{
return static_cast<QUrlQuery*>(ptr)->isEmpty();
}
struct QtCore_PackedString QUrlQuery_Query(void* ptr, long long encoding)
{
return ({ QByteArray* tc70807 = new QByteArray(static_cast<QUrlQuery*>(ptr)->query(static_cast<QUrl::ComponentFormattingOption>(encoding)).toUtf8()); QtCore_PackedString { const_cast<char*>(tc70807->prepend("WHITESPACE").constData()+10), tc70807->size()-10, tc70807 }; });
}
struct QtCore_PackedString QUrlQuery_QueryItemValue(void* ptr, struct QtCore_PackedString key, long long encoding)
{
return ({ QByteArray* t5453a9 = new QByteArray(static_cast<QUrlQuery*>(ptr)->queryItemValue(QString::fromUtf8(key.data, key.len), static_cast<QUrl::ComponentFormattingOption>(encoding)).toUtf8()); QtCore_PackedString { const_cast<char*>(t5453a9->prepend("WHITESPACE").constData()+10), t5453a9->size()-10, t5453a9 }; });
}
void* QUrlQuery_QueryPairDelimiter(void* ptr)
{
return new QChar(static_cast<QUrlQuery*>(ptr)->queryPairDelimiter());
}
void* QUrlQuery_QueryValueDelimiter(void* ptr)
{
return new QChar(static_cast<QUrlQuery*>(ptr)->queryValueDelimiter());
}
void QUrlQuery_RemoveAllQueryItems(void* ptr, struct QtCore_PackedString key)
{
static_cast<QUrlQuery*>(ptr)->removeAllQueryItems(QString::fromUtf8(key.data, key.len));
}
void QUrlQuery_RemoveQueryItem(void* ptr, struct QtCore_PackedString key)
{
static_cast<QUrlQuery*>(ptr)->removeQueryItem(QString::fromUtf8(key.data, key.len));
}
void QUrlQuery_SetQuery(void* ptr, struct QtCore_PackedString queryString)
{
static_cast<QUrlQuery*>(ptr)->setQuery(QString::fromUtf8(queryString.data, queryString.len));
}
void QUrlQuery_SetQueryDelimiters(void* ptr, void* valueDelimiter, void* pairDelimiter)
{
static_cast<QUrlQuery*>(ptr)->setQueryDelimiters(*static_cast<QChar*>(valueDelimiter), *static_cast<QChar*>(pairDelimiter));
}
void QUrlQuery_Swap(void* ptr, void* other)
{
static_cast<QUrlQuery*>(ptr)->swap(*static_cast<QUrlQuery*>(other));
}
struct QtCore_PackedString QUrlQuery_ToString(void* ptr, long long encoding)
{
return ({ QByteArray* t13eb00 = new QByteArray(static_cast<QUrlQuery*>(ptr)->toString(static_cast<QUrl::ComponentFormattingOption>(encoding)).toUtf8()); QtCore_PackedString { const_cast<char*>(t13eb00->prepend("WHITESPACE").constData()+10), t13eb00->size()-10, t13eb00 }; });
}
void QUrlQuery_DestroyQUrlQuery(void* ptr)
{
static_cast<QUrlQuery*>(ptr)->~QUrlQuery();
}
Q_DECLARE_METATYPE(QUuid)
Q_DECLARE_METATYPE(QUuid*)
void* QUuid_NewQUuid2()
{
return new QUuid();
}
void* QUuid_NewQUuid3(unsigned int l, unsigned short w1, unsigned short w2, char* b1, char* b2, char* b3, char* b4, char* b5, char* b6, char* b7, char* b8)
{
return new QUuid(l, w1, w2, *static_cast<uchar*>(static_cast<void*>(b1)), *static_cast<uchar*>(static_cast<void*>(b2)), *static_cast<uchar*>(static_cast<void*>(b3)), *static_cast<uchar*>(static_cast<void*>(b4)), *static_cast<uchar*>(static_cast<void*>(b5)), *static_cast<uchar*>(static_cast<void*>(b6)), *static_cast<uchar*>(static_cast<void*>(b7)), *static_cast<uchar*>(static_cast<void*>(b8)));
}
void* QUuid_NewQUuid4(struct QtCore_PackedString text)
{
return new QUuid(QString::fromUtf8(text.data, text.len));
}
void* QUuid_NewQUuid(void* text)
{
return new QUuid(*static_cast<QByteArray*>(text));
}
void* QUuid_QUuid_CreateUuid()
{
return new QUuid(QUuid::createUuid());
}
void* QUuid_QUuid_CreateUuidV3(void* ns, void* baseData)
{
return new QUuid(QUuid::createUuidV3(*static_cast<QUuid*>(ns), *static_cast<QByteArray*>(baseData)));
}
void* QUuid_QUuid_CreateUuidV32(void* ns, struct QtCore_PackedString baseData)
{
return new QUuid(QUuid::createUuidV3(*static_cast<QUuid*>(ns), QString::fromUtf8(baseData.data, baseData.len)));
}
void* QUuid_QUuid_CreateUuidV5(void* ns, void* baseData)
{
return new QUuid(QUuid::createUuidV5(*static_cast<QUuid*>(ns), *static_cast<QByteArray*>(baseData)));
}
void* QUuid_QUuid_CreateUuidV52(void* ns, struct QtCore_PackedString baseData)
{
return new QUuid(QUuid::createUuidV5(*static_cast<QUuid*>(ns), QString::fromUtf8(baseData.data, baseData.len)));
}
void* QUuid_QUuid_FromRfc4122(void* bytes)
{
return new QUuid(QUuid::fromRfc4122(*static_cast<QByteArray*>(bytes)));
}
void* QUuid_QUuid_FromString(void* text)
{
return new QUuid(QUuid::fromString(*static_cast<QStringView*>(text)));
}
void* QUuid_QUuid_FromString2(void* text)
{
return new QUuid(QUuid::fromString(*static_cast<QLatin1String*>(text)));
}
char QUuid_IsNull(void* ptr)
{
return static_cast<QUuid*>(ptr)->isNull();
}
void* QUuid_ToByteArray(void* ptr)
{
return new QByteArray(static_cast<QUuid*>(ptr)->toByteArray());
}
void* QUuid_ToByteArray2(void* ptr, long long mode)
{
return new QByteArray(static_cast<QUuid*>(ptr)->toByteArray(static_cast<QUuid::StringFormat>(mode)));
}
void* QUuid_ToRfc4122(void* ptr)
{
return new QByteArray(static_cast<QUuid*>(ptr)->toRfc4122());
}
struct QtCore_PackedString QUuid_ToString(void* ptr)
{
return ({ QByteArray* t6f28ec = new QByteArray(static_cast<QUuid*>(ptr)->toString().toUtf8()); QtCore_PackedString { const_cast<char*>(t6f28ec->prepend("WHITESPACE").constData()+10), t6f28ec->size()-10, t6f28ec }; });
}
struct QtCore_PackedString QUuid_ToString2(void* ptr, long long mode)
{
return ({ QByteArray* taf9869 = new QByteArray(static_cast<QUuid*>(ptr)->toString(static_cast<QUuid::StringFormat>(mode)).toUtf8()); QtCore_PackedString { const_cast<char*>(taf9869->prepend("WHITESPACE").constData()+10), taf9869->size()-10, taf9869 }; });
}
long long QUuid_Variant(void* ptr)
{
return static_cast<QUuid*>(ptr)->variant();
}
long long QUuid_Version(void* ptr)
{
return static_cast<QUuid*>(ptr)->version();
}
Q_DECLARE_METATYPE(QVariant*)
void* QVariant_NewQVariant()
{
return new QVariant();
}
void* QVariant_NewQVariant2(long long ty)
{
return new QVariant(static_cast<QVariant::Type>(ty));
}
void* QVariant_NewQVariant3(int typeId, void* copy)
{
return new QVariant(typeId, copy);
}
void* QVariant_NewQVariant4(void* s)
{
return new QVariant(*static_cast<QDataStream*>(s));
}
void* QVariant_NewQVariant5(int val)
{
return new QVariant(val);
}
void* QVariant_NewQVariant6(unsigned int val)
{
return new QVariant(val);
}
void* QVariant_NewQVariant7(long long val)
{
return new QVariant(val);
}
void* QVariant_NewQVariant8(unsigned long long val)
{
return new QVariant(val);
}
void* QVariant_NewQVariant9(char val)
{
return new QVariant(val != 0);
}
void* QVariant_NewQVariant10(double val)
{
return new QVariant(val);
}
void* QVariant_NewQVariant11(float val)
{
return new QVariant(val);
}
void* QVariant_NewQVariant12(char* val)
{
return new QVariant(const_cast<const char*>(val));
}
void* QVariant_NewQVariant13(void* val)
{
return new QVariant(*static_cast<QByteArray*>(val));
}
void* QVariant_NewQVariant14(void* val)
{
return new QVariant(*static_cast<QBitArray*>(val));
}
void* QVariant_NewQVariant15(struct QtCore_PackedString val)
{
return new QVariant(QString::fromUtf8(val.data, val.len));
}
void* QVariant_NewQVariant16(void* val)
{
return new QVariant(*static_cast<QLatin1String*>(val));
}
void* QVariant_NewQVariant17(struct QtCore_PackedString val)
{
return new QVariant(QString::fromUtf8(val.data, val.len).split("¡¦!", QString::SkipEmptyParts));
}
void* QVariant_NewQVariant18(void* c)
{
return new QVariant(*static_cast<QChar*>(c));
}
void* QVariant_NewQVariant19(void* val)
{
return new QVariant(*static_cast<QDate*>(val));
}
void* QVariant_NewQVariant20(void* val)
{
return new QVariant(*static_cast<QTime*>(val));
}
void* QVariant_NewQVariant21(void* val)
{
return new QVariant(*static_cast<QDateTime*>(val));
}
void* QVariant_NewQVariant22(void* val)
{
return new QVariant(({ QList<QVariant>* tmpP = static_cast<QList<QVariant>*>(val); QList<QVariant> tmpV = *tmpP; tmpP->~QList(); free(tmpP); tmpV; }));
}
void* QVariant_NewQVariant23(void* val)
{
return new QVariant(({ QMap<QString, QVariant>* tmpP = static_cast<QMap<QString, QVariant>*>(val); QMap<QString, QVariant> tmpV = *tmpP; tmpP->~QMap(); free(tmpP); tmpV; }));
}
void* QVariant_NewQVariant24(void* val)
{
return new QVariant(({ QHash<QString, QVariant>* tmpP = static_cast<QHash<QString, QVariant>*>(val); QHash<QString, QVariant> tmpV = *tmpP; tmpP->~QHash(); free(tmpP); tmpV; }));
}
void* QVariant_NewQVariant25(void* val)
{
return new QVariant(*static_cast<QSize*>(val));
}
void* QVariant_NewQVariant26(void* val)
{
return new QVariant(*static_cast<QSizeF*>(val));
}
void* QVariant_NewQVariant27(void* val)
{
return new QVariant(*static_cast<QPoint*>(val));
}
void* QVariant_NewQVariant28(void* val)
{
return new QVariant(*static_cast<QPointF*>(val));
}
void* QVariant_NewQVariant29(void* val)
{
return new QVariant(*static_cast<QLine*>(val));
}
void* QVariant_NewQVariant30(void* val)
{
return new QVariant(*static_cast<QLineF*>(val));
}
void* QVariant_NewQVariant31(void* val)
{
return new QVariant(*static_cast<QRect*>(val));
}
void* QVariant_NewQVariant32(void* val)
{
return new QVariant(*static_cast<QRectF*>(val));
}
void* QVariant_NewQVariant33(void* l)
{
return new QVariant(*static_cast<QLocale*>(l));
}
void* QVariant_NewQVariant34(void* regExp)
{
return new QVariant(*static_cast<QRegExp*>(regExp));
}
void* QVariant_NewQVariant35(void* re)
{
return new QVariant(*static_cast<QRegularExpression*>(re));
}
void* QVariant_NewQVariant36(void* val)
{
return new QVariant(*static_cast<QUrl*>(val));
}
void* QVariant_NewQVariant37(void* val)
{
return new QVariant(*static_cast<QEasingCurve*>(val));
}
void* QVariant_NewQVariant38(void* val)
{
return new QVariant(*static_cast<QUuid*>(val));
}
void* QVariant_NewQVariant39(void* val)
{
return new QVariant(*static_cast<QJsonValue*>(val));
}
void* QVariant_NewQVariant40(void* val)
{
return new QVariant(*static_cast<QJsonObject*>(val));
}
void* QVariant_NewQVariant41(void* val)
{
return new QVariant(*static_cast<QJsonArray*>(val));
}
void* QVariant_NewQVariant42(void* val)
{
return new QVariant(*static_cast<QJsonDocument*>(val));
}
void* QVariant_NewQVariant43(void* val)
{
return new QVariant(*static_cast<QModelIndex*>(val));
}
void* QVariant_NewQVariant44(void* val)
{
return new QVariant(*static_cast<QPersistentModelIndex*>(val));
}
void* QVariant_NewQVariant45(void* other)
{
return new QVariant(*static_cast<QVariant*>(other));
}
char QVariant_CanConvert(void* ptr, int targetTypeId)
{
return static_cast<QVariant*>(ptr)->canConvert(targetTypeId);
}
void QVariant_Clear(void* ptr)
{
static_cast<QVariant*>(ptr)->clear();
}
char QVariant_Convert(void* ptr, int targetTypeId)
{
return static_cast<QVariant*>(ptr)->convert(targetTypeId);
}
char QVariant_IsNull(void* ptr)
{
return static_cast<QVariant*>(ptr)->isNull();
}
char QVariant_IsValid(void* ptr)
{
return static_cast<QVariant*>(ptr)->isValid();
}
long long QVariant_QVariant_NameToType(char* name)
{
return QVariant::nameToType(const_cast<const char*>(name));
}
void QVariant_Swap(void* ptr, void* other)
{
static_cast<QVariant*>(ptr)->swap(*static_cast<QVariant*>(other));
}
void* QVariant_ToBitArray(void* ptr)
{
return new QBitArray(static_cast<QVariant*>(ptr)->toBitArray());
}
char QVariant_ToBool(void* ptr)
{
return static_cast<QVariant*>(ptr)->toBool();
}
void* QVariant_ToByteArray(void* ptr)
{
return new QByteArray(static_cast<QVariant*>(ptr)->toByteArray());
}
void* QVariant_ToChar(void* ptr)
{
return new QChar(static_cast<QVariant*>(ptr)->toChar());
}
void* QVariant_ToDate(void* ptr)
{
return new QDate(static_cast<QVariant*>(ptr)->toDate());
}
void* QVariant_ToDateTime(void* ptr)
{
return new QDateTime(static_cast<QVariant*>(ptr)->toDateTime());
}
double QVariant_ToDouble(void* ptr, char* ok)
{
return static_cast<QVariant*>(ptr)->toDouble(reinterpret_cast<bool*>(ok));
}
void* QVariant_ToEasingCurve(void* ptr)
{
return new QEasingCurve(static_cast<QVariant*>(ptr)->toEasingCurve());
}
float QVariant_ToFloat(void* ptr, char* ok)
{
return static_cast<QVariant*>(ptr)->toFloat(reinterpret_cast<bool*>(ok));
}
struct QtCore_PackedList QVariant_ToHash(void* ptr)
{
return ({ QHash<QString, QVariant>* tmpValue00701e = new QHash<QString, QVariant>(static_cast<QVariant*>(ptr)->toHash()); QtCore_PackedList { tmpValue00701e, tmpValue00701e->size() }; });
}
int QVariant_ToInt(void* ptr, char* ok)
{
return static_cast<QVariant*>(ptr)->toInt(reinterpret_cast<bool*>(ok));
}
void* QVariant_ToJsonArray(void* ptr)
{
return new QJsonArray(static_cast<QVariant*>(ptr)->toJsonArray());
}
void* QVariant_ToJsonDocument(void* ptr)
{
return new QJsonDocument(static_cast<QVariant*>(ptr)->toJsonDocument());
}
void* QVariant_ToJsonObject(void* ptr)
{
return new QJsonObject(static_cast<QVariant*>(ptr)->toJsonObject());
}
void* QVariant_ToJsonValue(void* ptr)
{
return new QJsonValue(static_cast<QVariant*>(ptr)->toJsonValue());
}
void* QVariant_ToLine(void* ptr)
{
return ({ QLine tmpValue = static_cast<QVariant*>(ptr)->toLine(); new QLine(tmpValue.p1(), tmpValue.p2()); });
}
void* QVariant_ToLineF(void* ptr)
{
return ({ QLineF tmpValue = static_cast<QVariant*>(ptr)->toLineF(); new QLineF(tmpValue.p1(), tmpValue.p2()); });
}
struct QtCore_PackedList QVariant_ToList(void* ptr)
{
return ({ QList<QVariant>* tmpValue8f6950 = new QList<QVariant>(static_cast<QVariant*>(ptr)->toList()); QtCore_PackedList { tmpValue8f6950, tmpValue8f6950->size() }; });
}
void* QVariant_ToLocale(void* ptr)
{
return new QLocale(static_cast<QVariant*>(ptr)->toLocale());
}
long long QVariant_ToLongLong(void* ptr, char* ok)
{
return static_cast<QVariant*>(ptr)->toLongLong(reinterpret_cast<bool*>(ok));
}
struct QtCore_PackedList QVariant_ToMap(void* ptr)
{
return ({ QMap<QString, QVariant>* tmpValue1e0d76 = new QMap<QString, QVariant>(static_cast<QVariant*>(ptr)->toMap()); QtCore_PackedList { tmpValue1e0d76, tmpValue1e0d76->size() }; });
}
void* QVariant_ToModelIndex(void* ptr)
{
return new QModelIndex(static_cast<QVariant*>(ptr)->toModelIndex());
}
void* QVariant_ToPersistentModelIndex(void* ptr)
{
return new QPersistentModelIndex(static_cast<QVariant*>(ptr)->toPersistentModelIndex());
}
void* QVariant_ToPoint(void* ptr)
{
return ({ QPoint tmpValue = static_cast<QVariant*>(ptr)->toPoint(); new QPoint(tmpValue.x(), tmpValue.y()); });
}
void* QVariant_ToPointF(void* ptr)
{
return ({ QPointF tmpValue = static_cast<QVariant*>(ptr)->toPointF(); new QPointF(tmpValue.x(), tmpValue.y()); });
}
double QVariant_ToReal(void* ptr, char* ok)
{
return static_cast<QVariant*>(ptr)->toReal(reinterpret_cast<bool*>(ok));
}
void* QVariant_ToRect(void* ptr)
{
return ({ QRect tmpValue = static_cast<QVariant*>(ptr)->toRect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QVariant_ToRectF(void* ptr)
{
return ({ QRectF tmpValue = static_cast<QVariant*>(ptr)->toRectF(); new QRectF(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
void* QVariant_ToRegExp(void* ptr)
{
return new QRegExp(static_cast<QVariant*>(ptr)->toRegExp());
}
void* QVariant_ToRegularExpression(void* ptr)
{
return new QRegularExpression(static_cast<QVariant*>(ptr)->toRegularExpression());
}
void* QVariant_ToSize(void* ptr)
{
return ({ QSize tmpValue = static_cast<QVariant*>(ptr)->toSize(); new QSize(tmpValue.width(), tmpValue.height()); });
}
void* QVariant_ToSizeF(void* ptr)
{
return ({ QSizeF tmpValue = static_cast<QVariant*>(ptr)->toSizeF(); new QSizeF(tmpValue.width(), tmpValue.height()); });
}
struct QtCore_PackedString QVariant_ToString(void* ptr)
{
return ({ QByteArray* tf9e1e4 = new QByteArray(static_cast<QVariant*>(ptr)->toString().toUtf8()); QtCore_PackedString { const_cast<char*>(tf9e1e4->prepend("WHITESPACE").constData()+10), tf9e1e4->size()-10, tf9e1e4 }; });
}
struct QtCore_PackedString QVariant_ToStringList(void* ptr)
{
return ({ QByteArray* tf99cb6 = new QByteArray(static_cast<QVariant*>(ptr)->toStringList().join("¡¦!").toUtf8()); QtCore_PackedString { const_cast<char*>(tf99cb6->prepend("WHITESPACE").constData()+10), tf99cb6->size()-10, tf99cb6 }; });
}
void* QVariant_ToTime(void* ptr)
{
return new QTime(static_cast<QVariant*>(ptr)->toTime());
}
unsigned int QVariant_ToUInt(void* ptr, char* ok)
{
return static_cast<QVariant*>(ptr)->toUInt(reinterpret_cast<bool*>(ok));
}
unsigned long long QVariant_ToULongLong(void* ptr, char* ok)
{
return static_cast<QVariant*>(ptr)->toULongLong(reinterpret_cast<bool*>(ok));
}
void* QVariant_ToUrl(void* ptr)
{
return new QUrl(static_cast<QVariant*>(ptr)->toUrl());
}
void* QVariant_ToUuid(void* ptr)
{
return new QUuid(static_cast<QVariant*>(ptr)->toUuid());
}
long long QVariant_Type(void* ptr)
{
return static_cast<QVariant*>(ptr)->type();
}
struct QtCore_PackedString QVariant_TypeName(void* ptr)
{
return QtCore_PackedString { const_cast<char*>(static_cast<QVariant*>(ptr)->typeName()), -1, NULL };
}
struct QtCore_PackedString QVariant_QVariant_TypeToName(int typeId)
{
return QtCore_PackedString { const_cast<char*>(QVariant::typeToName(typeId)), typeId, NULL };
}
int QVariant_UserType(void* ptr)
{
return static_cast<QVariant*>(ptr)->userType();
}
void QVariant_DestroyQVariant(void* ptr)
{
static_cast<QVariant*>(ptr)->~QVariant();
}
void* QVariant_ToColor(void* ptr)
{
return new QColor(qvariant_cast<QColor>(*static_cast<QVariant*>(ptr)));
}
void* QVariant_ToFont(void* ptr)
{
return new QFont(qvariant_cast<QFont>(*static_cast<QVariant*>(ptr)));
}
void* QVariant_ToImage(void* ptr)
{
return new QImage(qvariant_cast<QImage>(*static_cast<QVariant*>(ptr)));
}
void* QVariant_ToObject(void* ptr)
{
return qvariant_cast<QObject*>(*static_cast<QVariant*>(ptr));
}
void* QVariant_ToIcon(void* ptr)
{
return new QIcon(qvariant_cast<QIcon>(*static_cast<QVariant*>(ptr)));
}
void* QVariant_ToBrush(void* ptr)
{
return new QBrush(qvariant_cast<QBrush>(*static_cast<QVariant*>(ptr)));
}
void* QVariant___QVariant_val_atList22(void* ptr, int i)
{
return new QVariant(({QVariant tmp = static_cast<QList<QVariant>*>(ptr)->at(i); if (i == static_cast<QList<QVariant>*>(ptr)->size()-1) { static_cast<QList<QVariant>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QVariant___QVariant_val_setList22(void* ptr, void* i)
{
static_cast<QList<QVariant>*>(ptr)->append(*static_cast<QVariant*>(i));
}
void* QVariant___QVariant_val_newList22(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QVariant>();
}
void* QVariant___QVariant_val_atList23(void* ptr, struct QtCore_PackedString v, int i)
{
return new QVariant(({ QVariant tmp = static_cast<QMap<QString, QVariant>*>(ptr)->value(QString::fromUtf8(v.data, v.len)); if (i == static_cast<QMap<QString, QVariant>*>(ptr)->size()-1) { static_cast<QMap<QString, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}
void QVariant___QVariant_val_setList23(void* ptr, struct QtCore_PackedString key, void* i)
{
static_cast<QMap<QString, QVariant>*>(ptr)->insert(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(i));
}
void* QVariant___QVariant_val_newList23(void* ptr)
{
Q_UNUSED(ptr);
return new QMap<QString, QVariant>();
}
struct QtCore_PackedList QVariant___QVariant_val_keyList23(void* ptr)
{
return ({ QList<QString>* tmpValue1ab909 = new QList<QString>(static_cast<QMap<QString, QVariant>*>(ptr)->keys()); QtCore_PackedList { tmpValue1ab909, tmpValue1ab909->size() }; });
}
void* QVariant___QVariant_val_atList24(void* ptr, struct QtCore_PackedString v, int i)
{
return new QVariant(({ QVariant tmp = static_cast<QHash<QString, QVariant>*>(ptr)->value(QString::fromUtf8(v.data, v.len)); if (i == static_cast<QHash<QString, QVariant>*>(ptr)->size()-1) { static_cast<QHash<QString, QVariant>*>(ptr)->~QHash(); free(ptr); }; tmp; }));
}
void QVariant___QVariant_val_setList24(void* ptr, struct QtCore_PackedString key, void* i)
{
static_cast<QHash<QString, QVariant>*>(ptr)->insert(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(i));
}
void* QVariant___QVariant_val_newList24(void* ptr)
{
Q_UNUSED(ptr);
return new QHash<QString, QVariant>();
}
struct QtCore_PackedList QVariant___QVariant_val_keyList24(void* ptr)
{
return ({ QList<QString>* tmpValuef43bc5 = new QList<QString>(static_cast<QHash<QString, QVariant>*>(ptr)->keys()); QtCore_PackedList { tmpValuef43bc5, tmpValuef43bc5->size() }; });
}
void* QVariant___toHash_atList(void* ptr, struct QtCore_PackedString v, int i)
{
return new QVariant(({ QVariant tmp = static_cast<QHash<QString, QVariant>*>(ptr)->value(QString::fromUtf8(v.data, v.len)); if (i == static_cast<QHash<QString, QVariant>*>(ptr)->size()-1) { static_cast<QHash<QString, QVariant>*>(ptr)->~QHash(); free(ptr); }; tmp; }));
}
void QVariant___toHash_setList(void* ptr, struct QtCore_PackedString key, void* i)
{
static_cast<QHash<QString, QVariant>*>(ptr)->insert(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(i));
}
void* QVariant___toHash_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QHash<QString, QVariant>();
}
struct QtCore_PackedList QVariant___toHash_keyList(void* ptr)
{
return ({ QList<QString>* tmpValuef43bc5 = new QList<QString>(static_cast<QHash<QString, QVariant>*>(ptr)->keys()); QtCore_PackedList { tmpValuef43bc5, tmpValuef43bc5->size() }; });
}
void* QVariant___toList_atList(void* ptr, int i)
{
return new QVariant(({QVariant tmp = static_cast<QList<QVariant>*>(ptr)->at(i); if (i == static_cast<QList<QVariant>*>(ptr)->size()-1) { static_cast<QList<QVariant>*>(ptr)->~QList(); free(ptr); }; tmp; }));
}
void QVariant___toList_setList(void* ptr, void* i)
{
static_cast<QList<QVariant>*>(ptr)->append(*static_cast<QVariant*>(i));
}
void* QVariant___toList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QVariant>();
}
void* QVariant___toMap_atList(void* ptr, struct QtCore_PackedString v, int i)
{
return new QVariant(({ QVariant tmp = static_cast<QMap<QString, QVariant>*>(ptr)->value(QString::fromUtf8(v.data, v.len)); if (i == static_cast<QMap<QString, QVariant>*>(ptr)->size()-1) { static_cast<QMap<QString, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));
}
void QVariant___toMap_setList(void* ptr, struct QtCore_PackedString key, void* i)
{
static_cast<QMap<QString, QVariant>*>(ptr)->insert(QString::fromUtf8(key.data, key.len), *static_cast<QVariant*>(i));
}
void* QVariant___toMap_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QMap<QString, QVariant>();
}
struct QtCore_PackedList QVariant___toMap_keyList(void* ptr)
{
return ({ QList<QString>* tmpValue1ab909 = new QList<QString>(static_cast<QMap<QString, QVariant>*>(ptr)->keys()); QtCore_PackedList { tmpValue1ab909, tmpValue1ab909->size() }; });
}
struct QtCore_PackedString QVariant_____QVariant_val_keyList_atList23(void* ptr, int i)
{
return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtCore_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}
void QVariant_____QVariant_val_keyList_setList23(void* ptr, struct QtCore_PackedString i)
{
static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}
void* QVariant_____QVariant_val_keyList_newList23(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QString>();
}
struct QtCore_PackedString QVariant_____QVariant_val_keyList_atList24(void* ptr, int i)
{
return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtCore_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}
void QVariant_____QVariant_val_keyList_setList24(void* ptr, struct QtCore_PackedString i)
{
static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}
void* QVariant_____QVariant_val_keyList_newList24(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QString>();
}
struct QtCore_PackedString QVariant_____toHash_keyList_atList(void* ptr, int i)
{
return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtCore_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}
void QVariant_____toHash_keyList_setList(void* ptr, struct QtCore_PackedString i)
{
static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}
void* QVariant_____toHash_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QString>();
}
struct QtCore_PackedString QVariant_____toMap_keyList_atList(void* ptr, int i)
{
return ({ QByteArray* t94aa5e = new QByteArray(({QString tmp = static_cast<QList<QString>*>(ptr)->at(i); if (i == static_cast<QList<QString>*>(ptr)->size()-1) { static_cast<QList<QString>*>(ptr)->~QList(); free(ptr); }; tmp; }).toUtf8()); QtCore_PackedString { const_cast<char*>(t94aa5e->prepend("WHITESPACE").constData()+10), t94aa5e->size()-10, t94aa5e }; });
}
void QVariant_____toMap_keyList_setList(void* ptr, struct QtCore_PackedString i)
{
static_cast<QList<QString>*>(ptr)->append(QString::fromUtf8(i.data, i.len));
}
void* QVariant_____toMap_keyList_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QString>();
}
class MyQVariantAnimation: public QVariantAnimation
{
public:
MyQVariantAnimation(QObject *parent = Q_NULLPTR) : QVariantAnimation(parent) {QVariantAnimation_QVariantAnimation_QRegisterMetaType();};
int duration() const { return callbackQVariantAnimation_Duration(const_cast<void*>(static_cast<const void*>(this))); };
bool event(QEvent * event) { return callbackQObject_Event(this, event) != 0; };
QVariant interpolated(const QVariant & from, const QVariant & to, qreal progress) const { return *static_cast<QVariant*>(callbackQVariantAnimation_Interpolated(const_cast<void*>(static_cast<const void*>(this)), const_cast<QVariant*>(&from), const_cast<QVariant*>(&to), progress)); };
void updateCurrentTime(int vin) { callbackQVariantAnimation_UpdateCurrentTime(this, vin); };
void updateCurrentValue(const QVariant & value) { callbackQVariantAnimation_UpdateCurrentValue(this, const_cast<QVariant*>(&value)); };
void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { callbackQAbstractAnimation_UpdateState(this, newState, oldState); };
void Signal_ValueChanged(const QVariant & value) { callbackQVariantAnimation_ValueChanged(this, const_cast<QVariant*>(&value)); };
~MyQVariantAnimation() { callbackQVariantAnimation_DestroyQVariantAnimation(this); };
void Signal_CurrentLoopChanged(int currentLoop) { callbackQAbstractAnimation_CurrentLoopChanged(this, currentLoop); };
void Signal_DirectionChanged(QAbstractAnimation::Direction newDirection) { callbackQAbstractAnimation_DirectionChanged(this, newDirection); };
void Signal_Finished() { callbackQAbstractAnimation_Finished(this); };
void pause() { callbackQAbstractAnimation_Pause(this); };
void resume() { callbackQAbstractAnimation_Resume(this); };
void setCurrentTime(int msecs) { callbackQAbstractAnimation_SetCurrentTime(this, msecs); };
void setPaused(bool paused) { callbackQAbstractAnimation_SetPaused(this, paused); };
void start(QAbstractAnimation::DeletionPolicy policy) { callbackQAbstractAnimation_Start(this, policy); };
void Signal_StateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { callbackQAbstractAnimation_StateChanged(this, newState, oldState); };
void stop() { callbackQAbstractAnimation_Stop(this); };
void updateDirection(QAbstractAnimation::Direction direction) { callbackQAbstractAnimation_UpdateDirection(this, direction); };
void childEvent(QChildEvent * event) { callbackQObject_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQObject_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQObject_CustomEvent(this, event); };
void deleteLater() { callbackQObject_DeleteLater(this); };
void Signal_Destroyed(QObject * obj) { callbackQObject_Destroyed(this, obj); };
void disconnectNotify(const QMetaMethod & sign) { callbackQObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQObject_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
void Signal_ObjectNameChanged(const QString & objectName) { QByteArray* taa2c4f = new QByteArray(objectName.toUtf8()); QtCore_PackedString objectNamePacked = { const_cast<char*>(taa2c4f->prepend("WHITESPACE").constData()+10), taa2c4f->size()-10, taa2c4f };callbackQObject_ObjectNameChanged(this, objectNamePacked); };
void timerEvent(QTimerEvent * event) { callbackQObject_TimerEvent(this, event); };
};
Q_DECLARE_METATYPE(QVariantAnimation*)
Q_DECLARE_METATYPE(MyQVariantAnimation*)
int QVariantAnimation_QVariantAnimation_QRegisterMetaType(){qRegisterMetaType<QVariantAnimation*>(); return qRegisterMetaType<MyQVariantAnimation*>();}
void* QVariantAnimation_NewQVariantAnimation(void* parent)
{
if (dynamic_cast<QAudioSystemPlugin*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QAudioSystemPlugin*>(parent));
} else if (dynamic_cast<QCameraImageCapture*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QCameraImageCapture*>(parent));
} else if (dynamic_cast<QDBusPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QDBusPendingCallWatcher*>(parent));
} else if (dynamic_cast<QExtensionFactory*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QExtensionFactory*>(parent));
} else if (dynamic_cast<QExtensionManager*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QExtensionManager*>(parent));
} else if (dynamic_cast<QGraphicsObject*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QGraphicsObject*>(parent));
} else if (dynamic_cast<QGraphicsWidget*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QGraphicsWidget*>(parent));
} else if (dynamic_cast<QLayout*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QLayout*>(parent));
} else if (dynamic_cast<QMediaPlaylist*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QMediaPlaylist*>(parent));
} else if (dynamic_cast<QMediaRecorder*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QMediaRecorder*>(parent));
} else if (dynamic_cast<QMediaServiceProviderPlugin*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QMediaServiceProviderPlugin*>(parent));
} else if (dynamic_cast<QOffscreenSurface*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QOffscreenSurface*>(parent));
} else if (dynamic_cast<QPaintDeviceWindow*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QPaintDeviceWindow*>(parent));
} else if (dynamic_cast<QPdfWriter*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QPdfWriter*>(parent));
} else if (dynamic_cast<QQuickItem*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QQuickItem*>(parent));
} else if (dynamic_cast<QRadioData*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QRadioData*>(parent));
} else if (dynamic_cast<QRemoteObjectPendingCallWatcher*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QRemoteObjectPendingCallWatcher*>(parent));
} else if (dynamic_cast<QScriptExtensionPlugin*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QScriptExtensionPlugin*>(parent));
} else if (dynamic_cast<QWidget*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QWidget*>(parent));
} else if (dynamic_cast<QWindow*>(static_cast<QObject*>(parent))) {
return new MyQVariantAnimation(static_cast<QWindow*>(parent));
} else {
return new MyQVariantAnimation(static_cast<QObject*>(parent));
}
}
void* QVariantAnimation_CurrentValue(void* ptr)
{
return new QVariant(static_cast<QVariantAnimation*>(ptr)->currentValue());
}
int QVariantAnimation_Duration(void* ptr)
{
return static_cast<QVariantAnimation*>(ptr)->duration();
}
int QVariantAnimation_DurationDefault(void* ptr)
{
if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
return static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::duration();
} else {
return static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::duration();
}
}
void* QVariantAnimation_EasingCurve(void* ptr)
{
return new QEasingCurve(static_cast<QVariantAnimation*>(ptr)->easingCurve());
}
void* QVariantAnimation_EndValue(void* ptr)
{
return new QVariant(static_cast<QVariantAnimation*>(ptr)->endValue());
}
void* QVariantAnimation_Interpolated(void* ptr, void* from, void* to, double progress)
{
return new QVariant(static_cast<QVariantAnimation*>(ptr)->interpolated(*static_cast<QVariant*>(from), *static_cast<QVariant*>(to), progress));
}
void* QVariantAnimation_InterpolatedDefault(void* ptr, void* from, void* to, double progress)
{
if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
return new QVariant(static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::interpolated(*static_cast<QVariant*>(from), *static_cast<QVariant*>(to), progress));
} else {
return new QVariant(static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::interpolated(*static_cast<QVariant*>(from), *static_cast<QVariant*>(to), progress));
}
}
void* QVariantAnimation_KeyValueAt(void* ptr, double step)
{
return new QVariant(static_cast<QVariantAnimation*>(ptr)->keyValueAt(step));
}
void QVariantAnimation_SetDuration(void* ptr, int msecs)
{
static_cast<QVariantAnimation*>(ptr)->setDuration(msecs);
}
void QVariantAnimation_SetEasingCurve(void* ptr, void* easing)
{
static_cast<QVariantAnimation*>(ptr)->setEasingCurve(*static_cast<QEasingCurve*>(easing));
}
void QVariantAnimation_SetEndValue(void* ptr, void* value)
{
static_cast<QVariantAnimation*>(ptr)->setEndValue(*static_cast<QVariant*>(value));
}
void QVariantAnimation_SetKeyValueAt(void* ptr, double step, void* value)
{
static_cast<QVariantAnimation*>(ptr)->setKeyValueAt(step, *static_cast<QVariant*>(value));
}
void QVariantAnimation_SetStartValue(void* ptr, void* value)
{
static_cast<QVariantAnimation*>(ptr)->setStartValue(*static_cast<QVariant*>(value));
}
void* QVariantAnimation_StartValue(void* ptr)
{
return new QVariant(static_cast<QVariantAnimation*>(ptr)->startValue());
}
void QVariantAnimation_UpdateCurrentTime(void* ptr, int vin)
{
static_cast<QVariantAnimation*>(ptr)->updateCurrentTime(vin);
}
void QVariantAnimation_UpdateCurrentTimeDefault(void* ptr, int vin)
{
if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::updateCurrentTime(vin);
} else {
static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::updateCurrentTime(vin);
}
}
void QVariantAnimation_UpdateCurrentValue(void* ptr, void* value)
{
static_cast<QVariantAnimation*>(ptr)->updateCurrentValue(*static_cast<QVariant*>(value));
}
void QVariantAnimation_UpdateCurrentValueDefault(void* ptr, void* value)
{
if (dynamic_cast<QPropertyAnimation*>(static_cast<QObject*>(ptr))) {
static_cast<QPropertyAnimation*>(ptr)->QPropertyAnimation::updateCurrentValue(*static_cast<QVariant*>(value));
} else {
static_cast<QVariantAnimation*>(ptr)->QVariantAnimation::updateCurrentValue(*static_cast<QVariant*>(value));
}
}
void QVariantAnimation_ConnectValueChanged(void* ptr, long long t)
{
QObject::connect(static_cast<QVariantAnimation*>(ptr), static_cast<void (QVariantAnimation::*)(const QVariant &)>(&QVariantAnimation::valueChanged), static_cast<MyQVariantAnimation*>(ptr), static_cast<void (MyQVariantAnimation::*)(const QVariant &)>(&MyQVariantAnimation::Signal_ValueChanged), static_cast<Qt::ConnectionType>(t));
}
void QVariantAnimation_DisconnectValueChanged(void* ptr)
{
QObject::disconnect(static_cast<QVariantAnimation*>(ptr), static_cast<void (QVariantAnimation::*)(const QVariant &)>(&QVariantAnimation::valueChanged), static_cast<MyQVariantAnimation*>(ptr), static_cast<void (MyQVariantAnimation::*)(const QVariant &)>(&MyQVariantAnimation::Signal_ValueChanged));
}
void QVariantAnimation_ValueChanged(void* ptr, void* value)
{
static_cast<QVariantAnimation*>(ptr)->valueChanged(*static_cast<QVariant*>(value));
}
void QVariantAnimation_DestroyQVariantAnimation(void* ptr)
{
static_cast<QVariantAnimation*>(ptr)->~QVariantAnimation();
}
void QVariantAnimation_DestroyQVariantAnimationDefault(void* ptr)
{
Q_UNUSED(ptr);
}
Q_DECLARE_METATYPE(QVersionNumber*)
void* QVersionNumber_NewQVersionNumber()
{
return new QVersionNumber();
}
void* QVersionNumber_NewQVersionNumber2(void* seg)
{
return new QVersionNumber(*static_cast<QVector<int>*>(seg));
}
void* QVersionNumber_NewQVersionNumber3(void* seg)
{
return new QVersionNumber(({ QVector<int>* tmpP = static_cast<QVector<int>*>(seg); QVector<int> tmpV = *tmpP; tmpP->~QVector(); free(tmpP); tmpV; }));
}
void* QVersionNumber_NewQVersionNumber5(int maj)
{
return new QVersionNumber(maj);
}
void* QVersionNumber_NewQVersionNumber6(int maj, int min)
{
return new QVersionNumber(maj, min);
}
void* QVersionNumber_NewQVersionNumber7(int maj, int min, int mic)
{
return new QVersionNumber(maj, min, mic);
}
void* QVersionNumber_QVersionNumber_CommonPrefix(void* v1, void* v2)
{
return new QVersionNumber(QVersionNumber::commonPrefix(*static_cast<QVersionNumber*>(v1), *static_cast<QVersionNumber*>(v2)));
}
int QVersionNumber_QVersionNumber_Compare(void* v1, void* v2)
{
return QVersionNumber::compare(*static_cast<QVersionNumber*>(v1), *static_cast<QVersionNumber*>(v2));
}
void* QVersionNumber_QVersionNumber_FromString(struct QtCore_PackedString stri, int suffixIndex)
{
return new QVersionNumber(QVersionNumber::fromString(QString::fromUtf8(stri.data, stri.len), &suffixIndex));
}
void* QVersionNumber_QVersionNumber_FromString2(void* stri, int suffixIndex)
{
return new QVersionNumber(QVersionNumber::fromString(*static_cast<QLatin1String*>(stri), &suffixIndex));
}
void* QVersionNumber_QVersionNumber_FromString3(void* stri, int suffixIndex)
{
return new QVersionNumber(QVersionNumber::fromString(*static_cast<QStringView*>(stri), &suffixIndex));
}
char QVersionNumber_IsNormalized(void* ptr)
{
return static_cast<QVersionNumber*>(ptr)->isNormalized();
}
char QVersionNumber_IsNull(void* ptr)
{
return static_cast<QVersionNumber*>(ptr)->isNull();
}
char QVersionNumber_IsPrefixOf(void* ptr, void* other)
{
return static_cast<QVersionNumber*>(ptr)->isPrefixOf(*static_cast<QVersionNumber*>(other));
}
int QVersionNumber_MajorVersion(void* ptr)
{
return static_cast<QVersionNumber*>(ptr)->majorVersion();
}
int QVersionNumber_MicroVersion(void* ptr)
{
return static_cast<QVersionNumber*>(ptr)->microVersion();
}
int QVersionNumber_MinorVersion(void* ptr)
{
return static_cast<QVersionNumber*>(ptr)->minorVersion();
}
void* QVersionNumber_Normalized(void* ptr)
{
return new QVersionNumber(static_cast<QVersionNumber*>(ptr)->normalized());
}
int QVersionNumber_SegmentAt(void* ptr, int index)
{
return static_cast<QVersionNumber*>(ptr)->segmentAt(index);
}
int QVersionNumber_SegmentCount(void* ptr)
{
return static_cast<QVersionNumber*>(ptr)->segmentCount();
}
struct QtCore_PackedList QVersionNumber_Segments(void* ptr)
{
return ({ QVector<int>* tmpValue14199b = new QVector<int>(static_cast<QVersionNumber*>(ptr)->segments()); QtCore_PackedList { tmpValue14199b, tmpValue14199b->size() }; });
}
struct QtCore_PackedString QVersionNumber_ToString(void* ptr)
{
return ({ QByteArray* t62e3a8 = new QByteArray(static_cast<QVersionNumber*>(ptr)->toString().toUtf8()); QtCore_PackedString { const_cast<char*>(t62e3a8->prepend("WHITESPACE").constData()+10), t62e3a8->size()-10, t62e3a8 }; });
}
int QVersionNumber___QVersionNumber_seg_atList2(void* ptr, int i)
{
return ({int tmp = static_cast<QVector<int>*>(ptr)->at(i); if (i == static_cast<QVector<int>*>(ptr)->size()-1) { static_cast<QVector<int>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QVersionNumber___QVersionNumber_seg_setList2(void* ptr, int i)
{
static_cast<QVector<int>*>(ptr)->append(i);
}
void* QVersionNumber___QVersionNumber_seg_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<int>();
}
int QVersionNumber___QVersionNumber_seg_atList3(void* ptr, int i)
{
return ({int tmp = static_cast<QVector<int>*>(ptr)->at(i); if (i == static_cast<QVector<int>*>(ptr)->size()-1) { static_cast<QVector<int>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QVersionNumber___QVersionNumber_seg_setList3(void* ptr, int i)
{
static_cast<QVector<int>*>(ptr)->append(i);
}
void* QVersionNumber___QVersionNumber_seg_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<int>();
}
int QVersionNumber___segments_atList(void* ptr, int i)
{
return ({int tmp = static_cast<QVector<int>*>(ptr)->at(i); if (i == static_cast<QVector<int>*>(ptr)->size()-1) { static_cast<QVector<int>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QVersionNumber___segments_setList(void* ptr, int i)
{
static_cast<QVector<int>*>(ptr)->append(i);
}
void* QVersionNumber___segments_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<int>();
}
Q_DECLARE_METATYPE(QWaitCondition*)
void* QWaitCondition_NewQWaitCondition()
{
return new QWaitCondition();
}
void QWaitCondition_Notify_all(void* ptr)
{
static_cast<QWaitCondition*>(ptr)->notify_all();
}
void QWaitCondition_Notify_one(void* ptr)
{
static_cast<QWaitCondition*>(ptr)->notify_one();
}
char QWaitCondition_Wait(void* ptr, void* lockedMutex, unsigned long ti)
{
return static_cast<QWaitCondition*>(ptr)->wait(static_cast<QMutex*>(lockedMutex), ti);
}
char QWaitCondition_Wait3(void* ptr, void* lockedReadWriteLock, unsigned long ti)
{
return static_cast<QWaitCondition*>(ptr)->wait(static_cast<QReadWriteLock*>(lockedReadWriteLock), ti);
}
void QWaitCondition_WakeAll(void* ptr)
{
static_cast<QWaitCondition*>(ptr)->wakeAll();
}
void QWaitCondition_WakeOne(void* ptr)
{
static_cast<QWaitCondition*>(ptr)->wakeOne();
}
void QWaitCondition_DestroyQWaitCondition(void* ptr)
{
static_cast<QWaitCondition*>(ptr)->~QWaitCondition();
}
Q_DECLARE_METATYPE(QWriteLocker*)
void* QWriteLocker_NewQWriteLocker(void* lock)
{
return new QWriteLocker(static_cast<QReadWriteLock*>(lock));
}
void* QWriteLocker_ReadWriteLock(void* ptr)
{
return static_cast<QWriteLocker*>(ptr)->readWriteLock();
}
void QWriteLocker_Relock(void* ptr)
{
static_cast<QWriteLocker*>(ptr)->relock();
}
void QWriteLocker_Unlock(void* ptr)
{
static_cast<QWriteLocker*>(ptr)->unlock();
}
void QWriteLocker_DestroyQWriteLocker(void* ptr)
{
static_cast<QWriteLocker*>(ptr)->~QWriteLocker();
}
Q_DECLARE_METATYPE(QXmlStreamAttribute)
Q_DECLARE_METATYPE(QXmlStreamAttribute*)
void* QXmlStreamAttribute_NewQXmlStreamAttribute()
{
return new QXmlStreamAttribute();
}
void* QXmlStreamAttribute_NewQXmlStreamAttribute2(struct QtCore_PackedString qualifiedName, struct QtCore_PackedString value)
{
return new QXmlStreamAttribute(QString::fromUtf8(qualifiedName.data, qualifiedName.len), QString::fromUtf8(value.data, value.len));
}
void* QXmlStreamAttribute_NewQXmlStreamAttribute3(struct QtCore_PackedString namespaceUri, struct QtCore_PackedString name, struct QtCore_PackedString value)
{
return new QXmlStreamAttribute(QString::fromUtf8(namespaceUri.data, namespaceUri.len), QString::fromUtf8(name.data, name.len), QString::fromUtf8(value.data, value.len));
}
void* QXmlStreamAttribute_NewQXmlStreamAttribute4(void* other)
{
return new QXmlStreamAttribute(*static_cast<QXmlStreamAttribute*>(other));
}
char QXmlStreamAttribute_IsDefault(void* ptr)
{
return static_cast<QXmlStreamAttribute*>(ptr)->isDefault();
}
void* QXmlStreamAttribute_Name(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamAttribute*>(ptr)->name());
}
void* QXmlStreamAttribute_NamespaceUri(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamAttribute*>(ptr)->namespaceUri());
}
void* QXmlStreamAttribute_Prefix(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamAttribute*>(ptr)->prefix());
}
void* QXmlStreamAttribute_QualifiedName(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamAttribute*>(ptr)->qualifiedName());
}
void* QXmlStreamAttribute_Value(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamAttribute*>(ptr)->value());
}
void QXmlStreamAttribute_DestroyQXmlStreamAttribute(void* ptr)
{
static_cast<QXmlStreamAttribute*>(ptr)->~QXmlStreamAttribute();
}
Q_DECLARE_METATYPE(QXmlStreamAttributes)
Q_DECLARE_METATYPE(QXmlStreamAttributes*)
void* QXmlStreamAttributes_NewQXmlStreamAttributes()
{
return new QXmlStreamAttributes();
}
void QXmlStreamAttributes_Append(void* ptr, struct QtCore_PackedString namespaceUri, struct QtCore_PackedString name, struct QtCore_PackedString value)
{
static_cast<QXmlStreamAttributes*>(ptr)->append(QString::fromUtf8(namespaceUri.data, namespaceUri.len), QString::fromUtf8(name.data, name.len), QString::fromUtf8(value.data, value.len));
}
void QXmlStreamAttributes_Append2(void* ptr, struct QtCore_PackedString qualifiedName, struct QtCore_PackedString value)
{
static_cast<QXmlStreamAttributes*>(ptr)->append(QString::fromUtf8(qualifiedName.data, qualifiedName.len), QString::fromUtf8(value.data, value.len));
}
char QXmlStreamAttributes_HasAttribute(void* ptr, struct QtCore_PackedString qualifiedName)
{
return static_cast<QXmlStreamAttributes*>(ptr)->hasAttribute(QString::fromUtf8(qualifiedName.data, qualifiedName.len));
}
char QXmlStreamAttributes_HasAttribute2(void* ptr, void* qualifiedName)
{
return static_cast<QXmlStreamAttributes*>(ptr)->hasAttribute(*static_cast<QLatin1String*>(qualifiedName));
}
char QXmlStreamAttributes_HasAttribute3(void* ptr, struct QtCore_PackedString namespaceUri, struct QtCore_PackedString name)
{
return static_cast<QXmlStreamAttributes*>(ptr)->hasAttribute(QString::fromUtf8(namespaceUri.data, namespaceUri.len), QString::fromUtf8(name.data, name.len));
}
void* QXmlStreamAttributes_Value(void* ptr, struct QtCore_PackedString namespaceUri, struct QtCore_PackedString name)
{
return new QStringRef(static_cast<QXmlStreamAttributes*>(ptr)->value(QString::fromUtf8(namespaceUri.data, namespaceUri.len), QString::fromUtf8(name.data, name.len)));
}
void* QXmlStreamAttributes_Value2(void* ptr, struct QtCore_PackedString namespaceUri, void* name)
{
return new QStringRef(static_cast<QXmlStreamAttributes*>(ptr)->value(QString::fromUtf8(namespaceUri.data, namespaceUri.len), *static_cast<QLatin1String*>(name)));
}
void* QXmlStreamAttributes_Value3(void* ptr, void* namespaceUri, void* name)
{
return new QStringRef(static_cast<QXmlStreamAttributes*>(ptr)->value(*static_cast<QLatin1String*>(namespaceUri), *static_cast<QLatin1String*>(name)));
}
void* QXmlStreamAttributes_Value4(void* ptr, struct QtCore_PackedString qualifiedName)
{
return new QStringRef(static_cast<QXmlStreamAttributes*>(ptr)->value(QString::fromUtf8(qualifiedName.data, qualifiedName.len)));
}
void* QXmlStreamAttributes_Value5(void* ptr, void* qualifiedName)
{
return new QStringRef(static_cast<QXmlStreamAttributes*>(ptr)->value(*static_cast<QLatin1String*>(qualifiedName)));
}
Q_DECLARE_METATYPE(QXmlStreamEntityDeclaration)
Q_DECLARE_METATYPE(QXmlStreamEntityDeclaration*)
void* QXmlStreamEntityDeclaration_NewQXmlStreamEntityDeclaration()
{
return new QXmlStreamEntityDeclaration();
}
void* QXmlStreamEntityDeclaration_NewQXmlStreamEntityDeclaration2(void* other)
{
return new QXmlStreamEntityDeclaration(*static_cast<QXmlStreamEntityDeclaration*>(other));
}
void* QXmlStreamEntityDeclaration_Name(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamEntityDeclaration*>(ptr)->name());
}
void* QXmlStreamEntityDeclaration_NotationName(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamEntityDeclaration*>(ptr)->notationName());
}
void* QXmlStreamEntityDeclaration_PublicId(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamEntityDeclaration*>(ptr)->publicId());
}
void* QXmlStreamEntityDeclaration_SystemId(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamEntityDeclaration*>(ptr)->systemId());
}
void* QXmlStreamEntityDeclaration_Value(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamEntityDeclaration*>(ptr)->value());
}
void QXmlStreamEntityDeclaration_DestroyQXmlStreamEntityDeclaration(void* ptr)
{
static_cast<QXmlStreamEntityDeclaration*>(ptr)->~QXmlStreamEntityDeclaration();
}
class MyQXmlStreamEntityResolver: public QXmlStreamEntityResolver
{
public:
QString resolveUndeclaredEntity(const QString & name) { QByteArray* t6ae999 = new QByteArray(name.toUtf8()); QtCore_PackedString namePacked = { const_cast<char*>(t6ae999->prepend("WHITESPACE").constData()+10), t6ae999->size()-10, t6ae999 };return ({ QtCore_PackedString tempVal = callbackQXmlStreamEntityResolver_ResolveUndeclaredEntity(this, namePacked); QString ret = QString::fromUtf8(tempVal.data, tempVal.len); free(tempVal.data); ret; }); };
~MyQXmlStreamEntityResolver() { callbackQXmlStreamEntityResolver_DestroyQXmlStreamEntityResolver(this); };
};
Q_DECLARE_METATYPE(QXmlStreamEntityResolver*)
Q_DECLARE_METATYPE(MyQXmlStreamEntityResolver*)
int QXmlStreamEntityResolver_QXmlStreamEntityResolver_QRegisterMetaType(){qRegisterMetaType<QXmlStreamEntityResolver*>(); return qRegisterMetaType<MyQXmlStreamEntityResolver*>();}
struct QtCore_PackedString QXmlStreamEntityResolver_ResolveUndeclaredEntity(void* ptr, struct QtCore_PackedString name)
{
return ({ QByteArray* t961153 = new QByteArray(static_cast<QXmlStreamEntityResolver*>(ptr)->resolveUndeclaredEntity(QString::fromUtf8(name.data, name.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t961153->prepend("WHITESPACE").constData()+10), t961153->size()-10, t961153 }; });
}
struct QtCore_PackedString QXmlStreamEntityResolver_ResolveUndeclaredEntityDefault(void* ptr, struct QtCore_PackedString name)
{
return ({ QByteArray* t7ca7f1 = new QByteArray(static_cast<QXmlStreamEntityResolver*>(ptr)->QXmlStreamEntityResolver::resolveUndeclaredEntity(QString::fromUtf8(name.data, name.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t7ca7f1->prepend("WHITESPACE").constData()+10), t7ca7f1->size()-10, t7ca7f1 }; });
}
void QXmlStreamEntityResolver_DestroyQXmlStreamEntityResolver(void* ptr)
{
static_cast<QXmlStreamEntityResolver*>(ptr)->~QXmlStreamEntityResolver();
}
void QXmlStreamEntityResolver_DestroyQXmlStreamEntityResolverDefault(void* ptr)
{
Q_UNUSED(ptr);
}
Q_DECLARE_METATYPE(QXmlStreamNamespaceDeclaration)
Q_DECLARE_METATYPE(QXmlStreamNamespaceDeclaration*)
void* QXmlStreamNamespaceDeclaration_NewQXmlStreamNamespaceDeclaration()
{
return new QXmlStreamNamespaceDeclaration();
}
void* QXmlStreamNamespaceDeclaration_NewQXmlStreamNamespaceDeclaration2(void* other)
{
return new QXmlStreamNamespaceDeclaration(*static_cast<QXmlStreamNamespaceDeclaration*>(other));
}
void* QXmlStreamNamespaceDeclaration_NewQXmlStreamNamespaceDeclaration4(struct QtCore_PackedString prefix, struct QtCore_PackedString namespaceUri)
{
return new QXmlStreamNamespaceDeclaration(QString::fromUtf8(prefix.data, prefix.len), QString::fromUtf8(namespaceUri.data, namespaceUri.len));
}
void* QXmlStreamNamespaceDeclaration_NamespaceUri(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamNamespaceDeclaration*>(ptr)->namespaceUri());
}
void* QXmlStreamNamespaceDeclaration_Prefix(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamNamespaceDeclaration*>(ptr)->prefix());
}
void QXmlStreamNamespaceDeclaration_DestroyQXmlStreamNamespaceDeclaration(void* ptr)
{
static_cast<QXmlStreamNamespaceDeclaration*>(ptr)->~QXmlStreamNamespaceDeclaration();
}
Q_DECLARE_METATYPE(QXmlStreamNotationDeclaration)
Q_DECLARE_METATYPE(QXmlStreamNotationDeclaration*)
void* QXmlStreamNotationDeclaration_NewQXmlStreamNotationDeclaration()
{
return new QXmlStreamNotationDeclaration();
}
void* QXmlStreamNotationDeclaration_NewQXmlStreamNotationDeclaration2(void* other)
{
return new QXmlStreamNotationDeclaration(*static_cast<QXmlStreamNotationDeclaration*>(other));
}
void* QXmlStreamNotationDeclaration_Name(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamNotationDeclaration*>(ptr)->name());
}
void* QXmlStreamNotationDeclaration_PublicId(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamNotationDeclaration*>(ptr)->publicId());
}
void* QXmlStreamNotationDeclaration_SystemId(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamNotationDeclaration*>(ptr)->systemId());
}
void QXmlStreamNotationDeclaration_DestroyQXmlStreamNotationDeclaration(void* ptr)
{
static_cast<QXmlStreamNotationDeclaration*>(ptr)->~QXmlStreamNotationDeclaration();
}
Q_DECLARE_METATYPE(QXmlStreamReader*)
void* QXmlStreamReader_NewQXmlStreamReader()
{
return new QXmlStreamReader();
}
void* QXmlStreamReader_NewQXmlStreamReader2(void* device)
{
return new QXmlStreamReader(static_cast<QIODevice*>(device));
}
void* QXmlStreamReader_NewQXmlStreamReader3(void* data)
{
return new QXmlStreamReader(*static_cast<QByteArray*>(data));
}
void* QXmlStreamReader_NewQXmlStreamReader4(struct QtCore_PackedString data)
{
return new QXmlStreamReader(QString::fromUtf8(data.data, data.len));
}
void* QXmlStreamReader_NewQXmlStreamReader5(char* data)
{
return new QXmlStreamReader(const_cast<const char*>(data));
}
void QXmlStreamReader_AddData(void* ptr, void* data)
{
static_cast<QXmlStreamReader*>(ptr)->addData(*static_cast<QByteArray*>(data));
}
void QXmlStreamReader_AddData2(void* ptr, struct QtCore_PackedString data)
{
static_cast<QXmlStreamReader*>(ptr)->addData(QString::fromUtf8(data.data, data.len));
}
void QXmlStreamReader_AddData3(void* ptr, char* data)
{
static_cast<QXmlStreamReader*>(ptr)->addData(const_cast<const char*>(data));
}
void QXmlStreamReader_AddExtraNamespaceDeclaration(void* ptr, void* extraNamespaceDeclaration)
{
static_cast<QXmlStreamReader*>(ptr)->addExtraNamespaceDeclaration(*static_cast<QXmlStreamNamespaceDeclaration*>(extraNamespaceDeclaration));
}
char QXmlStreamReader_AtEnd(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->atEnd();
}
long long QXmlStreamReader_CharacterOffset(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->characterOffset();
}
void QXmlStreamReader_Clear(void* ptr)
{
static_cast<QXmlStreamReader*>(ptr)->clear();
}
long long QXmlStreamReader_ColumnNumber(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->columnNumber();
}
void* QXmlStreamReader_Device(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->device();
}
void* QXmlStreamReader_DocumentEncoding(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamReader*>(ptr)->documentEncoding());
}
void* QXmlStreamReader_DocumentVersion(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamReader*>(ptr)->documentVersion());
}
void* QXmlStreamReader_DtdName(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamReader*>(ptr)->dtdName());
}
void* QXmlStreamReader_DtdPublicId(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamReader*>(ptr)->dtdPublicId());
}
void* QXmlStreamReader_DtdSystemId(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamReader*>(ptr)->dtdSystemId());
}
void* QXmlStreamReader_EntityResolver(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->entityResolver();
}
long long QXmlStreamReader_Error(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->error();
}
struct QtCore_PackedString QXmlStreamReader_ErrorString(void* ptr)
{
return ({ QByteArray* td9cec5 = new QByteArray(static_cast<QXmlStreamReader*>(ptr)->errorString().toUtf8()); QtCore_PackedString { const_cast<char*>(td9cec5->prepend("WHITESPACE").constData()+10), td9cec5->size()-10, td9cec5 }; });
}
char QXmlStreamReader_HasError(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->hasError();
}
char QXmlStreamReader_IsCDATA(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->isCDATA();
}
char QXmlStreamReader_IsCharacters(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->isCharacters();
}
char QXmlStreamReader_IsComment(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->isComment();
}
char QXmlStreamReader_IsDTD(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->isDTD();
}
char QXmlStreamReader_IsEndDocument(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->isEndDocument();
}
char QXmlStreamReader_IsEndElement(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->isEndElement();
}
char QXmlStreamReader_IsEntityReference(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->isEntityReference();
}
char QXmlStreamReader_IsProcessingInstruction(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->isProcessingInstruction();
}
char QXmlStreamReader_IsStandaloneDocument(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->isStandaloneDocument();
}
char QXmlStreamReader_IsStartDocument(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->isStartDocument();
}
char QXmlStreamReader_IsStartElement(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->isStartElement();
}
char QXmlStreamReader_IsWhitespace(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->isWhitespace();
}
long long QXmlStreamReader_LineNumber(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->lineNumber();
}
void* QXmlStreamReader_Name(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamReader*>(ptr)->name());
}
char QXmlStreamReader_NamespaceProcessing(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->namespaceProcessing();
}
void* QXmlStreamReader_NamespaceUri(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamReader*>(ptr)->namespaceUri());
}
void* QXmlStreamReader_Prefix(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamReader*>(ptr)->prefix());
}
void* QXmlStreamReader_ProcessingInstructionData(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamReader*>(ptr)->processingInstructionData());
}
void* QXmlStreamReader_ProcessingInstructionTarget(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamReader*>(ptr)->processingInstructionTarget());
}
void* QXmlStreamReader_QualifiedName(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamReader*>(ptr)->qualifiedName());
}
void QXmlStreamReader_RaiseError(void* ptr, struct QtCore_PackedString message)
{
static_cast<QXmlStreamReader*>(ptr)->raiseError(QString::fromUtf8(message.data, message.len));
}
struct QtCore_PackedString QXmlStreamReader_ReadElementText(void* ptr, long long behaviour)
{
return ({ QByteArray* tbe9d44 = new QByteArray(static_cast<QXmlStreamReader*>(ptr)->readElementText(static_cast<QXmlStreamReader::ReadElementTextBehaviour>(behaviour)).toUtf8()); QtCore_PackedString { const_cast<char*>(tbe9d44->prepend("WHITESPACE").constData()+10), tbe9d44->size()-10, tbe9d44 }; });
}
long long QXmlStreamReader_ReadNext(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->readNext();
}
char QXmlStreamReader_ReadNextStartElement(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->readNextStartElement();
}
void QXmlStreamReader_SetDevice(void* ptr, void* device)
{
static_cast<QXmlStreamReader*>(ptr)->setDevice(static_cast<QIODevice*>(device));
}
void QXmlStreamReader_SetEntityResolver(void* ptr, void* resolver)
{
static_cast<QXmlStreamReader*>(ptr)->setEntityResolver(static_cast<QXmlStreamEntityResolver*>(resolver));
}
void QXmlStreamReader_SetNamespaceProcessing(void* ptr, char vbo)
{
static_cast<QXmlStreamReader*>(ptr)->setNamespaceProcessing(vbo != 0);
}
void QXmlStreamReader_SkipCurrentElement(void* ptr)
{
static_cast<QXmlStreamReader*>(ptr)->skipCurrentElement();
}
void* QXmlStreamReader_Text(void* ptr)
{
return new QStringRef(static_cast<QXmlStreamReader*>(ptr)->text());
}
struct QtCore_PackedString QXmlStreamReader_TokenString(void* ptr)
{
return ({ QByteArray* t5e8d05 = new QByteArray(static_cast<QXmlStreamReader*>(ptr)->tokenString().toUtf8()); QtCore_PackedString { const_cast<char*>(t5e8d05->prepend("WHITESPACE").constData()+10), t5e8d05->size()-10, t5e8d05 }; });
}
long long QXmlStreamReader_TokenType(void* ptr)
{
return static_cast<QXmlStreamReader*>(ptr)->tokenType();
}
void QXmlStreamReader_DestroyQXmlStreamReader(void* ptr)
{
static_cast<QXmlStreamReader*>(ptr)->~QXmlStreamReader();
}
Q_DECLARE_METATYPE(QXmlStreamWriter*)
void* QXmlStreamWriter_NewQXmlStreamWriter()
{
return new QXmlStreamWriter();
}
void* QXmlStreamWriter_NewQXmlStreamWriter2(void* device)
{
return new QXmlStreamWriter(static_cast<QIODevice*>(device));
}
void* QXmlStreamWriter_NewQXmlStreamWriter3(void* array)
{
return new QXmlStreamWriter(static_cast<QByteArray*>(array));
}
void* QXmlStreamWriter_NewQXmlStreamWriter4(struct QtCore_PackedString stri)
{
return new QXmlStreamWriter(new QString(QString::fromUtf8(stri.data, stri.len)));
}
char QXmlStreamWriter_AutoFormatting(void* ptr)
{
return static_cast<QXmlStreamWriter*>(ptr)->autoFormatting();
}
int QXmlStreamWriter_AutoFormattingIndent(void* ptr)
{
return static_cast<QXmlStreamWriter*>(ptr)->autoFormattingIndent();
}
void* QXmlStreamWriter_Codec(void* ptr)
{
return static_cast<QXmlStreamWriter*>(ptr)->codec();
}
void* QXmlStreamWriter_Device(void* ptr)
{
return static_cast<QXmlStreamWriter*>(ptr)->device();
}
char QXmlStreamWriter_HasError(void* ptr)
{
return static_cast<QXmlStreamWriter*>(ptr)->hasError();
}
void QXmlStreamWriter_SetAutoFormatting(void* ptr, char enable)
{
static_cast<QXmlStreamWriter*>(ptr)->setAutoFormatting(enable != 0);
}
void QXmlStreamWriter_SetAutoFormattingIndent(void* ptr, int spacesOrTabs)
{
static_cast<QXmlStreamWriter*>(ptr)->setAutoFormattingIndent(spacesOrTabs);
}
void QXmlStreamWriter_SetCodec(void* ptr, void* codec)
{
static_cast<QXmlStreamWriter*>(ptr)->setCodec(static_cast<QTextCodec*>(codec));
}
void QXmlStreamWriter_SetCodec2(void* ptr, char* codecName)
{
static_cast<QXmlStreamWriter*>(ptr)->setCodec(const_cast<const char*>(codecName));
}
void QXmlStreamWriter_SetDevice(void* ptr, void* device)
{
static_cast<QXmlStreamWriter*>(ptr)->setDevice(static_cast<QIODevice*>(device));
}
void QXmlStreamWriter_WriteAttribute(void* ptr, struct QtCore_PackedString namespaceUri, struct QtCore_PackedString name, struct QtCore_PackedString value)
{
static_cast<QXmlStreamWriter*>(ptr)->writeAttribute(QString::fromUtf8(namespaceUri.data, namespaceUri.len), QString::fromUtf8(name.data, name.len), QString::fromUtf8(value.data, value.len));
}
void QXmlStreamWriter_WriteAttribute2(void* ptr, struct QtCore_PackedString qualifiedName, struct QtCore_PackedString value)
{
static_cast<QXmlStreamWriter*>(ptr)->writeAttribute(QString::fromUtf8(qualifiedName.data, qualifiedName.len), QString::fromUtf8(value.data, value.len));
}
void QXmlStreamWriter_WriteAttribute3(void* ptr, void* attribute)
{
static_cast<QXmlStreamWriter*>(ptr)->writeAttribute(*static_cast<QXmlStreamAttribute*>(attribute));
}
void QXmlStreamWriter_WriteAttributes(void* ptr, void* attributes)
{
static_cast<QXmlStreamWriter*>(ptr)->writeAttributes(*static_cast<QXmlStreamAttributes*>(attributes));
}
void QXmlStreamWriter_WriteCDATA(void* ptr, struct QtCore_PackedString text)
{
static_cast<QXmlStreamWriter*>(ptr)->writeCDATA(QString::fromUtf8(text.data, text.len));
}
void QXmlStreamWriter_WriteCharacters(void* ptr, struct QtCore_PackedString text)
{
static_cast<QXmlStreamWriter*>(ptr)->writeCharacters(QString::fromUtf8(text.data, text.len));
}
void QXmlStreamWriter_WriteComment(void* ptr, struct QtCore_PackedString text)
{
static_cast<QXmlStreamWriter*>(ptr)->writeComment(QString::fromUtf8(text.data, text.len));
}
void QXmlStreamWriter_WriteCurrentToken(void* ptr, void* reader)
{
static_cast<QXmlStreamWriter*>(ptr)->writeCurrentToken(*static_cast<QXmlStreamReader*>(reader));
}
void QXmlStreamWriter_WriteDTD(void* ptr, struct QtCore_PackedString dtd)
{
static_cast<QXmlStreamWriter*>(ptr)->writeDTD(QString::fromUtf8(dtd.data, dtd.len));
}
void QXmlStreamWriter_WriteDefaultNamespace(void* ptr, struct QtCore_PackedString namespaceUri)
{
static_cast<QXmlStreamWriter*>(ptr)->writeDefaultNamespace(QString::fromUtf8(namespaceUri.data, namespaceUri.len));
}
void QXmlStreamWriter_WriteEmptyElement(void* ptr, struct QtCore_PackedString namespaceUri, struct QtCore_PackedString name)
{
static_cast<QXmlStreamWriter*>(ptr)->writeEmptyElement(QString::fromUtf8(namespaceUri.data, namespaceUri.len), QString::fromUtf8(name.data, name.len));
}
void QXmlStreamWriter_WriteEmptyElement2(void* ptr, struct QtCore_PackedString qualifiedName)
{
static_cast<QXmlStreamWriter*>(ptr)->writeEmptyElement(QString::fromUtf8(qualifiedName.data, qualifiedName.len));
}
void QXmlStreamWriter_WriteEndDocument(void* ptr)
{
static_cast<QXmlStreamWriter*>(ptr)->writeEndDocument();
}
void QXmlStreamWriter_WriteEndElement(void* ptr)
{
static_cast<QXmlStreamWriter*>(ptr)->writeEndElement();
}
void QXmlStreamWriter_WriteEntityReference(void* ptr, struct QtCore_PackedString name)
{
static_cast<QXmlStreamWriter*>(ptr)->writeEntityReference(QString::fromUtf8(name.data, name.len));
}
void QXmlStreamWriter_WriteNamespace(void* ptr, struct QtCore_PackedString namespaceUri, struct QtCore_PackedString prefix)
{
static_cast<QXmlStreamWriter*>(ptr)->writeNamespace(QString::fromUtf8(namespaceUri.data, namespaceUri.len), QString::fromUtf8(prefix.data, prefix.len));
}
void QXmlStreamWriter_WriteProcessingInstruction(void* ptr, struct QtCore_PackedString target, struct QtCore_PackedString data)
{
static_cast<QXmlStreamWriter*>(ptr)->writeProcessingInstruction(QString::fromUtf8(target.data, target.len), QString::fromUtf8(data.data, data.len));
}
void QXmlStreamWriter_WriteStartDocument(void* ptr, struct QtCore_PackedString version)
{
static_cast<QXmlStreamWriter*>(ptr)->writeStartDocument(QString::fromUtf8(version.data, version.len));
}
void QXmlStreamWriter_WriteStartDocument2(void* ptr)
{
static_cast<QXmlStreamWriter*>(ptr)->writeStartDocument();
}
void QXmlStreamWriter_WriteStartDocument3(void* ptr, struct QtCore_PackedString version, char standalone)
{
static_cast<QXmlStreamWriter*>(ptr)->writeStartDocument(QString::fromUtf8(version.data, version.len), standalone != 0);
}
void QXmlStreamWriter_WriteStartElement(void* ptr, struct QtCore_PackedString namespaceUri, struct QtCore_PackedString name)
{
static_cast<QXmlStreamWriter*>(ptr)->writeStartElement(QString::fromUtf8(namespaceUri.data, namespaceUri.len), QString::fromUtf8(name.data, name.len));
}
void QXmlStreamWriter_WriteStartElement2(void* ptr, struct QtCore_PackedString qualifiedName)
{
static_cast<QXmlStreamWriter*>(ptr)->writeStartElement(QString::fromUtf8(qualifiedName.data, qualifiedName.len));
}
void QXmlStreamWriter_WriteTextElement(void* ptr, struct QtCore_PackedString namespaceUri, struct QtCore_PackedString name, struct QtCore_PackedString text)
{
static_cast<QXmlStreamWriter*>(ptr)->writeTextElement(QString::fromUtf8(namespaceUri.data, namespaceUri.len), QString::fromUtf8(name.data, name.len), QString::fromUtf8(text.data, text.len));
}
void QXmlStreamWriter_WriteTextElement2(void* ptr, struct QtCore_PackedString qualifiedName, struct QtCore_PackedString text)
{
static_cast<QXmlStreamWriter*>(ptr)->writeTextElement(QString::fromUtf8(qualifiedName.data, qualifiedName.len), QString::fromUtf8(text.data, text.len));
}
void QXmlStreamWriter_DestroyQXmlStreamWriter(void* ptr)
{
static_cast<QXmlStreamWriter*>(ptr)->~QXmlStreamWriter();
}
int Qt_LastGestureType_Type()
{
return Qt::LastGestureType;
}
struct QtCore_PackedString Qt_Qt_ConvertFromPlainText(struct QtCore_PackedString plain, long long mode)
{
return ({ QByteArray* t896db1 = new QByteArray(Qt::convertFromPlainText(QString::fromUtf8(plain.data, plain.len), static_cast<Qt::WhiteSpaceMode>(mode)).toUtf8()); QtCore_PackedString { const_cast<char*>(t896db1->prepend("WHITESPACE").constData()+10), t896db1->size()-10, t896db1 }; });
}
char Qt_Qt_MightBeRichText(struct QtCore_PackedString text)
{
return Qt::mightBeRichText(QString::fromUtf8(text.data, text.len));
}
struct QtCore_PackedString QtGlobal_QtGlobal_qEnvironmentVariable(char* varName)
{
return ({ QByteArray* t239d80 = new QByteArray(qEnvironmentVariable(const_cast<const char*>(varName)).toUtf8()); QtCore_PackedString { const_cast<char*>(t239d80->prepend("WHITESPACE").constData()+10), t239d80->size()-10, t239d80 }; });
}
struct QtCore_PackedString QtGlobal_QtGlobal_qEnvironmentVariable2(char* varName, struct QtCore_PackedString defaultValue)
{
return ({ QByteArray* t422112 = new QByteArray(qEnvironmentVariable(const_cast<const char*>(varName), QString::fromUtf8(defaultValue.data, defaultValue.len)).toUtf8()); QtCore_PackedString { const_cast<char*>(t422112->prepend("WHITESPACE").constData()+10), t422112->size()-10, t422112 }; });
}
int QtGlobal_QtGlobal_qEnvironmentVariableIntValue(char* varName, char* ok)
{
return qEnvironmentVariableIntValue(const_cast<const char*>(varName), reinterpret_cast<bool*>(ok));
}
char QtGlobal_QtGlobal_qEnvironmentVariableIsEmpty(char* varName)
{
return qEnvironmentVariableIsEmpty(const_cast<const char*>(varName));
}
char QtGlobal_QtGlobal_qEnvironmentVariableIsSet(char* varName)
{
return qEnvironmentVariableIsSet(const_cast<const char*>(varName));
}
struct QtCore_PackedString QtGlobal_QtGlobal_qVersion()
{
return QtCore_PackedString { const_cast<char*>(qVersion()), -1, NULL };
}
void* QtGlobal_QtGlobal_qgetenv(char* varName)
{
return new QByteArray(qgetenv(const_cast<const char*>(varName)));
}
char QtGlobal_QtGlobal_qputenv(char* varName, void* value)
{
return qputenv(const_cast<const char*>(varName), *static_cast<QByteArray*>(value));
}
char QtGlobal_QtGlobal_qunsetenv(char* varName)
{
return qunsetenv(const_cast<const char*>(varName));
}
Reference in a new issue View git blame Copy permalink