| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Copyright (C) 2013 Olivier Goffart <ogoffart@woboq.com> |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the QtCore module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU Lesser General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Lesser |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
| ** packaging of this file. Please review the following information to |
| ** ensure the GNU Lesser General Public License version 3 requirements |
| ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 2.0 or (at your option) the GNU General |
| ** Public license version 3 or any later version approved by the KDE Free |
| ** Qt Foundation. The licenses are as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
| ** https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #ifndef QOBJECT_H |
| #define QOBJECT_H |
| |
| #ifndef QT_NO_QOBJECT |
| |
| #include <QtCore/qobjectdefs.h> |
| #include <QtCore/qstring.h> |
| #include <QtCore/qbytearray.h> |
| #include <QtCore/qlist.h> |
| #ifdef QT_INCLUDE_COMPAT |
| #include <QtCore/qcoreevent.h> |
| #endif |
| #include <QtCore/qscopedpointer.h> |
| #include <QtCore/qmetatype.h> |
| |
| #include <QtCore/qobject_impl.h> |
| |
| #if __has_include(<chrono>) |
| # include <chrono> |
| #endif |
| |
| QT_BEGIN_NAMESPACE |
| |
| |
| class QEvent; |
| class QTimerEvent; |
| class QChildEvent; |
| struct QMetaObject; |
| class QVariant; |
| class QObjectPrivate; |
| class QObject; |
| class QThread; |
| class QWidget; |
| class QAccessibleWidget; |
| #ifndef QT_NO_REGEXP |
| class QRegExp; |
| #endif |
| #if QT_CONFIG(regularexpression) |
| class QRegularExpression; |
| #endif |
| #if !QT_DEPRECATED_SINCE(5, 14) || QT_VERSION >= QT_VERSION_CHECK(6, 0, 0) |
| # define QT_NO_USERDATA |
| #endif |
| #ifndef QT_NO_USERDATA |
| class QObjectUserData; |
| #endif |
| struct QDynamicMetaObjectData; |
| |
| typedef QList<QObject*> QObjectList; |
| |
| Q_CORE_EXPORT void qt_qFindChildren_helper(const QObject *parent, const QString &name, |
| const QMetaObject &mo, QList<void *> *list, Qt::FindChildOptions options); |
| Q_CORE_EXPORT void qt_qFindChildren_helper(const QObject *parent, const QRegExp &re, |
| const QMetaObject &mo, QList<void *> *list, Qt::FindChildOptions options); |
| Q_CORE_EXPORT void qt_qFindChildren_helper(const QObject *parent, const QRegularExpression &re, |
| const QMetaObject &mo, QList<void *> *list, Qt::FindChildOptions options); |
| Q_CORE_EXPORT QObject *qt_qFindChild_helper(const QObject *parent, const QString &name, const QMetaObject &mo, Qt::FindChildOptions options); |
| |
| class Q_CORE_EXPORT QObjectData { |
| Q_DISABLE_COPY(QObjectData) |
| public: |
| QObjectData() = default; |
| virtual ~QObjectData() = 0; |
| QObject *q_ptr; |
| QObject *parent; |
| QObjectList children; |
| |
| uint isWidget : 1; |
| uint blockSig : 1; |
| uint wasDeleted : 1; |
| uint isDeletingChildren : 1; |
| uint sendChildEvents : 1; |
| uint receiveChildEvents : 1; |
| uint isWindow : 1; //for QWindow |
| uint deleteLaterCalled : 1; |
| uint unused : 24; |
| int postedEvents; |
| QDynamicMetaObjectData *metaObject; |
| QMetaObject *dynamicMetaObject() const; |
| |
| #ifdef QT_DEBUG |
| enum { CheckForParentChildLoopsWarnDepth = 4096 }; |
| #endif |
| }; |
| |
| |
| class Q_CORE_EXPORT QObject |
| { |
| Q_OBJECT |
| |
| Q_PROPERTY(QString objectName READ objectName WRITE setObjectName NOTIFY objectNameChanged) |
| Q_DECLARE_PRIVATE(QObject) |
| |
| public: |
| Q_INVOKABLE explicit QObject(QObject *parent=nullptr); |
| virtual ~QObject(); |
| |
| virtual bool event(QEvent *event); |
| virtual bool eventFilter(QObject *watched, QEvent *event); |
| |
| #if defined(QT_NO_TRANSLATION) || defined(Q_CLANG_QDOC) |
| static QString tr(const char *sourceText, const char * = nullptr, int = -1) |
| { return QString::fromUtf8(sourceText); } |
| #if QT_DEPRECATED_SINCE(5, 0) |
| QT_DEPRECATED static QString trUtf8(const char *sourceText, const char * = nullptr, int = -1) |
| { return QString::fromUtf8(sourceText); } |
| #endif |
| #endif //QT_NO_TRANSLATION |
| |
| QString objectName() const; |
| void setObjectName(const QString &name); |
| |
| inline bool isWidgetType() const { return d_ptr->isWidget; } |
| inline bool isWindowType() const { return d_ptr->isWindow; } |
| |
| inline bool signalsBlocked() const noexcept { return d_ptr->blockSig; } |
| bool blockSignals(bool b) noexcept; |
| |
| QThread *thread() const; |
| void moveToThread(QThread *thread); |
| |
| int startTimer(int interval, Qt::TimerType timerType = Qt::CoarseTimer); |
| #if __has_include(<chrono>) |
| Q_ALWAYS_INLINE |
| int startTimer(std::chrono::milliseconds time, Qt::TimerType timerType = Qt::CoarseTimer) |
| { |
| return startTimer(int(time.count()), timerType); |
| } |
| #endif |
| void killTimer(int id); |
| |
| template<typename T> |
| inline T findChild(const QString &aName = QString(), Qt::FindChildOptions options = Qt::FindChildrenRecursively) const |
| { |
| typedef typename std::remove_cv<typename std::remove_pointer<T>::type>::type ObjType; |
| return static_cast<T>(qt_qFindChild_helper(this, aName, ObjType::staticMetaObject, options)); |
| } |
| |
| template<typename T> |
| inline QList<T> findChildren(const QString &aName = QString(), Qt::FindChildOptions options = Qt::FindChildrenRecursively) const |
| { |
| typedef typename std::remove_cv<typename std::remove_pointer<T>::type>::type ObjType; |
| QList<T> list; |
| qt_qFindChildren_helper(this, aName, ObjType::staticMetaObject, |
| reinterpret_cast<QList<void *> *>(&list), options); |
| return list; |
| } |
| |
| #ifndef QT_NO_REGEXP |
| #if QT_DEPRECATED_SINCE(5, 13) |
| template<typename T> |
| QT_DEPRECATED_X("Use findChildren(const QRegularExpression &, ...) instead.") |
| inline QList<T> findChildren(const QRegExp &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const |
| { |
| typedef typename std::remove_cv<typename std::remove_pointer<T>::type>::type ObjType; |
| QList<T> list; |
| qt_qFindChildren_helper(this, re, ObjType::staticMetaObject, |
| reinterpret_cast<QList<void *> *>(&list), options); |
| return list; |
| } |
| #endif |
| #endif |
| |
| #if QT_CONFIG(regularexpression) |
| template<typename T> |
| inline QList<T> findChildren(const QRegularExpression &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const |
| { |
| typedef typename std::remove_cv<typename std::remove_pointer<T>::type>::type ObjType; |
| QList<T> list; |
| qt_qFindChildren_helper(this, re, ObjType::staticMetaObject, |
| reinterpret_cast<QList<void *> *>(&list), options); |
| return list; |
| } |
| #endif // QT_CONFIG(regularexpression) |
| |
| inline const QObjectList &children() const { return d_ptr->children; } |
| |
| void setParent(QObject *parent); |
| void installEventFilter(QObject *filterObj); |
| void removeEventFilter(QObject *obj); |
| |
| static QMetaObject::Connection connect(const QObject *sender, const char *signal, |
| const QObject *receiver, const char *member, Qt::ConnectionType = Qt::AutoConnection); |
| |
| static QMetaObject::Connection connect(const QObject *sender, const QMetaMethod &signal, |
| const QObject *receiver, const QMetaMethod &method, |
| Qt::ConnectionType type = Qt::AutoConnection); |
| |
| inline QMetaObject::Connection connect(const QObject *sender, const char *signal, |
| const char *member, Qt::ConnectionType type = Qt::AutoConnection) const; |
| |
| #ifdef Q_CLANG_QDOC |
| template<typename PointerToMemberFunction> |
| static QMetaObject::Connection connect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method, Qt::ConnectionType type = Qt::AutoConnection); |
| template<typename PointerToMemberFunction, typename Functor> |
| static QMetaObject::Connection connect(const QObject *sender, PointerToMemberFunction signal, Functor functor); |
| template<typename PointerToMemberFunction, typename Functor> |
| static QMetaObject::Connection connect(const QObject *sender, PointerToMemberFunction signal, const QObject *context, Functor functor, Qt::ConnectionType type = Qt::AutoConnection); |
| #else |
| //Connect a signal to a pointer to qobject member function |
| template <typename Func1, typename Func2> |
| static inline QMetaObject::Connection connect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal, |
| const typename QtPrivate::FunctionPointer<Func2>::Object *receiver, Func2 slot, |
| Qt::ConnectionType type = Qt::AutoConnection) |
| { |
| typedef QtPrivate::FunctionPointer<Func1> SignalType; |
| typedef QtPrivate::FunctionPointer<Func2> SlotType; |
| |
| Q_STATIC_ASSERT_X(QtPrivate::HasQ_OBJECT_Macro<typename SignalType::Object>::Value, |
| "No Q_OBJECT in the class with the signal"); |
| |
| //compilation error if the arguments does not match. |
| Q_STATIC_ASSERT_X(int(SignalType::ArgumentCount) >= int(SlotType::ArgumentCount), |
| "The slot requires more arguments than the signal provides."); |
| Q_STATIC_ASSERT_X((QtPrivate::CheckCompatibleArguments<typename SignalType::Arguments, typename SlotType::Arguments>::value), |
| "Signal and slot arguments are not compatible."); |
| Q_STATIC_ASSERT_X((QtPrivate::AreArgumentsCompatible<typename SlotType::ReturnType, typename SignalType::ReturnType>::value), |
| "Return type of the slot is not compatible with the return type of the signal."); |
| |
| const int *types = nullptr; |
| if (type == Qt::QueuedConnection || type == Qt::BlockingQueuedConnection) |
| types = QtPrivate::ConnectionTypes<typename SignalType::Arguments>::types(); |
| |
| return connectImpl(sender, reinterpret_cast<void **>(&signal), |
| receiver, reinterpret_cast<void **>(&slot), |
| new QtPrivate::QSlotObject<Func2, typename QtPrivate::List_Left<typename SignalType::Arguments, SlotType::ArgumentCount>::Value, |
| typename SignalType::ReturnType>(slot), |
| type, types, &SignalType::Object::staticMetaObject); |
| } |
| |
| //connect to a function pointer (not a member) |
| template <typename Func1, typename Func2> |
| static inline typename std::enable_if<int(QtPrivate::FunctionPointer<Func2>::ArgumentCount) >= 0, QMetaObject::Connection>::type |
| connect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal, Func2 slot) |
| { |
| return connect(sender, signal, sender, slot, Qt::DirectConnection); |
| } |
| |
| //connect to a function pointer (not a member) |
| template <typename Func1, typename Func2> |
| static inline typename std::enable_if<int(QtPrivate::FunctionPointer<Func2>::ArgumentCount) >= 0 && |
| !QtPrivate::FunctionPointer<Func2>::IsPointerToMemberFunction, QMetaObject::Connection>::type |
| connect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal, const QObject *context, Func2 slot, |
| Qt::ConnectionType type = Qt::AutoConnection) |
| { |
| typedef QtPrivate::FunctionPointer<Func1> SignalType; |
| typedef QtPrivate::FunctionPointer<Func2> SlotType; |
| |
| Q_STATIC_ASSERT_X(QtPrivate::HasQ_OBJECT_Macro<typename SignalType::Object>::Value, |
| "No Q_OBJECT in the class with the signal"); |
| |
| //compilation error if the arguments does not match. |
| Q_STATIC_ASSERT_X(int(SignalType::ArgumentCount) >= int(SlotType::ArgumentCount), |
| "The slot requires more arguments than the signal provides."); |
| Q_STATIC_ASSERT_X((QtPrivate::CheckCompatibleArguments<typename SignalType::Arguments, typename SlotType::Arguments>::value), |
| "Signal and slot arguments are not compatible."); |
| Q_STATIC_ASSERT_X((QtPrivate::AreArgumentsCompatible<typename SlotType::ReturnType, typename SignalType::ReturnType>::value), |
| "Return type of the slot is not compatible with the return type of the signal."); |
| |
| const int *types = nullptr; |
| if (type == Qt::QueuedConnection || type == Qt::BlockingQueuedConnection) |
| types = QtPrivate::ConnectionTypes<typename SignalType::Arguments>::types(); |
| |
| return connectImpl(sender, reinterpret_cast<void **>(&signal), context, nullptr, |
| new QtPrivate::QStaticSlotObject<Func2, |
| typename QtPrivate::List_Left<typename SignalType::Arguments, SlotType::ArgumentCount>::Value, |
| typename SignalType::ReturnType>(slot), |
| type, types, &SignalType::Object::staticMetaObject); |
| } |
| |
| //connect to a functor |
| template <typename Func1, typename Func2> |
| static inline typename std::enable_if<QtPrivate::FunctionPointer<Func2>::ArgumentCount == -1, QMetaObject::Connection>::type |
| connect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal, Func2 slot) |
| { |
| return connect(sender, signal, sender, std::move(slot), Qt::DirectConnection); |
| } |
| |
| //connect to a functor, with a "context" object defining in which event loop is going to be executed |
| template <typename Func1, typename Func2> |
| static inline typename std::enable_if<QtPrivate::FunctionPointer<Func2>::ArgumentCount == -1, QMetaObject::Connection>::type |
| connect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal, const QObject *context, Func2 slot, |
| Qt::ConnectionType type = Qt::AutoConnection) |
| { |
| typedef QtPrivate::FunctionPointer<Func1> SignalType; |
| const int FunctorArgumentCount = QtPrivate::ComputeFunctorArgumentCount<Func2 , typename SignalType::Arguments>::Value; |
| |
| Q_STATIC_ASSERT_X((FunctorArgumentCount >= 0), |
| "Signal and slot arguments are not compatible."); |
| const int SlotArgumentCount = (FunctorArgumentCount >= 0) ? FunctorArgumentCount : 0; |
| typedef typename QtPrivate::FunctorReturnType<Func2, typename QtPrivate::List_Left<typename SignalType::Arguments, SlotArgumentCount>::Value>::Value SlotReturnType; |
| |
| Q_STATIC_ASSERT_X((QtPrivate::AreArgumentsCompatible<SlotReturnType, typename SignalType::ReturnType>::value), |
| "Return type of the slot is not compatible with the return type of the signal."); |
| |
| Q_STATIC_ASSERT_X(QtPrivate::HasQ_OBJECT_Macro<typename SignalType::Object>::Value, |
| "No Q_OBJECT in the class with the signal"); |
| |
| const int *types = nullptr; |
| if (type == Qt::QueuedConnection || type == Qt::BlockingQueuedConnection) |
| types = QtPrivate::ConnectionTypes<typename SignalType::Arguments>::types(); |
| |
| return connectImpl(sender, reinterpret_cast<void **>(&signal), context, nullptr, |
| new QtPrivate::QFunctorSlotObject<Func2, SlotArgumentCount, |
| typename QtPrivate::List_Left<typename SignalType::Arguments, SlotArgumentCount>::Value, |
| typename SignalType::ReturnType>(std::move(slot)), |
| type, types, &SignalType::Object::staticMetaObject); |
| } |
| #endif //Q_CLANG_QDOC |
| |
| static bool disconnect(const QObject *sender, const char *signal, |
| const QObject *receiver, const char *member); |
| static bool disconnect(const QObject *sender, const QMetaMethod &signal, |
| const QObject *receiver, const QMetaMethod &member); |
| inline bool disconnect(const char *signal = nullptr, |
| const QObject *receiver = nullptr, const char *member = nullptr) const |
| { return disconnect(this, signal, receiver, member); } |
| inline bool disconnect(const QObject *receiver, const char *member = nullptr) const |
| { return disconnect(this, nullptr, receiver, member); } |
| static bool disconnect(const QMetaObject::Connection &); |
| |
| #ifdef Q_CLANG_QDOC |
| template<typename PointerToMemberFunction> |
| static bool disconnect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method); |
| #else |
| template <typename Func1, typename Func2> |
| static inline bool disconnect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal, |
| const typename QtPrivate::FunctionPointer<Func2>::Object *receiver, Func2 slot) |
| { |
| typedef QtPrivate::FunctionPointer<Func1> SignalType; |
| typedef QtPrivate::FunctionPointer<Func2> SlotType; |
| |
| Q_STATIC_ASSERT_X(QtPrivate::HasQ_OBJECT_Macro<typename SignalType::Object>::Value, |
| "No Q_OBJECT in the class with the signal"); |
| |
| //compilation error if the arguments does not match. |
| Q_STATIC_ASSERT_X((QtPrivate::CheckCompatibleArguments<typename SignalType::Arguments, typename SlotType::Arguments>::value), |
| "Signal and slot arguments are not compatible."); |
| |
| return disconnectImpl(sender, reinterpret_cast<void **>(&signal), receiver, reinterpret_cast<void **>(&slot), |
| &SignalType::Object::staticMetaObject); |
| } |
| template <typename Func1> |
| static inline bool disconnect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal, |
| const QObject *receiver, void **zero) |
| { |
| // This is the overload for when one wish to disconnect a signal from any slot. (slot=nullptr) |
| // Since the function template parameter cannot be deduced from '0', we use a |
| // dummy void ** parameter that must be equal to 0 |
| Q_ASSERT(!zero); |
| typedef QtPrivate::FunctionPointer<Func1> SignalType; |
| return disconnectImpl(sender, reinterpret_cast<void **>(&signal), receiver, zero, |
| &SignalType::Object::staticMetaObject); |
| } |
| #endif //Q_CLANG_QDOC |
| |
| |
| #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) |
| void dumpObjectTree(); // ### Qt 6: remove |
| void dumpObjectInfo(); // ### Qt 6: remove |
| #endif |
| void dumpObjectTree() const; |
| void dumpObjectInfo() const; |
| |
| #ifndef QT_NO_PROPERTIES |
| bool setProperty(const char *name, const QVariant &value); |
| QVariant property(const char *name) const; |
| QList<QByteArray> dynamicPropertyNames() const; |
| #endif // QT_NO_PROPERTIES |
| |
| #ifndef QT_NO_USERDATA |
| QT_DEPRECATED_VERSION_5_14 |
| static uint registerUserData(); |
| QT_DEPRECATED_VERSION_X_5_14("Use setProperty()") |
| void setUserData(uint id, QObjectUserData* data); |
| QT_DEPRECATED_VERSION_X_5_14("Use property()") |
| QObjectUserData* userData(uint id) const; |
| #endif // QT_NO_USERDATA |
| |
| Q_SIGNALS: |
| void destroyed(QObject * = nullptr); |
| void objectNameChanged(const QString &objectName, QPrivateSignal); |
| |
| public: |
| inline QObject *parent() const { return d_ptr->parent; } |
| |
| inline bool inherits(const char *classname) const |
| { return const_cast<QObject *>(this)->qt_metacast(classname) != nullptr; } |
| |
| public Q_SLOTS: |
| void deleteLater(); |
| |
| protected: |
| QObject *sender() const; |
| int senderSignalIndex() const; |
| int receivers(const char* signal) const; |
| bool isSignalConnected(const QMetaMethod &signal) const; |
| |
| virtual void timerEvent(QTimerEvent *event); |
| virtual void childEvent(QChildEvent *event); |
| virtual void customEvent(QEvent *event); |
| |
| virtual void connectNotify(const QMetaMethod &signal); |
| virtual void disconnectNotify(const QMetaMethod &signal); |
| |
| protected: |
| QObject(QObjectPrivate &dd, QObject *parent = nullptr); |
| |
| protected: |
| QScopedPointer<QObjectData> d_ptr; |
| |
| static const QMetaObject staticQtMetaObject; |
| friend inline const QMetaObject *qt_getQtMetaObject() noexcept; |
| |
| friend struct QMetaObject; |
| friend struct QMetaObjectPrivate; |
| friend class QMetaCallEvent; |
| friend class QApplication; |
| friend class QApplicationPrivate; |
| friend class QCoreApplication; |
| friend class QCoreApplicationPrivate; |
| friend class QWidget; |
| friend class QAccessibleWidget; |
| friend class QThreadData; |
| |
| private: |
| Q_DISABLE_COPY(QObject) |
| Q_PRIVATE_SLOT(d_func(), void _q_reregisterTimers(void *)) |
| |
| private: |
| static QMetaObject::Connection connectImpl(const QObject *sender, void **signal, |
| const QObject *receiver, void **slotPtr, |
| QtPrivate::QSlotObjectBase *slot, Qt::ConnectionType type, |
| const int *types, const QMetaObject *senderMetaObject); |
| |
| static bool disconnectImpl(const QObject *sender, void **signal, const QObject *receiver, void **slot, |
| const QMetaObject *senderMetaObject); |
| |
| }; |
| |
| inline QMetaObject::Connection QObject::connect(const QObject *asender, const char *asignal, |
| const char *amember, Qt::ConnectionType atype) const |
| { return connect(asender, asignal, this, amember, atype); } |
| |
| inline const QMetaObject *qt_getQtMetaObject() noexcept |
| { return &QObject::staticQtMetaObject; } |
| |
| #ifndef QT_NO_USERDATA |
| class Q_CORE_EXPORT QObjectUserData { |
| Q_DISABLE_COPY(QObjectUserData) |
| public: |
| QObjectUserData() = default; |
| virtual ~QObjectUserData(); |
| }; |
| #endif |
| |
| #if QT_DEPRECATED_SINCE(5, 0) |
| template<typename T> |
| inline QT_DEPRECATED T qFindChild(const QObject *o, const QString &name = QString()) |
| { return o->findChild<T>(name); } |
| |
| template<typename T> |
| inline QT_DEPRECATED QList<T> qFindChildren(const QObject *o, const QString &name = QString()) |
| { |
| return o->findChildren<T>(name); |
| } |
| |
| #if !defined(QT_NO_REGEXP) || defined(Q_CLANG_QDOC) |
| template<typename T> |
| inline QT_DEPRECATED QList<T> qFindChildren(const QObject *o, const QRegExp &re) |
| { |
| return o->findChildren<T>(re); |
| } |
| #endif |
| |
| #endif //QT_DEPRECATED |
| |
| template <class T> |
| inline T qobject_cast(QObject *object) |
| { |
| typedef typename std::remove_cv<typename std::remove_pointer<T>::type>::type ObjType; |
| Q_STATIC_ASSERT_X(QtPrivate::HasQ_OBJECT_Macro<ObjType>::Value, |
| "qobject_cast requires the type to have a Q_OBJECT macro"); |
| return static_cast<T>(ObjType::staticMetaObject.cast(object)); |
| } |
| |
| template <class T> |
| inline T qobject_cast(const QObject *object) |
| { |
| typedef typename std::remove_cv<typename std::remove_pointer<T>::type>::type ObjType; |
| Q_STATIC_ASSERT_X(QtPrivate::HasQ_OBJECT_Macro<ObjType>::Value, |
| "qobject_cast requires the type to have a Q_OBJECT macro"); |
| return static_cast<T>(ObjType::staticMetaObject.cast(object)); |
| } |
| |
| |
| template <class T> inline const char * qobject_interface_iid() |
| { return nullptr; } |
| |
| |
| #if defined(Q_CLANG_QDOC) |
| # define Q_DECLARE_INTERFACE(IFace, IId) |
| #elif !defined(Q_MOC_RUN) |
| # define Q_DECLARE_INTERFACE(IFace, IId) \ |
| template <> inline const char *qobject_interface_iid<IFace *>() \ |
| { return IId; } \ |
| template <> inline IFace *qobject_cast<IFace *>(QObject *object) \ |
| { return reinterpret_cast<IFace *>((object ? object->qt_metacast(IId) : nullptr)); } \ |
| template <> inline IFace *qobject_cast<IFace *>(const QObject *object) \ |
| { return reinterpret_cast<IFace *>((object ? const_cast<QObject *>(object)->qt_metacast(IId) : nullptr)); } |
| #endif // Q_MOC_RUN |
| |
| #ifndef QT_NO_DEBUG_STREAM |
| Q_CORE_EXPORT QDebug operator<<(QDebug, const QObject *); |
| #endif |
| |
| class QSignalBlocker |
| { |
| public: |
| inline explicit QSignalBlocker(QObject *o) noexcept; |
| inline explicit QSignalBlocker(QObject &o) noexcept; |
| inline ~QSignalBlocker(); |
| |
| inline QSignalBlocker(QSignalBlocker &&other) noexcept; |
| inline QSignalBlocker &operator=(QSignalBlocker &&other) noexcept; |
| |
| inline void reblock() noexcept; |
| inline void unblock() noexcept; |
| private: |
| Q_DISABLE_COPY(QSignalBlocker) |
| QObject * m_o; |
| bool m_blocked; |
| bool m_inhibited; |
| }; |
| |
| QSignalBlocker::QSignalBlocker(QObject *o) noexcept |
| : m_o(o), |
| m_blocked(o && o->blockSignals(true)), |
| m_inhibited(false) |
| {} |
| |
| QSignalBlocker::QSignalBlocker(QObject &o) noexcept |
| : m_o(&o), |
| m_blocked(o.blockSignals(true)), |
| m_inhibited(false) |
| {} |
| |
| QSignalBlocker::QSignalBlocker(QSignalBlocker &&other) noexcept |
| : m_o(other.m_o), |
| m_blocked(other.m_blocked), |
| m_inhibited(other.m_inhibited) |
| { |
| other.m_o = nullptr; |
| } |
| |
| QSignalBlocker &QSignalBlocker::operator=(QSignalBlocker &&other) noexcept |
| { |
| if (this != &other) { |
| // if both *this and other block the same object's signals: |
| // unblock *this iff our dtor would unblock, but other's wouldn't |
| if (m_o != other.m_o || (!m_inhibited && other.m_inhibited)) |
| unblock(); |
| m_o = other.m_o; |
| m_blocked = other.m_blocked; |
| m_inhibited = other.m_inhibited; |
| // disable other: |
| other.m_o = nullptr; |
| } |
| return *this; |
| } |
| |
| QSignalBlocker::~QSignalBlocker() |
| { |
| if (m_o && !m_inhibited) |
| m_o->blockSignals(m_blocked); |
| } |
| |
| void QSignalBlocker::reblock() noexcept |
| { |
| if (m_o) m_o->blockSignals(true); |
| m_inhibited = false; |
| } |
| |
| void QSignalBlocker::unblock() noexcept |
| { |
| if (m_o) m_o->blockSignals(m_blocked); |
| m_inhibited = true; |
| } |
| |
| namespace QtPrivate { |
| inline QObject & deref_for_methodcall(QObject &o) { return o; } |
| inline QObject & deref_for_methodcall(QObject *o) { return *o; } |
| } |
| #define Q_SET_OBJECT_NAME(obj) QT_PREPEND_NAMESPACE(QtPrivate)::deref_for_methodcall(obj).setObjectName(QLatin1String(#obj)) |
| |
| QT_END_NAMESPACE |
| |
| #endif |
| |
| #endif // QOBJECT_H |
