qabstracteventdispatcher.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qabstracteventdispatcher.h"
#include "qabstracteventdispatcher_p.h"
#include "qabstractnativeeventfilter.h"
 
#include "qthread.h"
#include <private/qthread_p.h>
#include <private/qcoreapplication_p.h>
#include <private/qfreelist_p.h>
#include <private/qnumeric_p.h>
 
QT_BEGIN_NAMESPACE
 
using namespace std::chrono_literals;
 
// we allow for 2^24 = 8^8 = 16777216 simultaneously running timers
struct QtTimerIdFreeListConstants : public QFreeListDefaultConstants
{
    enum
    {
        InitialNextValue = 1,
        BlockCount = 6
    };
 
    static const int Sizes[BlockCount];
};
 
enum {
    Offset0 = 0x00000000,
    Offset1 = 0x00000040,
    Offset2 = 0x00000100,
    Offset3 = 0x00001000,
    Offset4 = 0x00010000,
    Offset5 = 0x00100000,
 
    Size0 = Offset1 - Offset0,
    Size1 = Offset2 - Offset1,
    Size2 = Offset3 - Offset2,
    Size3 = Offset4 - Offset3,
    Size4 = Offset5 - Offset4,
    Size5 = QtTimerIdFreeListConstants::MaxIndex - Offset5
};
 
Q_CONSTINIT const int QtTimerIdFreeListConstants::Sizes[QtTimerIdFreeListConstants::BlockCount] = {
    Size0,
    Size1,
    Size2,
    Size3,
    Size4,
    Size5
};
 
typedef QFreeList<void, QtTimerIdFreeListConstants> QtTimerIdFreeList;
Q_GLOBAL_STATIC(QtTimerIdFreeList, timerIdFreeList)
 
template <typename T> static T fromDuration(std::chrono::nanoseconds interval)
{
    using namespace std::chrono;
    qint64 value = ceil<milliseconds>(interval).count();
    return qt_saturate<T>(value);
}
 
#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
static inline QAbstractEventDispatcherV2 *v2(QAbstractEventDispatcher *self)
{
    if (QAbstractEventDispatcherPrivate::get(self)->isV2)
        return static_cast<QAbstractEventDispatcherV2 *>(self);
    return nullptr;
}
 
static inline const QAbstractEventDispatcherV2 *v2(const QAbstractEventDispatcher *self)
{
    if (QAbstractEventDispatcherPrivate::get(self)->isV2)
        return static_cast<const QAbstractEventDispatcherV2 *>(self);
    return nullptr;
}
#endif // Qt 7
 
QAbstractEventDispatcherPrivate::QAbstractEventDispatcherPrivate()
{
    // Create the timer ID free list here to make sure that it is destroyed
    // after any global static thread that may be using it.
    // See also QTBUG-58732.
    if (!timerIdFreeList.isDestroyed())
        (void)timerIdFreeList();
}
 
QAbstractEventDispatcherPrivate::~QAbstractEventDispatcherPrivate()
    = default;
 
int QAbstractEventDispatcherPrivate::allocateTimerId()
{
    // This function may be called after timerIdFreeList() has been destructed
    // for example in case when application exits without waiting for
    // running threads to exit and running thread finished() has been connected
    // to a slot which triggers a sequence that registers new timer.
    // See https://bugreports.qt-project.org/browse/QTBUG-38957.
    if (QtTimerIdFreeList *fl = timerIdFreeList())
        return fl->next();
    return 0; // Note! returning 0 generates a warning
}
 
void QAbstractEventDispatcherPrivate::releaseTimerId(int timerId)
{
    // this function may be called by a global destructor after
    // timerIdFreeList() has been destructed
    if (QtTimerIdFreeList *fl = timerIdFreeList())
        fl->release(timerId);
}
 
QAbstractEventDispatcher::QAbstractEventDispatcher(QObject *parent)
    : QObject(*new QAbstractEventDispatcherPrivate, parent) {}
 
QAbstractEventDispatcher::QAbstractEventDispatcher(QAbstractEventDispatcherPrivate &dd,
                                                   QObject *parent)
    : QObject(dd, parent) {}
 
QAbstractEventDispatcher::~QAbstractEventDispatcher()
{ }
 
QAbstractEventDispatcher *QAbstractEventDispatcher::instance(QThread *thread)
{
    QThreadData *data = thread ? QThreadData::get2(thread) : QThreadData::current();
    return data->eventDispatcher.loadRelaxed();
}
 
int QAbstractEventDispatcher::registerTimer(qint64 interval, Qt::TimerType timerType, QObject *object)
{
    return int(registerTimer(interval * 1ms, timerType, object));
}
 
Qt::TimerId QAbstractEventDispatcher::registerTimer(Duration interval, Qt::TimerType timerType,
                                                    QObject *object)
{
    auto id = Qt::TimerId(QAbstractEventDispatcherPrivate::allocateTimerId());
#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
    if (QAbstractEventDispatcherV2 *self = v2(this))
        self->registerTimer(id, interval, timerType, object);
    else
        registerTimer(qToUnderlying(id), fromDuration<qint64>(interval), timerType, object);
#else
    registerTimer(id, interval, timerType, object);
#endif
    return id;
}
 
#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
#else // Qt 7
#endif
 
// ### DOC: Are these called when the _application_ starts/stops or just
// when the current _event loop_ starts/stops?
void QAbstractEventDispatcher::startingUp()
{ }
 
void QAbstractEventDispatcher::closingDown()
{ }
 
void QAbstractEventDispatcher::installNativeEventFilter(QAbstractNativeEventFilter *filterObj)
{
    Q_D(QAbstractEventDispatcher);
 
    // clean up unused items in the list
    d->eventFilters.removeAll(nullptr);
    d->eventFilters.removeAll(filterObj);
    d->eventFilters.prepend(filterObj);
}
 
void QAbstractEventDispatcher::removeNativeEventFilter(QAbstractNativeEventFilter *filter)
{
    Q_D(QAbstractEventDispatcher);
    for (int i = 0; i < d->eventFilters.size(); ++i) {
        if (d->eventFilters.at(i) == filter) {
            d->eventFilters[i] = nullptr;
            break;
        }
    }
}
 
bool QAbstractEventDispatcher::filterNativeEvent(const QByteArray &eventType, void *message, qintptr *result)
{
    Q_D(QAbstractEventDispatcher);
    if (!d->eventFilters.isEmpty()) {
        // Raise the loopLevel so that deleteLater() calls in or triggered
        // by event_filter() will be processed from the main event loop.
        QScopedScopeLevelCounter scopeLevelCounter(d->threadData.loadAcquire());
        for (int i = 0; i < d->eventFilters.size(); ++i) {
            QAbstractNativeEventFilter *filter = d->eventFilters.at(i);
            if (!filter)
                continue;
            if (filter->nativeEventFilter(eventType, message, result))
                return true;
        }
    }
    return false;
}
 
#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
void QAbstractEventDispatcher::registerTimer(Qt::TimerId timerId, Duration interval,
                                             Qt::TimerType timerType, QObject *object)
{
    if (QAbstractEventDispatcherV2 *self = v2(this))
        self->registerTimer(timerId, interval, timerType, object);
    else
        registerTimer(int(timerId), fromDuration<qint64>(interval), timerType, object);
}
 
bool QAbstractEventDispatcher::unregisterTimer(Qt::TimerId timerId)
{
    if (QAbstractEventDispatcherV2 *self = v2(this))
        return self->unregisterTimer(timerId);
    return unregisterTimer(int(timerId));
}
 
QList<QAbstractEventDispatcher::TimerInfoV2>
QAbstractEventDispatcher::timersForObject(QObject *object) const
{
    if (const QAbstractEventDispatcherV2 *self = v2(this))
        return self->timersForObject(object);
    QList<TimerInfo> timers = registeredTimers(object);
    QList<TimerInfoV2> result;
    result.reserve(timers.size());
    for (const TimerInfo &t : timers)
        result.emplaceBack(TimerInfoV2{ t.interval * 1ms, Qt::TimerId(t.timerId), t.timerType });
    return result;
}
 
QAbstractEventDispatcher::Duration
QAbstractEventDispatcher::remainingTime(Qt::TimerId timerId) const
{
    if (const QAbstractEventDispatcherV2 *self = v2(this))
        return self->remainingTime(timerId);
    return const_cast<QAbstractEventDispatcher *>(this)->remainingTime(int(timerId)) * 1ms;
}
 
QAbstractEventDispatcherV2::QAbstractEventDispatcherV2(QObject *parent)
    : QAbstractEventDispatcherV2(*new QAbstractEventDispatcherPrivate, parent)
{
}
 
QAbstractEventDispatcherV2::QAbstractEventDispatcherV2(QAbstractEventDispatcherPrivate &dd,
                                                       QObject *parent)
    : QAbstractEventDispatcher((dd.isV2 = true, dd), parent)
{
}
 
QAbstractEventDispatcherV2::~QAbstractEventDispatcherV2() = default;
 
void QAbstractEventDispatcherV2::registerTimer(int timerId, qint64 interval,
                                               Qt::TimerType timerType, QObject *object)
{
    auto self = static_cast<QAbstractEventDispatcherV2 *>(this);
    self->registerTimer(Qt::TimerId(timerId), interval * 1ms, timerType, object);
}
 
bool QAbstractEventDispatcherV2::unregisterTimer(int timerId)
{
    auto self = static_cast<QAbstractEventDispatcherV2 *>(this);
    return self->unregisterTimer(Qt::TimerId(timerId));
}
 
auto QAbstractEventDispatcherV2::registeredTimers(QObject *object) const -> QList<TimerInfo>
{
    auto self = static_cast<const QAbstractEventDispatcherV2 *>(this);
    QList<TimerInfoV2> timers = self->timersForObject(object);
    QList<TimerInfo> result;
    result.reserve(timers.size());
    for (const TimerInfoV2 &t : timers)
        result.emplaceBack(qToUnderlying(t.timerId), fromDuration<int>(t.interval), t.timerType);
    return result;
}
 
int QAbstractEventDispatcherV2::remainingTime(int timerId)
{
    auto self = static_cast<QAbstractEventDispatcherV2 *>(this);
    return fromDuration<int>(self->remainingTime(Qt::TimerId(timerId)));
}
#endif // ! Qt 7
 
QT_END_NAMESPACE
 
#include "moc_qabstracteventdispatcher.cpp"