fcntl(postEventSource->wakeUpPipe[1], F_SETFL,          fcntl(postEventSource->wakeUpPipe[1], F_GETFL) | O_NONBLOCK);    postEventSource->pollfd.fd = postEventSource->wakeUpPipe[0];    postEventSource->pollfd.events = G_IO_IN | G_IO_HUP | G_IO_ERR;    postEventSource->flags = postEventSource->previousFlags = QEventLoop::AllEvents;    g_source_add_poll(&postEventSource->source, &postEventSource->pollfd);    g_source_attach(&postEventSource->source, mainContext);    // setup socketNotifierSource    socketNotifierSource =        reinterpret_cast<GSocketNotifierSource *>(g_source_new(&socketNotifierSourceFuncs,                                                               sizeof(GSocketNotifierSource)));    (void) new (&socketNotifierSource->pollfds) QList<GPollFDWithQSocketNotifier *>();    g_source_set_can_recurse(&socketNotifierSource->source, true);    g_source_attach(&socketNotifierSource->source, mainContext);    // setup timerSource    timerSource = reinterpret_cast<GTimerSource *>(g_source_new(&timerSourceFuncs,                                                                sizeof(GTimerSource)));    (void) new (&timerSource->timerList) QTimerInfoList();    g_source_set_can_recurse(&timerSource->source, true);    g_source_attach(&timerSource->source, mainContext);}QEventDispatcherGlib::QEventDispatcherGlib(QObject *parent)    : QAbstractEventDispatcher(*(new QEventDispatcherGlibPrivate), parent){}QEventDispatcherGlib::~QEventDispatcherGlib(){    Q_D(QEventDispatcherGlib);    // destroy all timer sources    qDeleteAll(d->timerSource->timerList);    d->timerSource->timerList.~QTimerInfoList();    g_source_destroy(&d->timerSource->source);    g_source_unref(&d->timerSource->source);    d->timerSource = 0;    // destroy socket notifier source    for (int i = 0; i < d->socketNotifierSource->pollfds.count(); ++i) {        GPollFDWithQSocketNotifier *p = d->socketNotifierSource->pollfds[i];        g_source_remove_poll(&d->socketNotifierSource->source, &p->pollfd);        delete p;    }    d->socketNotifierSource->pollfds.~QList<GPollFDWithQSocketNotifier *>();    g_source_destroy(&d->socketNotifierSource->source);    g_source_unref(&d->socketNotifierSource->source);    d->socketNotifierSource = 0;    // destroy post event source    g_source_remove_poll(&d->postEventSource->source, &d->postEventSource->pollfd);    close(d->postEventSource->wakeUpPipe[0]);    close(d->postEventSource->wakeUpPipe[1]);    d->postEventSource->wakeUpPipe[0] = 0;    d->postEventSource->wakeUpPipe[1] = 0;    g_source_destroy(&d->postEventSource->source);    g_source_unref(&d->postEventSource->source);    d->postEventSource = 0;    g_main_context_unref(d->mainContext);    d->mainContext = 0;}bool QEventDispatcherGlib::processEvents(QEventLoop::ProcessEventsFlags flags){    Q_D(QEventDispatcherGlib);    const bool canWait = (flags & QEventLoop::WaitForMoreEvents);    if (canWait)        emit aboutToBlock();    else        emit awake();    // tell postEventSourcePrepare() about any new flags    d->postEventSource->flags = flags;    bool result = g_main_context_iteration(d->mainContext, canWait);    while (!result && canWait)        result = g_main_context_iteration(d->mainContext, canWait);    if (canWait)        emit awake();    return result;}bool QEventDispatcherGlib::hasPendingEvents(){    Q_D(QEventDispatcherGlib);    return g_main_context_pending(d->mainContext);}void QEventDispatcherGlib::registerSocketNotifier(QSocketNotifier *socketNotifier){    int sockfd;    int type;    if (!socketNotifier        || (sockfd = socketNotifier->socket()) < 0        || unsigned(sockfd) >= FD_SETSIZE        || (type = socketNotifier->type()) < 0        || type > 2) {        qWarning("QSocketNotifier: Internal error");        return;    } else if (socketNotifier->thread() != thread()               || thread() != QThread::currentThread()) {        qWarning("QSocketNotifier: socket notifiers cannot be enabled from another thread");        return;    }    Q_D(QEventDispatcherGlib);    GPollFDWithQSocketNotifier *p = new GPollFDWithQSocketNotifier;    p->pollfd.fd = sockfd;    switch (type) {    case QSocketNotifier::Read:        p->pollfd.events = G_IO_IN | G_IO_HUP | G_IO_ERR;        break;    case QSocketNotifier::Write:        p->pollfd.events = G_IO_OUT | G_IO_ERR;        break;    case QSocketNotifier::Exception:        p->pollfd.events = G_IO_PRI | G_IO_ERR;        break;    }    p->socketNotifier = socketNotifier;    d->socketNotifierSource->pollfds.append(p);    g_source_add_poll(&d->socketNotifierSource->source, &p->pollfd);}void QEventDispatcherGlib::unregisterSocketNotifier(QSocketNotifier *socketNotifier){    int sockfd;    int type;    if (!socketNotifier        || (sockfd = socketNotifier->socket()) < 0        || unsigned(sockfd) >= FD_SETSIZE        || (type = socketNotifier->type()) < 0        || type > 2) {        qWarning("QSocketNotifier: Internal error");        return;    } else if (socketNotifier->thread() != thread()               || thread() != QThread::currentThread()) {        qWarning("QSocketNotifier: socket notifiers cannot be disabled from another thread");        return;    }    Q_D(QEventDispatcherGlib);    for (int i = 0; i < d->socketNotifierSource->pollfds.count(); ++i) {        GPollFDWithQSocketNotifier *p = d->socketNotifierSource->pollfds.at(i);        if (p->socketNotifier == socketNotifier) {            // found it            g_source_remove_poll(&d->socketNotifierSource->source, &p->pollfd);            d->socketNotifierSource->pollfds.removeAt(i);            delete p;            return;        }    }}void QEventDispatcherGlib::registerTimer(int timerId, int interval, QObject *object){    if (timerId < 1 || interval < 0 || !object) {        qWarning("QEventDispatcherUNIX::registerTimer: invalid arguments");        return;    } else if (object->thread() != thread() || thread() != QThread::currentThread()) {        qWarning("QObject::startTimer: timers cannot be started from another thread");        return;    }    Q_D(QEventDispatcherGlib);    QTimerInfo *t = new QTimerInfo;    t->id = timerId;    t->interval.tv_sec  = interval / 1000;    t->interval.tv_usec = (interval % 1000) * 1000;    timeval currentTime;    getTime(currentTime);    t->timeout = currentTime + t->interval;    t->obj = object;    t->inTimerEvent = false;    d->timerSource->timerList.timerInsert(t);}bool QEventDispatcherGlib::unregisterTimer(int timerId){    if (timerId < 1) {        qWarning("QEventDispatcherUNIX::unregisterTimer: invalid argument");        return false;    } else if (thread() != QThread::currentThread()) {        qWarning("QObject::killTimer: timers cannot be stopped from another thread");        return false;    }    Q_D(QEventDispatcherGlib);    // set timer inactive    for (int i = 0; i < d->timerSource->timerList.size(); ++i) {        register QTimerInfo *t = d->timerSource->timerList.at(i);        if (t->id == timerId) {            d->timerSource->timerList.removeAt(i);            delete t;            return true;        }    }    // id not found    return false;}bool QEventDispatcherGlib::unregisterTimers(QObject *object){    if (!object) {        qWarning("QEventDispatcherUNIX::unregisterTimers: invalid argument");        return false;    } else if (object->thread() != thread() || thread() != QThread::currentThread()) {        qWarning("QObject::killTimers: timers cannot be stopped from another thread");        return false;    }    Q_D(QEventDispatcherGlib);    if (d->timerSource->timerList.isEmpty())        return false;    for (int i = 0; i < d->timerSource->timerList.size(); ++i) {        register QTimerInfo *t = d->timerSource->timerList.at(i);        if (t->obj == object) {            // object found            d->timerSource->timerList.removeAt(i);            delete t;            // move back one so that we don't skip the new current item            --i;        }    }    return true;}QList<QEventDispatcherGlib::TimerInfo> QEventDispatcherGlib::registeredTimers(QObject *object) const{    if (!object) {        qWarning("QEventDispatcherUNIX:registeredTimers: invalid argument");        return QList<TimerInfo>();    }    Q_D(const QEventDispatcherGlib);    QList<TimerInfo> list;    for (int i = 0; i < d->timerSource->timerList.size(); ++i) {        register const QTimerInfo * const t = d->timerSource->timerList.at(i);        if (t->obj == object)            list << TimerInfo(t->id, t->interval.tv_sec * 1000 + t->interval.tv_usec / 1000);    }    return list;}void QEventDispatcherGlib::interrupt(){    wakeUp();}void QEventDispatcherGlib::wakeUp(){    Q_D(QEventDispatcherGlib);    char c = 0;    ::write(d->postEventSource->wakeUpPipe[1], &c, 1);}void QEventDispatcherGlib::flush(){}QEventDispatcherGlib::QEventDispatcherGlib(QEventDispatcherGlibPrivate &dd, QObject *parent)    : QAbstractEventDispatcher(dd, parent){}