QAbstractEventDispatcher 抽象事件分发类

 

QAbstractEventDispatcher

QAbstractEventDispatcher 是一个抽象事件分发类，提供了一个事件循环，并将事件分发给相应的对象。

主要职责有：

1.管理一个事件循环，接收各种事件并分发

2.提供注册，注销事件等接口

3.处理定时器，到期后触发timeout 信号

4.处理异步信号连接，将其包装为事件进行分发

QAbstractEventDispatcher是一个抽象事件分发器类。它的主要作用是:
1. 管理定时器 
2. 分发事件 
3. 允许自定义事件过滤器
它定义了事件分发器的基本接口,而将具体实现留给子类。这个类使用了抽象工厂模式和模板方法模式。
主要成员函数包括:
1. registerTimer() - 注册定时器
2. unregisterTimer() - 删除定时器 
3. registerSocketNotifier() - 注册socket通知器 
4. unregisterSocketNotifier() - 删除socket通知器
5. processEvents() - 分发事件,这是一个模板方法 
6. setEventFilter() - 设置自定义事件过滤器 
7. filterEvent() - 根据事件过滤器过滤事件 
这个类描述了Qt事件分发的基本框架,而具体实现与平台相关的代码在子类中实现。这使得整个设计具有很好的可扩展性与跨平台性。

 

//QAbstractEventDispatcher 的私有实现类，
class Q_CORE_EXPORT QAbstractEventDispatcherPrivate : public QObjectPrivate
{
    Q_DECLARE_PUBLIC(QAbstractEventDispatcher)
public:
    inline QAbstractEventDispatcherPrivate()
        : event_filter(0)
    { }
    void init();
    QAbstractEventDispatcher::EventFilter event_filter;//事件过滤器,用于过滤事件 
​
    static int allocateTimerId(); //分配定时器id 
    static void releaseTimerId(int id); //释放定时器id
};
​

 

//事件分发器的抽象基类，定义了事件分发器的公共接口,并提供了部分默认实现
class Q_CORE_EXPORT QAbstractEventDispatcher : public QObject
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(QAbstractEventDispatcher)
​
public:
    typedef QPair<int, int> TimerInfo;
​
    explicit QAbstractEventDispatcher(QObject *parent = 0);
    ~QAbstractEventDispatcher();
​
    static QAbstractEventDispatcher *instance(QThread *thread = 0);
    //处理事件
    virtual bool processEvents(QEventLoop::ProcessEventsFlags flags) = 0;
    //待处理事件
    virtual bool hasPendingEvents() = 0;
    //注册/注销套接字监听器,抽象方法 
    virtual void registerSocketNotifier(QSocketNotifier *notifier) = 0;
    virtual void unregisterSocketNotifier(QSocketNotifier *notifier) = 0;
    //注册/注销定时器,部分实现 
    int registerTimer(int interval, QObject *object);
    virtual void registerTimer(int timerId, int interval, QObject *object) = 0;
    virtual bool unregisterTimer(int timerId) = 0;
    virtual bool unregisterTimers(QObject *object) = 0;
    virtual QList<TimerInfo> registeredTimers(QObject *object) const = 0;
    //唤醒事件循环
    virtual void wakeUp() = 0;
    //中断事件循环
    virtual void interrupt() = 0;
    //刷新事件循环
    virtual void flush() = 0;
    //开始事件循环,
    virtual void startingUp();
    //结束事件循环
    virtual void closingDown();
    //设置事件过滤器 
    typedef bool(*EventFilter)(void *message);
    EventFilter setEventFilter(EventFilter filter);
    //过滤事件 
    bool filterEvent(void *message);
​
Q_SIGNALS:
    void aboutToBlock();
    void awake();
​
protected:
    QAbstractEventDispatcher(QAbstractEventDispatcherPrivate &,
                             QObject *parent);
};

//用于准备一个带序列号的新定时器id
//新定时器id的低24位与旧定时器id的高7位组合,生成一个新的定时器id。
static inline int prepareNewValueWithSerialNumber(int oldId, int newId)
{
    return (newId & 0x00FFFFFF) | ((oldId + 0x01000000) & 0x7f000000);
}
//定时器id计算出所在的bucket
//通过遍历BucketSize数组,获得第一个大于定时器id的bucket索引。
static inline int bucketOffset(int timerId)
{
    for (int i = 0; i < NumberOfBuckets; ++i) {
        if (timerId < BucketSize[i])
            return i;
        timerId -= BucketSize[i];
    }
    qFatal("QAbstractEventDispatcher: INTERNAL ERROR, timer ID %d is too large", timerId);
    return -1;
}
//根据bucket和定时器id计算在bucket中的索引位置
//简单地将定时器id减去bucket的偏移量BucketOffset[bucket]
static inline int bucketIndex(int bucket, int timerId)
{
    return timerId - BucketOffset[bucket];
}
//分配一个新的bucket。
//它根据bucket大小在堆上分配一个数组,并将每个元素初始化为该bucket下一个可用定时器id。
static inline int *allocateBucket(int bucket)
{
    // allocate a new bucket
    const int size = BucketSize[bucket];
    const int offset = BucketOffset[bucket];
    int *b = new int[size];
    for (int i = 0; i != size; ++i)
        b[i] = offset + i + 1;
    return b;
}

 

//初始化，将当前事件分发器实例和线程数据关联起来
void QAbstractEventDispatcherPrivate::init()

//分配一个定时器id，从可用定时器id中分配一个
int QAbstractEventDispatcherPrivate::allocateTimerId()

//释放一个定时器id
void QAbstractEventDispatcherPrivate::releaseTimerId(int timerId)

//构造函数，析构函数
QAbstractEventDispatcher::QAbstractEventDispatcher(QObject *parent)
    : QObject(*new QAbstractEventDispatcherPrivate, parent)
 QAbstractEventDispatcher::QAbstractEventDispatcher(QAbstractEventDispatcherPrivate &dd,QObject *parent)
QAbstractEventDispatcher::~QAbstractEventDispatcher()  

 

//构造单件模式，返回指定线程中的事件分发器
//在不同线程中获取对应的事件分发器对象，以便处理线程相关的事件循环
QAbstractEventDispatcher *QAbstractEventDispatcher::instance(QThread *thread)

//将定时器注册到事件分发器，
int QAbstractEventDispatcher::registerTimer(int interval, QObject *object)

//虚接口类：
void QAbstractEventDispatcher::startingUp()
void QAbstractEventDispatcher::closingDown()
​

//更新事件过滤器，返回原先的事件过滤器函数,而使用新的事件过滤器替代之
QAbstractEventDispatcher::EventFilter QAbstractEventDispatcher::setEventFilter(EventFilter filter)
​

//调用事件过滤器函数对事件进行过滤
bool QAbstractEventDispatcher::filterEvent(void *message)