mirror of
https://github.com/Gator96100/ProxSpace.git
synced 2025-07-30 03:28:35 -07:00
635 lines
27 KiB
C++
635 lines
27 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2015 The Qt Company Ltd.
|
|
** Copyright (C) 2013 Olivier Goffart <ogoffart@woboq.com>
|
|
** Contact: http://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the QtCore module of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL21$
|
|
** 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 http://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at http://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 2.1 or version 3 as published by the Free
|
|
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
|
|
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
|
|
** following information to ensure the GNU Lesser General Public License
|
|
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
|
|
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
|
**
|
|
** As a special exception, The Qt Company gives you certain additional
|
|
** rights. These rights are described in The Qt Company LGPL Exception
|
|
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
|
**
|
|
** $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>
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
|
|
class QEvent;
|
|
class QTimerEvent;
|
|
class QChildEvent;
|
|
struct QMetaObject;
|
|
class QVariant;
|
|
class QObjectPrivate;
|
|
class QObject;
|
|
class QThread;
|
|
class QWidget;
|
|
#ifndef QT_NO_REGEXP
|
|
class QRegExp;
|
|
#endif
|
|
#ifndef QT_NO_REGULAREXPRESSION
|
|
class QRegularExpression;
|
|
#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 {
|
|
public:
|
|
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 unused : 25;
|
|
int postedEvents;
|
|
QDynamicMetaObjectData *metaObject;
|
|
QMetaObject *dynamicMetaObject() const;
|
|
};
|
|
|
|
|
|
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=Q_NULLPTR);
|
|
virtual ~QObject();
|
|
|
|
virtual bool event(QEvent *event);
|
|
virtual bool eventFilter(QObject *watched, QEvent *event);
|
|
|
|
#ifdef Q_QDOC
|
|
static QString tr(const char *sourceText, const char *comment = Q_NULLPTR, int n = -1);
|
|
static QString trUtf8(const char *sourceText, const char *comment = Q_NULLPTR, int n = -1);
|
|
virtual const QMetaObject *metaObject() const;
|
|
static const QMetaObject staticMetaObject;
|
|
#endif
|
|
#ifdef QT_NO_TRANSLATION
|
|
static QString tr(const char *sourceText, const char * = Q_NULLPTR, int = -1)
|
|
{ return QString::fromUtf8(sourceText); }
|
|
#if QT_DEPRECATED_SINCE(5, 0)
|
|
QT_DEPRECATED static QString trUtf8(const char *sourceText, const char * = Q_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 Q_DECL_NOTHROW { return d_ptr->blockSig; }
|
|
bool blockSignals(bool b) Q_DECL_NOTHROW;
|
|
|
|
QThread *thread() const;
|
|
void moveToThread(QThread *thread);
|
|
|
|
int startTimer(int interval, Qt::TimerType timerType = Qt::CoarseTimer);
|
|
void killTimer(int id);
|
|
|
|
template<typename T>
|
|
inline T findChild(const QString &aName = QString(), Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
|
|
{
|
|
typedef typename QtPrivate::remove_cv<typename QtPrivate::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 QtPrivate::remove_cv<typename QtPrivate::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
|
|
template<typename T>
|
|
inline QList<T> findChildren(const QRegExp &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
|
|
{
|
|
typedef typename QtPrivate::remove_cv<typename QtPrivate::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
|
|
|
|
#ifndef QT_NO_REGULAREXPRESSION
|
|
template<typename T>
|
|
inline QList<T> findChildren(const QRegularExpression &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
|
|
{
|
|
typedef typename QtPrivate::remove_cv<typename QtPrivate::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
|
|
|
|
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_QDOC
|
|
static QMetaObject::Connection connect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method, Qt::ConnectionType type = Qt::AutoConnection);
|
|
static QMetaObject::Connection connect(const QObject *sender, PointerToMemberFunction signal, Functor 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 = Q_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 QtPrivate::QEnableIf<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 QtPrivate::QEnableIf<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 = Q_NULLPTR;
|
|
if (type == Qt::QueuedConnection || type == Qt::BlockingQueuedConnection)
|
|
types = QtPrivate::ConnectionTypes<typename SignalType::Arguments>::types();
|
|
|
|
return connectImpl(sender, reinterpret_cast<void **>(&signal), context, Q_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 QtPrivate::QEnableIf<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, 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 QtPrivate::QEnableIf<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)
|
|
{
|
|
#if defined (Q_COMPILER_DECLTYPE) && defined (Q_COMPILER_VARIADIC_TEMPLATES)
|
|
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;
|
|
#else
|
|
// Without variadic template, we don't detect the best overload of operator(). We just
|
|
// assume there is only one simple operator() and connect to &Func2::operator()
|
|
|
|
/* If you get an error such as:
|
|
couldn't deduce template parameter 'Func2Operator'
|
|
or
|
|
cannot resolve address of overloaded function
|
|
It means the functor does not have a single operator().
|
|
Functors with overloaded or templated operator() are only supported if the compiler supports
|
|
C++11 variadic templates
|
|
*/
|
|
#ifndef Q_COMPILER_DECLTYPE //Workaround the lack of decltype using another function as indirection
|
|
return connect_functor(sender, signal, context, slot, &Func2::operator(), type); }
|
|
template <typename Func1, typename Func2, typename Func2Operator>
|
|
static inline QMetaObject::Connection connect_functor(const QObject *sender, Func1 signal, const QObject *context,
|
|
Func2 slot, Func2Operator, Qt::ConnectionType type) {
|
|
typedef QtPrivate::FunctionPointer<Func2Operator> SlotType ;
|
|
#else
|
|
typedef QtPrivate::FunctionPointer<decltype(&Func2::operator())> SlotType ;
|
|
#endif
|
|
typedef QtPrivate::FunctionPointer<Func1> SignalType;
|
|
typedef typename SlotType::ReturnType SlotReturnType;
|
|
const int SlotArgumentCount = SlotType::ArgumentCount;
|
|
|
|
Q_STATIC_ASSERT_X(int(SignalType::ArgumentCount) >= SlotArgumentCount,
|
|
"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.");
|
|
#endif
|
|
|
|
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 = Q_NULLPTR;
|
|
if (type == Qt::QueuedConnection || type == Qt::BlockingQueuedConnection)
|
|
types = QtPrivate::ConnectionTypes<typename SignalType::Arguments>::types();
|
|
|
|
return connectImpl(sender, reinterpret_cast<void **>(&signal), context, Q_NULLPTR,
|
|
new QtPrivate::QFunctorSlotObject<Func2, SlotArgumentCount,
|
|
typename QtPrivate::List_Left<typename SignalType::Arguments, SlotArgumentCount>::Value,
|
|
typename SignalType::ReturnType>(slot),
|
|
type, types, &SignalType::Object::staticMetaObject);
|
|
}
|
|
#endif //Q_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 = Q_NULLPTR,
|
|
const QObject *receiver = Q_NULLPTR, const char *member = Q_NULLPTR) const
|
|
{ return disconnect(this, signal, receiver, member); }
|
|
inline bool disconnect(const QObject *receiver, const char *member = Q_NULLPTR) const
|
|
{ return disconnect(this, Q_NULLPTR, receiver, member); }
|
|
static bool disconnect(const QMetaObject::Connection &);
|
|
|
|
#ifdef Q_QDOC
|
|
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=Q_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_QDOC
|
|
|
|
|
|
void dumpObjectTree();
|
|
void dumpObjectInfo();
|
|
|
|
#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
|
|
static uint registerUserData();
|
|
void setUserData(uint id, QObjectUserData* data);
|
|
QObjectUserData* userData(uint id) const;
|
|
#endif // QT_NO_USERDATA
|
|
|
|
Q_SIGNALS:
|
|
void destroyed(QObject * = Q_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) != Q_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 = Q_NULLPTR);
|
|
|
|
protected:
|
|
QScopedPointer<QObjectData> d_ptr;
|
|
|
|
static const QMetaObject staticQtMetaObject;
|
|
friend inline const QMetaObject *qt_getQtMetaObject() Q_DECL_NOEXCEPT
|
|
{ return &staticQtMetaObject; }
|
|
|
|
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 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); }
|
|
|
|
#ifndef QT_NO_USERDATA
|
|
class Q_CORE_EXPORT QObjectUserData {
|
|
public:
|
|
virtual ~QObjectUserData();
|
|
};
|
|
#endif
|
|
|
|
#ifdef Q_QDOC
|
|
T qFindChild(const QObject *o, const QString &name = QString());
|
|
QList<T> qFindChildren(const QObject *oobj, const QString &name = QString());
|
|
QList<T> qFindChildren(const QObject *o, const QRegExp &re);
|
|
#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);
|
|
}
|
|
|
|
#ifndef QT_NO_REGEXP
|
|
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 QtPrivate::remove_cv<typename QtPrivate::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 QtPrivate::remove_cv<typename QtPrivate::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 Q_NULLPTR; }
|
|
|
|
#ifndef 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) : Q_NULLPTR)); } \
|
|
template <> inline IFace *qobject_cast<IFace *>(const QObject *object) \
|
|
{ return reinterpret_cast<IFace *>((object ? const_cast<QObject *>(object)->qt_metacast(IId) : Q_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) Q_DECL_NOTHROW;
|
|
inline explicit QSignalBlocker(QObject &o) Q_DECL_NOTHROW;
|
|
inline ~QSignalBlocker();
|
|
|
|
#ifdef Q_COMPILER_RVALUE_REFS
|
|
inline QSignalBlocker(QSignalBlocker &&other) Q_DECL_NOTHROW;
|
|
inline QSignalBlocker &operator=(QSignalBlocker &&other) Q_DECL_NOTHROW;
|
|
#endif
|
|
|
|
inline void reblock() Q_DECL_NOTHROW;
|
|
inline void unblock() Q_DECL_NOTHROW;
|
|
private:
|
|
Q_DISABLE_COPY(QSignalBlocker)
|
|
QObject * m_o;
|
|
bool m_blocked;
|
|
bool m_inhibited;
|
|
};
|
|
|
|
QSignalBlocker::QSignalBlocker(QObject *o) Q_DECL_NOTHROW
|
|
: m_o(o),
|
|
m_blocked(o && o->blockSignals(true)),
|
|
m_inhibited(false)
|
|
{}
|
|
|
|
QSignalBlocker::QSignalBlocker(QObject &o) Q_DECL_NOTHROW
|
|
: m_o(&o),
|
|
m_blocked(o.blockSignals(true)),
|
|
m_inhibited(false)
|
|
{}
|
|
|
|
#ifdef Q_COMPILER_RVALUE_REFS
|
|
QSignalBlocker::QSignalBlocker(QSignalBlocker &&other) Q_DECL_NOTHROW
|
|
: m_o(other.m_o),
|
|
m_blocked(other.m_blocked),
|
|
m_inhibited(other.m_inhibited)
|
|
{
|
|
other.m_o = Q_NULLPTR;
|
|
}
|
|
|
|
QSignalBlocker &QSignalBlocker::operator=(QSignalBlocker &&other) Q_DECL_NOTHROW
|
|
{
|
|
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 = Q_NULLPTR;
|
|
}
|
|
return *this;
|
|
}
|
|
#endif
|
|
|
|
QSignalBlocker::~QSignalBlocker()
|
|
{
|
|
if (m_o && !m_inhibited)
|
|
m_o->blockSignals(m_blocked);
|
|
}
|
|
|
|
void QSignalBlocker::reblock() Q_DECL_NOTHROW
|
|
{
|
|
if (m_o) m_o->blockSignals(true);
|
|
m_inhibited = false;
|
|
}
|
|
|
|
void QSignalBlocker::unblock() Q_DECL_NOTHROW
|
|
{
|
|
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
|