From 30adfda14edb2f25e7d2102844d7ed0583e60510 Mon Sep 17 00:00:00 2001 From: MinyazevR Date: Fri, 14 Nov 2025 23:11:05 +0300 Subject: [PATCH 1/3] Correctly regenerate for Qt5.15.2 --- .../com_trolltech_qt_core0.cpp | 352 +++-------- .../com_trolltech_qt_core0.h | 199 ++---- .../com_trolltech_qt_core1.cpp | 462 +++++++------- .../com_trolltech_qt_core1.h | 207 +++++-- .../com_trolltech_qt_core2.cpp | 378 +++++++----- .../com_trolltech_qt_core2.h | 164 +++-- .../com_trolltech_qt_core3.cpp | 575 ++++++------------ .../com_trolltech_qt_core3.h | 203 +++---- .../com_trolltech_qt_core4.cpp | 396 ++++++++++++ .../com_trolltech_qt_core4.h | 105 ++++ .../com_trolltech_qt_core_init.cpp | 3 + .../com_trolltech_qt_gui0.cpp | 72 +-- .../com_trolltech_qt_gui0.h | 28 +- .../com_trolltech_qt_gui1.cpp | 60 +- .../com_trolltech_qt_gui1.h | 18 +- .../com_trolltech_qt_gui10.cpp | 20 - .../com_trolltech_qt_gui10.h | 4 - .../com_trolltech_qt_gui11.cpp | 30 +- .../com_trolltech_qt_gui11.h | 12 +- .../com_trolltech_qt_gui12.cpp | 28 +- .../com_trolltech_qt_gui12.h | 20 +- .../com_trolltech_qt_gui2.cpp | 23 +- .../com_trolltech_qt_gui2.h | 7 +- .../com_trolltech_qt_gui3.cpp | 12 +- .../com_trolltech_qt_gui3.h | 4 +- .../com_trolltech_qt_gui4.cpp | 37 +- .../com_trolltech_qt_gui4.h | 13 +- .../com_trolltech_qt_gui5.cpp | 43 +- .../com_trolltech_qt_gui5.h | 13 +- .../com_trolltech_qt_gui6.cpp | 12 +- .../com_trolltech_qt_gui6.h | 4 +- .../com_trolltech_qt_gui7.cpp | 65 +- .../com_trolltech_qt_gui7.h | 17 +- .../com_trolltech_qt_gui8.cpp | 67 +- .../com_trolltech_qt_gui8.h | 19 +- .../com_trolltech_qt_gui_builtin0.cpp | 10 +- .../com_trolltech_qt_gui_builtin0.h | 10 +- .../com_trolltech_qt_multimedia1.cpp | 6 +- .../com_trolltech_qt_multimedia1.h | 2 +- .../com_trolltech_qt_multimedia3.cpp | 11 +- .../com_trolltech_qt_multimedia3.h | 3 +- .../com_trolltech_qt_opengl0.cpp | 12 +- .../com_trolltech_qt_opengl0.h | 4 +- .../com_trolltech_qt_quick0.cpp | 11 +- .../com_trolltech_qt_quick0.h | 3 +- .../com_trolltech_qt_svg0.cpp | 11 +- .../com_trolltech_qt_svg0.h | 3 +- 47 files changed, 1827 insertions(+), 1931 deletions(-) diff --git a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core0.cpp b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core0.cpp index 44df4cee6..678070c2c 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core0.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core0.cpp @@ -6,6 +6,7 @@ #include #include #include +#include #include #include #include @@ -25,7 +26,6 @@ #include #include #include -#include #include #include #include @@ -37,6 +37,7 @@ #include #include #include +#include #include #include #include @@ -370,6 +371,103 @@ void PythonQtWrapper_QAbstractAnimation::updateState(QAbstractAnimation* theWrap +void PythonQtWrapper_QAbstractEventDispatcher::closingDown(QAbstractEventDispatcher* theWrappedObject) +{ + ( theWrappedObject->closingDown()); +} + +bool PythonQtWrapper_QAbstractEventDispatcher::filterNativeEvent(QAbstractEventDispatcher* theWrappedObject, const QByteArray& eventType, void* message, long* result) +{ + return ( theWrappedObject->filterNativeEvent(eventType, message, result)); +} + +void PythonQtWrapper_QAbstractEventDispatcher::flush(QAbstractEventDispatcher* theWrappedObject) +{ + ( theWrappedObject->flush()); +} + +bool PythonQtWrapper_QAbstractEventDispatcher::hasPendingEvents(QAbstractEventDispatcher* theWrappedObject) +{ + return ( theWrappedObject->hasPendingEvents()); +} + +QAbstractEventDispatcher* PythonQtWrapper_QAbstractEventDispatcher::static_QAbstractEventDispatcher_instance(QThread* thread) +{ + return (QAbstractEventDispatcher::instance(thread)); +} + +void PythonQtWrapper_QAbstractEventDispatcher::interrupt(QAbstractEventDispatcher* theWrappedObject) +{ + ( theWrappedObject->interrupt()); +} + +bool PythonQtWrapper_QAbstractEventDispatcher::processEvents(QAbstractEventDispatcher* theWrappedObject, QEventLoop::ProcessEventsFlags flags) +{ + return ( theWrappedObject->processEvents(flags)); +} + +void PythonQtWrapper_QAbstractEventDispatcher::registerSocketNotifier(QAbstractEventDispatcher* theWrappedObject, QSocketNotifier* notifier) +{ + ( theWrappedObject->registerSocketNotifier(notifier)); +} + +int PythonQtWrapper_QAbstractEventDispatcher::registerTimer(QAbstractEventDispatcher* theWrappedObject, int interval, Qt::TimerType timerType, QObject* object) +{ + return ( theWrappedObject->registerTimer(interval, timerType, object)); +} + +void PythonQtWrapper_QAbstractEventDispatcher::registerTimer(QAbstractEventDispatcher* theWrappedObject, int timerId, int interval, Qt::TimerType timerType, QObject* object) +{ + ( theWrappedObject->registerTimer(timerId, interval, timerType, object)); +} + +QList PythonQtWrapper_QAbstractEventDispatcher::registeredTimers(QAbstractEventDispatcher* theWrappedObject, QObject* object) const +{ + return ( theWrappedObject->registeredTimers(object)); +} + +int PythonQtWrapper_QAbstractEventDispatcher::remainingTime(QAbstractEventDispatcher* theWrappedObject, int timerId) +{ + return ( theWrappedObject->remainingTime(timerId)); +} + +void PythonQtWrapper_QAbstractEventDispatcher::startingUp(QAbstractEventDispatcher* theWrappedObject) +{ + ( theWrappedObject->startingUp()); +} + +void PythonQtWrapper_QAbstractEventDispatcher::unregisterSocketNotifier(QAbstractEventDispatcher* theWrappedObject, QSocketNotifier* notifier) +{ + ( theWrappedObject->unregisterSocketNotifier(notifier)); +} + +bool PythonQtWrapper_QAbstractEventDispatcher::unregisterTimer(QAbstractEventDispatcher* theWrappedObject, int timerId) +{ + return ( theWrappedObject->unregisterTimer(timerId)); +} + +bool PythonQtWrapper_QAbstractEventDispatcher::unregisterTimers(QAbstractEventDispatcher* theWrappedObject, QObject* object) +{ + return ( theWrappedObject->unregisterTimers(object)); +} + +void PythonQtWrapper_QAbstractEventDispatcher::wakeUp(QAbstractEventDispatcher* theWrappedObject) +{ + ( theWrappedObject->wakeUp()); +} + + + +PythonQtShell_QAbstractEventDispatcher__TimerInfo::~PythonQtShell_QAbstractEventDispatcher__TimerInfo() { + PythonQtPrivate* priv = PythonQt::priv(); + if (priv) { priv->shellClassDeleted(this); } +} +QAbstractEventDispatcher::TimerInfo* PythonQtWrapper_QAbstractEventDispatcher__TimerInfo::new_QAbstractEventDispatcher__TimerInfo(int id, int i, Qt::TimerType t) +{ +return new PythonQtShell_QAbstractEventDispatcher__TimerInfo(id, i, t); } + + + PythonQtShell_QAbstractItemModel::~PythonQtShell_QAbstractItemModel() { PythonQtPrivate* priv = PythonQt::priv(); if (priv) { priv->shellClassDeleted(this); } @@ -6735,255 +6833,3 @@ QByteArray PythonQtWrapper_QCryptographicHash::result(QCryptographicHash* theWr } - -QDataStream* PythonQtWrapper_QDataStream::new_QDataStream() -{ -return new QDataStream(); } - -QDataStream* PythonQtWrapper_QDataStream::new_QDataStream(QByteArray* arg__1, QIODevice::OpenMode flags) -{ -return new QDataStream(arg__1, flags); } - -QDataStream* PythonQtWrapper_QDataStream::new_QDataStream(QIODevice* arg__1) -{ -return new QDataStream(arg__1); } - -QDataStream* PythonQtWrapper_QDataStream::new_QDataStream(const QByteArray& arg__1) -{ -return new QDataStream(arg__1); } - -void PythonQtWrapper_QDataStream::abortTransaction(QDataStream* theWrappedObject) -{ - ( theWrappedObject->abortTransaction()); -} - -bool PythonQtWrapper_QDataStream::atEnd(QDataStream* theWrappedObject) const -{ - return ( theWrappedObject->atEnd()); -} - -QDataStream::ByteOrder PythonQtWrapper_QDataStream::byteOrder(QDataStream* theWrappedObject) const -{ - return ( theWrappedObject->byteOrder()); -} - -bool PythonQtWrapper_QDataStream::commitTransaction(QDataStream* theWrappedObject) -{ - return ( theWrappedObject->commitTransaction()); -} - -QIODevice* PythonQtWrapper_QDataStream::device(QDataStream* theWrappedObject) const -{ - return ( theWrappedObject->device()); -} - -QDataStream::FloatingPointPrecision PythonQtWrapper_QDataStream::floatingPointPrecision(QDataStream* theWrappedObject) const -{ - return ( theWrappedObject->floatingPointPrecision()); -} - -void PythonQtWrapper_QDataStream::resetStatus(QDataStream* theWrappedObject) -{ - ( theWrappedObject->resetStatus()); -} - -void PythonQtWrapper_QDataStream::rollbackTransaction(QDataStream* theWrappedObject) -{ - ( theWrappedObject->rollbackTransaction()); -} - -void PythonQtWrapper_QDataStream::setByteOrder(QDataStream* theWrappedObject, QDataStream::ByteOrder arg__1) -{ - ( theWrappedObject->setByteOrder(arg__1)); -} - -void PythonQtWrapper_QDataStream::setDevice(QDataStream* theWrappedObject, QIODevice* arg__1) -{ - ( theWrappedObject->setDevice(arg__1)); -} - -void PythonQtWrapper_QDataStream::setFloatingPointPrecision(QDataStream* theWrappedObject, QDataStream::FloatingPointPrecision precision) -{ - ( theWrappedObject->setFloatingPointPrecision(precision)); -} - -void PythonQtWrapper_QDataStream::setStatus(QDataStream* theWrappedObject, QDataStream::Status status) -{ - ( theWrappedObject->setStatus(status)); -} - -void PythonQtWrapper_QDataStream::setVersion(QDataStream* theWrappedObject, int arg__1) -{ - ( theWrappedObject->setVersion(arg__1)); -} - -int PythonQtWrapper_QDataStream::skipRawData(QDataStream* theWrappedObject, int len) -{ - return ( theWrappedObject->skipRawData(len)); -} - -void PythonQtWrapper_QDataStream::startTransaction(QDataStream* theWrappedObject) -{ - ( theWrappedObject->startTransaction()); -} - -QDataStream::Status PythonQtWrapper_QDataStream::status(QDataStream* theWrappedObject) const -{ - return ( theWrappedObject->status()); -} - -void PythonQtWrapper_QDataStream::unsetDevice(QDataStream* theWrappedObject) -{ - ( theWrappedObject->unsetDevice()); -} - -int PythonQtWrapper_QDataStream::version(QDataStream* theWrappedObject) const -{ - return ( theWrappedObject->version()); -} - - - -QDeadlineTimer* PythonQtWrapper_QDeadlineTimer::new_QDeadlineTimer(QDeadlineTimer::ForeverConstant arg__1, Qt::TimerType type_) -{ -return new QDeadlineTimer(arg__1, type_); } - -QDeadlineTimer* PythonQtWrapper_QDeadlineTimer::new_QDeadlineTimer(Qt::TimerType type_) -{ -return new QDeadlineTimer(type_); } - -QDeadlineTimer* PythonQtWrapper_QDeadlineTimer::new_QDeadlineTimer(qint64 msecs, Qt::TimerType type) -{ -return new QDeadlineTimer(msecs, type); } - -QDeadlineTimer PythonQtWrapper_QDeadlineTimer::static_QDeadlineTimer_addNSecs(QDeadlineTimer dt, qint64 nsecs) -{ - return (QDeadlineTimer::addNSecs(dt, nsecs)); -} - -QDeadlineTimer PythonQtWrapper_QDeadlineTimer::static_QDeadlineTimer_current(Qt::TimerType timerType) -{ - return (QDeadlineTimer::current(timerType)); -} - -qint64 PythonQtWrapper_QDeadlineTimer::deadline(QDeadlineTimer* theWrappedObject) const -{ - return ( theWrappedObject->deadline()); -} - -qint64 PythonQtWrapper_QDeadlineTimer::deadlineNSecs(QDeadlineTimer* theWrappedObject) const -{ - return ( theWrappedObject->deadlineNSecs()); -} - -bool PythonQtWrapper_QDeadlineTimer::hasExpired(QDeadlineTimer* theWrappedObject) const -{ - return ( theWrappedObject->hasExpired()); -} - -bool PythonQtWrapper_QDeadlineTimer::isForever(QDeadlineTimer* theWrappedObject) const -{ - return ( theWrappedObject->isForever()); -} - -bool PythonQtWrapper_QDeadlineTimer::__ne__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2) -{ - return ( (*theWrappedObject)!= d2); -} - -QDeadlineTimer PythonQtWrapper_QDeadlineTimer::__add__(QDeadlineTimer* theWrappedObject, qint64 msecs) -{ - return ( (*theWrappedObject)+ msecs); -} - -QDeadlineTimer* PythonQtWrapper_QDeadlineTimer::__iadd__(QDeadlineTimer* theWrappedObject, qint64 msecs) -{ - return &( (*theWrappedObject)+= msecs); -} - -qint64 PythonQtWrapper_QDeadlineTimer::__sub__(QDeadlineTimer* theWrappedObject, QDeadlineTimer dt2) -{ - return ( (*theWrappedObject)- dt2); -} - -QDeadlineTimer PythonQtWrapper_QDeadlineTimer::__sub__(QDeadlineTimer* theWrappedObject, qint64 msecs) -{ - return ( (*theWrappedObject)- msecs); -} - -QDeadlineTimer* PythonQtWrapper_QDeadlineTimer::__isub__(QDeadlineTimer* theWrappedObject, qint64 msecs) -{ - return &( (*theWrappedObject)-= msecs); -} - -bool PythonQtWrapper_QDeadlineTimer::__lt__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2) -{ - return ( (*theWrappedObject)< d2); -} - -bool PythonQtWrapper_QDeadlineTimer::__le__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2) -{ - return ( (*theWrappedObject)<= d2); -} - -bool PythonQtWrapper_QDeadlineTimer::__eq__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2) -{ - return ( (*theWrappedObject)== d2); -} - -bool PythonQtWrapper_QDeadlineTimer::__gt__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2) -{ - return ( (*theWrappedObject)> d2); -} - -bool PythonQtWrapper_QDeadlineTimer::__ge__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2) -{ - return ( (*theWrappedObject)>= d2); -} - -qint64 PythonQtWrapper_QDeadlineTimer::remainingTime(QDeadlineTimer* theWrappedObject) const -{ - return ( theWrappedObject->remainingTime()); -} - -qint64 PythonQtWrapper_QDeadlineTimer::remainingTimeNSecs(QDeadlineTimer* theWrappedObject) const -{ - return ( theWrappedObject->remainingTimeNSecs()); -} - -void PythonQtWrapper_QDeadlineTimer::setDeadline(QDeadlineTimer* theWrappedObject, qint64 msecs, Qt::TimerType timerType) -{ - ( theWrappedObject->setDeadline(msecs, timerType)); -} - -void PythonQtWrapper_QDeadlineTimer::setPreciseDeadline(QDeadlineTimer* theWrappedObject, qint64 secs, qint64 nsecs, Qt::TimerType type) -{ - ( theWrappedObject->setPreciseDeadline(secs, nsecs, type)); -} - -void PythonQtWrapper_QDeadlineTimer::setPreciseRemainingTime(QDeadlineTimer* theWrappedObject, qint64 secs, qint64 nsecs, Qt::TimerType type) -{ - ( theWrappedObject->setPreciseRemainingTime(secs, nsecs, type)); -} - -void PythonQtWrapper_QDeadlineTimer::setRemainingTime(QDeadlineTimer* theWrappedObject, qint64 msecs, Qt::TimerType type) -{ - ( theWrappedObject->setRemainingTime(msecs, type)); -} - -void PythonQtWrapper_QDeadlineTimer::setTimerType(QDeadlineTimer* theWrappedObject, Qt::TimerType type) -{ - ( theWrappedObject->setTimerType(type)); -} - -void PythonQtWrapper_QDeadlineTimer::swap(QDeadlineTimer* theWrappedObject, QDeadlineTimer& other) -{ - ( theWrappedObject->swap(other)); -} - -Qt::TimerType PythonQtWrapper_QDeadlineTimer::timerType(QDeadlineTimer* theWrappedObject) const -{ - return ( theWrappedObject->timerType()); -} - - diff --git a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core0.h b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core0.h index f123f7354..c66264ea9 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core0.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core0.h @@ -1,10 +1,10 @@ #include -#include #include #include #include #include #include +#include #include #include #include @@ -28,7 +28,6 @@ #include #include #include -#include #include #include #include @@ -42,6 +41,7 @@ #include #include #include +#include #include #include #include @@ -122,6 +122,63 @@ void delete_QAbstractAnimation(QAbstractAnimation* obj) { delete obj; } +class PythonQtWrapper_QAbstractEventDispatcher : public QObject +{ Q_OBJECT +public: +public Q_SLOTS: +void delete_QAbstractEventDispatcher(QAbstractEventDispatcher* obj) { delete obj; } + void closingDown(QAbstractEventDispatcher* theWrappedObject); + bool filterNativeEvent(QAbstractEventDispatcher* theWrappedObject, const QByteArray& eventType, void* message, long* result); + void flush(QAbstractEventDispatcher* theWrappedObject); + bool hasPendingEvents(QAbstractEventDispatcher* theWrappedObject); + QAbstractEventDispatcher* static_QAbstractEventDispatcher_instance(QThread* thread = nullptr); + void interrupt(QAbstractEventDispatcher* theWrappedObject); + bool processEvents(QAbstractEventDispatcher* theWrappedObject, QEventLoop::ProcessEventsFlags flags); + void registerSocketNotifier(QAbstractEventDispatcher* theWrappedObject, QSocketNotifier* notifier); + int registerTimer(QAbstractEventDispatcher* theWrappedObject, int interval, Qt::TimerType timerType, QObject* object); + void registerTimer(QAbstractEventDispatcher* theWrappedObject, int timerId, int interval, Qt::TimerType timerType, QObject* object); + QList registeredTimers(QAbstractEventDispatcher* theWrappedObject, QObject* object) const; + int remainingTime(QAbstractEventDispatcher* theWrappedObject, int timerId); + void startingUp(QAbstractEventDispatcher* theWrappedObject); + void unregisterSocketNotifier(QAbstractEventDispatcher* theWrappedObject, QSocketNotifier* notifier); + bool unregisterTimer(QAbstractEventDispatcher* theWrappedObject, int timerId); + bool unregisterTimers(QAbstractEventDispatcher* theWrappedObject, QObject* object); + void wakeUp(QAbstractEventDispatcher* theWrappedObject); +}; + + + + + +class PythonQtShell_QAbstractEventDispatcher__TimerInfo : public QAbstractEventDispatcher::TimerInfo +{ +public: + PythonQtShell_QAbstractEventDispatcher__TimerInfo(int id, int i, Qt::TimerType t):QAbstractEventDispatcher::TimerInfo(id, i, t),_wrapper(nullptr) {}; + + ~PythonQtShell_QAbstractEventDispatcher__TimerInfo(); + + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtWrapper_QAbstractEventDispatcher__TimerInfo : public QObject +{ Q_OBJECT +public: +public Q_SLOTS: +QAbstractEventDispatcher::TimerInfo* new_QAbstractEventDispatcher__TimerInfo(int id, int i, Qt::TimerType t); +void delete_QAbstractEventDispatcher__TimerInfo(QAbstractEventDispatcher::TimerInfo* obj) { delete obj; } +void py_set_interval(QAbstractEventDispatcher::TimerInfo* theWrappedObject, int interval){ theWrappedObject->interval = interval; } +int py_get_interval(QAbstractEventDispatcher::TimerInfo* theWrappedObject){ return theWrappedObject->interval; } +void py_set_timerId(QAbstractEventDispatcher::TimerInfo* theWrappedObject, int timerId){ theWrappedObject->timerId = timerId; } +int py_get_timerId(QAbstractEventDispatcher::TimerInfo* theWrappedObject){ return theWrappedObject->timerId; } +void py_set_timerType(QAbstractEventDispatcher::TimerInfo* theWrappedObject, Qt::TimerType timerType){ theWrappedObject->timerType = timerType; } +Qt::TimerType py_get_timerType(QAbstractEventDispatcher::TimerInfo* theWrappedObject){ return theWrappedObject->timerType; } +}; + + + + + class PythonQtShell_QAbstractItemModel : public QAbstractItemModel { public: @@ -1495,141 +1552,3 @@ void delete_QCryptographicHash(QCryptographicHash* obj) { delete obj; } }; - - - -class PythonQtWrapper_QDataStream : public QObject -{ Q_OBJECT -public: -Q_ENUMS(ByteOrder FloatingPointPrecision Status Version ) -enum ByteOrder{ - BigEndian = QDataStream::BigEndian, LittleEndian = QDataStream::LittleEndian}; -enum FloatingPointPrecision{ - SinglePrecision = QDataStream::SinglePrecision, DoublePrecision = QDataStream::DoublePrecision}; -enum Status{ - Ok = QDataStream::Ok, ReadPastEnd = QDataStream::ReadPastEnd, ReadCorruptData = QDataStream::ReadCorruptData, WriteFailed = QDataStream::WriteFailed}; -enum Version{ - Qt_1_0 = QDataStream::Qt_1_0, Qt_2_0 = QDataStream::Qt_2_0, Qt_2_1 = QDataStream::Qt_2_1, Qt_3_0 = QDataStream::Qt_3_0, Qt_3_1 = QDataStream::Qt_3_1, Qt_3_3 = QDataStream::Qt_3_3, Qt_4_0 = QDataStream::Qt_4_0, Qt_4_1 = QDataStream::Qt_4_1, Qt_4_2 = QDataStream::Qt_4_2, Qt_4_3 = QDataStream::Qt_4_3, Qt_4_4 = QDataStream::Qt_4_4, Qt_4_5 = QDataStream::Qt_4_5, Qt_4_6 = QDataStream::Qt_4_6, Qt_4_7 = QDataStream::Qt_4_7, Qt_4_8 = QDataStream::Qt_4_8, Qt_4_9 = QDataStream::Qt_4_9, Qt_5_0 = QDataStream::Qt_5_0, Qt_5_1 = QDataStream::Qt_5_1, Qt_5_2 = QDataStream::Qt_5_2, Qt_5_3 = QDataStream::Qt_5_3, Qt_5_4 = QDataStream::Qt_5_4, Qt_5_5 = QDataStream::Qt_5_5, Qt_5_6 = QDataStream::Qt_5_6, Qt_5_7 = QDataStream::Qt_5_7, Qt_5_8 = QDataStream::Qt_5_8, Qt_5_9 = QDataStream::Qt_5_9, Qt_5_10 = QDataStream::Qt_5_10, Qt_5_11 = QDataStream::Qt_5_11, Qt_5_12 = QDataStream::Qt_5_12, Qt_5_13 = QDataStream::Qt_5_13, Qt_5_14 = QDataStream::Qt_5_14, Qt_5_15 = QDataStream::Qt_5_15, Qt_DefaultCompiledVersion = QDataStream::Qt_DefaultCompiledVersion}; -public Q_SLOTS: -QDataStream* new_QDataStream(); -QDataStream* new_QDataStream(QByteArray* arg__1, QIODevice::OpenMode flags); -QDataStream* new_QDataStream(QIODevice* arg__1); -QDataStream* new_QDataStream(const QByteArray& arg__1); -void delete_QDataStream(QDataStream* obj) { delete obj; } - void abortTransaction(QDataStream* theWrappedObject); - bool atEnd(QDataStream* theWrappedObject) const; - QDataStream::ByteOrder byteOrder(QDataStream* theWrappedObject) const; - bool commitTransaction(QDataStream* theWrappedObject); - QIODevice* device(QDataStream* theWrappedObject) const; - QDataStream::FloatingPointPrecision floatingPointPrecision(QDataStream* theWrappedObject) const; - void resetStatus(QDataStream* theWrappedObject); - void rollbackTransaction(QDataStream* theWrappedObject); - void setByteOrder(QDataStream* theWrappedObject, QDataStream::ByteOrder arg__1); - void setDevice(QDataStream* theWrappedObject, QIODevice* arg__1); - void setFloatingPointPrecision(QDataStream* theWrappedObject, QDataStream::FloatingPointPrecision precision); - void setStatus(QDataStream* theWrappedObject, QDataStream::Status status); - void setVersion(QDataStream* theWrappedObject, int arg__1); - int skipRawData(QDataStream* theWrappedObject, int len); - void startTransaction(QDataStream* theWrappedObject); - QDataStream::Status status(QDataStream* theWrappedObject) const; - void unsetDevice(QDataStream* theWrappedObject); - int version(QDataStream* theWrappedObject) const; - - QString readQString(QDataStream* d) { QString r; (*d) >> r; return r; } - QString readString(QDataStream* d) { QString r; (*d) >> r; return r; } - QChar readQChar(QDataStream* d) { QChar r; (*d) >> r; return r; } - QStringList readQStringList(QDataStream* d) { QStringList r; (*d) >> r; return r; } - QVariant readQVariant(QDataStream* d) { QVariant r; (*d) >> r; return r; } - bool readBool(QDataStream* d) { bool r; (*d) >> r; return r; } - qint8 readInt8(QDataStream* d) { qint8 r; (*d) >> r; return r; } - quint8 readUInt8(QDataStream* d) { quint8 r; (*d) >> r; return r; } - qint16 readInt16(QDataStream* d) { qint16 r; (*d) >> r; return r; } - quint16 readUInt16(QDataStream* d) { quint16 r; (*d) >> r; return r; } - qint32 readInt32(QDataStream* d) { qint32 r; (*d) >> r; return r; } - quint32 readUInt32(QDataStream* d) { quint32 r; (*d) >> r; return r; } - qint64 readInt64(QDataStream* d) { qint64 r; (*d) >> r; return r; } - quint64 readUInt64(QDataStream* d) { quint64 r; (*d) >> r; return r; } - float readFloat(QDataStream* d) { float r; (*d) >> r; return r; } - double readDouble(QDataStream* d) { double r; (*d) >> r; return r; } - - void writeQString(QDataStream* d, const QString& v) { (*d) << v; } - void writeString(QDataStream* d, const QString& v) { (*d) << v; } - void writeQChar(QDataStream* d, const QChar& v) { (*d) << v; } - void writeQStringList(QDataStream* d, const QStringList& v) { (*d) << v; } - void writeQVariant(QDataStream* d, const QVariant& v) { (*d) << v; } - void writeBool(QDataStream* d, bool v) { (*d) << v; } - void writeInt8(QDataStream* d, qint8 v) { (*d) << v; } - void writeUInt8(QDataStream* d, quint8 v) { (*d) << v; } - void writeInt16(QDataStream* d, qint16 v) { (*d) << v; } - void writeUInt16(QDataStream* d, quint16 v) { (*d) << v; } - void writeInt32(QDataStream* d, qint32 v) { (*d) << v; } - void writeUInt32(QDataStream* d, quint32 v) { (*d) << v; } - void writeInt64(QDataStream* d, qint64 v) { (*d) << v; } - void writeUInt64(QDataStream* d, quint64 v) { (*d) << v; } - void writeFloat(QDataStream* d, float v) { (*d) << v; } - void writeDouble(QDataStream* d, double v) { (*d) << v; } - - int writeRawData(QDataStream* d, PyObject* o) { - bool ok; - QByteArray r = PythonQtConv::PyObjGetBytes(o, false, ok); - return (*d).writeRawData(r.constData(), r.size()); - } - - PyObject* readRawData(QDataStream* d, int len) { - QByteArray r; - r.resize(len); - int result = d->readRawData(r.data(), r.size()); - if (result>=0) { - return PyBytes_FromStringAndSize(r.data(), result); - } else { - Py_INCREF(Py_None); - return Py_None; - } - } - -}; - - - - - -class PythonQtWrapper_QDeadlineTimer : public QObject -{ Q_OBJECT -public: -Q_ENUMS(ForeverConstant ) -enum ForeverConstant{ - Forever = QDeadlineTimer::Forever}; -public Q_SLOTS: -QDeadlineTimer* new_QDeadlineTimer(QDeadlineTimer::ForeverConstant arg__1, Qt::TimerType type_ = Qt::CoarseTimer); -QDeadlineTimer* new_QDeadlineTimer(Qt::TimerType type_ = Qt::CoarseTimer); -QDeadlineTimer* new_QDeadlineTimer(qint64 msecs, Qt::TimerType type = Qt::CoarseTimer); -void delete_QDeadlineTimer(QDeadlineTimer* obj) { delete obj; } - QDeadlineTimer static_QDeadlineTimer_addNSecs(QDeadlineTimer dt, qint64 nsecs); - QDeadlineTimer static_QDeadlineTimer_current(Qt::TimerType timerType = Qt::CoarseTimer); - qint64 deadline(QDeadlineTimer* theWrappedObject) const; - qint64 deadlineNSecs(QDeadlineTimer* theWrappedObject) const; - bool hasExpired(QDeadlineTimer* theWrappedObject) const; - bool isForever(QDeadlineTimer* theWrappedObject) const; - bool __ne__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2); - QDeadlineTimer __add__(QDeadlineTimer* theWrappedObject, qint64 msecs); - QDeadlineTimer* __iadd__(QDeadlineTimer* theWrappedObject, qint64 msecs); - qint64 __sub__(QDeadlineTimer* theWrappedObject, QDeadlineTimer dt2); - QDeadlineTimer __sub__(QDeadlineTimer* theWrappedObject, qint64 msecs); - QDeadlineTimer* __isub__(QDeadlineTimer* theWrappedObject, qint64 msecs); - bool __lt__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2); - bool __le__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2); - bool __eq__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2); - bool __gt__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2); - bool __ge__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2); - qint64 remainingTime(QDeadlineTimer* theWrappedObject) const; - qint64 remainingTimeNSecs(QDeadlineTimer* theWrappedObject) const; - void setDeadline(QDeadlineTimer* theWrappedObject, qint64 msecs, Qt::TimerType timerType = Qt::CoarseTimer); - void setPreciseDeadline(QDeadlineTimer* theWrappedObject, qint64 secs, qint64 nsecs = 0, Qt::TimerType type = Qt::CoarseTimer); - void setPreciseRemainingTime(QDeadlineTimer* theWrappedObject, qint64 secs, qint64 nsecs = 0, Qt::TimerType type = Qt::CoarseTimer); - void setRemainingTime(QDeadlineTimer* theWrappedObject, qint64 msecs, Qt::TimerType type = Qt::CoarseTimer); - void setTimerType(QDeadlineTimer* theWrappedObject, Qt::TimerType type); - void swap(QDeadlineTimer* theWrappedObject, QDeadlineTimer& other); - Qt::TimerType timerType(QDeadlineTimer* theWrappedObject) const; -}; - - diff --git a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core1.cpp b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core1.cpp index 22a75999c..3852c72b5 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core1.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core1.cpp @@ -14,6 +14,7 @@ #include #include #include +#include #include #include #include @@ -27,12 +28,10 @@ #include #include #include -#include #include #include #include #include -#include #include #include #include @@ -42,6 +41,258 @@ #include #include +QDataStream* PythonQtWrapper_QDataStream::new_QDataStream() +{ +return new QDataStream(); } + +QDataStream* PythonQtWrapper_QDataStream::new_QDataStream(QByteArray* arg__1, QIODevice::OpenMode flags) +{ +return new QDataStream(arg__1, flags); } + +QDataStream* PythonQtWrapper_QDataStream::new_QDataStream(QIODevice* arg__1) +{ +return new QDataStream(arg__1); } + +QDataStream* PythonQtWrapper_QDataStream::new_QDataStream(const QByteArray& arg__1) +{ +return new QDataStream(arg__1); } + +void PythonQtWrapper_QDataStream::abortTransaction(QDataStream* theWrappedObject) +{ + ( theWrappedObject->abortTransaction()); +} + +bool PythonQtWrapper_QDataStream::atEnd(QDataStream* theWrappedObject) const +{ + return ( theWrappedObject->atEnd()); +} + +QDataStream::ByteOrder PythonQtWrapper_QDataStream::byteOrder(QDataStream* theWrappedObject) const +{ + return ( theWrappedObject->byteOrder()); +} + +bool PythonQtWrapper_QDataStream::commitTransaction(QDataStream* theWrappedObject) +{ + return ( theWrappedObject->commitTransaction()); +} + +QIODevice* PythonQtWrapper_QDataStream::device(QDataStream* theWrappedObject) const +{ + return ( theWrappedObject->device()); +} + +QDataStream::FloatingPointPrecision PythonQtWrapper_QDataStream::floatingPointPrecision(QDataStream* theWrappedObject) const +{ + return ( theWrappedObject->floatingPointPrecision()); +} + +void PythonQtWrapper_QDataStream::resetStatus(QDataStream* theWrappedObject) +{ + ( theWrappedObject->resetStatus()); +} + +void PythonQtWrapper_QDataStream::rollbackTransaction(QDataStream* theWrappedObject) +{ + ( theWrappedObject->rollbackTransaction()); +} + +void PythonQtWrapper_QDataStream::setByteOrder(QDataStream* theWrappedObject, QDataStream::ByteOrder arg__1) +{ + ( theWrappedObject->setByteOrder(arg__1)); +} + +void PythonQtWrapper_QDataStream::setDevice(QDataStream* theWrappedObject, QIODevice* arg__1) +{ + ( theWrappedObject->setDevice(arg__1)); +} + +void PythonQtWrapper_QDataStream::setFloatingPointPrecision(QDataStream* theWrappedObject, QDataStream::FloatingPointPrecision precision) +{ + ( theWrappedObject->setFloatingPointPrecision(precision)); +} + +void PythonQtWrapper_QDataStream::setStatus(QDataStream* theWrappedObject, QDataStream::Status status) +{ + ( theWrappedObject->setStatus(status)); +} + +void PythonQtWrapper_QDataStream::setVersion(QDataStream* theWrappedObject, int arg__1) +{ + ( theWrappedObject->setVersion(arg__1)); +} + +int PythonQtWrapper_QDataStream::skipRawData(QDataStream* theWrappedObject, int len) +{ + return ( theWrappedObject->skipRawData(len)); +} + +void PythonQtWrapper_QDataStream::startTransaction(QDataStream* theWrappedObject) +{ + ( theWrappedObject->startTransaction()); +} + +QDataStream::Status PythonQtWrapper_QDataStream::status(QDataStream* theWrappedObject) const +{ + return ( theWrappedObject->status()); +} + +void PythonQtWrapper_QDataStream::unsetDevice(QDataStream* theWrappedObject) +{ + ( theWrappedObject->unsetDevice()); +} + +int PythonQtWrapper_QDataStream::version(QDataStream* theWrappedObject) const +{ + return ( theWrappedObject->version()); +} + + + +QDeadlineTimer* PythonQtWrapper_QDeadlineTimer::new_QDeadlineTimer(QDeadlineTimer::ForeverConstant arg__1, Qt::TimerType type_) +{ +return new QDeadlineTimer(arg__1, type_); } + +QDeadlineTimer* PythonQtWrapper_QDeadlineTimer::new_QDeadlineTimer(Qt::TimerType type_) +{ +return new QDeadlineTimer(type_); } + +QDeadlineTimer* PythonQtWrapper_QDeadlineTimer::new_QDeadlineTimer(qint64 msecs, Qt::TimerType type) +{ +return new QDeadlineTimer(msecs, type); } + +QDeadlineTimer PythonQtWrapper_QDeadlineTimer::static_QDeadlineTimer_addNSecs(QDeadlineTimer dt, qint64 nsecs) +{ + return (QDeadlineTimer::addNSecs(dt, nsecs)); +} + +QDeadlineTimer PythonQtWrapper_QDeadlineTimer::static_QDeadlineTimer_current(Qt::TimerType timerType) +{ + return (QDeadlineTimer::current(timerType)); +} + +qint64 PythonQtWrapper_QDeadlineTimer::deadline(QDeadlineTimer* theWrappedObject) const +{ + return ( theWrappedObject->deadline()); +} + +qint64 PythonQtWrapper_QDeadlineTimer::deadlineNSecs(QDeadlineTimer* theWrappedObject) const +{ + return ( theWrappedObject->deadlineNSecs()); +} + +bool PythonQtWrapper_QDeadlineTimer::hasExpired(QDeadlineTimer* theWrappedObject) const +{ + return ( theWrappedObject->hasExpired()); +} + +bool PythonQtWrapper_QDeadlineTimer::isForever(QDeadlineTimer* theWrappedObject) const +{ + return ( theWrappedObject->isForever()); +} + +bool PythonQtWrapper_QDeadlineTimer::__ne__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2) +{ + return ( (*theWrappedObject)!= d2); +} + +QDeadlineTimer PythonQtWrapper_QDeadlineTimer::__add__(QDeadlineTimer* theWrappedObject, qint64 msecs) +{ + return ( (*theWrappedObject)+ msecs); +} + +QDeadlineTimer* PythonQtWrapper_QDeadlineTimer::__iadd__(QDeadlineTimer* theWrappedObject, qint64 msecs) +{ + return &( (*theWrappedObject)+= msecs); +} + +qint64 PythonQtWrapper_QDeadlineTimer::__sub__(QDeadlineTimer* theWrappedObject, QDeadlineTimer dt2) +{ + return ( (*theWrappedObject)- dt2); +} + +QDeadlineTimer PythonQtWrapper_QDeadlineTimer::__sub__(QDeadlineTimer* theWrappedObject, qint64 msecs) +{ + return ( (*theWrappedObject)- msecs); +} + +QDeadlineTimer* PythonQtWrapper_QDeadlineTimer::__isub__(QDeadlineTimer* theWrappedObject, qint64 msecs) +{ + return &( (*theWrappedObject)-= msecs); +} + +bool PythonQtWrapper_QDeadlineTimer::__lt__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2) +{ + return ( (*theWrappedObject)< d2); +} + +bool PythonQtWrapper_QDeadlineTimer::__le__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2) +{ + return ( (*theWrappedObject)<= d2); +} + +bool PythonQtWrapper_QDeadlineTimer::__eq__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2) +{ + return ( (*theWrappedObject)== d2); +} + +bool PythonQtWrapper_QDeadlineTimer::__gt__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2) +{ + return ( (*theWrappedObject)> d2); +} + +bool PythonQtWrapper_QDeadlineTimer::__ge__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2) +{ + return ( (*theWrappedObject)>= d2); +} + +qint64 PythonQtWrapper_QDeadlineTimer::remainingTime(QDeadlineTimer* theWrappedObject) const +{ + return ( theWrappedObject->remainingTime()); +} + +qint64 PythonQtWrapper_QDeadlineTimer::remainingTimeNSecs(QDeadlineTimer* theWrappedObject) const +{ + return ( theWrappedObject->remainingTimeNSecs()); +} + +void PythonQtWrapper_QDeadlineTimer::setDeadline(QDeadlineTimer* theWrappedObject, qint64 msecs, Qt::TimerType timerType) +{ + ( theWrappedObject->setDeadline(msecs, timerType)); +} + +void PythonQtWrapper_QDeadlineTimer::setPreciseDeadline(QDeadlineTimer* theWrappedObject, qint64 secs, qint64 nsecs, Qt::TimerType type) +{ + ( theWrappedObject->setPreciseDeadline(secs, nsecs, type)); +} + +void PythonQtWrapper_QDeadlineTimer::setPreciseRemainingTime(QDeadlineTimer* theWrappedObject, qint64 secs, qint64 nsecs, Qt::TimerType type) +{ + ( theWrappedObject->setPreciseRemainingTime(secs, nsecs, type)); +} + +void PythonQtWrapper_QDeadlineTimer::setRemainingTime(QDeadlineTimer* theWrappedObject, qint64 msecs, Qt::TimerType type) +{ + ( theWrappedObject->setRemainingTime(msecs, type)); +} + +void PythonQtWrapper_QDeadlineTimer::setTimerType(QDeadlineTimer* theWrappedObject, Qt::TimerType type) +{ + ( theWrappedObject->setTimerType(type)); +} + +void PythonQtWrapper_QDeadlineTimer::swap(QDeadlineTimer* theWrappedObject, QDeadlineTimer& other) +{ + ( theWrappedObject->swap(other)); +} + +Qt::TimerType PythonQtWrapper_QDeadlineTimer::timerType(QDeadlineTimer* theWrappedObject) const +{ + return ( theWrappedObject->timerType()); +} + + + QDeferredDeleteEvent* PythonQtWrapper_QDeferredDeleteEvent::new_QDeferredDeleteEvent() { return new QDeferredDeleteEvent(); } @@ -7354,210 +7605,3 @@ void PythonQtWrapper_QLoggingCategory::static_QLoggingCategory_setFilterRules(co } - -QMarginsF* PythonQtWrapper_QMarginsF::new_QMarginsF() -{ -return new QMarginsF(); } - -QMarginsF* PythonQtWrapper_QMarginsF::new_QMarginsF(const QMargins& margins) -{ -return new QMarginsF(margins); } - -QMarginsF* PythonQtWrapper_QMarginsF::new_QMarginsF(qreal left, qreal top, qreal right, qreal bottom) -{ -return new QMarginsF(left, top, right, bottom); } - -qreal PythonQtWrapper_QMarginsF::bottom(QMarginsF* theWrappedObject) const -{ - return ( theWrappedObject->bottom()); -} - -bool PythonQtWrapper_QMarginsF::isNull(QMarginsF* theWrappedObject) const -{ - return ( theWrappedObject->isNull()); -} - -qreal PythonQtWrapper_QMarginsF::left(QMarginsF* theWrappedObject) const -{ - return ( theWrappedObject->left()); -} - -bool PythonQtWrapper_QMarginsF::__ne__(QMarginsF* theWrappedObject, const QMarginsF& rhs) -{ - return ( (*theWrappedObject)!= rhs); -} - -QMarginsF PythonQtWrapper_QMarginsF::__mul__(QMarginsF* theWrappedObject, qreal rhs) -{ - return ( (*theWrappedObject)* rhs); -} - -QMarginsF* PythonQtWrapper_QMarginsF::__imul__(QMarginsF* theWrappedObject, qreal factor) -{ - return &( (*theWrappedObject)*= factor); -} - -QMarginsF PythonQtWrapper_QMarginsF::__add__(QMarginsF* theWrappedObject) -{ - return (+ (*theWrappedObject)); -} - -QMarginsF PythonQtWrapper_QMarginsF::__add__(QMarginsF* theWrappedObject, const QMarginsF& rhs) -{ - return ( (*theWrappedObject)+ rhs); -} - -QRectF PythonQtWrapper_QMarginsF::__add__(QMarginsF* theWrappedObject, const QRectF& rhs) -{ - return ( (*theWrappedObject)+ rhs); -} - -QMarginsF PythonQtWrapper_QMarginsF::__add__(QMarginsF* theWrappedObject, qreal rhs) -{ - return ( (*theWrappedObject)+ rhs); -} - -QMarginsF* PythonQtWrapper_QMarginsF::__iadd__(QMarginsF* theWrappedObject, const QMarginsF& margins) -{ - return &( (*theWrappedObject)+= margins); -} - -QMarginsF* PythonQtWrapper_QMarginsF::__iadd__(QMarginsF* theWrappedObject, qreal addend) -{ - return &( (*theWrappedObject)+= addend); -} - -QMarginsF PythonQtWrapper_QMarginsF::__sub__(QMarginsF* theWrappedObject) -{ - return (- (*theWrappedObject)); -} - -QMarginsF PythonQtWrapper_QMarginsF::__sub__(QMarginsF* theWrappedObject, const QMarginsF& rhs) -{ - return ( (*theWrappedObject)- rhs); -} - -QMarginsF PythonQtWrapper_QMarginsF::__sub__(QMarginsF* theWrappedObject, qreal rhs) -{ - return ( (*theWrappedObject)- rhs); -} - -QMarginsF* PythonQtWrapper_QMarginsF::__isub__(QMarginsF* theWrappedObject, const QMarginsF& margins) -{ - return &( (*theWrappedObject)-= margins); -} - -QMarginsF* PythonQtWrapper_QMarginsF::__isub__(QMarginsF* theWrappedObject, qreal subtrahend) -{ - return &( (*theWrappedObject)-= subtrahend); -} - -QMarginsF PythonQtWrapper_QMarginsF::__div__(QMarginsF* theWrappedObject, qreal divisor) -{ - return ( (*theWrappedObject)/ divisor); -} - -QMarginsF* PythonQtWrapper_QMarginsF::__idiv__(QMarginsF* theWrappedObject, qreal divisor) -{ - return &( (*theWrappedObject)/= divisor); -} - -void PythonQtWrapper_QMarginsF::writeTo(QMarginsF* theWrappedObject, QDataStream& arg__1) -{ - arg__1 << (*theWrappedObject); -} - -bool PythonQtWrapper_QMarginsF::__eq__(QMarginsF* theWrappedObject, const QMarginsF& rhs) -{ - return ( (*theWrappedObject)== rhs); -} - -void PythonQtWrapper_QMarginsF::readFrom(QMarginsF* theWrappedObject, QDataStream& arg__1) -{ - arg__1 >> (*theWrappedObject); -} - -qreal PythonQtWrapper_QMarginsF::right(QMarginsF* theWrappedObject) const -{ - return ( theWrappedObject->right()); -} - -void PythonQtWrapper_QMarginsF::setBottom(QMarginsF* theWrappedObject, qreal bottom) -{ - ( theWrappedObject->setBottom(bottom)); -} - -void PythonQtWrapper_QMarginsF::setLeft(QMarginsF* theWrappedObject, qreal left) -{ - ( theWrappedObject->setLeft(left)); -} - -void PythonQtWrapper_QMarginsF::setRight(QMarginsF* theWrappedObject, qreal right) -{ - ( theWrappedObject->setRight(right)); -} - -void PythonQtWrapper_QMarginsF::setTop(QMarginsF* theWrappedObject, qreal top) -{ - ( theWrappedObject->setTop(top)); -} - -QMargins PythonQtWrapper_QMarginsF::toMargins(QMarginsF* theWrappedObject) const -{ - return ( theWrappedObject->toMargins()); -} - -qreal PythonQtWrapper_QMarginsF::top(QMarginsF* theWrappedObject) const -{ - return ( theWrappedObject->top()); -} - -QString PythonQtWrapper_QMarginsF::py_toString(QMarginsF* obj) { - QString result; - QDebug d(&result); - d << *obj; - return result; -} - - - -QMessageAuthenticationCode* PythonQtWrapper_QMessageAuthenticationCode::new_QMessageAuthenticationCode(QCryptographicHash::Algorithm method, const QByteArray& key) -{ -return new QMessageAuthenticationCode(method, key); } - -bool PythonQtWrapper_QMessageAuthenticationCode::addData(QMessageAuthenticationCode* theWrappedObject, QIODevice* device) -{ - return ( theWrappedObject->addData(device)); -} - -void PythonQtWrapper_QMessageAuthenticationCode::addData(QMessageAuthenticationCode* theWrappedObject, const QByteArray& data) -{ - ( theWrappedObject->addData(data)); -} - -void PythonQtWrapper_QMessageAuthenticationCode::addData(QMessageAuthenticationCode* theWrappedObject, const char* data, int length) -{ - ( theWrappedObject->addData(data, length)); -} - -QByteArray PythonQtWrapper_QMessageAuthenticationCode::static_QMessageAuthenticationCode_hash(const QByteArray& message, const QByteArray& key, QCryptographicHash::Algorithm method) -{ - return (QMessageAuthenticationCode::hash(message, key, method)); -} - -void PythonQtWrapper_QMessageAuthenticationCode::reset(QMessageAuthenticationCode* theWrappedObject) -{ - ( theWrappedObject->reset()); -} - -QByteArray PythonQtWrapper_QMessageAuthenticationCode::result(QMessageAuthenticationCode* theWrappedObject) const -{ - return ( theWrappedObject->result()); -} - -void PythonQtWrapper_QMessageAuthenticationCode::setKey(QMessageAuthenticationCode* theWrappedObject, const QByteArray& key) -{ - ( theWrappedObject->setKey(key)); -} - - diff --git a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core1.h b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core1.h index e73740091..49fbf5cc5 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core1.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core1.h @@ -1,4 +1,5 @@ #include +#include #include #include #include @@ -12,6 +13,7 @@ #include #include #include +#include #include #include #include @@ -38,13 +40,10 @@ #include #include #include -#include -#include #include #include #include #include -#include #include #include #include @@ -56,6 +55,144 @@ +class PythonQtWrapper_QDataStream : public QObject +{ Q_OBJECT +public: +Q_ENUMS(ByteOrder FloatingPointPrecision Status Version ) +enum ByteOrder{ + BigEndian = QDataStream::BigEndian, LittleEndian = QDataStream::LittleEndian}; +enum FloatingPointPrecision{ + SinglePrecision = QDataStream::SinglePrecision, DoublePrecision = QDataStream::DoublePrecision}; +enum Status{ + Ok = QDataStream::Ok, ReadPastEnd = QDataStream::ReadPastEnd, ReadCorruptData = QDataStream::ReadCorruptData, WriteFailed = QDataStream::WriteFailed}; +enum Version{ + Qt_1_0 = QDataStream::Qt_1_0, Qt_2_0 = QDataStream::Qt_2_0, Qt_2_1 = QDataStream::Qt_2_1, Qt_3_0 = QDataStream::Qt_3_0, Qt_3_1 = QDataStream::Qt_3_1, Qt_3_3 = QDataStream::Qt_3_3, Qt_4_0 = QDataStream::Qt_4_0, Qt_4_1 = QDataStream::Qt_4_1, Qt_4_2 = QDataStream::Qt_4_2, Qt_4_3 = QDataStream::Qt_4_3, Qt_4_4 = QDataStream::Qt_4_4, Qt_4_5 = QDataStream::Qt_4_5, Qt_4_6 = QDataStream::Qt_4_6, Qt_4_7 = QDataStream::Qt_4_7, Qt_4_8 = QDataStream::Qt_4_8, Qt_4_9 = QDataStream::Qt_4_9, Qt_5_0 = QDataStream::Qt_5_0, Qt_5_1 = QDataStream::Qt_5_1, Qt_5_2 = QDataStream::Qt_5_2, Qt_5_3 = QDataStream::Qt_5_3, Qt_5_4 = QDataStream::Qt_5_4, Qt_5_5 = QDataStream::Qt_5_5, Qt_5_6 = QDataStream::Qt_5_6, Qt_5_7 = QDataStream::Qt_5_7, Qt_5_8 = QDataStream::Qt_5_8, Qt_5_9 = QDataStream::Qt_5_9, Qt_5_10 = QDataStream::Qt_5_10, Qt_5_11 = QDataStream::Qt_5_11, Qt_5_12 = QDataStream::Qt_5_12, Qt_5_13 = QDataStream::Qt_5_13, Qt_5_14 = QDataStream::Qt_5_14, Qt_5_15 = QDataStream::Qt_5_15, Qt_DefaultCompiledVersion = QDataStream::Qt_DefaultCompiledVersion}; +public Q_SLOTS: +QDataStream* new_QDataStream(); +QDataStream* new_QDataStream(QByteArray* arg__1, QIODevice::OpenMode flags); +QDataStream* new_QDataStream(QIODevice* arg__1); +QDataStream* new_QDataStream(const QByteArray& arg__1); +void delete_QDataStream(QDataStream* obj) { delete obj; } + void abortTransaction(QDataStream* theWrappedObject); + bool atEnd(QDataStream* theWrappedObject) const; + QDataStream::ByteOrder byteOrder(QDataStream* theWrappedObject) const; + bool commitTransaction(QDataStream* theWrappedObject); + QIODevice* device(QDataStream* theWrappedObject) const; + QDataStream::FloatingPointPrecision floatingPointPrecision(QDataStream* theWrappedObject) const; + void resetStatus(QDataStream* theWrappedObject); + void rollbackTransaction(QDataStream* theWrappedObject); + void setByteOrder(QDataStream* theWrappedObject, QDataStream::ByteOrder arg__1); + void setDevice(QDataStream* theWrappedObject, QIODevice* arg__1); + void setFloatingPointPrecision(QDataStream* theWrappedObject, QDataStream::FloatingPointPrecision precision); + void setStatus(QDataStream* theWrappedObject, QDataStream::Status status); + void setVersion(QDataStream* theWrappedObject, int arg__1); + int skipRawData(QDataStream* theWrappedObject, int len); + void startTransaction(QDataStream* theWrappedObject); + QDataStream::Status status(QDataStream* theWrappedObject) const; + void unsetDevice(QDataStream* theWrappedObject); + int version(QDataStream* theWrappedObject) const; + + QString readQString(QDataStream* d) { QString r; (*d) >> r; return r; } + QString readString(QDataStream* d) { QString r; (*d) >> r; return r; } + QChar readQChar(QDataStream* d) { QChar r; (*d) >> r; return r; } + QStringList readQStringList(QDataStream* d) { QStringList r; (*d) >> r; return r; } + QVariant readQVariant(QDataStream* d) { QVariant r; (*d) >> r; return r; } + bool readBool(QDataStream* d) { bool r; (*d) >> r; return r; } + qint8 readInt8(QDataStream* d) { qint8 r; (*d) >> r; return r; } + quint8 readUInt8(QDataStream* d) { quint8 r; (*d) >> r; return r; } + qint16 readInt16(QDataStream* d) { qint16 r; (*d) >> r; return r; } + quint16 readUInt16(QDataStream* d) { quint16 r; (*d) >> r; return r; } + qint32 readInt32(QDataStream* d) { qint32 r; (*d) >> r; return r; } + quint32 readUInt32(QDataStream* d) { quint32 r; (*d) >> r; return r; } + qint64 readInt64(QDataStream* d) { qint64 r; (*d) >> r; return r; } + quint64 readUInt64(QDataStream* d) { quint64 r; (*d) >> r; return r; } + float readFloat(QDataStream* d) { float r; (*d) >> r; return r; } + double readDouble(QDataStream* d) { double r; (*d) >> r; return r; } + + void writeQString(QDataStream* d, const QString& v) { (*d) << v; } + void writeString(QDataStream* d, const QString& v) { (*d) << v; } + void writeQChar(QDataStream* d, const QChar& v) { (*d) << v; } + void writeQStringList(QDataStream* d, const QStringList& v) { (*d) << v; } + void writeQVariant(QDataStream* d, const QVariant& v) { (*d) << v; } + void writeBool(QDataStream* d, bool v) { (*d) << v; } + void writeInt8(QDataStream* d, qint8 v) { (*d) << v; } + void writeUInt8(QDataStream* d, quint8 v) { (*d) << v; } + void writeInt16(QDataStream* d, qint16 v) { (*d) << v; } + void writeUInt16(QDataStream* d, quint16 v) { (*d) << v; } + void writeInt32(QDataStream* d, qint32 v) { (*d) << v; } + void writeUInt32(QDataStream* d, quint32 v) { (*d) << v; } + void writeInt64(QDataStream* d, qint64 v) { (*d) << v; } + void writeUInt64(QDataStream* d, quint64 v) { (*d) << v; } + void writeFloat(QDataStream* d, float v) { (*d) << v; } + void writeDouble(QDataStream* d, double v) { (*d) << v; } + + int writeRawData(QDataStream* d, PyObject* o) { + bool ok; + QByteArray r = PythonQtConv::PyObjGetBytes(o, false, ok); + return (*d).writeRawData(r.constData(), r.size()); + } + + PyObject* readRawData(QDataStream* d, int len) { + QByteArray r; + r.resize(len); + int result = d->readRawData(r.data(), r.size()); + if (result>=0) { + return PyBytes_FromStringAndSize(r.data(), result); + } else { + Py_INCREF(Py_None); + return Py_None; + } + } + +}; + + + + + +class PythonQtWrapper_QDeadlineTimer : public QObject +{ Q_OBJECT +public: +Q_ENUMS(ForeverConstant ) +enum ForeverConstant{ + Forever = QDeadlineTimer::Forever}; +public Q_SLOTS: +QDeadlineTimer* new_QDeadlineTimer(QDeadlineTimer::ForeverConstant arg__1, Qt::TimerType type_ = Qt::CoarseTimer); +QDeadlineTimer* new_QDeadlineTimer(Qt::TimerType type_ = Qt::CoarseTimer); +QDeadlineTimer* new_QDeadlineTimer(qint64 msecs, Qt::TimerType type = Qt::CoarseTimer); +void delete_QDeadlineTimer(QDeadlineTimer* obj) { delete obj; } + QDeadlineTimer static_QDeadlineTimer_addNSecs(QDeadlineTimer dt, qint64 nsecs); + QDeadlineTimer static_QDeadlineTimer_current(Qt::TimerType timerType = Qt::CoarseTimer); + qint64 deadline(QDeadlineTimer* theWrappedObject) const; + qint64 deadlineNSecs(QDeadlineTimer* theWrappedObject) const; + bool hasExpired(QDeadlineTimer* theWrappedObject) const; + bool isForever(QDeadlineTimer* theWrappedObject) const; + bool __ne__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2); + QDeadlineTimer __add__(QDeadlineTimer* theWrappedObject, qint64 msecs); + QDeadlineTimer* __iadd__(QDeadlineTimer* theWrappedObject, qint64 msecs); + qint64 __sub__(QDeadlineTimer* theWrappedObject, QDeadlineTimer dt2); + QDeadlineTimer __sub__(QDeadlineTimer* theWrappedObject, qint64 msecs); + QDeadlineTimer* __isub__(QDeadlineTimer* theWrappedObject, qint64 msecs); + bool __lt__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2); + bool __le__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2); + bool __eq__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2); + bool __gt__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2); + bool __ge__(QDeadlineTimer* theWrappedObject, QDeadlineTimer d2); + qint64 remainingTime(QDeadlineTimer* theWrappedObject) const; + qint64 remainingTimeNSecs(QDeadlineTimer* theWrappedObject) const; + void setDeadline(QDeadlineTimer* theWrappedObject, qint64 msecs, Qt::TimerType timerType = Qt::CoarseTimer); + void setPreciseDeadline(QDeadlineTimer* theWrappedObject, qint64 secs, qint64 nsecs = 0, Qt::TimerType type = Qt::CoarseTimer); + void setPreciseRemainingTime(QDeadlineTimer* theWrappedObject, qint64 secs, qint64 nsecs = 0, Qt::TimerType type = Qt::CoarseTimer); + void setRemainingTime(QDeadlineTimer* theWrappedObject, qint64 msecs, Qt::TimerType type = Qt::CoarseTimer); + void setTimerType(QDeadlineTimer* theWrappedObject, Qt::TimerType type); + void swap(QDeadlineTimer* theWrappedObject, QDeadlineTimer& other); + Qt::TimerType timerType(QDeadlineTimer* theWrappedObject) const; +}; + + + + + class PythonQtWrapper_QDeferredDeleteEvent : public QObject { Q_OBJECT public: @@ -1465,67 +1602,3 @@ void delete_QLoggingCategory(QLoggingCategory* obj) { delete obj; } }; - - - -class PythonQtWrapper_QMarginsF : public QObject -{ Q_OBJECT -public: -public Q_SLOTS: -QMarginsF* new_QMarginsF(); -QMarginsF* new_QMarginsF(const QMargins& margins); -QMarginsF* new_QMarginsF(qreal left, qreal top, qreal right, qreal bottom); -void delete_QMarginsF(QMarginsF* obj) { delete obj; } - qreal bottom(QMarginsF* theWrappedObject) const; - bool isNull(QMarginsF* theWrappedObject) const; - qreal left(QMarginsF* theWrappedObject) const; - bool __ne__(QMarginsF* theWrappedObject, const QMarginsF& rhs); - QMarginsF __mul__(QMarginsF* theWrappedObject, qreal rhs); - QMarginsF* __imul__(QMarginsF* theWrappedObject, qreal factor); - QMarginsF __add__(QMarginsF* theWrappedObject); - QMarginsF __add__(QMarginsF* theWrappedObject, const QMarginsF& rhs); - QRectF __add__(QMarginsF* theWrappedObject, const QRectF& rhs); - QMarginsF __add__(QMarginsF* theWrappedObject, qreal rhs); - QMarginsF* __iadd__(QMarginsF* theWrappedObject, const QMarginsF& margins); - QMarginsF* __iadd__(QMarginsF* theWrappedObject, qreal addend); - QMarginsF __sub__(QMarginsF* theWrappedObject); - QMarginsF __sub__(QMarginsF* theWrappedObject, const QMarginsF& rhs); - QMarginsF __sub__(QMarginsF* theWrappedObject, qreal rhs); - QMarginsF* __isub__(QMarginsF* theWrappedObject, const QMarginsF& margins); - QMarginsF* __isub__(QMarginsF* theWrappedObject, qreal subtrahend); - QMarginsF __div__(QMarginsF* theWrappedObject, qreal divisor); - QMarginsF* __idiv__(QMarginsF* theWrappedObject, qreal divisor); - void writeTo(QMarginsF* theWrappedObject, QDataStream& arg__1); - bool __eq__(QMarginsF* theWrappedObject, const QMarginsF& rhs); - void readFrom(QMarginsF* theWrappedObject, QDataStream& arg__1); - qreal right(QMarginsF* theWrappedObject) const; - void setBottom(QMarginsF* theWrappedObject, qreal bottom); - void setLeft(QMarginsF* theWrappedObject, qreal left); - void setRight(QMarginsF* theWrappedObject, qreal right); - void setTop(QMarginsF* theWrappedObject, qreal top); - QMargins toMargins(QMarginsF* theWrappedObject) const; - qreal top(QMarginsF* theWrappedObject) const; - QString py_toString(QMarginsF*); - bool __nonzero__(QMarginsF* obj) { return !obj->isNull(); } -}; - - - - - -class PythonQtWrapper_QMessageAuthenticationCode : public QObject -{ Q_OBJECT -public: -public Q_SLOTS: -QMessageAuthenticationCode* new_QMessageAuthenticationCode(QCryptographicHash::Algorithm method, const QByteArray& key = QByteArray()); -void delete_QMessageAuthenticationCode(QMessageAuthenticationCode* obj) { delete obj; } - bool addData(QMessageAuthenticationCode* theWrappedObject, QIODevice* device); - void addData(QMessageAuthenticationCode* theWrappedObject, const QByteArray& data); - void addData(QMessageAuthenticationCode* theWrappedObject, const char* data, int length); - QByteArray static_QMessageAuthenticationCode_hash(const QByteArray& message, const QByteArray& key, QCryptographicHash::Algorithm method); - void reset(QMessageAuthenticationCode* theWrappedObject); - QByteArray result(QMessageAuthenticationCode* theWrappedObject) const; - void setKey(QMessageAuthenticationCode* theWrappedObject, const QByteArray& key); -}; - - diff --git a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core2.cpp b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core2.cpp index 5a491d6e5..80f0d2aad 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core2.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core2.cpp @@ -12,13 +12,12 @@ #include #include #include -#include #include #include #include #include -#include #include +#include #include #include #include @@ -29,12 +28,220 @@ #include #include #include +#include #include #include #include #include #include +QMarginsF* PythonQtWrapper_QMarginsF::new_QMarginsF() +{ +return new QMarginsF(); } + +QMarginsF* PythonQtWrapper_QMarginsF::new_QMarginsF(const QMargins& margins) +{ +return new QMarginsF(margins); } + +QMarginsF* PythonQtWrapper_QMarginsF::new_QMarginsF(qreal left, qreal top, qreal right, qreal bottom) +{ +return new QMarginsF(left, top, right, bottom); } + +qreal PythonQtWrapper_QMarginsF::bottom(QMarginsF* theWrappedObject) const +{ + return ( theWrappedObject->bottom()); +} + +bool PythonQtWrapper_QMarginsF::isNull(QMarginsF* theWrappedObject) const +{ + return ( theWrappedObject->isNull()); +} + +qreal PythonQtWrapper_QMarginsF::left(QMarginsF* theWrappedObject) const +{ + return ( theWrappedObject->left()); +} + +bool PythonQtWrapper_QMarginsF::__ne__(QMarginsF* theWrappedObject, const QMarginsF& rhs) +{ + return ( (*theWrappedObject)!= rhs); +} + +QMarginsF PythonQtWrapper_QMarginsF::__mul__(QMarginsF* theWrappedObject, qreal rhs) +{ + return ( (*theWrappedObject)* rhs); +} + +QMarginsF* PythonQtWrapper_QMarginsF::__imul__(QMarginsF* theWrappedObject, qreal factor) +{ + return &( (*theWrappedObject)*= factor); +} + +QMarginsF PythonQtWrapper_QMarginsF::__add__(QMarginsF* theWrappedObject) +{ + return (+ (*theWrappedObject)); +} + +QMarginsF PythonQtWrapper_QMarginsF::__add__(QMarginsF* theWrappedObject, const QMarginsF& rhs) +{ + return ( (*theWrappedObject)+ rhs); +} + +QRectF PythonQtWrapper_QMarginsF::__add__(QMarginsF* theWrappedObject, const QRectF& rhs) +{ + return ( (*theWrappedObject)+ rhs); +} + +QMarginsF PythonQtWrapper_QMarginsF::__add__(QMarginsF* theWrappedObject, qreal rhs) +{ + return ( (*theWrappedObject)+ rhs); +} + +QMarginsF* PythonQtWrapper_QMarginsF::__iadd__(QMarginsF* theWrappedObject, const QMarginsF& margins) +{ + return &( (*theWrappedObject)+= margins); +} + +QMarginsF* PythonQtWrapper_QMarginsF::__iadd__(QMarginsF* theWrappedObject, qreal addend) +{ + return &( (*theWrappedObject)+= addend); +} + +QMarginsF PythonQtWrapper_QMarginsF::__sub__(QMarginsF* theWrappedObject) +{ + return (- (*theWrappedObject)); +} + +QMarginsF PythonQtWrapper_QMarginsF::__sub__(QMarginsF* theWrappedObject, const QMarginsF& rhs) +{ + return ( (*theWrappedObject)- rhs); +} + +QMarginsF PythonQtWrapper_QMarginsF::__sub__(QMarginsF* theWrappedObject, qreal rhs) +{ + return ( (*theWrappedObject)- rhs); +} + +QMarginsF* PythonQtWrapper_QMarginsF::__isub__(QMarginsF* theWrappedObject, const QMarginsF& margins) +{ + return &( (*theWrappedObject)-= margins); +} + +QMarginsF* PythonQtWrapper_QMarginsF::__isub__(QMarginsF* theWrappedObject, qreal subtrahend) +{ + return &( (*theWrappedObject)-= subtrahend); +} + +QMarginsF PythonQtWrapper_QMarginsF::__div__(QMarginsF* theWrappedObject, qreal divisor) +{ + return ( (*theWrappedObject)/ divisor); +} + +QMarginsF* PythonQtWrapper_QMarginsF::__idiv__(QMarginsF* theWrappedObject, qreal divisor) +{ + return &( (*theWrappedObject)/= divisor); +} + +void PythonQtWrapper_QMarginsF::writeTo(QMarginsF* theWrappedObject, QDataStream& arg__1) +{ + arg__1 << (*theWrappedObject); +} + +bool PythonQtWrapper_QMarginsF::__eq__(QMarginsF* theWrappedObject, const QMarginsF& rhs) +{ + return ( (*theWrappedObject)== rhs); +} + +void PythonQtWrapper_QMarginsF::readFrom(QMarginsF* theWrappedObject, QDataStream& arg__1) +{ + arg__1 >> (*theWrappedObject); +} + +qreal PythonQtWrapper_QMarginsF::right(QMarginsF* theWrappedObject) const +{ + return ( theWrappedObject->right()); +} + +void PythonQtWrapper_QMarginsF::setBottom(QMarginsF* theWrappedObject, qreal bottom) +{ + ( theWrappedObject->setBottom(bottom)); +} + +void PythonQtWrapper_QMarginsF::setLeft(QMarginsF* theWrappedObject, qreal left) +{ + ( theWrappedObject->setLeft(left)); +} + +void PythonQtWrapper_QMarginsF::setRight(QMarginsF* theWrappedObject, qreal right) +{ + ( theWrappedObject->setRight(right)); +} + +void PythonQtWrapper_QMarginsF::setTop(QMarginsF* theWrappedObject, qreal top) +{ + ( theWrappedObject->setTop(top)); +} + +QMargins PythonQtWrapper_QMarginsF::toMargins(QMarginsF* theWrappedObject) const +{ + return ( theWrappedObject->toMargins()); +} + +qreal PythonQtWrapper_QMarginsF::top(QMarginsF* theWrappedObject) const +{ + return ( theWrappedObject->top()); +} + +QString PythonQtWrapper_QMarginsF::py_toString(QMarginsF* obj) { + QString result; + QDebug d(&result); + d << *obj; + return result; +} + + + +QMessageAuthenticationCode* PythonQtWrapper_QMessageAuthenticationCode::new_QMessageAuthenticationCode(QCryptographicHash::Algorithm method, const QByteArray& key) +{ +return new QMessageAuthenticationCode(method, key); } + +bool PythonQtWrapper_QMessageAuthenticationCode::addData(QMessageAuthenticationCode* theWrappedObject, QIODevice* device) +{ + return ( theWrappedObject->addData(device)); +} + +void PythonQtWrapper_QMessageAuthenticationCode::addData(QMessageAuthenticationCode* theWrappedObject, const QByteArray& data) +{ + ( theWrappedObject->addData(data)); +} + +void PythonQtWrapper_QMessageAuthenticationCode::addData(QMessageAuthenticationCode* theWrappedObject, const char* data, int length) +{ + ( theWrappedObject->addData(data, length)); +} + +QByteArray PythonQtWrapper_QMessageAuthenticationCode::static_QMessageAuthenticationCode_hash(const QByteArray& message, const QByteArray& key, QCryptographicHash::Algorithm method) +{ + return (QMessageAuthenticationCode::hash(message, key, method)); +} + +void PythonQtWrapper_QMessageAuthenticationCode::reset(QMessageAuthenticationCode* theWrappedObject) +{ + ( theWrappedObject->reset()); +} + +QByteArray PythonQtWrapper_QMessageAuthenticationCode::result(QMessageAuthenticationCode* theWrappedObject) const +{ + return ( theWrappedObject->result()); +} + +void PythonQtWrapper_QMessageAuthenticationCode::setKey(QMessageAuthenticationCode* theWrappedObject, const QByteArray& key) +{ + ( theWrappedObject->setKey(key)); +} + + + PythonQtShell_QMessageLogContext::~PythonQtShell_QMessageLogContext() { PythonQtPrivate* priv = PythonQt::priv(); if (priv) { priv->shellClassDeleted(this); } @@ -4040,170 +4247,3 @@ void PythonQtWrapper_QRegularExpressionMatchIterator::swap(QRegularExpressionMat } - -PythonQtShell_QResource::~PythonQtShell_QResource() { - PythonQtPrivate* priv = PythonQt::priv(); - if (priv) { priv->shellClassDeleted(this); } -} -QResource* PythonQtWrapper_QResource::new_QResource(const QString& file, const QLocale& locale) -{ -return new PythonQtShell_QResource(file, locale); } - -QString PythonQtWrapper_QResource::absoluteFilePath(QResource* theWrappedObject) const -{ - return ( theWrappedObject->absoluteFilePath()); -} - -void PythonQtWrapper_QResource::static_QResource_addSearchPath(const QString& path) -{ - (QResource::addSearchPath(path)); -} - -QStringList PythonQtWrapper_QResource::children(QResource* theWrappedObject) const -{ - return ( ((PythonQtPublicPromoter_QResource*)theWrappedObject)->promoted_children()); -} - -QResource::Compression PythonQtWrapper_QResource::compressionAlgorithm(QResource* theWrappedObject) const -{ - return ( theWrappedObject->compressionAlgorithm()); -} - -const uchar* PythonQtWrapper_QResource::data(QResource* theWrappedObject) const -{ - return ( theWrappedObject->data()); -} - -QString PythonQtWrapper_QResource::fileName(QResource* theWrappedObject) const -{ - return ( theWrappedObject->fileName()); -} - -bool PythonQtWrapper_QResource::isCompressed(QResource* theWrappedObject) const -{ - return ( theWrappedObject->isCompressed()); -} - -bool PythonQtWrapper_QResource::isDir(QResource* theWrappedObject) const -{ - return ( ((PythonQtPublicPromoter_QResource*)theWrappedObject)->promoted_isDir()); -} - -bool PythonQtWrapper_QResource::isFile(QResource* theWrappedObject) const -{ - return ( ((PythonQtPublicPromoter_QResource*)theWrappedObject)->promoted_isFile()); -} - -bool PythonQtWrapper_QResource::isValid(QResource* theWrappedObject) const -{ - return ( theWrappedObject->isValid()); -} - -QDateTime PythonQtWrapper_QResource::lastModified(QResource* theWrappedObject) const -{ - return ( theWrappedObject->lastModified()); -} - -QLocale PythonQtWrapper_QResource::locale(QResource* theWrappedObject) const -{ - return ( theWrappedObject->locale()); -} - -bool PythonQtWrapper_QResource::static_QResource_registerResource(const QString& rccFilename, const QString& resourceRoot) -{ - return (QResource::registerResource(rccFilename, resourceRoot)); -} - -bool PythonQtWrapper_QResource::static_QResource_registerResource(const uchar* rccData, const QString& resourceRoot) -{ - return (QResource::registerResource(rccData, resourceRoot)); -} - -QStringList PythonQtWrapper_QResource::static_QResource_searchPaths() -{ - return (QResource::searchPaths()); -} - -void PythonQtWrapper_QResource::setFileName(QResource* theWrappedObject, const QString& file) -{ - ( theWrappedObject->setFileName(file)); -} - -void PythonQtWrapper_QResource::setLocale(QResource* theWrappedObject, const QLocale& locale) -{ - ( theWrappedObject->setLocale(locale)); -} - -qint64 PythonQtWrapper_QResource::size(QResource* theWrappedObject) const -{ - return ( theWrappedObject->size()); -} - -QByteArray PythonQtWrapper_QResource::uncompressedData(QResource* theWrappedObject) const -{ - return ( theWrappedObject->uncompressedData()); -} - -qint64 PythonQtWrapper_QResource::uncompressedSize(QResource* theWrappedObject) const -{ - return ( theWrappedObject->uncompressedSize()); -} - -bool PythonQtWrapper_QResource::static_QResource_unregisterResource(const QString& rccFilename, const QString& resourceRoot) -{ - return (QResource::unregisterResource(rccFilename, resourceRoot)); -} - -bool PythonQtWrapper_QResource::static_QResource_unregisterResource(const uchar* rccData, const QString& resourceRoot) -{ - return (QResource::unregisterResource(rccData, resourceRoot)); -} - - - -PythonQtShell_QRunnable::~PythonQtShell_QRunnable() { - PythonQtPrivate* priv = PythonQt::priv(); - if (priv) { priv->shellClassDeleted(this); } -} -void PythonQtShell_QRunnable::run() -{ -if (_wrapper) { - PYTHONQT_GIL_SCOPE - if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("run"); - PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); - if (obj) { - static const char* argumentList[] ={""}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); - void* args[1] = {nullptr}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } else { - PyErr_Clear(); - } - } -} - -} -QRunnable* PythonQtWrapper_QRunnable::new_QRunnable() -{ -return new PythonQtShell_QRunnable(); } - -bool PythonQtWrapper_QRunnable::autoDelete(QRunnable* theWrappedObject) const -{ - return ( theWrappedObject->autoDelete()); -} - -void PythonQtWrapper_QRunnable::run(QRunnable* theWrappedObject) -{ - ( theWrappedObject->run()); -} - -void PythonQtWrapper_QRunnable::setAutoDelete(QRunnable* theWrappedObject, bool _autoDelete) -{ - ( theWrappedObject->setAutoDelete(_autoDelete)); -} - - diff --git a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core2.h b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core2.h index 78ee2cee1..892cc42c6 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core2.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core2.h @@ -10,13 +10,13 @@ #include #include #include -#include #include #include #include #include -#include #include +#include +#include #include #include #include @@ -32,9 +32,8 @@ #include #include #include +#include #include -#include -#include #include #include #include @@ -42,6 +41,70 @@ +class PythonQtWrapper_QMarginsF : public QObject +{ Q_OBJECT +public: +public Q_SLOTS: +QMarginsF* new_QMarginsF(); +QMarginsF* new_QMarginsF(const QMargins& margins); +QMarginsF* new_QMarginsF(qreal left, qreal top, qreal right, qreal bottom); +void delete_QMarginsF(QMarginsF* obj) { delete obj; } + qreal bottom(QMarginsF* theWrappedObject) const; + bool isNull(QMarginsF* theWrappedObject) const; + qreal left(QMarginsF* theWrappedObject) const; + bool __ne__(QMarginsF* theWrappedObject, const QMarginsF& rhs); + QMarginsF __mul__(QMarginsF* theWrappedObject, qreal rhs); + QMarginsF* __imul__(QMarginsF* theWrappedObject, qreal factor); + QMarginsF __add__(QMarginsF* theWrappedObject); + QMarginsF __add__(QMarginsF* theWrappedObject, const QMarginsF& rhs); + QRectF __add__(QMarginsF* theWrappedObject, const QRectF& rhs); + QMarginsF __add__(QMarginsF* theWrappedObject, qreal rhs); + QMarginsF* __iadd__(QMarginsF* theWrappedObject, const QMarginsF& margins); + QMarginsF* __iadd__(QMarginsF* theWrappedObject, qreal addend); + QMarginsF __sub__(QMarginsF* theWrappedObject); + QMarginsF __sub__(QMarginsF* theWrappedObject, const QMarginsF& rhs); + QMarginsF __sub__(QMarginsF* theWrappedObject, qreal rhs); + QMarginsF* __isub__(QMarginsF* theWrappedObject, const QMarginsF& margins); + QMarginsF* __isub__(QMarginsF* theWrappedObject, qreal subtrahend); + QMarginsF __div__(QMarginsF* theWrappedObject, qreal divisor); + QMarginsF* __idiv__(QMarginsF* theWrappedObject, qreal divisor); + void writeTo(QMarginsF* theWrappedObject, QDataStream& arg__1); + bool __eq__(QMarginsF* theWrappedObject, const QMarginsF& rhs); + void readFrom(QMarginsF* theWrappedObject, QDataStream& arg__1); + qreal right(QMarginsF* theWrappedObject) const; + void setBottom(QMarginsF* theWrappedObject, qreal bottom); + void setLeft(QMarginsF* theWrappedObject, qreal left); + void setRight(QMarginsF* theWrappedObject, qreal right); + void setTop(QMarginsF* theWrappedObject, qreal top); + QMargins toMargins(QMarginsF* theWrappedObject) const; + qreal top(QMarginsF* theWrappedObject) const; + QString py_toString(QMarginsF*); + bool __nonzero__(QMarginsF* obj) { return !obj->isNull(); } +}; + + + + + +class PythonQtWrapper_QMessageAuthenticationCode : public QObject +{ Q_OBJECT +public: +public Q_SLOTS: +QMessageAuthenticationCode* new_QMessageAuthenticationCode(QCryptographicHash::Algorithm method, const QByteArray& key = QByteArray()); +void delete_QMessageAuthenticationCode(QMessageAuthenticationCode* obj) { delete obj; } + bool addData(QMessageAuthenticationCode* theWrappedObject, QIODevice* device); + void addData(QMessageAuthenticationCode* theWrappedObject, const QByteArray& data); + void addData(QMessageAuthenticationCode* theWrappedObject, const char* data, int length); + QByteArray static_QMessageAuthenticationCode_hash(const QByteArray& message, const QByteArray& key, QCryptographicHash::Algorithm method); + void reset(QMessageAuthenticationCode* theWrappedObject); + QByteArray result(QMessageAuthenticationCode* theWrappedObject) const; + void setKey(QMessageAuthenticationCode* theWrappedObject, const QByteArray& key); +}; + + + + + class PythonQtShell_QMessageLogContext : public QMessageLogContext { public: @@ -218,10 +281,8 @@ void delete_QMetaProperty(QMetaProperty* obj) { delete obj; } class PythonQtWrapper_QMetaType : public QObject { Q_OBJECT public: -Q_ENUMS(Type TypeFlag ) +Q_ENUMS(TypeFlag ) Q_FLAGS(TypeFlags ) -enum Type{ - Void = QMetaType::Void, Bool = QMetaType::Bool, Int = QMetaType::Int, UInt = QMetaType::UInt, LongLong = QMetaType::LongLong, ULongLong = QMetaType::ULongLong, Double = QMetaType::Double, Long = QMetaType::Long, Short = QMetaType::Short, Char = QMetaType::Char, ULong = QMetaType::ULong, UShort = QMetaType::UShort, UChar = QMetaType::UChar, Float = QMetaType::Float, SChar = QMetaType::SChar, Nullptr = QMetaType::Nullptr, QCborSimpleType = QMetaType::QCborSimpleType, VoidStar = QMetaType::VoidStar, QChar = QMetaType::QChar, QString = QMetaType::QString, QStringList = QMetaType::QStringList, QByteArray = QMetaType::QByteArray, QBitArray = QMetaType::QBitArray, QDate = QMetaType::QDate, QTime = QMetaType::QTime, QDateTime = QMetaType::QDateTime, QUrl = QMetaType::QUrl, QLocale = QMetaType::QLocale, QRect = QMetaType::QRect, QRectF = QMetaType::QRectF, QSize = QMetaType::QSize, QSizeF = QMetaType::QSizeF, QLine = QMetaType::QLine, QLineF = QMetaType::QLineF, QPoint = QMetaType::QPoint, QPointF = QMetaType::QPointF, QRegExp = QMetaType::QRegExp, QEasingCurve = QMetaType::QEasingCurve, QUuid = QMetaType::QUuid, QVariant = QMetaType::QVariant, QRegularExpression = QMetaType::QRegularExpression, QJsonValue = QMetaType::QJsonValue, QJsonObject = QMetaType::QJsonObject, QJsonArray = QMetaType::QJsonArray, QJsonDocument = QMetaType::QJsonDocument, QCborValue = QMetaType::QCborValue, QCborArray = QMetaType::QCborArray, QCborMap = QMetaType::QCborMap, QModelIndex = QMetaType::QModelIndex, QPersistentModelIndex = QMetaType::QPersistentModelIndex, QObjectStar = QMetaType::QObjectStar, QVariantMap = QMetaType::QVariantMap, QVariantList = QMetaType::QVariantList, QVariantHash = QMetaType::QVariantHash, QByteArrayList = QMetaType::QByteArrayList, QFont = QMetaType::QFont, QPixmap = QMetaType::QPixmap, QBrush = QMetaType::QBrush, QColor = QMetaType::QColor, QPalette = QMetaType::QPalette, QIcon = QMetaType::QIcon, QImage = QMetaType::QImage, QPolygon = QMetaType::QPolygon, QRegion = QMetaType::QRegion, QBitmap = QMetaType::QBitmap, QCursor = QMetaType::QCursor, QKeySequence = QMetaType::QKeySequence, QPen = QMetaType::QPen, QTextLength = QMetaType::QTextLength, QTextFormat = QMetaType::QTextFormat, QMatrix = QMetaType::QMatrix, QTransform = QMetaType::QTransform, QMatrix4x4 = QMetaType::QMatrix4x4, QVector2D = QMetaType::QVector2D, QVector3D = QMetaType::QVector3D, QVector4D = QMetaType::QVector4D, QQuaternion = QMetaType::QQuaternion, QPolygonF = QMetaType::QPolygonF, QColorSpace = QMetaType::QColorSpace, QSizePolicy = QMetaType::QSizePolicy, FirstCoreType = QMetaType::FirstCoreType, LastCoreType = QMetaType::LastCoreType, FirstGuiType = QMetaType::FirstGuiType, LastGuiType = QMetaType::LastGuiType, FirstWidgetsType = QMetaType::FirstWidgetsType, LastWidgetsType = QMetaType::LastWidgetsType, HighestInternalId = QMetaType::HighestInternalId, QReal = QMetaType::QReal, UnknownType = QMetaType::UnknownType, User = QMetaType::User}; enum TypeFlag{ NeedsConstruction = QMetaType::NeedsConstruction, NeedsDestruction = QMetaType::NeedsDestruction, MovableType = QMetaType::MovableType, PointerToQObject = QMetaType::PointerToQObject, IsEnumeration = QMetaType::IsEnumeration, SharedPointerToQObject = QMetaType::SharedPointerToQObject, WeakPointerToQObject = QMetaType::WeakPointerToQObject, TrackingPointerToQObject = QMetaType::TrackingPointerToQObject, WasDeclaredAsMetaType = QMetaType::WasDeclaredAsMetaType, IsGadget = QMetaType::IsGadget, PointerToGadget = QMetaType::PointerToGadget}; Q_DECLARE_FLAGS(TypeFlags, TypeFlag) @@ -1094,92 +1155,3 @@ void delete_QRegularExpressionMatchIterator(QRegularExpressionMatchIterator* obj }; - - - -class PythonQtShell_QResource : public QResource -{ -public: - PythonQtShell_QResource(const QString& file = QString(), const QLocale& locale = QLocale()):QResource(file, locale),_wrapper(nullptr) {}; - - ~PythonQtShell_QResource(); - - - PythonQtInstanceWrapper* _wrapper; -}; - -class PythonQtPublicPromoter_QResource : public QResource -{ public: -inline QStringList promoted_children() const { return this->children(); } -inline bool promoted_isDir() const { return this->isDir(); } -inline bool promoted_isFile() const { return this->isFile(); } -}; - -class PythonQtWrapper_QResource : public QObject -{ Q_OBJECT -public: -Q_ENUMS(Compression ) -enum Compression{ - NoCompression = QResource::NoCompression, ZlibCompression = QResource::ZlibCompression, ZstdCompression = QResource::ZstdCompression}; -public Q_SLOTS: -QResource* new_QResource(const QString& file = QString(), const QLocale& locale = QLocale()); -void delete_QResource(QResource* obj) { delete obj; } - QString absoluteFilePath(QResource* theWrappedObject) const; - void static_QResource_addSearchPath(const QString& path); - QStringList children(QResource* theWrappedObject) const; - QResource::Compression compressionAlgorithm(QResource* theWrappedObject) const; - const uchar* data(QResource* theWrappedObject) const; - QString fileName(QResource* theWrappedObject) const; - bool isCompressed(QResource* theWrappedObject) const; - bool isDir(QResource* theWrappedObject) const; - bool isFile(QResource* theWrappedObject) const; - bool isValid(QResource* theWrappedObject) const; - QDateTime lastModified(QResource* theWrappedObject) const; - QLocale locale(QResource* theWrappedObject) const; - bool static_QResource_registerResource(const QString& rccFilename, const QString& resourceRoot = QString()); - bool static_QResource_registerResource(const uchar* rccData, const QString& resourceRoot = QString()); - QStringList static_QResource_searchPaths(); - void setFileName(QResource* theWrappedObject, const QString& file); - void setLocale(QResource* theWrappedObject, const QLocale& locale); - qint64 size(QResource* theWrappedObject) const; - QByteArray uncompressedData(QResource* theWrappedObject) const; - qint64 uncompressedSize(QResource* theWrappedObject) const; - bool static_QResource_unregisterResource(const QString& rccFilename, const QString& resourceRoot = QString()); - bool static_QResource_unregisterResource(const uchar* rccData, const QString& resourceRoot = QString()); - bool __nonzero__(QResource* obj) { return obj->isValid(); } -}; - - - - - -class PythonQtShell_QRunnable : public QRunnable -{ -public: - PythonQtShell_QRunnable():QRunnable(),_wrapper(nullptr) {}; - - ~PythonQtShell_QRunnable() override; - -void run() override; - - PythonQtInstanceWrapper* _wrapper; -}; - -class PythonQtPublicPromoter_QRunnable : public QRunnable -{ public: -inline void py_q_run() { this->run(); } -}; - -class PythonQtWrapper_QRunnable : public QObject -{ Q_OBJECT -public: -public Q_SLOTS: -QRunnable* new_QRunnable(); -void delete_QRunnable(QRunnable* obj) { delete obj; } - bool autoDelete(QRunnable* theWrappedObject) const; - void run(QRunnable* theWrappedObject); - void py_q_run(QRunnable* theWrappedObject){ (((PythonQtPublicPromoter_QRunnable*)theWrappedObject)->py_q_run());} - void setAutoDelete(QRunnable* theWrappedObject, bool _autoDelete); -}; - - diff --git a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core3.cpp b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core3.cpp index 28728965d..e9823c1d8 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core3.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core3.cpp @@ -7,12 +7,12 @@ #include #include #include +#include #include #include #include #include #include -#include #include #include #include @@ -37,7 +37,173 @@ #include #include #include -#include + +PythonQtShell_QResource::~PythonQtShell_QResource() { + PythonQtPrivate* priv = PythonQt::priv(); + if (priv) { priv->shellClassDeleted(this); } +} +QResource* PythonQtWrapper_QResource::new_QResource(const QString& file, const QLocale& locale) +{ +return new PythonQtShell_QResource(file, locale); } + +QString PythonQtWrapper_QResource::absoluteFilePath(QResource* theWrappedObject) const +{ + return ( theWrappedObject->absoluteFilePath()); +} + +void PythonQtWrapper_QResource::static_QResource_addSearchPath(const QString& path) +{ + (QResource::addSearchPath(path)); +} + +QStringList PythonQtWrapper_QResource::children(QResource* theWrappedObject) const +{ + return ( ((PythonQtPublicPromoter_QResource*)theWrappedObject)->promoted_children()); +} + +QResource::Compression PythonQtWrapper_QResource::compressionAlgorithm(QResource* theWrappedObject) const +{ + return ( theWrappedObject->compressionAlgorithm()); +} + +const uchar* PythonQtWrapper_QResource::data(QResource* theWrappedObject) const +{ + return ( theWrappedObject->data()); +} + +QString PythonQtWrapper_QResource::fileName(QResource* theWrappedObject) const +{ + return ( theWrappedObject->fileName()); +} + +bool PythonQtWrapper_QResource::isCompressed(QResource* theWrappedObject) const +{ + return ( theWrappedObject->isCompressed()); +} + +bool PythonQtWrapper_QResource::isDir(QResource* theWrappedObject) const +{ + return ( ((PythonQtPublicPromoter_QResource*)theWrappedObject)->promoted_isDir()); +} + +bool PythonQtWrapper_QResource::isFile(QResource* theWrappedObject) const +{ + return ( ((PythonQtPublicPromoter_QResource*)theWrappedObject)->promoted_isFile()); +} + +bool PythonQtWrapper_QResource::isValid(QResource* theWrappedObject) const +{ + return ( theWrappedObject->isValid()); +} + +QDateTime PythonQtWrapper_QResource::lastModified(QResource* theWrappedObject) const +{ + return ( theWrappedObject->lastModified()); +} + +QLocale PythonQtWrapper_QResource::locale(QResource* theWrappedObject) const +{ + return ( theWrappedObject->locale()); +} + +bool PythonQtWrapper_QResource::static_QResource_registerResource(const QString& rccFilename, const QString& resourceRoot) +{ + return (QResource::registerResource(rccFilename, resourceRoot)); +} + +bool PythonQtWrapper_QResource::static_QResource_registerResource(const uchar* rccData, const QString& resourceRoot) +{ + return (QResource::registerResource(rccData, resourceRoot)); +} + +QStringList PythonQtWrapper_QResource::static_QResource_searchPaths() +{ + return (QResource::searchPaths()); +} + +void PythonQtWrapper_QResource::setFileName(QResource* theWrappedObject, const QString& file) +{ + ( theWrappedObject->setFileName(file)); +} + +void PythonQtWrapper_QResource::setLocale(QResource* theWrappedObject, const QLocale& locale) +{ + ( theWrappedObject->setLocale(locale)); +} + +qint64 PythonQtWrapper_QResource::size(QResource* theWrappedObject) const +{ + return ( theWrappedObject->size()); +} + +QByteArray PythonQtWrapper_QResource::uncompressedData(QResource* theWrappedObject) const +{ + return ( theWrappedObject->uncompressedData()); +} + +qint64 PythonQtWrapper_QResource::uncompressedSize(QResource* theWrappedObject) const +{ + return ( theWrappedObject->uncompressedSize()); +} + +bool PythonQtWrapper_QResource::static_QResource_unregisterResource(const QString& rccFilename, const QString& resourceRoot) +{ + return (QResource::unregisterResource(rccFilename, resourceRoot)); +} + +bool PythonQtWrapper_QResource::static_QResource_unregisterResource(const uchar* rccData, const QString& resourceRoot) +{ + return (QResource::unregisterResource(rccData, resourceRoot)); +} + + + +PythonQtShell_QRunnable::~PythonQtShell_QRunnable() { + PythonQtPrivate* priv = PythonQt::priv(); + if (priv) { priv->shellClassDeleted(this); } +} +void PythonQtShell_QRunnable::run() +{ +if (_wrapper) { + PYTHONQT_GIL_SCOPE + if (Py_REFCNT((PyObject*)_wrapper) > 0) { + static PyObject* name = PyUnicode_FromString("run"); + PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); + if (obj) { + static const char* argumentList[] ={""}; + static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); + void* args[1] = {nullptr}; + PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); + if (result) { Py_DECREF(result); } + Py_DECREF(obj); + return; + } else { + PyErr_Clear(); + } + } +} + +} +QRunnable* PythonQtWrapper_QRunnable::new_QRunnable() +{ +return new PythonQtShell_QRunnable(); } + +bool PythonQtWrapper_QRunnable::autoDelete(QRunnable* theWrappedObject) const +{ + return ( theWrappedObject->autoDelete()); +} + +void PythonQtWrapper_QRunnable::run(QRunnable* theWrappedObject) +{ + ( theWrappedObject->run()); +} + +void PythonQtWrapper_QRunnable::setAutoDelete(QRunnable* theWrappedObject, bool _autoDelete) +{ + ( theWrappedObject->setAutoDelete(_autoDelete)); +} + + PythonQtShell_QSaveFile::~PythonQtShell_QSaveFile() { PythonQtPrivate* priv = PythonQt::priv(); @@ -3688,12 +3854,12 @@ if (_wrapper) { } return QTemporaryFile::eventFilter(watched0, event1); } -QString PythonQtShell_QTemporaryFile::uniqueFilename() const +QString PythonQtShell_QTemporaryFile::fileName() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("uniqueFilename"); + static PyObject* name = PyUnicode_FromString("fileName"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QString"}; @@ -3705,7 +3871,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("uniqueFilename", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("fileName", methodInfo, result); } else { returnValue = *((QString*)args[0]); } @@ -4259,11 +4425,6 @@ QTemporaryFile* PythonQtWrapper_QTemporaryFile::static_QTemporaryFile_createNat return (QTemporaryFile::createNativeFile(fileName)); } -QString PythonQtWrapper_QTemporaryFile::uniqueFilename(QTemporaryFile* theWrappedObject) const -{ - return ( theWrappedObject->fileName()); -} - QString PythonQtWrapper_QTemporaryFile::fileTemplate(QTemporaryFile* theWrappedObject) const { return ( theWrappedObject->fileTemplate()); @@ -5797,397 +5958,3 @@ qreal PythonQtWrapper_QTimeLine::valueForTime(QTimeLine* theWrappedObject, int } - -QTimeZone* PythonQtWrapper_QTimeZone::new_QTimeZone() -{ -return new QTimeZone(); } - -QTimeZone* PythonQtWrapper_QTimeZone::new_QTimeZone(const QByteArray& ianaId) -{ -return new QTimeZone(ianaId); } - -QTimeZone* PythonQtWrapper_QTimeZone::new_QTimeZone(const QByteArray& zoneId, int offsetSeconds, const QString& name, const QString& abbreviation, QLocale::Country country, const QString& comment) -{ -return new QTimeZone(zoneId, offsetSeconds, name, abbreviation, country, comment); } - -QTimeZone* PythonQtWrapper_QTimeZone::new_QTimeZone(const QTimeZone& other) -{ -return new QTimeZone(other); } - -QTimeZone* PythonQtWrapper_QTimeZone::new_QTimeZone(int offsetSeconds) -{ -return new QTimeZone(offsetSeconds); } - -QString PythonQtWrapper_QTimeZone::abbreviation(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const -{ - return ( theWrappedObject->abbreviation(atDateTime)); -} - -QList PythonQtWrapper_QTimeZone::static_QTimeZone_availableTimeZoneIds() -{ - return (QTimeZone::availableTimeZoneIds()); -} - -QList PythonQtWrapper_QTimeZone::static_QTimeZone_availableTimeZoneIds(QLocale::Country country) -{ - return (QTimeZone::availableTimeZoneIds(country)); -} - -QList PythonQtWrapper_QTimeZone::static_QTimeZone_availableTimeZoneIds(int offsetSeconds) -{ - return (QTimeZone::availableTimeZoneIds(offsetSeconds)); -} - -QString PythonQtWrapper_QTimeZone::comment(QTimeZone* theWrappedObject) const -{ - return ( theWrappedObject->comment()); -} - -QLocale::Country PythonQtWrapper_QTimeZone::country(QTimeZone* theWrappedObject) const -{ - return ( theWrappedObject->country()); -} - -int PythonQtWrapper_QTimeZone::daylightTimeOffset(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const -{ - return ( theWrappedObject->daylightTimeOffset(atDateTime)); -} - -QString PythonQtWrapper_QTimeZone::displayName(QTimeZone* theWrappedObject, QTimeZone::TimeType timeType, QTimeZone::NameType nameType, const QLocale& locale) const -{ - return ( theWrappedObject->displayName(timeType, nameType, locale)); -} - -QString PythonQtWrapper_QTimeZone::displayName(QTimeZone* theWrappedObject, const QDateTime& atDateTime, QTimeZone::NameType nameType, const QLocale& locale) const -{ - return ( theWrappedObject->displayName(atDateTime, nameType, locale)); -} - -bool PythonQtWrapper_QTimeZone::hasDaylightTime(QTimeZone* theWrappedObject) const -{ - return ( theWrappedObject->hasDaylightTime()); -} - -bool PythonQtWrapper_QTimeZone::hasTransitions(QTimeZone* theWrappedObject) const -{ - return ( theWrappedObject->hasTransitions()); -} - -QByteArray PythonQtWrapper_QTimeZone::static_QTimeZone_ianaIdToWindowsId(const QByteArray& ianaId) -{ - return (QTimeZone::ianaIdToWindowsId(ianaId)); -} - -QByteArray PythonQtWrapper_QTimeZone::id(QTimeZone* theWrappedObject) const -{ - return ( theWrappedObject->id()); -} - -bool PythonQtWrapper_QTimeZone::isDaylightTime(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const -{ - return ( theWrappedObject->isDaylightTime(atDateTime)); -} - -bool PythonQtWrapper_QTimeZone::static_QTimeZone_isTimeZoneIdAvailable(const QByteArray& ianaId) -{ - return (QTimeZone::isTimeZoneIdAvailable(ianaId)); -} - -bool PythonQtWrapper_QTimeZone::isValid(QTimeZone* theWrappedObject) const -{ - return ( theWrappedObject->isValid()); -} - -int PythonQtWrapper_QTimeZone::offsetFromUtc(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const -{ - return ( theWrappedObject->offsetFromUtc(atDateTime)); -} - -bool PythonQtWrapper_QTimeZone::__ne__(QTimeZone* theWrappedObject, const QTimeZone& other) const -{ - return ( (*theWrappedObject)!= other); -} - -void PythonQtWrapper_QTimeZone::writeTo(QTimeZone* theWrappedObject, QDataStream& ds) -{ - ds << (*theWrappedObject); -} - -QTimeZone* PythonQtWrapper_QTimeZone::operator_assign(QTimeZone* theWrappedObject, const QTimeZone& other) -{ - return &( (*theWrappedObject)= other); -} - -bool PythonQtWrapper_QTimeZone::__eq__(QTimeZone* theWrappedObject, const QTimeZone& other) const -{ - return ( (*theWrappedObject)== other); -} - -void PythonQtWrapper_QTimeZone::readFrom(QTimeZone* theWrappedObject, QDataStream& ds) -{ - ds >> (*theWrappedObject); -} - -int PythonQtWrapper_QTimeZone::standardTimeOffset(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const -{ - return ( theWrappedObject->standardTimeOffset(atDateTime)); -} - -void PythonQtWrapper_QTimeZone::swap(QTimeZone* theWrappedObject, QTimeZone& other) -{ - ( theWrappedObject->swap(other)); -} - -QTimeZone PythonQtWrapper_QTimeZone::static_QTimeZone_systemTimeZone() -{ - return (QTimeZone::systemTimeZone()); -} - -QByteArray PythonQtWrapper_QTimeZone::static_QTimeZone_systemTimeZoneId() -{ - return (QTimeZone::systemTimeZoneId()); -} - -QTimeZone PythonQtWrapper_QTimeZone::static_QTimeZone_utc() -{ - return (QTimeZone::utc()); -} - -QByteArray PythonQtWrapper_QTimeZone::static_QTimeZone_windowsIdToDefaultIanaId(const QByteArray& windowsId) -{ - return (QTimeZone::windowsIdToDefaultIanaId(windowsId)); -} - -QByteArray PythonQtWrapper_QTimeZone::static_QTimeZone_windowsIdToDefaultIanaId(const QByteArray& windowsId, QLocale::Country country) -{ - return (QTimeZone::windowsIdToDefaultIanaId(windowsId, country)); -} - -QList PythonQtWrapper_QTimeZone::static_QTimeZone_windowsIdToIanaIds(const QByteArray& windowsId) -{ - return (QTimeZone::windowsIdToIanaIds(windowsId)); -} - -QList PythonQtWrapper_QTimeZone::static_QTimeZone_windowsIdToIanaIds(const QByteArray& windowsId, QLocale::Country country) -{ - return (QTimeZone::windowsIdToIanaIds(windowsId, country)); -} - -QString PythonQtWrapper_QTimeZone::py_toString(QTimeZone* obj) { - QString result; - QDebug d(&result); - d << *obj; - return result; -} - - - -PythonQtShell_QTimer::~PythonQtShell_QTimer() { - PythonQtPrivate* priv = PythonQt::priv(); - if (priv) { priv->shellClassDeleted(this); } -} -void PythonQtShell_QTimer::childEvent(QChildEvent* event0) -{ -if (_wrapper) { - PYTHONQT_GIL_SCOPE - if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("childEvent"); - PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); - if (obj) { - static const char* argumentList[] ={"" , "QChildEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {nullptr, (void*)&event0}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } else { - PyErr_Clear(); - } - } -} - QTimer::childEvent(event0); -} -void PythonQtShell_QTimer::customEvent(QEvent* event0) -{ -if (_wrapper) { - PYTHONQT_GIL_SCOPE - if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("customEvent"); - PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); - if (obj) { - static const char* argumentList[] ={"" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {nullptr, (void*)&event0}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } else { - PyErr_Clear(); - } - } -} - QTimer::customEvent(event0); -} -bool PythonQtShell_QTimer::event(QEvent* event0) -{ -if (_wrapper) { - PYTHONQT_GIL_SCOPE - if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("event"); - PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); - if (obj) { - static const char* argumentList[] ={"bool" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - bool returnValue{}; - void* args[2] = {nullptr, (void*)&event0}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); - } else { - returnValue = *((bool*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } else { - PyErr_Clear(); - } - } -} - return QTimer::event(event0); -} -bool PythonQtShell_QTimer::eventFilter(QObject* watched0, QEvent* event1) -{ -if (_wrapper) { - PYTHONQT_GIL_SCOPE - if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("eventFilter"); - PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); - if (obj) { - static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); - bool returnValue{}; - void* args[3] = {nullptr, (void*)&watched0, (void*)&event1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { - args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); - if (args[0]!=&returnValue) { - if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); - } else { - returnValue = *((bool*)args[0]); - } - } - } - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return returnValue; - } else { - PyErr_Clear(); - } - } -} - return QTimer::eventFilter(watched0, event1); -} -void PythonQtShell_QTimer::timerEvent(QTimerEvent* arg__1) -{ -if (_wrapper) { - PYTHONQT_GIL_SCOPE - if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("timerEvent"); - PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); - if (obj) { - static const char* argumentList[] ={"" , "QTimerEvent*"}; - static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); - void* args[2] = {nullptr, (void*)&arg__1}; - PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); - if (result) { Py_DECREF(result); } - Py_DECREF(obj); - return; - } else { - PyErr_Clear(); - } - } -} - QTimer::timerEvent(arg__1); -} -QTimer* PythonQtWrapper_QTimer::new_QTimer(QObject* parent) -{ -return new PythonQtShell_QTimer(parent); } - -const QMetaObject* PythonQtShell_QTimer::metaObject() const { - if (QObject::d_ptr->metaObject) { - return QObject::d_ptr->dynamicMetaObject(); - } else if (_wrapper) { - return PythonQt::priv()->getDynamicMetaObject(_wrapper, &QTimer::staticMetaObject); - } else { - return &QTimer::staticMetaObject; - } -} -int PythonQtShell_QTimer::qt_metacall(QMetaObject::Call call, int id, void** args) { - int result = QTimer::qt_metacall(call, id, args); - return result >= 0 ? PythonQt::priv()->handleMetaCall(this, _wrapper, call, id, args) : result; -} -int PythonQtWrapper_QTimer::interval(QTimer* theWrappedObject) const -{ - return ( theWrappedObject->interval()); -} - -bool PythonQtWrapper_QTimer::isActive(QTimer* theWrappedObject) const -{ - return ( theWrappedObject->isActive()); -} - -bool PythonQtWrapper_QTimer::isSingleShot(QTimer* theWrappedObject) const -{ - return ( theWrappedObject->isSingleShot()); -} - -int PythonQtWrapper_QTimer::remainingTime(QTimer* theWrappedObject) const -{ - return ( theWrappedObject->remainingTime()); -} - -void PythonQtWrapper_QTimer::setInterval(QTimer* theWrappedObject, int msec) -{ - ( theWrappedObject->setInterval(msec)); -} - -void PythonQtWrapper_QTimer::setSingleShot(QTimer* theWrappedObject, bool singleShot) -{ - ( theWrappedObject->setSingleShot(singleShot)); -} - -void PythonQtWrapper_QTimer::setTimerType(QTimer* theWrappedObject, Qt::TimerType atype) -{ - ( theWrappedObject->setTimerType(atype)); -} - -void PythonQtWrapper_QTimer::static_QTimer_singleShot(int msec, Qt::TimerType timerType, const QObject* receiver, const char* member) -{ - (QTimer::singleShot(msec, timerType, receiver, member)); -} - -void PythonQtWrapper_QTimer::static_QTimer_singleShot(int msec, const QObject* receiver, const char* member) -{ - (QTimer::singleShot(msec, receiver, member)); -} - -int PythonQtWrapper_QTimer::timerId(QTimer* theWrappedObject) const -{ - return ( theWrappedObject->timerId()); -} - -Qt::TimerType PythonQtWrapper_QTimer::timerType(QTimer* theWrappedObject) const -{ - return ( theWrappedObject->timerType()); -} - - diff --git a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core3.h b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core3.h index 1c3fd71c1..2ee4f9b0a 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core3.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core3.h @@ -5,12 +5,12 @@ #include #include #include +#include #include #include #include #include #include -#include #include #include #include @@ -22,6 +22,7 @@ #include #include #include +#include #include #include #include @@ -47,8 +48,95 @@ #include #include #include -#include -#include + + + +class PythonQtShell_QResource : public QResource +{ +public: + PythonQtShell_QResource(const QString& file = QString(), const QLocale& locale = QLocale()):QResource(file, locale),_wrapper(nullptr) {}; + + ~PythonQtShell_QResource(); + + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_QResource : public QResource +{ public: +inline QStringList promoted_children() const { return this->children(); } +inline bool promoted_isDir() const { return this->isDir(); } +inline bool promoted_isFile() const { return this->isFile(); } +}; + +class PythonQtWrapper_QResource : public QObject +{ Q_OBJECT +public: +Q_ENUMS(Compression ) +enum Compression{ + NoCompression = QResource::NoCompression, ZlibCompression = QResource::ZlibCompression, ZstdCompression = QResource::ZstdCompression}; +public Q_SLOTS: +QResource* new_QResource(const QString& file = QString(), const QLocale& locale = QLocale()); +void delete_QResource(QResource* obj) { delete obj; } + QString absoluteFilePath(QResource* theWrappedObject) const; + void static_QResource_addSearchPath(const QString& path); + QStringList children(QResource* theWrappedObject) const; + QResource::Compression compressionAlgorithm(QResource* theWrappedObject) const; + const uchar* data(QResource* theWrappedObject) const; + QString fileName(QResource* theWrappedObject) const; + bool isCompressed(QResource* theWrappedObject) const; + bool isDir(QResource* theWrappedObject) const; + bool isFile(QResource* theWrappedObject) const; + bool isValid(QResource* theWrappedObject) const; + QDateTime lastModified(QResource* theWrappedObject) const; + QLocale locale(QResource* theWrappedObject) const; + bool static_QResource_registerResource(const QString& rccFilename, const QString& resourceRoot = QString()); + bool static_QResource_registerResource(const uchar* rccData, const QString& resourceRoot = QString()); + QStringList static_QResource_searchPaths(); + void setFileName(QResource* theWrappedObject, const QString& file); + void setLocale(QResource* theWrappedObject, const QLocale& locale); + qint64 size(QResource* theWrappedObject) const; + QByteArray uncompressedData(QResource* theWrappedObject) const; + qint64 uncompressedSize(QResource* theWrappedObject) const; + bool static_QResource_unregisterResource(const QString& rccFilename, const QString& resourceRoot = QString()); + bool static_QResource_unregisterResource(const uchar* rccData, const QString& resourceRoot = QString()); + bool __nonzero__(QResource* obj) { return obj->isValid(); } +}; + + + + + +class PythonQtShell_QRunnable : public QRunnable +{ +public: + PythonQtShell_QRunnable():QRunnable(),_wrapper(nullptr) {}; + + ~PythonQtShell_QRunnable() override; + +void run() override; + + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_QRunnable : public QRunnable +{ public: +inline void py_q_run() { this->run(); } +}; + +class PythonQtWrapper_QRunnable : public QObject +{ Q_OBJECT +public: +public Q_SLOTS: +QRunnable* new_QRunnable(); +void delete_QRunnable(QRunnable* obj) { delete obj; } + bool autoDelete(QRunnable* theWrappedObject) const; + void run(QRunnable* theWrappedObject); + void py_q_run(QRunnable* theWrappedObject){ (((PythonQtPublicPromoter_QRunnable*)theWrappedObject)->py_q_run());} + void setAutoDelete(QRunnable* theWrappedObject, bool _autoDelete); +}; + + @@ -839,7 +927,7 @@ void close() override; void customEvent(QEvent* event) override; bool event(QEvent* event) override; bool eventFilter(QObject* watched, QEvent* event) override; -QString uniqueFilename() const override; +QString fileName() const override; bool isSequential() const override; bool open(QIODevice::OpenMode flags) override; QFileDevice::Permissions permissions() const override; @@ -864,7 +952,7 @@ qint64 writeData(const char* data, qint64 len) override; class PythonQtPublicPromoter_QTemporaryFile : public QTemporaryFile { public: inline bool promoted_open(QIODevice::OpenMode flags) { return this->open(flags); } -inline QString py_q_uniqueFilename() const { return QTemporaryFile::fileName(); } +inline QString py_q_fileName() const { return QTemporaryFile::fileName(); } inline bool py_q_open(QIODevice::OpenMode flags) { return QTemporaryFile::open(flags); } }; @@ -882,8 +970,7 @@ void delete_QTemporaryFile(QTemporaryFile* obj) { delete obj; } QTemporaryFile* static_QTemporaryFile_createLocalFile(const QString& fileName); QTemporaryFile* static_QTemporaryFile_createNativeFile(QFile& file); QTemporaryFile* static_QTemporaryFile_createNativeFile(const QString& fileName); - QString uniqueFilename(QTemporaryFile* theWrappedObject) const; - QString py_q_uniqueFilename(QTemporaryFile* theWrappedObject) const{ return (((PythonQtPublicPromoter_QTemporaryFile*)theWrappedObject)->py_q_fileName());} + QString py_q_fileName(QTemporaryFile* theWrappedObject) const{ return (((PythonQtPublicPromoter_QTemporaryFile*)theWrappedObject)->py_q_fileName());} QString fileTemplate(QTemporaryFile* theWrappedObject) const; bool open(QTemporaryFile* theWrappedObject); bool py_q_open(QTemporaryFile* theWrappedObject, QIODevice::OpenMode flags){ return (((PythonQtPublicPromoter_QTemporaryFile*)theWrappedObject)->py_q_open(flags));} @@ -1301,105 +1388,3 @@ void delete_QTimeLine(QTimeLine* obj) { delete obj; } }; - - - -class PythonQtWrapper_QTimeZone : public QObject -{ Q_OBJECT -public: -Q_ENUMS(NameType TimeType ) -enum NameType{ - DefaultName = QTimeZone::DefaultName, LongName = QTimeZone::LongName, ShortName = QTimeZone::ShortName, OffsetName = QTimeZone::OffsetName}; -enum TimeType{ - StandardTime = QTimeZone::StandardTime, DaylightTime = QTimeZone::DaylightTime, GenericTime = QTimeZone::GenericTime}; -public Q_SLOTS: -QTimeZone* new_QTimeZone(); -QTimeZone* new_QTimeZone(const QByteArray& ianaId); -QTimeZone* new_QTimeZone(const QByteArray& zoneId, int offsetSeconds, const QString& name, const QString& abbreviation, QLocale::Country country = QLocale::AnyCountry, const QString& comment = QString()); -QTimeZone* new_QTimeZone(const QTimeZone& other); -QTimeZone* new_QTimeZone(int offsetSeconds); -void delete_QTimeZone(QTimeZone* obj) { delete obj; } - QString abbreviation(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const; - QList static_QTimeZone_availableTimeZoneIds(); - QList static_QTimeZone_availableTimeZoneIds(QLocale::Country country); - QList static_QTimeZone_availableTimeZoneIds(int offsetSeconds); - QString comment(QTimeZone* theWrappedObject) const; - QLocale::Country country(QTimeZone* theWrappedObject) const; - int daylightTimeOffset(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const; - QString displayName(QTimeZone* theWrappedObject, QTimeZone::TimeType timeType, QTimeZone::NameType nameType = QTimeZone::DefaultName, const QLocale& locale = QLocale()) const; - QString displayName(QTimeZone* theWrappedObject, const QDateTime& atDateTime, QTimeZone::NameType nameType = QTimeZone::DefaultName, const QLocale& locale = QLocale()) const; - bool hasDaylightTime(QTimeZone* theWrappedObject) const; - bool hasTransitions(QTimeZone* theWrappedObject) const; - QByteArray static_QTimeZone_ianaIdToWindowsId(const QByteArray& ianaId); - QByteArray id(QTimeZone* theWrappedObject) const; - bool isDaylightTime(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const; - bool static_QTimeZone_isTimeZoneIdAvailable(const QByteArray& ianaId); - bool isValid(QTimeZone* theWrappedObject) const; - int offsetFromUtc(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const; - bool __ne__(QTimeZone* theWrappedObject, const QTimeZone& other) const; - void writeTo(QTimeZone* theWrappedObject, QDataStream& ds); - QTimeZone* operator_assign(QTimeZone* theWrappedObject, const QTimeZone& other); - bool __eq__(QTimeZone* theWrappedObject, const QTimeZone& other) const; - void readFrom(QTimeZone* theWrappedObject, QDataStream& ds); - int standardTimeOffset(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const; - void swap(QTimeZone* theWrappedObject, QTimeZone& other); - QTimeZone static_QTimeZone_systemTimeZone(); - QByteArray static_QTimeZone_systemTimeZoneId(); - QTimeZone static_QTimeZone_utc(); - QByteArray static_QTimeZone_windowsIdToDefaultIanaId(const QByteArray& windowsId); - QByteArray static_QTimeZone_windowsIdToDefaultIanaId(const QByteArray& windowsId, QLocale::Country country); - QList static_QTimeZone_windowsIdToIanaIds(const QByteArray& windowsId); - QList static_QTimeZone_windowsIdToIanaIds(const QByteArray& windowsId, QLocale::Country country); - QString py_toString(QTimeZone*); - bool __nonzero__(QTimeZone* obj) { return obj->isValid(); } -}; - - - - - -class PythonQtShell_QTimer : public QTimer -{ -public: - PythonQtShell_QTimer(QObject* parent = nullptr):QTimer(parent),_wrapper(nullptr) {}; - - ~PythonQtShell_QTimer() override; - -void childEvent(QChildEvent* event) override; -void customEvent(QEvent* event) override; -bool event(QEvent* event) override; -bool eventFilter(QObject* watched, QEvent* event) override; -void timerEvent(QTimerEvent* arg__1) override; - - const QMetaObject* metaObject() const override; - int qt_metacall(QMetaObject::Call call, int id, void** args) override; - PythonQtInstanceWrapper* _wrapper; -}; - -class PythonQtPublicPromoter_QTimer : public QTimer -{ public: -inline void promoted_timerEvent(QTimerEvent* arg__1) { this->timerEvent(arg__1); } -inline void py_q_timerEvent(QTimerEvent* arg__1) { QTimer::timerEvent(arg__1); } -}; - -class PythonQtWrapper_QTimer : public QObject -{ Q_OBJECT -public: -public Q_SLOTS: -QTimer* new_QTimer(QObject* parent = nullptr); -void delete_QTimer(QTimer* obj) { delete obj; } - int interval(QTimer* theWrappedObject) const; - bool isActive(QTimer* theWrappedObject) const; - bool isSingleShot(QTimer* theWrappedObject) const; - int remainingTime(QTimer* theWrappedObject) const; - void setInterval(QTimer* theWrappedObject, int msec); - void setSingleShot(QTimer* theWrappedObject, bool singleShot); - void setTimerType(QTimer* theWrappedObject, Qt::TimerType atype); - void static_QTimer_singleShot(int msec, Qt::TimerType timerType, const QObject* receiver, const char* member); - void static_QTimer_singleShot(int msec, const QObject* receiver, const char* member); - void py_q_timerEvent(QTimer* theWrappedObject, QTimerEvent* arg__1){ (((PythonQtPublicPromoter_QTimer*)theWrappedObject)->py_q_timerEvent(arg__1));} - int timerId(QTimer* theWrappedObject) const; - Qt::TimerType timerType(QTimer* theWrappedObject) const; -}; - - diff --git a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core4.cpp b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core4.cpp index 9b1e5e3eb..2f3419f49 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core4.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core4.cpp @@ -8,6 +8,7 @@ #include #include #include +#include #include #include #include @@ -20,12 +21,407 @@ #include #include #include +#include #include #include #include #include #include +QTimeZone* PythonQtWrapper_QTimeZone::new_QTimeZone() +{ +return new QTimeZone(); } + +QTimeZone* PythonQtWrapper_QTimeZone::new_QTimeZone(const QByteArray& ianaId) +{ +return new QTimeZone(ianaId); } + +QTimeZone* PythonQtWrapper_QTimeZone::new_QTimeZone(const QByteArray& zoneId, int offsetSeconds, const QString& name, const QString& abbreviation, QLocale::Country country, const QString& comment) +{ +return new QTimeZone(zoneId, offsetSeconds, name, abbreviation, country, comment); } + +QTimeZone* PythonQtWrapper_QTimeZone::new_QTimeZone(const QTimeZone& other) +{ +return new QTimeZone(other); } + +QTimeZone* PythonQtWrapper_QTimeZone::new_QTimeZone(int offsetSeconds) +{ +return new QTimeZone(offsetSeconds); } + +QString PythonQtWrapper_QTimeZone::abbreviation(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const +{ + return ( theWrappedObject->abbreviation(atDateTime)); +} + +QList PythonQtWrapper_QTimeZone::static_QTimeZone_availableTimeZoneIds() +{ + return (QTimeZone::availableTimeZoneIds()); +} + +QList PythonQtWrapper_QTimeZone::static_QTimeZone_availableTimeZoneIds(QLocale::Country country) +{ + return (QTimeZone::availableTimeZoneIds(country)); +} + +QList PythonQtWrapper_QTimeZone::static_QTimeZone_availableTimeZoneIds(int offsetSeconds) +{ + return (QTimeZone::availableTimeZoneIds(offsetSeconds)); +} + +QString PythonQtWrapper_QTimeZone::comment(QTimeZone* theWrappedObject) const +{ + return ( theWrappedObject->comment()); +} + +QLocale::Country PythonQtWrapper_QTimeZone::country(QTimeZone* theWrappedObject) const +{ + return ( theWrappedObject->country()); +} + +int PythonQtWrapper_QTimeZone::daylightTimeOffset(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const +{ + return ( theWrappedObject->daylightTimeOffset(atDateTime)); +} + +QString PythonQtWrapper_QTimeZone::displayName(QTimeZone* theWrappedObject, QTimeZone::TimeType timeType, QTimeZone::NameType nameType, const QLocale& locale) const +{ + return ( theWrappedObject->displayName(timeType, nameType, locale)); +} + +QString PythonQtWrapper_QTimeZone::displayName(QTimeZone* theWrappedObject, const QDateTime& atDateTime, QTimeZone::NameType nameType, const QLocale& locale) const +{ + return ( theWrappedObject->displayName(atDateTime, nameType, locale)); +} + +bool PythonQtWrapper_QTimeZone::hasDaylightTime(QTimeZone* theWrappedObject) const +{ + return ( theWrappedObject->hasDaylightTime()); +} + +bool PythonQtWrapper_QTimeZone::hasTransitions(QTimeZone* theWrappedObject) const +{ + return ( theWrappedObject->hasTransitions()); +} + +QByteArray PythonQtWrapper_QTimeZone::static_QTimeZone_ianaIdToWindowsId(const QByteArray& ianaId) +{ + return (QTimeZone::ianaIdToWindowsId(ianaId)); +} + +QByteArray PythonQtWrapper_QTimeZone::id(QTimeZone* theWrappedObject) const +{ + return ( theWrappedObject->id()); +} + +bool PythonQtWrapper_QTimeZone::isDaylightTime(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const +{ + return ( theWrappedObject->isDaylightTime(atDateTime)); +} + +bool PythonQtWrapper_QTimeZone::static_QTimeZone_isTimeZoneIdAvailable(const QByteArray& ianaId) +{ + return (QTimeZone::isTimeZoneIdAvailable(ianaId)); +} + +bool PythonQtWrapper_QTimeZone::isValid(QTimeZone* theWrappedObject) const +{ + return ( theWrappedObject->isValid()); +} + +int PythonQtWrapper_QTimeZone::offsetFromUtc(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const +{ + return ( theWrappedObject->offsetFromUtc(atDateTime)); +} + +bool PythonQtWrapper_QTimeZone::__ne__(QTimeZone* theWrappedObject, const QTimeZone& other) const +{ + return ( (*theWrappedObject)!= other); +} + +void PythonQtWrapper_QTimeZone::writeTo(QTimeZone* theWrappedObject, QDataStream& ds) +{ + ds << (*theWrappedObject); +} + +QTimeZone* PythonQtWrapper_QTimeZone::operator_assign(QTimeZone* theWrappedObject, const QTimeZone& other) +{ + return &( (*theWrappedObject)= other); +} + +bool PythonQtWrapper_QTimeZone::__eq__(QTimeZone* theWrappedObject, const QTimeZone& other) const +{ + return ( (*theWrappedObject)== other); +} + +void PythonQtWrapper_QTimeZone::readFrom(QTimeZone* theWrappedObject, QDataStream& ds) +{ + ds >> (*theWrappedObject); +} + +int PythonQtWrapper_QTimeZone::standardTimeOffset(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const +{ + return ( theWrappedObject->standardTimeOffset(atDateTime)); +} + +void PythonQtWrapper_QTimeZone::swap(QTimeZone* theWrappedObject, QTimeZone& other) +{ + ( theWrappedObject->swap(other)); +} + +QTimeZone PythonQtWrapper_QTimeZone::static_QTimeZone_systemTimeZone() +{ + return (QTimeZone::systemTimeZone()); +} + +QByteArray PythonQtWrapper_QTimeZone::static_QTimeZone_systemTimeZoneId() +{ + return (QTimeZone::systemTimeZoneId()); +} + +QTimeZone PythonQtWrapper_QTimeZone::static_QTimeZone_utc() +{ + return (QTimeZone::utc()); +} + +QByteArray PythonQtWrapper_QTimeZone::static_QTimeZone_windowsIdToDefaultIanaId(const QByteArray& windowsId) +{ + return (QTimeZone::windowsIdToDefaultIanaId(windowsId)); +} + +QByteArray PythonQtWrapper_QTimeZone::static_QTimeZone_windowsIdToDefaultIanaId(const QByteArray& windowsId, QLocale::Country country) +{ + return (QTimeZone::windowsIdToDefaultIanaId(windowsId, country)); +} + +QList PythonQtWrapper_QTimeZone::static_QTimeZone_windowsIdToIanaIds(const QByteArray& windowsId) +{ + return (QTimeZone::windowsIdToIanaIds(windowsId)); +} + +QList PythonQtWrapper_QTimeZone::static_QTimeZone_windowsIdToIanaIds(const QByteArray& windowsId, QLocale::Country country) +{ + return (QTimeZone::windowsIdToIanaIds(windowsId, country)); +} + +QString PythonQtWrapper_QTimeZone::py_toString(QTimeZone* obj) { + QString result; + QDebug d(&result); + d << *obj; + return result; +} + + + +PythonQtShell_QTimer::~PythonQtShell_QTimer() { + PythonQtPrivate* priv = PythonQt::priv(); + if (priv) { priv->shellClassDeleted(this); } +} +void PythonQtShell_QTimer::childEvent(QChildEvent* event0) +{ +if (_wrapper) { + PYTHONQT_GIL_SCOPE + if (Py_REFCNT((PyObject*)_wrapper) > 0) { + static PyObject* name = PyUnicode_FromString("childEvent"); + PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); + if (obj) { + static const char* argumentList[] ={"" , "QChildEvent*"}; + static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); + void* args[2] = {nullptr, (void*)&event0}; + PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); + if (result) { Py_DECREF(result); } + Py_DECREF(obj); + return; + } else { + PyErr_Clear(); + } + } +} + QTimer::childEvent(event0); +} +void PythonQtShell_QTimer::customEvent(QEvent* event0) +{ +if (_wrapper) { + PYTHONQT_GIL_SCOPE + if (Py_REFCNT((PyObject*)_wrapper) > 0) { + static PyObject* name = PyUnicode_FromString("customEvent"); + PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); + if (obj) { + static const char* argumentList[] ={"" , "QEvent*"}; + static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); + void* args[2] = {nullptr, (void*)&event0}; + PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); + if (result) { Py_DECREF(result); } + Py_DECREF(obj); + return; + } else { + PyErr_Clear(); + } + } +} + QTimer::customEvent(event0); +} +bool PythonQtShell_QTimer::event(QEvent* event0) +{ +if (_wrapper) { + PYTHONQT_GIL_SCOPE + if (Py_REFCNT((PyObject*)_wrapper) > 0) { + static PyObject* name = PyUnicode_FromString("event"); + PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); + if (obj) { + static const char* argumentList[] ={"bool" , "QEvent*"}; + static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); + bool returnValue{}; + void* args[2] = {nullptr, (void*)&event0}; + PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); + if (result) { + args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); + if (args[0]!=&returnValue) { + if (args[0]==nullptr) { + PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); + } else { + returnValue = *((bool*)args[0]); + } + } + } + if (result) { Py_DECREF(result); } + Py_DECREF(obj); + return returnValue; + } else { + PyErr_Clear(); + } + } +} + return QTimer::event(event0); +} +bool PythonQtShell_QTimer::eventFilter(QObject* watched0, QEvent* event1) +{ +if (_wrapper) { + PYTHONQT_GIL_SCOPE + if (Py_REFCNT((PyObject*)_wrapper) > 0) { + static PyObject* name = PyUnicode_FromString("eventFilter"); + PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); + if (obj) { + static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; + static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); + bool returnValue{}; + void* args[3] = {nullptr, (void*)&watched0, (void*)&event1}; + PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); + if (result) { + args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); + if (args[0]!=&returnValue) { + if (args[0]==nullptr) { + PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); + } else { + returnValue = *((bool*)args[0]); + } + } + } + if (result) { Py_DECREF(result); } + Py_DECREF(obj); + return returnValue; + } else { + PyErr_Clear(); + } + } +} + return QTimer::eventFilter(watched0, event1); +} +void PythonQtShell_QTimer::timerEvent(QTimerEvent* arg__1) +{ +if (_wrapper) { + PYTHONQT_GIL_SCOPE + if (Py_REFCNT((PyObject*)_wrapper) > 0) { + static PyObject* name = PyUnicode_FromString("timerEvent"); + PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); + if (obj) { + static const char* argumentList[] ={"" , "QTimerEvent*"}; + static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); + void* args[2] = {nullptr, (void*)&arg__1}; + PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); + if (result) { Py_DECREF(result); } + Py_DECREF(obj); + return; + } else { + PyErr_Clear(); + } + } +} + QTimer::timerEvent(arg__1); +} +QTimer* PythonQtWrapper_QTimer::new_QTimer(QObject* parent) +{ +return new PythonQtShell_QTimer(parent); } + +const QMetaObject* PythonQtShell_QTimer::metaObject() const { + if (QObject::d_ptr->metaObject) { + return QObject::d_ptr->dynamicMetaObject(); + } else if (_wrapper) { + return PythonQt::priv()->getDynamicMetaObject(_wrapper, &QTimer::staticMetaObject); + } else { + return &QTimer::staticMetaObject; + } +} +int PythonQtShell_QTimer::qt_metacall(QMetaObject::Call call, int id, void** args) { + int result = QTimer::qt_metacall(call, id, args); + return result >= 0 ? PythonQt::priv()->handleMetaCall(this, _wrapper, call, id, args) : result; +} +int PythonQtWrapper_QTimer::interval(QTimer* theWrappedObject) const +{ + return ( theWrappedObject->interval()); +} + +bool PythonQtWrapper_QTimer::isActive(QTimer* theWrappedObject) const +{ + return ( theWrappedObject->isActive()); +} + +bool PythonQtWrapper_QTimer::isSingleShot(QTimer* theWrappedObject) const +{ + return ( theWrappedObject->isSingleShot()); +} + +int PythonQtWrapper_QTimer::remainingTime(QTimer* theWrappedObject) const +{ + return ( theWrappedObject->remainingTime()); +} + +void PythonQtWrapper_QTimer::setInterval(QTimer* theWrappedObject, int msec) +{ + ( theWrappedObject->setInterval(msec)); +} + +void PythonQtWrapper_QTimer::setSingleShot(QTimer* theWrappedObject, bool singleShot) +{ + ( theWrappedObject->setSingleShot(singleShot)); +} + +void PythonQtWrapper_QTimer::setTimerType(QTimer* theWrappedObject, Qt::TimerType atype) +{ + ( theWrappedObject->setTimerType(atype)); +} + +void PythonQtWrapper_QTimer::static_QTimer_singleShot(int msec, Qt::TimerType timerType, const QObject* receiver, const char* member) +{ + (QTimer::singleShot(msec, timerType, receiver, member)); +} + +void PythonQtWrapper_QTimer::static_QTimer_singleShot(int msec, const QObject* receiver, const char* member) +{ + (QTimer::singleShot(msec, receiver, member)); +} + +int PythonQtWrapper_QTimer::timerId(QTimer* theWrappedObject) const +{ + return ( theWrappedObject->timerId()); +} + +Qt::TimerType PythonQtWrapper_QTimer::timerType(QTimer* theWrappedObject) const +{ + return ( theWrappedObject->timerType()); +} + + + PythonQtShell_QTimerEvent::~PythonQtShell_QTimerEvent() { PythonQtPrivate* priv = PythonQt::priv(); if (priv) { priv->shellClassDeleted(this); } diff --git a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core4.h b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core4.h index 640ba0e2e..572ad1db0 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core4.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core4.h @@ -6,6 +6,7 @@ #include #include #include +#include #include #include #include @@ -18,6 +19,8 @@ #include #include #include +#include +#include #include #include #include @@ -30,6 +33,108 @@ +class PythonQtWrapper_QTimeZone : public QObject +{ Q_OBJECT +public: +Q_ENUMS(NameType TimeType ) +enum NameType{ + DefaultName = QTimeZone::DefaultName, LongName = QTimeZone::LongName, ShortName = QTimeZone::ShortName, OffsetName = QTimeZone::OffsetName}; +enum TimeType{ + StandardTime = QTimeZone::StandardTime, DaylightTime = QTimeZone::DaylightTime, GenericTime = QTimeZone::GenericTime}; +public Q_SLOTS: +QTimeZone* new_QTimeZone(); +QTimeZone* new_QTimeZone(const QByteArray& ianaId); +QTimeZone* new_QTimeZone(const QByteArray& zoneId, int offsetSeconds, const QString& name, const QString& abbreviation, QLocale::Country country = QLocale::AnyCountry, const QString& comment = QString()); +QTimeZone* new_QTimeZone(const QTimeZone& other); +QTimeZone* new_QTimeZone(int offsetSeconds); +void delete_QTimeZone(QTimeZone* obj) { delete obj; } + QString abbreviation(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const; + QList static_QTimeZone_availableTimeZoneIds(); + QList static_QTimeZone_availableTimeZoneIds(QLocale::Country country); + QList static_QTimeZone_availableTimeZoneIds(int offsetSeconds); + QString comment(QTimeZone* theWrappedObject) const; + QLocale::Country country(QTimeZone* theWrappedObject) const; + int daylightTimeOffset(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const; + QString displayName(QTimeZone* theWrappedObject, QTimeZone::TimeType timeType, QTimeZone::NameType nameType = QTimeZone::DefaultName, const QLocale& locale = QLocale()) const; + QString displayName(QTimeZone* theWrappedObject, const QDateTime& atDateTime, QTimeZone::NameType nameType = QTimeZone::DefaultName, const QLocale& locale = QLocale()) const; + bool hasDaylightTime(QTimeZone* theWrappedObject) const; + bool hasTransitions(QTimeZone* theWrappedObject) const; + QByteArray static_QTimeZone_ianaIdToWindowsId(const QByteArray& ianaId); + QByteArray id(QTimeZone* theWrappedObject) const; + bool isDaylightTime(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const; + bool static_QTimeZone_isTimeZoneIdAvailable(const QByteArray& ianaId); + bool isValid(QTimeZone* theWrappedObject) const; + int offsetFromUtc(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const; + bool __ne__(QTimeZone* theWrappedObject, const QTimeZone& other) const; + void writeTo(QTimeZone* theWrappedObject, QDataStream& ds); + QTimeZone* operator_assign(QTimeZone* theWrappedObject, const QTimeZone& other); + bool __eq__(QTimeZone* theWrappedObject, const QTimeZone& other) const; + void readFrom(QTimeZone* theWrappedObject, QDataStream& ds); + int standardTimeOffset(QTimeZone* theWrappedObject, const QDateTime& atDateTime) const; + void swap(QTimeZone* theWrappedObject, QTimeZone& other); + QTimeZone static_QTimeZone_systemTimeZone(); + QByteArray static_QTimeZone_systemTimeZoneId(); + QTimeZone static_QTimeZone_utc(); + QByteArray static_QTimeZone_windowsIdToDefaultIanaId(const QByteArray& windowsId); + QByteArray static_QTimeZone_windowsIdToDefaultIanaId(const QByteArray& windowsId, QLocale::Country country); + QList static_QTimeZone_windowsIdToIanaIds(const QByteArray& windowsId); + QList static_QTimeZone_windowsIdToIanaIds(const QByteArray& windowsId, QLocale::Country country); + QString py_toString(QTimeZone*); + bool __nonzero__(QTimeZone* obj) { return obj->isValid(); } +}; + + + + + +class PythonQtShell_QTimer : public QTimer +{ +public: + PythonQtShell_QTimer(QObject* parent = nullptr):QTimer(parent),_wrapper(nullptr) {}; + + ~PythonQtShell_QTimer() override; + +void childEvent(QChildEvent* event) override; +void customEvent(QEvent* event) override; +bool event(QEvent* event) override; +bool eventFilter(QObject* watched, QEvent* event) override; +void timerEvent(QTimerEvent* arg__1) override; + + const QMetaObject* metaObject() const override; + int qt_metacall(QMetaObject::Call call, int id, void** args) override; + PythonQtInstanceWrapper* _wrapper; +}; + +class PythonQtPublicPromoter_QTimer : public QTimer +{ public: +inline void promoted_timerEvent(QTimerEvent* arg__1) { this->timerEvent(arg__1); } +inline void py_q_timerEvent(QTimerEvent* arg__1) { QTimer::timerEvent(arg__1); } +}; + +class PythonQtWrapper_QTimer : public QObject +{ Q_OBJECT +public: +public Q_SLOTS: +QTimer* new_QTimer(QObject* parent = nullptr); +void delete_QTimer(QTimer* obj) { delete obj; } + int interval(QTimer* theWrappedObject) const; + bool isActive(QTimer* theWrappedObject) const; + bool isSingleShot(QTimer* theWrappedObject) const; + int remainingTime(QTimer* theWrappedObject) const; + void setInterval(QTimer* theWrappedObject, int msec); + void setSingleShot(QTimer* theWrappedObject, bool singleShot); + void setTimerType(QTimer* theWrappedObject, Qt::TimerType atype); + void static_QTimer_singleShot(int msec, Qt::TimerType timerType, const QObject* receiver, const char* member); + void static_QTimer_singleShot(int msec, const QObject* receiver, const char* member); + void py_q_timerEvent(QTimer* theWrappedObject, QTimerEvent* arg__1){ (((PythonQtPublicPromoter_QTimer*)theWrappedObject)->py_q_timerEvent(arg__1));} + int timerId(QTimer* theWrappedObject) const; + Qt::TimerType timerType(QTimer* theWrappedObject) const; +}; + + + + + class PythonQtShell_QTimerEvent : public QTimerEvent { public: diff --git a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core_init.cpp b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core_init.cpp index 5e8d5df3a..2edb4cb9d 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core_init.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_core/com_trolltech_qt_core_init.cpp @@ -48,6 +48,8 @@ static void* polymorphichandler_QEvent(const void *ptr, const char **class_name) void PythonQt_init_QtCore(PyObject* module) { PythonQt::priv()->registerClass(&QAbstractAnimation::staticMetaObject, "QtCore", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); +PythonQt::priv()->registerClass(&QAbstractEventDispatcher::staticMetaObject, "QtCore", PythonQtCreateObject, nullptr, module, 0); +PythonQt::priv()->registerCPPClass("QAbstractEventDispatcher::TimerInfo", "", "QtCore", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); PythonQt::priv()->registerClass(&QAbstractItemModel::staticMetaObject, "QtCore", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); PythonQt::priv()->registerClass(&QAbstractListModel::staticMetaObject, "QtCore", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); PythonQt::priv()->registerClass(&QAbstractState::staticMetaObject, "QtCore", PythonQtCreateObject, PythonQtSetInstanceWrapperOnShell, module, 0); @@ -180,6 +182,7 @@ PythonQt::priv()->registerGlobalNamespace("QtCore", "QtCore", PythonQtCreateObje PythonQt::self()->addPolymorphicHandler("QEvent", polymorphichandler_QEvent); +PythonQtRegisterListTemplateConverterForKnownClass(QList, QAbstractEventDispatcher::TimerInfo); PythonQtRegisterListTemplateConverterForKnownClass(QList, QCommandLineOption); PythonQtRegisterListTemplateConverterForKnownClass(QList, QFileInfo); PythonQtRegisterListTemplateConverterForKnownClass(QList, QMimeType); diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui0.cpp b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui0.cpp index 7a72785ce..c2f6eaf57 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui0.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui0.cpp @@ -40,6 +40,7 @@ #include #include #include +#include #include #include #include @@ -841,12 +842,12 @@ if (_wrapper) { } return QAbstractButton::metric(arg__1); } -QSize PythonQtShell_QAbstractButton::getMinimumSizeHint() const +QSize PythonQtShell_QAbstractButton::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -858,7 +859,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -1226,12 +1227,12 @@ if (_wrapper) { } QAbstractButton::showEvent(event0); } -QSize PythonQtShell_QAbstractButton::getSizeHint() const +QSize PythonQtShell_QAbstractButton::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -1243,7 +1244,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -9648,11 +9649,6 @@ QSize PythonQtWrapper_QAbstractScrollArea::maximumViewportSize(QAbstractScrollA return ( theWrappedObject->maximumViewportSize()); } -QSize PythonQtWrapper_QAbstractScrollArea::minimumSizeHint(QAbstractScrollArea* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - QList PythonQtWrapper_QAbstractScrollArea::scrollBarWidgets(QAbstractScrollArea* theWrappedObject, Qt::Alignment alignment) { return ( theWrappedObject->scrollBarWidgets(alignment)); @@ -10436,12 +10432,12 @@ if (_wrapper) { } return QAbstractSlider::metric(arg__1); } -QSize PythonQtShell_QAbstractSlider::getMinimumSizeHint() const +QSize PythonQtShell_QAbstractSlider::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -10453,7 +10449,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -10799,12 +10795,12 @@ if (_wrapper) { } QAbstractSlider::showEvent(event0); } -QSize PythonQtShell_QAbstractSlider::getSizeHint() const +QSize PythonQtShell_QAbstractSlider::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -10816,7 +10812,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -12421,11 +12417,6 @@ QLineEdit* PythonQtWrapper_QAbstractSpinBox::lineEdit(QAbstractSpinBox* theWrap return ( ((PythonQtPublicPromoter_QAbstractSpinBox*)theWrappedObject)->promoted_lineEdit()); } -QSize PythonQtWrapper_QAbstractSpinBox::minimumSizeHint(QAbstractSpinBox* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - void PythonQtWrapper_QAbstractSpinBox::setAccelerated(QAbstractSpinBox* theWrappedObject, bool on) { ( theWrappedObject->setAccelerated(on)); @@ -12481,11 +12472,6 @@ void PythonQtWrapper_QAbstractSpinBox::setWrapping(QAbstractSpinBox* theWrappedO ( theWrappedObject->setWrapping(w)); } -QSize PythonQtWrapper_QAbstractSpinBox::sizeHint(QAbstractSpinBox* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - QString PythonQtWrapper_QAbstractSpinBox::specialValueText(QAbstractSpinBox* theWrappedObject) const { return ( theWrappedObject->specialValueText()); @@ -16985,12 +16971,12 @@ if (_wrapper) { } return QCalendarWidget::metric(arg__1); } -QSize PythonQtShell_QCalendarWidget::getMinimumSizeHint() const +QSize PythonQtShell_QCalendarWidget::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -17002,7 +16988,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -17370,12 +17356,12 @@ if (_wrapper) { } QCalendarWidget::showEvent(event0); } -QSize PythonQtShell_QCalendarWidget::getSizeHint() const +QSize PythonQtShell_QCalendarWidget::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -17387,7 +17373,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -18914,11 +18900,6 @@ bool PythonQtWrapper_QCheckBox::isTristate(QCheckBox* theWrappedObject) const return ( theWrappedObject->isTristate()); } -QSize PythonQtWrapper_QCheckBox::minimumSizeHint(QCheckBox* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - void PythonQtWrapper_QCheckBox::setCheckState(QCheckBox* theWrappedObject, Qt::CheckState state) { ( theWrappedObject->setCheckState(state)); @@ -18929,11 +18910,6 @@ void PythonQtWrapper_QCheckBox::setTristate(QCheckBox* theWrappedObject, bool y ( theWrappedObject->setTristate(y)); } -QSize PythonQtWrapper_QCheckBox::sizeHint(QCheckBox* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - void PythonQtWrapper_QClipboard::clear(QClipboard* theWrappedObject, QClipboard::Mode mode) @@ -24205,11 +24181,6 @@ int PythonQtWrapper_QComboBox::minimumContentsLength(QComboBox* theWrappedObjec return ( theWrappedObject->minimumContentsLength()); } -QSize PythonQtWrapper_QComboBox::minimumSizeHint(QComboBox* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - QAbstractItemModel* PythonQtWrapper_QComboBox::model(QComboBox* theWrappedObject) const { return ( theWrappedObject->model()); @@ -24350,11 +24321,6 @@ QComboBox::SizeAdjustPolicy PythonQtWrapper_QComboBox::sizeAdjustPolicy(QComboB return ( theWrappedObject->sizeAdjustPolicy()); } -QSize PythonQtWrapper_QComboBox::sizeHint(QComboBox* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - const QValidator* PythonQtWrapper_QComboBox::validator(QComboBox* theWrappedObject) const { return ( theWrappedObject->validator()); diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui0.h b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui0.h index 7839f0364..e3eb5702e 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui0.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui0.h @@ -49,6 +49,7 @@ #include #include #include +#include #include #include #include @@ -149,7 +150,7 @@ void keyPressEvent(QKeyEvent* e) override; void keyReleaseEvent(QKeyEvent* e) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* e) override; void mousePressEvent(QMouseEvent* e) override; @@ -164,7 +165,7 @@ void resizeEvent(QResizeEvent* event) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* event) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* e) override; void wheelEvent(QWheelEvent* event) override; @@ -1146,7 +1147,6 @@ void delete_QAbstractScrollArea(QAbstractScrollArea* obj) { delete obj; } Qt::ScrollBarPolicy horizontalScrollBarPolicy(QAbstractScrollArea* theWrappedObject) const; void py_q_keyPressEvent(QAbstractScrollArea* theWrappedObject, QKeyEvent* arg__1){ (((PythonQtPublicPromoter_QAbstractScrollArea*)theWrappedObject)->py_q_keyPressEvent(arg__1));} QSize maximumViewportSize(QAbstractScrollArea* theWrappedObject) const; - QSize minimumSizeHint(QAbstractScrollArea* theWrappedObject) const; QSize py_q_minimumSizeHint(QAbstractScrollArea* theWrappedObject) const{ return (((PythonQtPublicPromoter_QAbstractScrollArea*)theWrappedObject)->py_q_minimumSizeHint());} void py_q_mouseDoubleClickEvent(QAbstractScrollArea* theWrappedObject, QMouseEvent* arg__1){ (((PythonQtPublicPromoter_QAbstractScrollArea*)theWrappedObject)->py_q_mouseDoubleClickEvent(arg__1));} void py_q_mouseMoveEvent(QAbstractScrollArea* theWrappedObject, QMouseEvent* arg__1){ (((PythonQtPublicPromoter_QAbstractScrollArea*)theWrappedObject)->py_q_mouseMoveEvent(arg__1));} @@ -1219,7 +1219,7 @@ void keyPressEvent(QKeyEvent* ev) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -1233,7 +1233,7 @@ void resizeEvent(QResizeEvent* event) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* event) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void sliderChange(QAbstractSlider::SliderChange change) override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* arg__1) override; @@ -1459,7 +1459,6 @@ void delete_QAbstractSpinBox(QAbstractSpinBox* obj) { delete obj; } void py_q_keyReleaseEvent(QAbstractSpinBox* theWrappedObject, QKeyEvent* event){ (((PythonQtPublicPromoter_QAbstractSpinBox*)theWrappedObject)->py_q_keyReleaseEvent(event));} bool keyboardTracking(QAbstractSpinBox* theWrappedObject) const; QLineEdit* lineEdit(QAbstractSpinBox* theWrappedObject) const; - QSize minimumSizeHint(QAbstractSpinBox* theWrappedObject) const; QSize py_q_minimumSizeHint(QAbstractSpinBox* theWrappedObject) const{ return (((PythonQtPublicPromoter_QAbstractSpinBox*)theWrappedObject)->py_q_minimumSizeHint());} void py_q_mouseMoveEvent(QAbstractSpinBox* theWrappedObject, QMouseEvent* event){ (((PythonQtPublicPromoter_QAbstractSpinBox*)theWrappedObject)->py_q_mouseMoveEvent(event));} void py_q_mousePressEvent(QAbstractSpinBox* theWrappedObject, QMouseEvent* event){ (((PythonQtPublicPromoter_QAbstractSpinBox*)theWrappedObject)->py_q_mousePressEvent(event));} @@ -1478,7 +1477,6 @@ void delete_QAbstractSpinBox(QAbstractSpinBox* obj) { delete obj; } void setSpecialValueText(QAbstractSpinBox* theWrappedObject, const QString& txt); void setWrapping(QAbstractSpinBox* theWrappedObject, bool w); void py_q_showEvent(QAbstractSpinBox* theWrappedObject, QShowEvent* event){ (((PythonQtPublicPromoter_QAbstractSpinBox*)theWrappedObject)->py_q_showEvent(event));} - QSize sizeHint(QAbstractSpinBox* theWrappedObject) const; QSize py_q_sizeHint(QAbstractSpinBox* theWrappedObject) const{ return (((PythonQtPublicPromoter_QAbstractSpinBox*)theWrappedObject)->py_q_sizeHint());} QString specialValueText(QAbstractSpinBox* theWrappedObject) const; void stepBy(QAbstractSpinBox* theWrappedObject, int steps); @@ -2171,7 +2169,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -2186,7 +2184,7 @@ void resizeEvent(QResizeEvent* event) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* event) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* event) override; void wheelEvent(QWheelEvent* event) override; @@ -2209,11 +2207,11 @@ inline void promoted_updateCells() { this->updateCells(); } inline bool py_q_event(QEvent* event) { return QCalendarWidget::event(event); } inline bool py_q_eventFilter(QObject* watched, QEvent* event) { return QCalendarWidget::eventFilter(watched, event); } inline void py_q_keyPressEvent(QKeyEvent* event) { QCalendarWidget::keyPressEvent(event); } -inline QSize py_q_getMinimumSizeHint() const { return QCalendarWidget::minimumSizeHint(); } +inline QSize py_q_minimumSizeHint() const { return QCalendarWidget::minimumSizeHint(); } inline void py_q_mousePressEvent(QMouseEvent* event) { QCalendarWidget::mousePressEvent(event); } inline void py_q_paintCell(QPainter* painter, const QRect& rect, const QDate& date) const { QCalendarWidget::paintCell(painter, rect, date); } inline void py_q_resizeEvent(QResizeEvent* event) { QCalendarWidget::resizeEvent(event); } -inline QSize py_q_getSizeHint() const { return QCalendarWidget::sizeHint(); } +inline QSize py_q_sizeHint() const { return QCalendarWidget::sizeHint(); } }; class PythonQtWrapper_QCalendarWidget : public QObject @@ -2237,7 +2235,7 @@ void delete_QCalendarWidget(QCalendarWidget* obj) { delete obj; } void py_q_keyPressEvent(QCalendarWidget* theWrappedObject, QKeyEvent* event){ (((PythonQtPublicPromoter_QCalendarWidget*)theWrappedObject)->py_q_keyPressEvent(event));} QDate maximumDate(QCalendarWidget* theWrappedObject) const; QDate minimumDate(QCalendarWidget* theWrappedObject) const; - QSize py_q_getMinimumSizeHint(QCalendarWidget* theWrappedObject) const{ return (((PythonQtPublicPromoter_QCalendarWidget*)theWrappedObject)->py_q_minimumSizeHint());} + QSize py_q_minimumSizeHint(QCalendarWidget* theWrappedObject) const{ return (((PythonQtPublicPromoter_QCalendarWidget*)theWrappedObject)->py_q_minimumSizeHint());} int monthShown(QCalendarWidget* theWrappedObject) const; void py_q_mousePressEvent(QCalendarWidget* theWrappedObject, QMouseEvent* event){ (((PythonQtPublicPromoter_QCalendarWidget*)theWrappedObject)->py_q_mousePressEvent(event));} void paintCell(QCalendarWidget* theWrappedObject, QPainter* painter, const QRect& rect, const QDate& date) const; @@ -2257,7 +2255,7 @@ void delete_QCalendarWidget(QCalendarWidget* obj) { delete obj; } void setSelectionMode(QCalendarWidget* theWrappedObject, QCalendarWidget::SelectionMode mode); void setVerticalHeaderFormat(QCalendarWidget* theWrappedObject, QCalendarWidget::VerticalHeaderFormat format); void setWeekdayTextFormat(QCalendarWidget* theWrappedObject, Qt::DayOfWeek dayOfWeek, const QTextCharFormat& format); - QSize py_q_getSizeHint(QCalendarWidget* theWrappedObject) const{ return (((PythonQtPublicPromoter_QCalendarWidget*)theWrappedObject)->py_q_sizeHint());} + QSize py_q_sizeHint(QCalendarWidget* theWrappedObject) const{ return (((PythonQtPublicPromoter_QCalendarWidget*)theWrappedObject)->py_q_sizeHint());} void updateCell(QCalendarWidget* theWrappedObject, const QDate& date); void updateCells(QCalendarWidget* theWrappedObject); QCalendarWidget::VerticalHeaderFormat verticalHeaderFormat(QCalendarWidget* theWrappedObject) const; @@ -2363,14 +2361,12 @@ void delete_QCheckBox(QCheckBox* obj) { delete obj; } bool py_q_hitButton(QCheckBox* theWrappedObject, const QPoint& pos) const{ return (((PythonQtPublicPromoter_QCheckBox*)theWrappedObject)->py_q_hitButton(pos));} void initStyleOption(QCheckBox* theWrappedObject, QStyleOptionButton* option) const; bool isTristate(QCheckBox* theWrappedObject) const; - QSize minimumSizeHint(QCheckBox* theWrappedObject) const; QSize py_q_minimumSizeHint(QCheckBox* theWrappedObject) const{ return (((PythonQtPublicPromoter_QCheckBox*)theWrappedObject)->py_q_minimumSizeHint());} void py_q_mouseMoveEvent(QCheckBox* theWrappedObject, QMouseEvent* arg__1){ (((PythonQtPublicPromoter_QCheckBox*)theWrappedObject)->py_q_mouseMoveEvent(arg__1));} void py_q_nextCheckState(QCheckBox* theWrappedObject){ (((PythonQtPublicPromoter_QCheckBox*)theWrappedObject)->py_q_nextCheckState());} void py_q_paintEvent(QCheckBox* theWrappedObject, QPaintEvent* arg__1){ (((PythonQtPublicPromoter_QCheckBox*)theWrappedObject)->py_q_paintEvent(arg__1));} void setCheckState(QCheckBox* theWrappedObject, Qt::CheckState state); void setTristate(QCheckBox* theWrappedObject, bool y = true); - QSize sizeHint(QCheckBox* theWrappedObject) const; QSize py_q_sizeHint(QCheckBox* theWrappedObject) const{ return (((PythonQtPublicPromoter_QCheckBox*)theWrappedObject)->py_q_sizeHint());} }; @@ -2908,7 +2904,6 @@ void delete_QComboBox(QComboBox* obj) { delete obj; } int maxCount(QComboBox* theWrappedObject) const; int maxVisibleItems(QComboBox* theWrappedObject) const; int minimumContentsLength(QComboBox* theWrappedObject) const; - QSize minimumSizeHint(QComboBox* theWrappedObject) const; QSize py_q_minimumSizeHint(QComboBox* theWrappedObject) const{ return (((PythonQtPublicPromoter_QComboBox*)theWrappedObject)->py_q_minimumSizeHint());} QAbstractItemModel* model(QComboBox* theWrappedObject) const; int modelColumn(QComboBox* theWrappedObject) const; @@ -2944,7 +2939,6 @@ void delete_QComboBox(QComboBox* obj) { delete obj; } void showPopup(QComboBox* theWrappedObject); void py_q_showPopup(QComboBox* theWrappedObject){ (((PythonQtPublicPromoter_QComboBox*)theWrappedObject)->py_q_showPopup());} QComboBox::SizeAdjustPolicy sizeAdjustPolicy(QComboBox* theWrappedObject) const; - QSize sizeHint(QComboBox* theWrappedObject) const; QSize py_q_sizeHint(QComboBox* theWrappedObject) const{ return (((PythonQtPublicPromoter_QComboBox*)theWrappedObject)->py_q_sizeHint());} const QValidator* validator(QComboBox* theWrappedObject) const; QAbstractItemView* view(QComboBox* theWrappedObject) const; diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui1.cpp b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui1.cpp index 2e616149d..43159cd6c 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui1.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui1.cpp @@ -6840,10 +6840,6 @@ QDateTimeEdit* PythonQtWrapper_QDateTimeEdit::new_QDateTimeEdit(const QTime& t, { return new PythonQtShell_QDateTimeEdit(t, parent); } -QDateTimeEdit* PythonQtWrapper_QDateTimeEdit::new_QDateTimeEdit(const QVariant& val, QMetaType::Type parserType, QWidget* parent) -{ -return new PythonQtShell_QDateTimeEdit(val, parserType, parent); } - QDateTimeEdit* PythonQtWrapper_QDateTimeEdit::new_QDateTimeEdit(const QVariant& val, QVariant::Type parserType, QWidget* parent) { return new PythonQtShell_QDateTimeEdit(val, parserType, parent); } @@ -7804,12 +7800,12 @@ if (_wrapper) { } return QDesktopWidget::metric(arg__1); } -QSize PythonQtShell_QDesktopWidget::getMinimumSizeHint() const +QSize PythonQtShell_QDesktopWidget::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -7821,7 +7817,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -8167,12 +8163,12 @@ if (_wrapper) { } QDesktopWidget::showEvent(event0); } -QSize PythonQtShell_QDesktopWidget::getSizeHint() const +QSize PythonQtShell_QDesktopWidget::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -8184,7 +8180,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -9542,11 +9538,6 @@ void PythonQtWrapper_QDial::initStyleOption(QDial* theWrappedObject, QStyleOptio ( ((PythonQtPublicPromoter_QDial*)theWrappedObject)->promoted_initStyleOption(option)); } -QSize PythonQtWrapper_QDial::minimumSizeHint(QDial* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - int PythonQtWrapper_QDial::notchSize(QDial* theWrappedObject) const { return ( theWrappedObject->notchSize()); @@ -9567,11 +9558,6 @@ void PythonQtWrapper_QDial::setNotchTarget(QDial* theWrappedObject, double targ ( theWrappedObject->setNotchTarget(target)); } -QSize PythonQtWrapper_QDial::sizeHint(QDial* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - bool PythonQtWrapper_QDial::wrapping(QDial* theWrappedObject) const { return ( theWrappedObject->wrapping()); @@ -10875,11 +10861,6 @@ bool PythonQtWrapper_QDialog::isSizeGripEnabled(QDialog* theWrappedObject) cons return ( theWrappedObject->isSizeGripEnabled()); } -QSize PythonQtWrapper_QDialog::minimumSizeHint(QDialog* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - int PythonQtWrapper_QDialog::result(QDialog* theWrappedObject) const { return ( theWrappedObject->result()); @@ -10900,11 +10881,6 @@ void PythonQtWrapper_QDialog::setSizeGripEnabled(QDialog* theWrappedObject, bool ( theWrappedObject->setSizeGripEnabled(arg__1)); } -QSize PythonQtWrapper_QDialog::sizeHint(QDialog* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - PythonQtShell_QDialogButtonBox::~PythonQtShell_QDialogButtonBox() { @@ -11593,12 +11569,12 @@ if (_wrapper) { } return QDialogButtonBox::metric(arg__1); } -QSize PythonQtShell_QDialogButtonBox::getMinimumSizeHint() const +QSize PythonQtShell_QDialogButtonBox::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -11610,7 +11586,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -11956,12 +11932,12 @@ if (_wrapper) { } QDialogButtonBox::showEvent(event0); } -QSize PythonQtShell_QDialogButtonBox::getSizeHint() const +QSize PythonQtShell_QDialogButtonBox::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -11973,7 +11949,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -14210,12 +14186,12 @@ if (_wrapper) { } return QDockWidget::metric(arg__1); } -QSize PythonQtShell_QDockWidget::getMinimumSizeHint() const +QSize PythonQtShell_QDockWidget::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -14227,7 +14203,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -14573,12 +14549,12 @@ if (_wrapper) { } QDockWidget::showEvent(event0); } -QSize PythonQtShell_QDockWidget::getSizeHint() const +QSize PythonQtShell_QDockWidget::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -14590,7 +14566,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui1.h b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui1.h index bedd1becb..4562eeaea 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui1.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui1.h @@ -661,7 +661,6 @@ class PythonQtShell_QDateTimeEdit : public QDateTimeEdit PythonQtShell_QDateTimeEdit(const QDate& d, QWidget* parent = nullptr):QDateTimeEdit(d, parent),_wrapper(nullptr) {}; PythonQtShell_QDateTimeEdit(const QDateTime& dt, QWidget* parent = nullptr):QDateTimeEdit(dt, parent),_wrapper(nullptr) {}; PythonQtShell_QDateTimeEdit(const QTime& t, QWidget* parent = nullptr):QDateTimeEdit(t, parent),_wrapper(nullptr) {}; - PythonQtShell_QDateTimeEdit(const QVariant& val, QMetaType::Type parserType, QWidget* parent = nullptr):QDateTimeEdit(val, parserType, parent),_wrapper(nullptr) {}; PythonQtShell_QDateTimeEdit(const QVariant& val, QVariant::Type parserType, QWidget* parent = nullptr):QDateTimeEdit(val, parserType, parent),_wrapper(nullptr) {}; ~PythonQtShell_QDateTimeEdit() override; @@ -768,7 +767,6 @@ QDateTimeEdit* new_QDateTimeEdit(QWidget* parent = nullptr); QDateTimeEdit* new_QDateTimeEdit(const QDate& d, QWidget* parent = nullptr); QDateTimeEdit* new_QDateTimeEdit(const QDateTime& dt, QWidget* parent = nullptr); QDateTimeEdit* new_QDateTimeEdit(const QTime& t, QWidget* parent = nullptr); -QDateTimeEdit* new_QDateTimeEdit(const QVariant& val, QMetaType::Type parserType, QWidget* parent = nullptr); QDateTimeEdit* new_QDateTimeEdit(const QVariant& val, QVariant::Type parserType, QWidget* parent = nullptr); void delete_QDateTimeEdit(QDateTimeEdit* obj) { delete obj; } QCalendar calendar(QDateTimeEdit* theWrappedObject) const; @@ -898,7 +896,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -912,7 +910,7 @@ void resizeEvent(QResizeEvent* e) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* event) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* event) override; void wheelEvent(QWheelEvent* event) override; @@ -1042,7 +1040,6 @@ QDial* new_QDial(QWidget* parent = nullptr); void delete_QDial(QDial* obj) { delete obj; } bool py_q_event(QDial* theWrappedObject, QEvent* e){ return (((PythonQtPublicPromoter_QDial*)theWrappedObject)->py_q_event(e));} void initStyleOption(QDial* theWrappedObject, QStyleOptionSlider* option) const; - QSize minimumSizeHint(QDial* theWrappedObject) const; QSize py_q_minimumSizeHint(QDial* theWrappedObject) const{ return (((PythonQtPublicPromoter_QDial*)theWrappedObject)->py_q_minimumSizeHint());} void py_q_mouseMoveEvent(QDial* theWrappedObject, QMouseEvent* me){ (((PythonQtPublicPromoter_QDial*)theWrappedObject)->py_q_mouseMoveEvent(me));} void py_q_mousePressEvent(QDial* theWrappedObject, QMouseEvent* me){ (((PythonQtPublicPromoter_QDial*)theWrappedObject)->py_q_mousePressEvent(me));} @@ -1053,7 +1050,6 @@ void delete_QDial(QDial* obj) { delete obj; } void py_q_paintEvent(QDial* theWrappedObject, QPaintEvent* pe){ (((PythonQtPublicPromoter_QDial*)theWrappedObject)->py_q_paintEvent(pe));} void py_q_resizeEvent(QDial* theWrappedObject, QResizeEvent* re){ (((PythonQtPublicPromoter_QDial*)theWrappedObject)->py_q_resizeEvent(re));} void setNotchTarget(QDial* theWrappedObject, double target); - QSize sizeHint(QDial* theWrappedObject) const; QSize py_q_sizeHint(QDial* theWrappedObject) const{ return (((PythonQtPublicPromoter_QDial*)theWrappedObject)->py_q_sizeHint());} void py_q_sliderChange(QDial* theWrappedObject, int change){ (((PythonQtPublicPromoter_QDial*)theWrappedObject)->py_q_sliderChange(change));} bool wrapping(QDial* theWrappedObject) const; @@ -1169,7 +1165,6 @@ void delete_QDialog(QDialog* obj) { delete obj; } int py_q_exec(QDialog* theWrappedObject){ return (((PythonQtPublicPromoter_QDialog*)theWrappedObject)->py_q_exec());} bool isSizeGripEnabled(QDialog* theWrappedObject) const; void py_q_keyPressEvent(QDialog* theWrappedObject, QKeyEvent* arg__1){ (((PythonQtPublicPromoter_QDialog*)theWrappedObject)->py_q_keyPressEvent(arg__1));} - QSize minimumSizeHint(QDialog* theWrappedObject) const; QSize py_q_minimumSizeHint(QDialog* theWrappedObject) const{ return (((PythonQtPublicPromoter_QDialog*)theWrappedObject)->py_q_minimumSizeHint());} void py_q_open(QDialog* theWrappedObject){ (((PythonQtPublicPromoter_QDialog*)theWrappedObject)->py_q_open());} void py_q_reject(QDialog* theWrappedObject){ (((PythonQtPublicPromoter_QDialog*)theWrappedObject)->py_q_reject());} @@ -1180,7 +1175,6 @@ void delete_QDialog(QDialog* obj) { delete obj; } void setSizeGripEnabled(QDialog* theWrappedObject, bool arg__1); void py_q_setVisible(QDialog* theWrappedObject, bool visible){ (((PythonQtPublicPromoter_QDialog*)theWrappedObject)->py_q_setVisible(visible));} void py_q_showEvent(QDialog* theWrappedObject, QShowEvent* arg__1){ (((PythonQtPublicPromoter_QDialog*)theWrappedObject)->py_q_showEvent(arg__1));} - QSize sizeHint(QDialog* theWrappedObject) const; QSize py_q_sizeHint(QDialog* theWrappedObject) const{ return (((PythonQtPublicPromoter_QDialog*)theWrappedObject)->py_q_sizeHint());} }; @@ -1225,7 +1219,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -1239,7 +1233,7 @@ void resizeEvent(QResizeEvent* event) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* event) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* event) override; void wheelEvent(QWheelEvent* event) override; @@ -1457,7 +1451,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -1471,7 +1465,7 @@ void resizeEvent(QResizeEvent* event) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* event) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* event) override; void wheelEvent(QWheelEvent* event) override; diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui10.cpp b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui10.cpp index 18666dfcc..a90a4c83f 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui10.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui10.cpp @@ -3272,11 +3272,6 @@ bool PythonQtWrapper_QTabBar::isTabVisible(QTabBar* theWrappedObject, int inde return ( theWrappedObject->isTabVisible(index)); } -QSize PythonQtWrapper_QTabBar::minimumSizeHint(QTabBar* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - QSize PythonQtWrapper_QTabBar::minimumTabSizeHint(QTabBar* theWrappedObject, int index) const { return ( ((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->promoted_minimumTabSizeHint(index)); @@ -3412,11 +3407,6 @@ QTabBar::Shape PythonQtWrapper_QTabBar::shape(QTabBar* theWrappedObject) const return ( theWrappedObject->shape()); } -QSize PythonQtWrapper_QTabBar::sizeHint(QTabBar* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - int PythonQtWrapper_QTabBar::tabAt(QTabBar* theWrappedObject, const QPoint& pos) const { return ( theWrappedObject->tabAt(pos)); @@ -4788,11 +4778,6 @@ bool PythonQtWrapper_QTabWidget::isTabVisible(QTabWidget* theWrappedObject, int return ( theWrappedObject->isTabVisible(index)); } -QSize PythonQtWrapper_QTabWidget::minimumSizeHint(QTabWidget* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - void PythonQtWrapper_QTabWidget::removeTab(QTabWidget* theWrappedObject, int index) { ( theWrappedObject->removeTab(index)); @@ -4883,11 +4868,6 @@ void PythonQtWrapper_QTabWidget::setUsesScrollButtons(QTabWidget* theWrappedObje ( theWrappedObject->setUsesScrollButtons(useButtons)); } -QSize PythonQtWrapper_QTabWidget::sizeHint(QTabWidget* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - QTabBar* PythonQtWrapper_QTabWidget::tabBar(QTabWidget* theWrappedObject) const { return ( theWrappedObject->tabBar()); diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui10.h b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui10.h index 89c6d6149..dc3b44082 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui10.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui10.h @@ -644,7 +644,6 @@ void delete_QTabBar(QTabBar* obj) { delete obj; } bool isTabEnabled(QTabBar* theWrappedObject, int index) const; bool isTabVisible(QTabBar* theWrappedObject, int index) const; void py_q_keyPressEvent(QTabBar* theWrappedObject, QKeyEvent* arg__1){ (((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->py_q_keyPressEvent(arg__1));} - QSize minimumSizeHint(QTabBar* theWrappedObject) const; QSize py_q_minimumSizeHint(QTabBar* theWrappedObject) const{ return (((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->py_q_minimumSizeHint());} QSize minimumTabSizeHint(QTabBar* theWrappedObject, int index) const; QSize py_q_minimumTabSizeHint(QTabBar* theWrappedObject, int index) const{ return (((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->py_q_minimumTabSizeHint(index));} @@ -680,7 +679,6 @@ void delete_QTabBar(QTabBar* obj) { delete obj; } void setUsesScrollButtons(QTabBar* theWrappedObject, bool useButtons); QTabBar::Shape shape(QTabBar* theWrappedObject) const; void py_q_showEvent(QTabBar* theWrappedObject, QShowEvent* arg__1){ (((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->py_q_showEvent(arg__1));} - QSize sizeHint(QTabBar* theWrappedObject) const; QSize py_q_sizeHint(QTabBar* theWrappedObject) const{ return (((PythonQtPublicPromoter_QTabBar*)theWrappedObject)->py_q_sizeHint());} int tabAt(QTabBar* theWrappedObject, const QPoint& pos) const; QWidget* tabButton(QTabBar* theWrappedObject, int index, QTabBar::ButtonPosition position) const; @@ -823,7 +821,6 @@ void delete_QTabWidget(QTabWidget* obj) { delete obj; } bool isTabEnabled(QTabWidget* theWrappedObject, int index) const; bool isTabVisible(QTabWidget* theWrappedObject, int index) const; void py_q_keyPressEvent(QTabWidget* theWrappedObject, QKeyEvent* arg__1){ (((PythonQtPublicPromoter_QTabWidget*)theWrappedObject)->py_q_keyPressEvent(arg__1));} - QSize minimumSizeHint(QTabWidget* theWrappedObject) const; QSize py_q_minimumSizeHint(QTabWidget* theWrappedObject) const{ return (((PythonQtPublicPromoter_QTabWidget*)theWrappedObject)->py_q_minimumSizeHint());} void py_q_paintEvent(QTabWidget* theWrappedObject, QPaintEvent* arg__1){ (((PythonQtPublicPromoter_QTabWidget*)theWrappedObject)->py_q_paintEvent(arg__1));} void removeTab(QTabWidget* theWrappedObject, int index); @@ -846,7 +843,6 @@ void delete_QTabWidget(QTabWidget* obj) { delete obj; } void setTabsClosable(QTabWidget* theWrappedObject, bool closeable); void setUsesScrollButtons(QTabWidget* theWrappedObject, bool useButtons); void py_q_showEvent(QTabWidget* theWrappedObject, QShowEvent* arg__1){ (((PythonQtPublicPromoter_QTabWidget*)theWrappedObject)->py_q_showEvent(arg__1));} - QSize sizeHint(QTabWidget* theWrappedObject) const; QSize py_q_sizeHint(QTabWidget* theWrappedObject) const{ return (((PythonQtPublicPromoter_QTabWidget*)theWrappedObject)->py_q_sizeHint());} QTabBar* tabBar(QTabWidget* theWrappedObject) const; bool tabBarAutoHide(QTabWidget* theWrappedObject) const; diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui11.cpp b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui11.cpp index 9bf46b308..0469d4d84 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui11.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui11.cpp @@ -1210,7 +1210,7 @@ int PythonQtWrapper_QTextList::count(QTextList* theWrappedObject) const return ( theWrappedObject->count()); } -QTextListFormat PythonQtWrapper_QTextList::textListFormat(QTextList* theWrappedObject) const +QTextListFormat PythonQtWrapper_QTextList::format(QTextList* theWrappedObject) const { return ( theWrappedObject->format()); } @@ -4316,12 +4316,12 @@ if (_wrapper) { } return QToolBar::metric(arg__1); } -QSize PythonQtShell_QToolBar::getMinimumSizeHint() const +QSize PythonQtShell_QToolBar::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -4333,7 +4333,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -4679,12 +4679,12 @@ if (_wrapper) { } QToolBar::showEvent(event0); } -QSize PythonQtShell_QToolBar::getSizeHint() const +QSize PythonQtShell_QToolBar::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -4696,7 +4696,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -5677,12 +5677,12 @@ if (_wrapper) { } return QToolBox::metric(arg__1); } -QSize PythonQtShell_QToolBox::getMinimumSizeHint() const +QSize PythonQtShell_QToolBox::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -5694,7 +5694,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -7525,11 +7525,6 @@ QMenu* PythonQtWrapper_QToolButton::menu(QToolButton* theWrappedObject) const return ( theWrappedObject->menu()); } -QSize PythonQtWrapper_QToolButton::minimumSizeHint(QToolButton* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - QToolButton::ToolButtonPopupMode PythonQtWrapper_QToolButton::popupMode(QToolButton* theWrappedObject) const { return ( theWrappedObject->popupMode()); @@ -7555,11 +7550,6 @@ void PythonQtWrapper_QToolButton::setPopupMode(QToolButton* theWrappedObject, QT ( theWrappedObject->setPopupMode(mode)); } -QSize PythonQtWrapper_QToolButton::sizeHint(QToolButton* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - Qt::ToolButtonStyle PythonQtWrapper_QToolButton::toolButtonStyle(QToolButton* theWrappedObject) const { return ( theWrappedObject->toolButtonStyle()); diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui11.h b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui11.h index 4f4c24358..9de32a261 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui11.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui11.h @@ -459,7 +459,7 @@ QTextList* new_QTextList(QTextDocument* doc); void delete_QTextList(QTextList* obj) { delete obj; } void add(QTextList* theWrappedObject, const QTextBlock& block); int count(QTextList* theWrappedObject) const; - QTextListFormat textListFormat(QTextList* theWrappedObject) const; + QTextListFormat format(QTextList* theWrappedObject) const; QTextBlock item(QTextList* theWrappedObject, int i) const; int itemNumber(QTextList* theWrappedObject, const QTextBlock& arg__1) const; QString itemText(QTextList* theWrappedObject, const QTextBlock& arg__1) const; @@ -967,7 +967,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -981,7 +981,7 @@ void resizeEvent(QResizeEvent* event) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* event) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* event) override; void wheelEvent(QWheelEvent* event) override; @@ -1049,7 +1049,7 @@ void delete_QToolBar(QToolBar* obj) { delete obj; } PythonQt::self()->addSignalHandler(a, SIGNAL(triggered(bool)), callable); return a; } - + QAction* addAction (QToolBar* menu, const QIcon& icon, const QString& text, PyObject* callable) { QAction* a = menu->addAction(text); @@ -1113,7 +1113,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -1295,7 +1295,6 @@ void delete_QToolButton(QToolButton* obj) { delete obj; } void initStyleOption(QToolButton* theWrappedObject, QStyleOptionToolButton* option) const; void py_q_leaveEvent(QToolButton* theWrappedObject, QEvent* arg__1){ (((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->py_q_leaveEvent(arg__1));} QMenu* menu(QToolButton* theWrappedObject) const; - QSize minimumSizeHint(QToolButton* theWrappedObject) const; QSize py_q_minimumSizeHint(QToolButton* theWrappedObject) const{ return (((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->py_q_minimumSizeHint());} void py_q_mousePressEvent(QToolButton* theWrappedObject, QMouseEvent* arg__1){ (((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->py_q_mousePressEvent(arg__1));} void py_q_mouseReleaseEvent(QToolButton* theWrappedObject, QMouseEvent* arg__1){ (((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->py_q_mouseReleaseEvent(arg__1));} @@ -1306,7 +1305,6 @@ void delete_QToolButton(QToolButton* obj) { delete obj; } void setAutoRaise(QToolButton* theWrappedObject, bool enable); void setMenu(QToolButton* theWrappedObject, QMenu* menu); void setPopupMode(QToolButton* theWrappedObject, QToolButton::ToolButtonPopupMode mode); - QSize sizeHint(QToolButton* theWrappedObject) const; QSize py_q_sizeHint(QToolButton* theWrappedObject) const{ return (((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->py_q_sizeHint());} void py_q_timerEvent(QToolButton* theWrappedObject, QTimerEvent* arg__1){ (((PythonQtPublicPromoter_QToolButton*)theWrappedObject)->py_q_timerEvent(arg__1));} Qt::ToolButtonStyle toolButtonStyle(QToolButton* theWrappedObject) const; diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui12.cpp b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui12.cpp index 5d3c24ca0..1a36b7e0b 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui12.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui12.cpp @@ -6027,12 +6027,12 @@ if (_wrapper) { } return QWidget::metric(arg__1); } -QSize PythonQtShell_QWidget::getMinimumSizeHint() const +QSize PythonQtShell_QWidget::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -6044,7 +6044,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -6390,12 +6390,12 @@ if (_wrapper) { } QWidget::showEvent(event0); } -QSize PythonQtShell_QWidget::getSizeHint() const +QSize PythonQtShell_QWidget::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -6407,7 +6407,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -7031,7 +7031,7 @@ QSize PythonQtWrapper_QWidget::minimumSize(QWidget* theWrappedObject) const return ( theWrappedObject->minimumSize()); } -QSize PythonQtWrapper_QWidget::getMinimumSizeHint(QWidget* theWrappedObject) const +QSize PythonQtWrapper_QWidget::minimumSizeHint(QWidget* theWrappedObject) const { return ( theWrappedObject->minimumSizeHint()); } @@ -7561,7 +7561,7 @@ QSize PythonQtWrapper_QWidget::size(QWidget* theWrappedObject) const return ( theWrappedObject->size()); } -QSize PythonQtWrapper_QWidget::getSizeHint(QWidget* theWrappedObject) const +QSize PythonQtWrapper_QWidget::sizeHint(QWidget* theWrappedObject) const { return ( theWrappedObject->sizeHint()); } @@ -12018,12 +12018,12 @@ if (_wrapper) { } return QWizardPage::metric(arg__1); } -QSize PythonQtShell_QWizardPage::getMinimumSizeHint() const +QSize PythonQtShell_QWizardPage::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -12035,7 +12035,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -12414,12 +12414,12 @@ if (_wrapper) { } QWizardPage::showEvent(event0); } -QSize PythonQtShell_QWizardPage::getSizeHint() const +QSize PythonQtShell_QWizardPage::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -12431,7 +12431,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui12.h b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui12.h index b64c4e9b6..ded0d8fdf 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui12.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui12.h @@ -857,7 +857,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -871,7 +871,7 @@ void resizeEvent(QResizeEvent* event) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* event) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* event) override; void wheelEvent(QWheelEvent* event) override; @@ -944,7 +944,7 @@ inline void py_q_keyPressEvent(QKeyEvent* event) { QWidget::keyPressEvent(event inline void py_q_keyReleaseEvent(QKeyEvent* event) { QWidget::keyReleaseEvent(event); } inline void py_q_leaveEvent(QEvent* event) { QWidget::leaveEvent(event); } inline int py_q_metric(QPaintDevice::PaintDeviceMetric arg__1) const { return QWidget::metric(arg__1); } -inline QSize py_q_getMinimumSizeHint() const { return QWidget::minimumSizeHint(); } +inline QSize py_q_minimumSizeHint() const { return QWidget::minimumSizeHint(); } inline void py_q_mouseDoubleClickEvent(QMouseEvent* event) { QWidget::mouseDoubleClickEvent(event); } inline void py_q_mouseMoveEvent(QMouseEvent* event) { QWidget::mouseMoveEvent(event); } inline void py_q_mousePressEvent(QMouseEvent* event) { QWidget::mousePressEvent(event); } @@ -958,7 +958,7 @@ inline void py_q_resizeEvent(QResizeEvent* event) { QWidget::resizeEvent(event) inline void py_q_setVisible(bool visible) { QWidget::setVisible(visible); } inline QPainter* py_q_sharedPainter() const { return QWidget::sharedPainter(); } inline void py_q_showEvent(QShowEvent* event) { QWidget::showEvent(event); } -inline QSize py_q_getSizeHint() const { return QWidget::sizeHint(); } +inline QSize py_q_sizeHint() const { return QWidget::sizeHint(); } inline void py_q_tabletEvent(QTabletEvent* event) { QWidget::tabletEvent(event); } inline void py_q_wheelEvent(QWheelEvent* event) { QWidget::wheelEvent(event); } }; @@ -1103,8 +1103,8 @@ void delete_QWidget(QWidget* obj) { delete obj; } int py_q_metric(QWidget* theWrappedObject, QPaintDevice::PaintDeviceMetric arg__1) const{ return (((PythonQtPublicPromoter_QWidget*)theWrappedObject)->py_q_metric(arg__1));} int minimumHeight(QWidget* theWrappedObject) const; QSize minimumSize(QWidget* theWrappedObject) const; - QSize getMinimumSizeHint(QWidget* theWrappedObject) const; - QSize py_q_getMinimumSizeHint(QWidget* theWrappedObject) const{ return (((PythonQtPublicPromoter_QWidget*)theWrappedObject)->py_q_minimumSizeHint());} + QSize minimumSizeHint(QWidget* theWrappedObject) const; + QSize py_q_minimumSizeHint(QWidget* theWrappedObject) const{ return (((PythonQtPublicPromoter_QWidget*)theWrappedObject)->py_q_minimumSizeHint());} int minimumWidth(QWidget* theWrappedObject) const; void mouseDoubleClickEvent(QWidget* theWrappedObject, QMouseEvent* event); void py_q_mouseDoubleClickEvent(QWidget* theWrappedObject, QMouseEvent* event){ (((PythonQtPublicPromoter_QWidget*)theWrappedObject)->py_q_mouseDoubleClickEvent(event));} @@ -1223,8 +1223,8 @@ void delete_QWidget(QWidget* obj) { delete obj; } void showEvent(QWidget* theWrappedObject, QShowEvent* event); void py_q_showEvent(QWidget* theWrappedObject, QShowEvent* event){ (((PythonQtPublicPromoter_QWidget*)theWrappedObject)->py_q_showEvent(event));} QSize size(QWidget* theWrappedObject) const; - QSize getSizeHint(QWidget* theWrappedObject) const; - QSize py_q_getSizeHint(QWidget* theWrappedObject) const{ return (((PythonQtPublicPromoter_QWidget*)theWrappedObject)->py_q_sizeHint());} + QSize sizeHint(QWidget* theWrappedObject) const; + QSize py_q_sizeHint(QWidget* theWrappedObject) const{ return (((PythonQtPublicPromoter_QWidget*)theWrappedObject)->py_q_sizeHint());} QSize sizeIncrement(QWidget* theWrappedObject) const; QSizePolicy sizePolicy(QWidget* theWrappedObject) const; void stackUnder(QWidget* theWrappedObject, QWidget* arg__1); @@ -1815,7 +1815,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -1830,7 +1830,7 @@ void resizeEvent(QResizeEvent* event) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* event) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* event) override; bool validatePage() override; diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui2.cpp b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui2.cpp index a9e219f53..e99afd4c4 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui2.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui2.cpp @@ -780,12 +780,12 @@ if (_wrapper) { } return QFocusFrame::metric(arg__1); } -QSize PythonQtShell_QFocusFrame::getMinimumSizeHint() const +QSize PythonQtShell_QFocusFrame::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -797,7 +797,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -1143,12 +1143,12 @@ if (_wrapper) { } QFocusFrame::showEvent(event0); } -QSize PythonQtShell_QFocusFrame::getSizeHint() const +QSize PythonQtShell_QFocusFrame::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -1160,7 +1160,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -6110,12 +6110,12 @@ if (_wrapper) { } return QFrame::metric(arg__1); } -QSize PythonQtShell_QFrame::getMinimumSizeHint() const +QSize PythonQtShell_QFrame::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -6127,7 +6127,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -6664,11 +6664,6 @@ void PythonQtWrapper_QFrame::setMidLineWidth(QFrame* theWrappedObject, int arg_ ( theWrappedObject->setMidLineWidth(arg__1)); } -QSize PythonQtWrapper_QFrame::sizeHint(QFrame* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - PythonQtShell_QGesture::~PythonQtShell_QGesture() { diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui2.h b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui2.h index b8e662afc..93eb8b218 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui2.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui2.h @@ -130,7 +130,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -144,7 +144,7 @@ void resizeEvent(QResizeEvent* event) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* event) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* event) override; void wheelEvent(QWheelEvent* event) override; @@ -741,7 +741,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -805,7 +805,6 @@ void delete_QFrame(QFrame* obj) { delete obj; } void setFrameStyle(QFrame* theWrappedObject, int arg__1); void setLineWidth(QFrame* theWrappedObject, int arg__1); void setMidLineWidth(QFrame* theWrappedObject, int arg__1); - QSize sizeHint(QFrame* theWrappedObject) const; QSize py_q_sizeHint(QFrame* theWrappedObject) const{ return (((PythonQtPublicPromoter_QFrame*)theWrappedObject)->py_q_sizeHint());} }; diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui3.cpp b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui3.cpp index d3d6a93de..189364b79 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui3.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui3.cpp @@ -25,6 +25,7 @@ #include #include #include +#include #include #include #include @@ -17254,12 +17255,12 @@ if (_wrapper) { } QGroupBox::showEvent(event0); } -QSize PythonQtShell_QGroupBox::getSizeHint() const +QSize PythonQtShell_QGroupBox::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -17271,7 +17272,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -17399,11 +17400,6 @@ bool PythonQtWrapper_QGroupBox::isFlat(QGroupBox* theWrappedObject) const return ( theWrappedObject->isFlat()); } -QSize PythonQtWrapper_QGroupBox::minimumSizeHint(QGroupBox* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - void PythonQtWrapper_QGroupBox::setAlignment(QGroupBox* theWrappedObject, int alignment) { ( theWrappedObject->setAlignment(alignment)); diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui3.h b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui3.h index 451430da4..381af76ad 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui3.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui3.h @@ -28,6 +28,7 @@ #include #include #include +#include #include #include #include @@ -2329,7 +2330,7 @@ void resizeEvent(QResizeEvent* event) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* event) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* event) override; void wheelEvent(QWheelEvent* event) override; @@ -2379,7 +2380,6 @@ void delete_QGroupBox(QGroupBox* obj) { delete obj; } bool isCheckable(QGroupBox* theWrappedObject) const; bool isChecked(QGroupBox* theWrappedObject) const; bool isFlat(QGroupBox* theWrappedObject) const; - QSize minimumSizeHint(QGroupBox* theWrappedObject) const; QSize py_q_minimumSizeHint(QGroupBox* theWrappedObject) const{ return (((PythonQtPublicPromoter_QGroupBox*)theWrappedObject)->py_q_minimumSizeHint());} void py_q_mouseMoveEvent(QGroupBox* theWrappedObject, QMouseEvent* event){ (((PythonQtPublicPromoter_QGroupBox*)theWrappedObject)->py_q_mouseMoveEvent(event));} void py_q_mousePressEvent(QGroupBox* theWrappedObject, QMouseEvent* event){ (((PythonQtPublicPromoter_QGroupBox*)theWrappedObject)->py_q_mousePressEvent(event));} diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui4.cpp b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui4.cpp index bbb64475b..1e0f13ef9 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui4.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui4.cpp @@ -6210,12 +6210,12 @@ if (_wrapper) { } return QKeySequenceEdit::metric(arg__1); } -QSize PythonQtShell_QKeySequenceEdit::getMinimumSizeHint() const +QSize PythonQtShell_QKeySequenceEdit::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -6227,7 +6227,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -6573,12 +6573,12 @@ if (_wrapper) { } QKeySequenceEdit::showEvent(event0); } -QSize PythonQtShell_QKeySequenceEdit::getSizeHint() const +QSize PythonQtShell_QKeySequenceEdit::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -6590,7 +6590,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -7386,12 +7386,12 @@ if (_wrapper) { } return QLCDNumber::metric(arg__1); } -QSize PythonQtShell_QLCDNumber::getMinimumSizeHint() const +QSize PythonQtShell_QLCDNumber::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -7403,7 +7403,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -9125,11 +9125,6 @@ int PythonQtWrapper_QLabel::margin(QLabel* theWrappedObject) const return ( theWrappedObject->margin()); } -QSize PythonQtWrapper_QLabel::minimumSizeHint(QLabel* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - QMovie* PythonQtWrapper_QLabel::movie(QLabel* theWrappedObject) const { return ( theWrappedObject->movie()); @@ -10156,7 +10151,7 @@ void PythonQtWrapper_QLayout::setSizeConstraint(QLayout* theWrappedObject, QLayo ( theWrappedObject->setSizeConstraint(arg__1)); } -void PythonQtWrapper_QLayout::setWidgetSpacing(QLayout* theWrappedObject, int arg__1) +void PythonQtWrapper_QLayout::setSpacing(QLayout* theWrappedObject, int arg__1) { ( theWrappedObject->setSpacing(arg__1)); } @@ -10166,7 +10161,7 @@ QLayout::SizeConstraint PythonQtWrapper_QLayout::sizeConstraint(QLayout* theWra return ( theWrappedObject->sizeConstraint()); } -int PythonQtWrapper_QLayout::widgetSpacing(QLayout* theWrappedObject) const +int PythonQtWrapper_QLayout::spacing(QLayout* theWrappedObject) const { return ( theWrappedObject->spacing()); } @@ -12120,11 +12115,6 @@ int PythonQtWrapper_QLineEdit::maxLength(QLineEdit* theWrappedObject) const return ( theWrappedObject->maxLength()); } -QSize PythonQtWrapper_QLineEdit::minimumSizeHint(QLineEdit* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - QString PythonQtWrapper_QLineEdit::placeholderText(QLineEdit* theWrappedObject) const { return ( theWrappedObject->placeholderText()); @@ -12235,11 +12225,6 @@ void PythonQtWrapper_QLineEdit::setValidator(QLineEdit* theWrappedObject, const ( theWrappedObject->setValidator(arg__1)); } -QSize PythonQtWrapper_QLineEdit::sizeHint(QLineEdit* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - QString PythonQtWrapper_QLineEdit::text(QLineEdit* theWrappedObject) const { return ( theWrappedObject->text()); diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui4.h b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui4.h index 96cf828a2..95b692ad9 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui4.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui4.h @@ -1263,7 +1263,7 @@ void keyPressEvent(QKeyEvent* arg__1) override; void keyReleaseEvent(QKeyEvent* arg__1) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -1277,7 +1277,7 @@ void resizeEvent(QResizeEvent* event) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* event) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* arg__1) override; void wheelEvent(QWheelEvent* event) override; @@ -1352,7 +1352,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -1521,7 +1521,6 @@ void delete_QLabel(QLabel* obj) { delete obj; } int indent(QLabel* theWrappedObject) const; void py_q_keyPressEvent(QLabel* theWrappedObject, QKeyEvent* ev){ (((PythonQtPublicPromoter_QLabel*)theWrappedObject)->py_q_keyPressEvent(ev));} int margin(QLabel* theWrappedObject) const; - QSize minimumSizeHint(QLabel* theWrappedObject) const; QSize py_q_minimumSizeHint(QLabel* theWrappedObject) const{ return (((PythonQtPublicPromoter_QLabel*)theWrappedObject)->py_q_minimumSizeHint());} void py_q_mouseMoveEvent(QLabel* theWrappedObject, QMouseEvent* ev){ (((PythonQtPublicPromoter_QLabel*)theWrappedObject)->py_q_mouseMoveEvent(ev));} void py_q_mousePressEvent(QLabel* theWrappedObject, QMouseEvent* ev){ (((PythonQtPublicPromoter_QLabel*)theWrappedObject)->py_q_mousePressEvent(ev));} @@ -1667,9 +1666,9 @@ void delete_QLayout(QLayout* obj) { delete obj; } void setMargin(QLayout* theWrappedObject, int arg__1); void setMenuBar(QLayout* theWrappedObject, QWidget* w); void setSizeConstraint(QLayout* theWrappedObject, QLayout::SizeConstraint arg__1); - void setWidgetSpacing(QLayout* theWrappedObject, int arg__1); + void setSpacing(QLayout* theWrappedObject, int arg__1); QLayout::SizeConstraint sizeConstraint(QLayout* theWrappedObject) const; - int widgetSpacing(QLayout* theWrappedObject) const; + int spacing(QLayout* theWrappedObject) const; PythonQtPassOwnershipToPython takeAt(QLayout* theWrappedObject, int index); PythonQtPassOwnershipToPython py_q_takeAt(QLayout* theWrappedObject, int index){ return (((PythonQtPublicPromoter_QLayout*)theWrappedObject)->py_q_takeAt(index));} int totalHeightForWidth(QLayout* theWrappedObject, int w) const; @@ -1928,7 +1927,6 @@ void delete_QLineEdit(QLineEdit* obj) { delete obj; } bool isUndoAvailable(QLineEdit* theWrappedObject) const; void py_q_keyPressEvent(QLineEdit* theWrappedObject, QKeyEvent* arg__1){ (((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->py_q_keyPressEvent(arg__1));} int maxLength(QLineEdit* theWrappedObject) const; - QSize minimumSizeHint(QLineEdit* theWrappedObject) const; QSize py_q_minimumSizeHint(QLineEdit* theWrappedObject) const{ return (((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->py_q_minimumSizeHint());} void py_q_mouseDoubleClickEvent(QLineEdit* theWrappedObject, QMouseEvent* arg__1){ (((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->py_q_mouseDoubleClickEvent(arg__1));} void py_q_mouseMoveEvent(QLineEdit* theWrappedObject, QMouseEvent* arg__1){ (((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->py_q_mouseMoveEvent(arg__1));} @@ -1957,7 +1955,6 @@ void delete_QLineEdit(QLineEdit* obj) { delete obj; } void setTextMargins(QLineEdit* theWrappedObject, const QMargins& margins); void setTextMargins(QLineEdit* theWrappedObject, int left, int top, int right, int bottom); void setValidator(QLineEdit* theWrappedObject, const QValidator* arg__1); - QSize sizeHint(QLineEdit* theWrappedObject) const; QSize py_q_sizeHint(QLineEdit* theWrappedObject) const{ return (((PythonQtPublicPromoter_QLineEdit*)theWrappedObject)->py_q_sizeHint());} QString text(QLineEdit* theWrappedObject) const; QMargins textMargins(QLineEdit* theWrappedObject) const; diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui5.cpp b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui5.cpp index d6a3c74c1..3e053c388 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui5.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui5.cpp @@ -6177,12 +6177,12 @@ if (_wrapper) { } return QMainWindow::metric(arg__1); } -QSize PythonQtShell_QMainWindow::getMinimumSizeHint() const +QSize PythonQtShell_QMainWindow::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -6194,7 +6194,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -6540,12 +6540,12 @@ if (_wrapper) { } QMainWindow::showEvent(event0); } -QSize PythonQtShell_QMainWindow::getSizeHint() const +QSize PythonQtShell_QMainWindow::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -6557,7 +6557,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -9667,11 +9667,6 @@ QMdiArea* PythonQtWrapper_QMdiSubWindow::mdiArea(QMdiSubWindow* theWrappedObjec return ( theWrappedObject->mdiArea()); } -QSize PythonQtWrapper_QMdiSubWindow::minimumSizeHint(QMdiSubWindow* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - void PythonQtWrapper_QMdiSubWindow::setKeyboardPageStep(QMdiSubWindow* theWrappedObject, int step) { ( theWrappedObject->setKeyboardPageStep(step)); @@ -9697,11 +9692,6 @@ void PythonQtWrapper_QMdiSubWindow::setWidget(QMdiSubWindow* theWrappedObject, Q ( theWrappedObject->setWidget(widget)); } -QSize PythonQtWrapper_QMdiSubWindow::sizeHint(QMdiSubWindow* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - QMenu* PythonQtWrapper_QMdiSubWindow::systemMenu(QMdiSubWindow* theWrappedObject) const { return ( theWrappedObject->systemMenu()); @@ -10405,12 +10395,12 @@ if (_wrapper) { } return QMenu::metric(arg__1); } -QSize PythonQtShell_QMenu::getMinimumSizeHint() const +QSize PythonQtShell_QMenu::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -10422,7 +10412,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -11093,11 +11083,6 @@ void PythonQtWrapper_QMenu::showTearOffMenu(QMenu* theWrappedObject, const QPoin ( theWrappedObject->showTearOffMenu(pos)); } -QSize PythonQtWrapper_QMenu::sizeHint(QMenu* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - QString PythonQtWrapper_QMenu::title(QMenu* theWrappedObject) const { return ( theWrappedObject->title()); @@ -12355,11 +12340,6 @@ bool PythonQtWrapper_QMenuBar::isNativeMenuBar(QMenuBar* theWrappedObject) cons return ( theWrappedObject->isNativeMenuBar()); } -QSize PythonQtWrapper_QMenuBar::minimumSizeHint(QMenuBar* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - void PythonQtWrapper_QMenuBar::setActiveAction(QMenuBar* theWrappedObject, QAction* action) { ( theWrappedObject->setActiveAction(action)); @@ -12380,11 +12360,6 @@ void PythonQtWrapper_QMenuBar::setNativeMenuBar(QMenuBar* theWrappedObject, bool ( theWrappedObject->setNativeMenuBar(nativeMenuBar)); } -QSize PythonQtWrapper_QMenuBar::sizeHint(QMenuBar* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - PythonQtShell_QMessageBox::~PythonQtShell_QMessageBox() { diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui5.h b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui5.h index ce5088538..28f0c9115 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui5.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui5.h @@ -670,7 +670,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -684,7 +684,7 @@ void resizeEvent(QResizeEvent* event) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* event) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* event) override; void wheelEvent(QWheelEvent* event) override; @@ -1095,7 +1095,6 @@ void delete_QMdiSubWindow(QMdiSubWindow* obj) { delete obj; } QWidget* maximizedButtonsWidget(QMdiSubWindow* theWrappedObject) const; QWidget* maximizedSystemMenuIconWidget(QMdiSubWindow* theWrappedObject) const; QMdiArea* mdiArea(QMdiSubWindow* theWrappedObject) const; - QSize minimumSizeHint(QMdiSubWindow* theWrappedObject) const; QSize py_q_minimumSizeHint(QMdiSubWindow* theWrappedObject) const{ return (((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->py_q_minimumSizeHint());} void py_q_mouseDoubleClickEvent(QMdiSubWindow* theWrappedObject, QMouseEvent* mouseEvent){ (((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->py_q_mouseDoubleClickEvent(mouseEvent));} void py_q_mouseMoveEvent(QMdiSubWindow* theWrappedObject, QMouseEvent* mouseEvent){ (((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->py_q_mouseMoveEvent(mouseEvent));} @@ -1110,7 +1109,6 @@ void delete_QMdiSubWindow(QMdiSubWindow* obj) { delete obj; } void setSystemMenu(QMdiSubWindow* theWrappedObject, QMenu* systemMenu); void setWidget(QMdiSubWindow* theWrappedObject, QWidget* widget); void py_q_showEvent(QMdiSubWindow* theWrappedObject, QShowEvent* showEvent){ (((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->py_q_showEvent(showEvent));} - QSize sizeHint(QMdiSubWindow* theWrappedObject) const; QSize py_q_sizeHint(QMdiSubWindow* theWrappedObject) const{ return (((PythonQtPublicPromoter_QMdiSubWindow*)theWrappedObject)->py_q_sizeHint());} QMenu* systemMenu(QMdiSubWindow* theWrappedObject) const; bool testOption(QMdiSubWindow* theWrappedObject, QMdiSubWindow::SubWindowOption arg__1) const; @@ -1157,7 +1155,7 @@ void keyPressEvent(QKeyEvent* arg__1) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* arg__1) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* arg__1) override; void mousePressEvent(QMouseEvent* arg__1) override; @@ -1276,7 +1274,6 @@ void delete_QMenu(QMenu* obj) { delete obj; } void setToolTipsVisible(QMenu* theWrappedObject, bool visible); void showTearOffMenu(QMenu* theWrappedObject); void showTearOffMenu(QMenu* theWrappedObject, const QPoint& pos); - QSize sizeHint(QMenu* theWrappedObject) const; QSize py_q_sizeHint(QMenu* theWrappedObject) const{ return (((PythonQtPublicPromoter_QMenu*)theWrappedObject)->py_q_sizeHint());} void py_q_timerEvent(QMenu* theWrappedObject, QTimerEvent* arg__1){ (((PythonQtPublicPromoter_QMenu*)theWrappedObject)->py_q_timerEvent(arg__1));} QString title(QMenu* theWrappedObject) const; @@ -1290,7 +1287,7 @@ void delete_QMenu(QMenu* obj) { delete obj; } PythonQt::self()->addSignalHandler(a, SIGNAL(triggered(bool)), callable); return a; } - + QAction* addAction (QMenu* menu, const QIcon& icon, const QString& text, PyObject* callable, const QKeySequence& shortcut = 0) { QAction* a = menu->addAction(text); @@ -1432,7 +1429,6 @@ void delete_QMenuBar(QMenuBar* obj) { delete obj; } bool isNativeMenuBar(QMenuBar* theWrappedObject) const; void py_q_keyPressEvent(QMenuBar* theWrappedObject, QKeyEvent* arg__1){ (((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->py_q_keyPressEvent(arg__1));} void py_q_leaveEvent(QMenuBar* theWrappedObject, QEvent* arg__1){ (((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->py_q_leaveEvent(arg__1));} - QSize minimumSizeHint(QMenuBar* theWrappedObject) const; QSize py_q_minimumSizeHint(QMenuBar* theWrappedObject) const{ return (((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->py_q_minimumSizeHint());} void py_q_mouseMoveEvent(QMenuBar* theWrappedObject, QMouseEvent* arg__1){ (((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->py_q_mouseMoveEvent(arg__1));} void py_q_mousePressEvent(QMenuBar* theWrappedObject, QMouseEvent* arg__1){ (((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->py_q_mousePressEvent(arg__1));} @@ -1444,7 +1440,6 @@ void delete_QMenuBar(QMenuBar* obj) { delete obj; } void setDefaultUp(QMenuBar* theWrappedObject, bool arg__1); void setNativeMenuBar(QMenuBar* theWrappedObject, bool nativeMenuBar); void py_q_setVisible(QMenuBar* theWrappedObject, bool visible){ (((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->py_q_setVisible(visible));} - QSize sizeHint(QMenuBar* theWrappedObject) const; QSize py_q_sizeHint(QMenuBar* theWrappedObject) const{ return (((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->py_q_sizeHint());} void py_q_timerEvent(QMenuBar* theWrappedObject, QTimerEvent* arg__1){ (((PythonQtPublicPromoter_QMenuBar*)theWrappedObject)->py_q_timerEvent(arg__1));} diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui6.cpp b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui6.cpp index b6007eacc..6d4cfe1d3 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui6.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui6.cpp @@ -973,12 +973,12 @@ if (_wrapper) { } return QOpenGLWidget::metric(metric0); } -QSize PythonQtShell_QOpenGLWidget::getMinimumSizeHint() const +QSize PythonQtShell_QOpenGLWidget::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -990,7 +990,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -1380,12 +1380,12 @@ if (_wrapper) { } QOpenGLWidget::showEvent(event0); } -QSize PythonQtShell_QOpenGLWidget::getSizeHint() const +QSize PythonQtShell_QOpenGLWidget::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -1397,7 +1397,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui6.h b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui6.h index 2a6381f08..3661fe600 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui6.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui6.h @@ -161,7 +161,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric metric) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -177,7 +177,7 @@ void resizeGL(int w, int h) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* event) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* event) override; void wheelEvent(QWheelEvent* event) override; diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui7.cpp b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui7.cpp index 6ed9e65d1..d618463bd 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui7.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui7.cpp @@ -3946,12 +3946,12 @@ if (_wrapper) { } return QPrintPreviewWidget::metric(arg__1); } -QSize PythonQtShell_QPrintPreviewWidget::getMinimumSizeHint() const +QSize PythonQtShell_QPrintPreviewWidget::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -3963,7 +3963,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -4309,12 +4309,12 @@ if (_wrapper) { } QPrintPreviewWidget::showEvent(event0); } -QSize PythonQtShell_QPrintPreviewWidget::getSizeHint() const +QSize PythonQtShell_QPrintPreviewWidget::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -4326,7 +4326,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -6470,11 +6470,6 @@ int PythonQtWrapper_QProgressBar::minimum(QProgressBar* theWrappedObject) const return ( theWrappedObject->minimum()); } -QSize PythonQtWrapper_QProgressBar::minimumSizeHint(QProgressBar* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - Qt::Orientation PythonQtWrapper_QProgressBar::orientation(QProgressBar* theWrappedObject) const { return ( theWrappedObject->orientation()); @@ -6510,11 +6505,6 @@ void PythonQtWrapper_QProgressBar::setTextVisible(QProgressBar* theWrappedObject ( theWrappedObject->setTextVisible(visible)); } -QSize PythonQtWrapper_QProgressBar::sizeHint(QProgressBar* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - QString PythonQtWrapper_QProgressBar::text(QProgressBar* theWrappedObject) const { return ( theWrappedObject->text()); @@ -9970,11 +9960,6 @@ QMenu* PythonQtWrapper_QPushButton::menu(QPushButton* theWrappedObject) const return ( theWrappedObject->menu()); } -QSize PythonQtWrapper_QPushButton::minimumSizeHint(QPushButton* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - void PythonQtWrapper_QPushButton::setAutoDefault(QPushButton* theWrappedObject, bool arg__1) { ( theWrappedObject->setAutoDefault(arg__1)); @@ -9995,11 +9980,6 @@ void PythonQtWrapper_QPushButton::setMenu(QPushButton* theWrappedObject, QMenu* ( theWrappedObject->setMenu(menu)); } -QSize PythonQtWrapper_QPushButton::sizeHint(QPushButton* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - QQuaternion* PythonQtWrapper_QQuaternion::new_QQuaternion() @@ -11633,16 +11613,6 @@ void PythonQtWrapper_QRadioButton::initStyleOption(QRadioButton* theWrappedObjec ( ((PythonQtPublicPromoter_QRadioButton*)theWrappedObject)->promoted_initStyleOption(button)); } -QSize PythonQtWrapper_QRadioButton::minimumSizeHint(QRadioButton* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - -QSize PythonQtWrapper_QRadioButton::sizeHint(QRadioButton* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - PythonQtShell_QRasterWindow::~PythonQtShell_QRasterWindow() { @@ -13971,12 +13941,12 @@ if (_wrapper) { } return QRubberBand::metric(arg__1); } -QSize PythonQtShell_QRubberBand::getMinimumSizeHint() const +QSize PythonQtShell_QRubberBand::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -13988,7 +13958,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -14334,12 +14304,12 @@ if (_wrapper) { } QRubberBand::showEvent(arg__1); } -QSize PythonQtShell_QRubberBand::getSizeHint() const +QSize PythonQtShell_QRubberBand::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -14351,7 +14321,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -16700,12 +16670,12 @@ if (_wrapper) { } return QScrollBar::metric(arg__1); } -QSize PythonQtShell_QScrollBar::getMinimumSizeHint() const +QSize PythonQtShell_QScrollBar::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -16717,7 +16687,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -17210,11 +17180,6 @@ void PythonQtWrapper_QScrollBar::initStyleOption(QScrollBar* theWrappedObject, Q ( ((PythonQtPublicPromoter_QScrollBar*)theWrappedObject)->promoted_initStyleOption(option)); } -QSize PythonQtWrapper_QScrollBar::sizeHint(QScrollBar* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - QScrollEvent* PythonQtWrapper_QScrollEvent::new_QScrollEvent(const QPointF& contentPos, const QPointF& overshoot, QScrollEvent::ScrollState scrollState) diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui7.h b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui7.h index affa48f2f..f483db524 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui7.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui7.h @@ -443,7 +443,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -457,7 +457,7 @@ void resizeEvent(QResizeEvent* event) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* event) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* event) override; void wheelEvent(QWheelEvent* event) override; @@ -766,7 +766,6 @@ void delete_QProgressBar(QProgressBar* obj) { delete obj; } bool isTextVisible(QProgressBar* theWrappedObject) const; int maximum(QProgressBar* theWrappedObject) const; int minimum(QProgressBar* theWrappedObject) const; - QSize minimumSizeHint(QProgressBar* theWrappedObject) const; QSize py_q_minimumSizeHint(QProgressBar* theWrappedObject) const{ return (((PythonQtPublicPromoter_QProgressBar*)theWrappedObject)->py_q_minimumSizeHint());} Qt::Orientation orientation(QProgressBar* theWrappedObject) const; void py_q_paintEvent(QProgressBar* theWrappedObject, QPaintEvent* arg__1){ (((PythonQtPublicPromoter_QProgressBar*)theWrappedObject)->py_q_paintEvent(arg__1));} @@ -776,7 +775,6 @@ void delete_QProgressBar(QProgressBar* obj) { delete obj; } void setInvertedAppearance(QProgressBar* theWrappedObject, bool invert); void setTextDirection(QProgressBar* theWrappedObject, QProgressBar::Direction textDirection); void setTextVisible(QProgressBar* theWrappedObject, bool visible); - QSize sizeHint(QProgressBar* theWrappedObject) const; QSize py_q_sizeHint(QProgressBar* theWrappedObject) const{ return (((PythonQtPublicPromoter_QProgressBar*)theWrappedObject)->py_q_sizeHint());} QString text(QProgressBar* theWrappedObject) const; QString py_q_text(QProgressBar* theWrappedObject) const{ return (((PythonQtPublicPromoter_QProgressBar*)theWrappedObject)->py_q_text());} @@ -1108,14 +1106,12 @@ void delete_QPushButton(QPushButton* obj) { delete obj; } bool isFlat(QPushButton* theWrappedObject) const; void py_q_keyPressEvent(QPushButton* theWrappedObject, QKeyEvent* arg__1){ (((PythonQtPublicPromoter_QPushButton*)theWrappedObject)->py_q_keyPressEvent(arg__1));} QMenu* menu(QPushButton* theWrappedObject) const; - QSize minimumSizeHint(QPushButton* theWrappedObject) const; QSize py_q_minimumSizeHint(QPushButton* theWrappedObject) const{ return (((PythonQtPublicPromoter_QPushButton*)theWrappedObject)->py_q_minimumSizeHint());} void py_q_paintEvent(QPushButton* theWrappedObject, QPaintEvent* arg__1){ (((PythonQtPublicPromoter_QPushButton*)theWrappedObject)->py_q_paintEvent(arg__1));} void setAutoDefault(QPushButton* theWrappedObject, bool arg__1); void setDefault(QPushButton* theWrappedObject, bool arg__1); void setFlat(QPushButton* theWrappedObject, bool arg__1); void setMenu(QPushButton* theWrappedObject, QMenu* menu); - QSize sizeHint(QPushButton* theWrappedObject) const; QSize py_q_sizeHint(QPushButton* theWrappedObject) const{ return (((PythonQtPublicPromoter_QPushButton*)theWrappedObject)->py_q_sizeHint());} }; @@ -1318,11 +1314,9 @@ void delete_QRadioButton(QRadioButton* obj) { delete obj; } bool py_q_event(QRadioButton* theWrappedObject, QEvent* e){ return (((PythonQtPublicPromoter_QRadioButton*)theWrappedObject)->py_q_event(e));} bool py_q_hitButton(QRadioButton* theWrappedObject, const QPoint& arg__1) const{ return (((PythonQtPublicPromoter_QRadioButton*)theWrappedObject)->py_q_hitButton(arg__1));} void initStyleOption(QRadioButton* theWrappedObject, QStyleOptionButton* button) const; - QSize minimumSizeHint(QRadioButton* theWrappedObject) const; QSize py_q_minimumSizeHint(QRadioButton* theWrappedObject) const{ return (((PythonQtPublicPromoter_QRadioButton*)theWrappedObject)->py_q_minimumSizeHint());} void py_q_mouseMoveEvent(QRadioButton* theWrappedObject, QMouseEvent* arg__1){ (((PythonQtPublicPromoter_QRadioButton*)theWrappedObject)->py_q_mouseMoveEvent(arg__1));} void py_q_paintEvent(QRadioButton* theWrappedObject, QPaintEvent* arg__1){ (((PythonQtPublicPromoter_QRadioButton*)theWrappedObject)->py_q_paintEvent(arg__1));} - QSize sizeHint(QRadioButton* theWrappedObject) const; QSize py_q_sizeHint(QRadioButton* theWrappedObject) const{ return (((PythonQtPublicPromoter_QRadioButton*)theWrappedObject)->py_q_sizeHint());} }; @@ -1639,7 +1633,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -1653,7 +1647,7 @@ void resizeEvent(QResizeEvent* arg__1) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* arg__1) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* event) override; void wheelEvent(QWheelEvent* event) override; @@ -1911,7 +1905,7 @@ void keyPressEvent(QKeyEvent* ev) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* arg__1) override; void mousePressEvent(QMouseEvent* arg__1) override; @@ -1974,7 +1968,6 @@ void delete_QScrollBar(QScrollBar* obj) { delete obj; } void py_q_mousePressEvent(QScrollBar* theWrappedObject, QMouseEvent* arg__1){ (((PythonQtPublicPromoter_QScrollBar*)theWrappedObject)->py_q_mousePressEvent(arg__1));} void py_q_mouseReleaseEvent(QScrollBar* theWrappedObject, QMouseEvent* arg__1){ (((PythonQtPublicPromoter_QScrollBar*)theWrappedObject)->py_q_mouseReleaseEvent(arg__1));} void py_q_paintEvent(QScrollBar* theWrappedObject, QPaintEvent* arg__1){ (((PythonQtPublicPromoter_QScrollBar*)theWrappedObject)->py_q_paintEvent(arg__1));} - QSize sizeHint(QScrollBar* theWrappedObject) const; QSize py_q_sizeHint(QScrollBar* theWrappedObject) const{ return (((PythonQtPublicPromoter_QScrollBar*)theWrappedObject)->py_q_sizeHint());} void py_q_sliderChange(QScrollBar* theWrappedObject, int change){ (((PythonQtPublicPromoter_QScrollBar*)theWrappedObject)->py_q_sliderChange(change));} void py_q_wheelEvent(QScrollBar* theWrappedObject, QWheelEvent* arg__1){ (((PythonQtPublicPromoter_QScrollBar*)theWrappedObject)->py_q_wheelEvent(arg__1));} diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui8.cpp b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui8.cpp index 7480e9ef4..d38e80711 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui8.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui8.cpp @@ -998,12 +998,12 @@ if (_wrapper) { } return QSizeGrip::metric(arg__1); } -QSize PythonQtShell_QSizeGrip::getMinimumSizeHint() const +QSize PythonQtShell_QSizeGrip::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -1015,7 +1015,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -1477,11 +1477,6 @@ int PythonQtShell_QSizeGrip::qt_metacall(QMetaObject::Call call, int id, void** int result = QSizeGrip::qt_metacall(call, id, args); return result >= 0 ? PythonQt::priv()->handleMetaCall(this, _wrapper, call, id, args) : result; } -QSize PythonQtWrapper_QSizeGrip::sizeHint(QSizeGrip* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - PythonQtShell_QSlider::~PythonQtShell_QSlider() { @@ -2680,11 +2675,6 @@ void PythonQtWrapper_QSlider::initStyleOption(QSlider* theWrappedObject, QStyleO ( ((PythonQtPublicPromoter_QSlider*)theWrappedObject)->promoted_initStyleOption(option)); } -QSize PythonQtWrapper_QSlider::minimumSizeHint(QSlider* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - void PythonQtWrapper_QSlider::setTickInterval(QSlider* theWrappedObject, int ti) { ( theWrappedObject->setTickInterval(ti)); @@ -2695,11 +2685,6 @@ void PythonQtWrapper_QSlider::setTickPosition(QSlider* theWrappedObject, QSlider ( theWrappedObject->setTickPosition(position)); } -QSize PythonQtWrapper_QSlider::sizeHint(QSlider* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - int PythonQtWrapper_QSlider::tickInterval(QSlider* theWrappedObject) const { return ( theWrappedObject->tickInterval()); @@ -6990,12 +6975,12 @@ if (_wrapper) { } return QSplashScreen::metric(arg__1); } -QSize PythonQtShell_QSplashScreen::getMinimumSizeHint() const +QSize PythonQtShell_QSplashScreen::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -7007,7 +6992,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -7353,12 +7338,12 @@ if (_wrapper) { } QSplashScreen::showEvent(event0); } -QSize PythonQtShell_QSplashScreen::getSizeHint() const +QSize PythonQtShell_QSplashScreen::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -7370,7 +7355,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -8756,11 +8741,6 @@ bool PythonQtWrapper_QSplitter::isCollapsible(QSplitter* theWrappedObject, int return ( theWrappedObject->isCollapsible(index)); } -QSize PythonQtWrapper_QSplitter::minimumSizeHint(QSplitter* theWrappedObject) const -{ - return ( theWrappedObject->minimumSizeHint()); -} - void PythonQtWrapper_QSplitter::moveSplitter(QSplitter* theWrappedObject, int pos, int index) { ( ((PythonQtPublicPromoter_QSplitter*)theWrappedObject)->promoted_moveSplitter(pos, index)); @@ -9544,12 +9524,12 @@ if (_wrapper) { } return QSplitterHandle::metric(arg__1); } -QSize PythonQtShell_QSplitterHandle::getMinimumSizeHint() const +QSize PythonQtShell_QSplitterHandle::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -9561,7 +9541,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -10048,11 +10028,6 @@ void PythonQtWrapper_QSplitterHandle::setOrientation(QSplitterHandle* theWrapped ( theWrappedObject->setOrientation(o)); } -QSize PythonQtWrapper_QSplitterHandle::sizeHint(QSplitterHandle* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - QSplitter* PythonQtWrapper_QSplitterHandle::splitter(QSplitterHandle* theWrappedObject) const { return ( theWrappedObject->splitter()); @@ -11538,12 +11513,12 @@ if (_wrapper) { } return QStackedWidget::metric(arg__1); } -QSize PythonQtShell_QStackedWidget::getMinimumSizeHint() const +QSize PythonQtShell_QStackedWidget::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -11555,7 +11530,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -14878,12 +14853,12 @@ if (_wrapper) { } return QStatusBar::metric(arg__1); } -QSize PythonQtShell_QStatusBar::getMinimumSizeHint() const +QSize PythonQtShell_QStatusBar::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -14895,7 +14870,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -15241,12 +15216,12 @@ if (_wrapper) { } QStatusBar::showEvent(arg__1); } -QSize PythonQtShell_QStatusBar::getSizeHint() const +QSize PythonQtShell_QStatusBar::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -15258,7 +15233,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui8.h b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui8.h index 90c16610d..cb89ffc74 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui8.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui/com_trolltech_qt_gui8.h @@ -197,7 +197,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* arg__1) override; void mousePressEvent(QMouseEvent* arg__1) override; @@ -261,7 +261,6 @@ void delete_QSizeGrip(QSizeGrip* obj) { delete obj; } void py_q_paintEvent(QSizeGrip* theWrappedObject, QPaintEvent* arg__1){ (((PythonQtPublicPromoter_QSizeGrip*)theWrappedObject)->py_q_paintEvent(arg__1));} void py_q_setVisible(QSizeGrip* theWrappedObject, bool arg__1){ (((PythonQtPublicPromoter_QSizeGrip*)theWrappedObject)->py_q_setVisible(arg__1));} void py_q_showEvent(QSizeGrip* theWrappedObject, QShowEvent* showEvent){ (((PythonQtPublicPromoter_QSizeGrip*)theWrappedObject)->py_q_showEvent(showEvent));} - QSize sizeHint(QSizeGrip* theWrappedObject) const; QSize py_q_sizeHint(QSizeGrip* theWrappedObject) const{ return (((PythonQtPublicPromoter_QSizeGrip*)theWrappedObject)->py_q_sizeHint());} }; @@ -354,7 +353,6 @@ QSlider* new_QSlider(Qt::Orientation orientation, QWidget* parent = nullptr); void delete_QSlider(QSlider* obj) { delete obj; } bool py_q_event(QSlider* theWrappedObject, QEvent* event){ return (((PythonQtPublicPromoter_QSlider*)theWrappedObject)->py_q_event(event));} void initStyleOption(QSlider* theWrappedObject, QStyleOptionSlider* option) const; - QSize minimumSizeHint(QSlider* theWrappedObject) const; QSize py_q_minimumSizeHint(QSlider* theWrappedObject) const{ return (((PythonQtPublicPromoter_QSlider*)theWrappedObject)->py_q_minimumSizeHint());} void py_q_mouseMoveEvent(QSlider* theWrappedObject, QMouseEvent* ev){ (((PythonQtPublicPromoter_QSlider*)theWrappedObject)->py_q_mouseMoveEvent(ev));} void py_q_mousePressEvent(QSlider* theWrappedObject, QMouseEvent* ev){ (((PythonQtPublicPromoter_QSlider*)theWrappedObject)->py_q_mousePressEvent(ev));} @@ -362,7 +360,6 @@ void delete_QSlider(QSlider* obj) { delete obj; } void py_q_paintEvent(QSlider* theWrappedObject, QPaintEvent* ev){ (((PythonQtPublicPromoter_QSlider*)theWrappedObject)->py_q_paintEvent(ev));} void setTickInterval(QSlider* theWrappedObject, int ti); void setTickPosition(QSlider* theWrappedObject, QSlider::TickPosition position); - QSize sizeHint(QSlider* theWrappedObject) const; QSize py_q_sizeHint(QSlider* theWrappedObject) const{ return (((PythonQtPublicPromoter_QSlider*)theWrappedObject)->py_q_sizeHint());} int tickInterval(QSlider* theWrappedObject) const; QSlider::TickPosition tickPosition(QSlider* theWrappedObject) const; @@ -755,7 +752,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* arg__1) override; @@ -769,7 +766,7 @@ void resizeEvent(QResizeEvent* event) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* event) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* event) override; void wheelEvent(QWheelEvent* event) override; @@ -911,7 +908,6 @@ void delete_QSplitter(QSplitter* obj) { delete obj; } int indexOf(QSplitter* theWrappedObject, QWidget* w) const; void insertWidget(QSplitter* theWrappedObject, int index, PythonQtPassOwnershipToCPP widget); bool isCollapsible(QSplitter* theWrappedObject, int index) const; - QSize minimumSizeHint(QSplitter* theWrappedObject) const; QSize py_q_minimumSizeHint(QSplitter* theWrappedObject) const{ return (((PythonQtPublicPromoter_QSplitter*)theWrappedObject)->py_q_minimumSizeHint());} void moveSplitter(QSplitter* theWrappedObject, int pos, int index); bool opaqueResize(QSplitter* theWrappedObject) const; @@ -974,7 +970,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* arg__1) override; void mousePressEvent(QMouseEvent* arg__1) override; @@ -1034,7 +1030,6 @@ void delete_QSplitterHandle(QSplitterHandle* obj) { delete obj; } void py_q_paintEvent(QSplitterHandle* theWrappedObject, QPaintEvent* arg__1){ (((PythonQtPublicPromoter_QSplitterHandle*)theWrappedObject)->py_q_paintEvent(arg__1));} void py_q_resizeEvent(QSplitterHandle* theWrappedObject, QResizeEvent* arg__1){ (((PythonQtPublicPromoter_QSplitterHandle*)theWrappedObject)->py_q_resizeEvent(arg__1));} void setOrientation(QSplitterHandle* theWrappedObject, Qt::Orientation o); - QSize sizeHint(QSplitterHandle* theWrappedObject) const; QSize py_q_sizeHint(QSplitterHandle* theWrappedObject) const{ return (((PythonQtPublicPromoter_QSplitterHandle*)theWrappedObject)->py_q_sizeHint());} QSplitter* splitter(QSplitterHandle* theWrappedObject) const; }; @@ -1160,7 +1155,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -1569,7 +1564,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -1583,7 +1578,7 @@ void resizeEvent(QResizeEvent* arg__1) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* arg__1) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* event) override; void wheelEvent(QWheelEvent* event) override; diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui_builtin/com_trolltech_qt_gui_builtin0.cpp b/generated_cpp_5.15.2/com_trolltech_qt_gui_builtin/com_trolltech_qt_gui_builtin0.cpp index 55c2ed977..05c53ea9c 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui_builtin/com_trolltech_qt_gui_builtin0.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui_builtin/com_trolltech_qt_gui_builtin0.cpp @@ -2579,12 +2579,12 @@ void PythonQtWrapper_QMatrix::reset(QMatrix* theWrappedObject) ( theWrappedObject->reset()); } -QMatrix* PythonQtWrapper_QMatrix::rotate_private(QMatrix* theWrappedObject, qreal a) +QMatrix* PythonQtWrapper_QMatrix::rotate(QMatrix* theWrappedObject, qreal a) { return &( theWrappedObject->rotate(a)); } -QMatrix* PythonQtWrapper_QMatrix::scale_private(QMatrix* theWrappedObject, qreal sx, qreal sy) +QMatrix* PythonQtWrapper_QMatrix::scale(QMatrix* theWrappedObject, qreal sx, qreal sy) { return &( theWrappedObject->scale(sx, sy)); } @@ -2594,12 +2594,12 @@ void PythonQtWrapper_QMatrix::setMatrix(QMatrix* theWrappedObject, qreal m11, q ( theWrappedObject->setMatrix(m11, m12, m21, m22, dx, dy)); } -QMatrix* PythonQtWrapper_QMatrix::shear_private(QMatrix* theWrappedObject, qreal sh, qreal sv) +QMatrix* PythonQtWrapper_QMatrix::shear(QMatrix* theWrappedObject, qreal sh, qreal sv) { return &( theWrappedObject->shear(sh, sv)); } -QMatrix* PythonQtWrapper_QMatrix::translate_private(QMatrix* theWrappedObject, qreal dx, qreal dy) +QMatrix* PythonQtWrapper_QMatrix::translate(QMatrix* theWrappedObject, qreal dx, qreal dy) { return &( theWrappedObject->translate(dx, dy)); } @@ -4744,7 +4744,7 @@ void PythonQtWrapper_QTextFormat::setProperty(QTextFormat* theWrappedObject, int ( theWrappedObject->setProperty(propertyId, value)); } -void PythonQtWrapper_QTextFormat::setLengthVectorProperty(QTextFormat* theWrappedObject, int propertyId, const QVector& lengths) +void PythonQtWrapper_QTextFormat::setProperty(QTextFormat* theWrappedObject, int propertyId, const QVector& lengths) { ( theWrappedObject->setProperty(propertyId, lengths)); } diff --git a/generated_cpp_5.15.2/com_trolltech_qt_gui_builtin/com_trolltech_qt_gui_builtin0.h b/generated_cpp_5.15.2/com_trolltech_qt_gui_builtin/com_trolltech_qt_gui_builtin0.h index b6cabc89a..ec0ffdf25 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_gui_builtin/com_trolltech_qt_gui_builtin0.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_gui_builtin/com_trolltech_qt_gui_builtin0.h @@ -724,11 +724,11 @@ void delete_QMatrix(QMatrix* obj) { delete obj; } bool __eq__(QMatrix* theWrappedObject, const QMatrix& arg__1) const; void readFrom(QMatrix* theWrappedObject, QDataStream& arg__1); void reset(QMatrix* theWrappedObject); - QMatrix* rotate_private(QMatrix* theWrappedObject, qreal a); - QMatrix* scale_private(QMatrix* theWrappedObject, qreal sx, qreal sy); + QMatrix* rotate(QMatrix* theWrappedObject, qreal a); + QMatrix* scale(QMatrix* theWrappedObject, qreal sx, qreal sy); void setMatrix(QMatrix* theWrappedObject, qreal m11, qreal m12, qreal m21, qreal m22, qreal dx, qreal dy); - QMatrix* shear_private(QMatrix* theWrappedObject, qreal sh, qreal sv); - QMatrix* translate_private(QMatrix* theWrappedObject, qreal dx, qreal dy); + QMatrix* shear(QMatrix* theWrappedObject, qreal sh, qreal sv); + QMatrix* translate(QMatrix* theWrappedObject, qreal dx, qreal dy); QString py_toString(QMatrix*); }; @@ -1279,7 +1279,7 @@ void delete_QTextFormat(QTextFormat* obj) { delete obj; } void setObjectIndex(QTextFormat* theWrappedObject, int object); void setObjectType(QTextFormat* theWrappedObject, int type); void setProperty(QTextFormat* theWrappedObject, int propertyId, const QVariant& value); - void setLengthVectorProperty(QTextFormat* theWrappedObject, int propertyId, const QVector& lengths); + void setProperty(QTextFormat* theWrappedObject, int propertyId, const QVector& lengths); QString stringProperty(QTextFormat* theWrappedObject, int propertyId) const; void swap(QTextFormat* theWrappedObject, QTextFormat& other); QTextBlockFormat toBlockFormat(QTextFormat* theWrappedObject) const; diff --git a/generated_cpp_5.15.2/com_trolltech_qt_multimedia/com_trolltech_qt_multimedia1.cpp b/generated_cpp_5.15.2/com_trolltech_qt_multimedia/com_trolltech_qt_multimedia1.cpp index b2e4f9609..b795e30aa 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_multimedia/com_trolltech_qt_multimedia1.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_multimedia/com_trolltech_qt_multimedia1.cpp @@ -2984,12 +2984,12 @@ if (_wrapper) { } return QCameraViewfinder::metric(arg__1); } -QSize PythonQtShell_QCameraViewfinder::getMinimumSizeHint() const +QSize PythonQtShell_QCameraViewfinder::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -3001,7 +3001,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } diff --git a/generated_cpp_5.15.2/com_trolltech_qt_multimedia/com_trolltech_qt_multimedia1.h b/generated_cpp_5.15.2/com_trolltech_qt_multimedia/com_trolltech_qt_multimedia1.h index 168223c3f..688f4c205 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_multimedia/com_trolltech_qt_multimedia1.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_multimedia/com_trolltech_qt_multimedia1.h @@ -566,7 +566,7 @@ void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; QMediaObject* mediaObject() const override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; diff --git a/generated_cpp_5.15.2/com_trolltech_qt_multimedia/com_trolltech_qt_multimedia3.cpp b/generated_cpp_5.15.2/com_trolltech_qt_multimedia/com_trolltech_qt_multimedia3.cpp index de2be060e..c542008a6 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_multimedia/com_trolltech_qt_multimedia3.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_multimedia/com_trolltech_qt_multimedia3.cpp @@ -1142,12 +1142,12 @@ if (_wrapper) { } return QVideoWidget::metric(arg__1); } -QSize PythonQtShell_QVideoWidget::getMinimumSizeHint() const +QSize PythonQtShell_QVideoWidget::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -1159,7 +1159,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -1679,11 +1679,6 @@ int PythonQtWrapper_QVideoWidget::saturation(QVideoWidget* theWrappedObject) co return ( theWrappedObject->saturation()); } -QSize PythonQtWrapper_QVideoWidget::sizeHint(QVideoWidget* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - QAbstractVideoSurface* PythonQtWrapper_QVideoWidget::videoSurface(QVideoWidget* theWrappedObject) const { return ( theWrappedObject->videoSurface()); diff --git a/generated_cpp_5.15.2/com_trolltech_qt_multimedia/com_trolltech_qt_multimedia3.h b/generated_cpp_5.15.2/com_trolltech_qt_multimedia/com_trolltech_qt_multimedia3.h index 5faa19f32..d79a84f85 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_multimedia/com_trolltech_qt_multimedia3.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_multimedia/com_trolltech_qt_multimedia3.h @@ -172,7 +172,7 @@ void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; QMediaObject* mediaObject() const override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -236,7 +236,6 @@ void delete_QVideoWidget(QVideoWidget* obj) { delete obj; } int saturation(QVideoWidget* theWrappedObject) const; bool py_q_setMediaObject(QVideoWidget* theWrappedObject, QMediaObject* object){ return (((PythonQtPublicPromoter_QVideoWidget*)theWrappedObject)->py_q_setMediaObject(object));} void py_q_showEvent(QVideoWidget* theWrappedObject, QShowEvent* event){ (((PythonQtPublicPromoter_QVideoWidget*)theWrappedObject)->py_q_showEvent(event));} - QSize sizeHint(QVideoWidget* theWrappedObject) const; QSize py_q_sizeHint(QVideoWidget* theWrappedObject) const{ return (((PythonQtPublicPromoter_QVideoWidget*)theWrappedObject)->py_q_sizeHint());} QAbstractVideoSurface* videoSurface(QVideoWidget* theWrappedObject) const; }; diff --git a/generated_cpp_5.15.2/com_trolltech_qt_opengl/com_trolltech_qt_opengl0.cpp b/generated_cpp_5.15.2/com_trolltech_qt_opengl/com_trolltech_qt_opengl0.cpp index 2a9ce6795..2bba67d05 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_opengl/com_trolltech_qt_opengl0.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_opengl/com_trolltech_qt_opengl0.cpp @@ -3759,12 +3759,12 @@ if (_wrapper) { } return QGLWidget::metric(arg__1); } -QSize PythonQtShell_QGLWidget::getMinimumSizeHint() const +QSize PythonQtShell_QGLWidget::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -3776,7 +3776,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -4210,12 +4210,12 @@ if (_wrapper) { } QGLWidget::showEvent(event0); } -QSize PythonQtShell_QGLWidget::getSizeHint() const +QSize PythonQtShell_QGLWidget::sizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getSizeHint"); + static PyObject* name = PyUnicode_FromString("sizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -4227,7 +4227,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } diff --git a/generated_cpp_5.15.2/com_trolltech_qt_opengl/com_trolltech_qt_opengl0.h b/generated_cpp_5.15.2/com_trolltech_qt_opengl/com_trolltech_qt_opengl0.h index 82c1b18a9..1ce5fec2d 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_opengl/com_trolltech_qt_opengl0.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_opengl/com_trolltech_qt_opengl0.h @@ -825,7 +825,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -843,7 +843,7 @@ void resizeOverlayGL(int w, int h) override; void setVisible(bool visible) override; QPainter* sharedPainter() const override; void showEvent(QShowEvent* event) override; -QSize getSizeHint() const override; +QSize sizeHint() const override; void tabletEvent(QTabletEvent* event) override; void timerEvent(QTimerEvent* event) override; void updateGL() override; diff --git a/generated_cpp_5.15.2/com_trolltech_qt_quick/com_trolltech_qt_quick0.cpp b/generated_cpp_5.15.2/com_trolltech_qt_quick/com_trolltech_qt_quick0.cpp index a0ba2764c..4282bd060 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_quick/com_trolltech_qt_quick0.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_quick/com_trolltech_qt_quick0.cpp @@ -5802,12 +5802,12 @@ if (_wrapper) { } return QQuickWidget::metric(arg__1); } -QSize PythonQtShell_QQuickWidget::getMinimumSizeHint() const +QSize PythonQtShell_QQuickWidget::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -5819,7 +5819,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -6349,11 +6349,6 @@ void PythonQtWrapper_QQuickWidget::setResizeMode(QQuickWidget* theWrappedObject, ( theWrappedObject->setResizeMode(arg__1)); } -QSize PythonQtWrapper_QQuickWidget::sizeHint(QQuickWidget* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - QUrl PythonQtWrapper_QQuickWidget::source(QQuickWidget* theWrappedObject) const { return ( theWrappedObject->source()); diff --git a/generated_cpp_5.15.2/com_trolltech_qt_quick/com_trolltech_qt_quick0.h b/generated_cpp_5.15.2/com_trolltech_qt_quick/com_trolltech_qt_quick0.h index 05f80df2f..980821e35 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_quick/com_trolltech_qt_quick0.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_quick/com_trolltech_qt_quick0.h @@ -928,7 +928,7 @@ void keyPressEvent(QKeyEvent* arg__1) override; void keyReleaseEvent(QKeyEvent* arg__1) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* arg__1) override; void mouseMoveEvent(QMouseEvent* arg__1) override; void mousePressEvent(QMouseEvent* arg__1) override; @@ -1035,7 +1035,6 @@ void delete_QQuickWidget(QQuickWidget* obj) { delete obj; } void setFormat(QQuickWidget* theWrappedObject, const QSurfaceFormat& format); void setResizeMode(QQuickWidget* theWrappedObject, QQuickWidget::ResizeMode arg__1); void py_q_showEvent(QQuickWidget* theWrappedObject, QShowEvent* arg__1){ (((PythonQtPublicPromoter_QQuickWidget*)theWrappedObject)->py_q_showEvent(arg__1));} - QSize sizeHint(QQuickWidget* theWrappedObject) const; QSize py_q_sizeHint(QQuickWidget* theWrappedObject) const{ return (((PythonQtPublicPromoter_QQuickWidget*)theWrappedObject)->py_q_sizeHint());} QUrl source(QQuickWidget* theWrappedObject) const; QQuickWidget::Status status(QQuickWidget* theWrappedObject) const; diff --git a/generated_cpp_5.15.2/com_trolltech_qt_svg/com_trolltech_qt_svg0.cpp b/generated_cpp_5.15.2/com_trolltech_qt_svg/com_trolltech_qt_svg0.cpp index a7da3851a..e02cabda5 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_svg/com_trolltech_qt_svg0.cpp +++ b/generated_cpp_5.15.2/com_trolltech_qt_svg/com_trolltech_qt_svg0.cpp @@ -2404,12 +2404,12 @@ if (_wrapper) { } return QSvgWidget::metric(arg__1); } -QSize PythonQtShell_QSvgWidget::getMinimumSizeHint() const +QSize PythonQtShell_QSvgWidget::minimumSizeHint() const { if (_wrapper) { PYTHONQT_GIL_SCOPE if (Py_REFCNT((PyObject*)_wrapper) > 0) { - static PyObject* name = PyUnicode_FromString("getMinimumSizeHint"); + static PyObject* name = PyUnicode_FromString("minimumSizeHint"); PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name); if (obj) { static const char* argumentList[] ={"QSize"}; @@ -2421,7 +2421,7 @@ if (_wrapper) { args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue); if (args[0]!=&returnValue) { if (args[0]==nullptr) { - PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); + PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result); } else { returnValue = *((QSize*)args[0]); } @@ -2892,9 +2892,4 @@ QSvgRenderer* PythonQtWrapper_QSvgWidget::renderer(QSvgWidget* theWrappedObject return ( theWrappedObject->renderer()); } -QSize PythonQtWrapper_QSvgWidget::sizeHint(QSvgWidget* theWrappedObject) const -{ - return ( theWrappedObject->sizeHint()); -} - diff --git a/generated_cpp_5.15.2/com_trolltech_qt_svg/com_trolltech_qt_svg0.h b/generated_cpp_5.15.2/com_trolltech_qt_svg/com_trolltech_qt_svg0.h index 62f23f34b..f6127a1b9 100644 --- a/generated_cpp_5.15.2/com_trolltech_qt_svg/com_trolltech_qt_svg0.h +++ b/generated_cpp_5.15.2/com_trolltech_qt_svg/com_trolltech_qt_svg0.h @@ -294,7 +294,7 @@ void keyPressEvent(QKeyEvent* event) override; void keyReleaseEvent(QKeyEvent* event) override; void leaveEvent(QEvent* event) override; int metric(QPaintDevice::PaintDeviceMetric arg__1) const override; -QSize getMinimumSizeHint() const override; +QSize minimumSizeHint() const override; void mouseDoubleClickEvent(QMouseEvent* event) override; void mouseMoveEvent(QMouseEvent* event) override; void mousePressEvent(QMouseEvent* event) override; @@ -334,7 +334,6 @@ QSvgWidget* new_QSvgWidget(const QString& file, QWidget* parent = nullptr); void delete_QSvgWidget(QSvgWidget* obj) { delete obj; } void py_q_paintEvent(QSvgWidget* theWrappedObject, QPaintEvent* event){ (((PythonQtPublicPromoter_QSvgWidget*)theWrappedObject)->py_q_paintEvent(event));} QSvgRenderer* renderer(QSvgWidget* theWrappedObject) const; - QSize sizeHint(QSvgWidget* theWrappedObject) const; QSize py_q_sizeHint(QSvgWidget* theWrappedObject) const{ return (((PythonQtPublicPromoter_QSvgWidget*)theWrappedObject)->py_q_sizeHint());} }; From c07de8926e0694883b71ce1f1292e1e7ba81c1c9 Mon Sep 17 00:00:00 2001 From: MinyazevR Date: Fri, 14 Nov 2025 23:13:42 +0300 Subject: [PATCH 2/3] Allow resolution of the Qt minor version --- build/common.prf | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/build/common.prf b/build/common.prf index adb11819f..694e2562a 100644 --- a/build/common.prf +++ b/build/common.prf @@ -29,10 +29,11 @@ isEmpty(PYTHONQT_GENERATED_PATH) { # Fallbacks to checked-in wrappers !exists($$PYTHONQT_GENERATED_PATH) { - # Exact version directory (e.g., generated_cpp_515 or generated_cpp_69) - PYTHONQT_GENERATED_PATH_VERSIONED = $$PWD/../generated_cpp_$${QT_MAJOR_VERSION}$${QT_MINOR_VERSION} - exists($$PYTHONQT_GENERATED_PATH_VERSIONED) { - PYTHONQT_GENERATED_PATH = $$PYTHONQT_GENERATED_PATH_VERSIONED + # If no files are generated, try the checked-in wrappers: + PYTHONQT_GENERATED_PATH = $$PWD/../generated_cpp_$${QT_MAJOR_VERSION}.$${QT_MINOR_VERSION}.$${QT_PATCH_VERSION} + + !exists($$PYTHONQT_GENERATED_PATH) { + PYTHONQT_GENERATED_PATH = $$PWD/../generated_cpp_$${QT_MAJOR_VERSION}.$${QT_MINOR_VERSION} } } @@ -40,7 +41,7 @@ isEmpty(PYTHONQT_GENERATED_PATH) { error("No generated wrapper sources for Qt $${QT_VERSION}.\n" \ "Looked in:\n" \ " - $$PWD/../generated_cpp\n" \ - " - $$PWD/../generated_cpp_$${QT_MAJOR_VERSION}$${QT_MINOR_VERSION} (e.g., generated_cpp_515)\n" \ + " - $$PWD/../generated_cpp_$${QT_MAJOR_VERSION}.$${QT_MINOR_VERSION} (e.g., generated_cpp_5.15)\n" \ "Generate them first:\n" \ " qmake CONFIG+=generator_only && make\n" \ " cd generator && ./pythonqt_generator\n" \ From dd5ce3bb446540675b3abb5f92cc66e3630ff5ce Mon Sep 17 00:00:00 2001 From: MinyazevR Date: Fri, 14 Nov 2025 23:24:31 +0300 Subject: [PATCH 3/3] Add symlink for fallback to Qt5.15.2 --- generated_cpp_5.15 | 1 + 1 file changed, 1 insertion(+) create mode 120000 generated_cpp_5.15 diff --git a/generated_cpp_5.15 b/generated_cpp_5.15 new file mode 120000 index 000000000..a0a3b719b --- /dev/null +++ b/generated_cpp_5.15 @@ -0,0 +1 @@ +generated_cpp_5.15.2 \ No newline at end of file