QEventDispatcherX11 Class Reference

#include <qeventdispatcher_x11_p.h>

Inheritance diagram for QEventDispatcherX11:

[legend]Collaboration diagram for QEventDispatcherX11:

[legend]List of all members.

---

Detailed Description

Definition at line 42 of file qeventdispatcher_x11_p.h.

Public Member Functions
	QEventDispatcherX11 (QObject *parent=0)
	~QEventDispatcherX11 ()
bool	processEvents (QEventLoop::ProcessEventsFlags flags)
bool	hasPendingEvents ()
void	flush ()
void	startingUp ()
void	closingDown ()
Protected Member Functions
int	select (int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, timeval *timeout)

---

Constructor & Destructor Documentation

QEventDispatcherX11::QEventDispatcherX11

(

QObject *

parent = 0

)

[explicit]

Definition at line 43 of file qeventdispatcher_x11.cpp.

    : QEventDispatcherUNIX(*new QEventDispatcherX11Private, parent)
{ }

QEventDispatcherX11::~QEventDispatcherX11

(

)

Definition at line 47 of file qeventdispatcher_x11.cpp.

{ }

---

Member Function Documentation

bool QEventDispatcherX11::processEvents

(

QEventLoop::ProcessEventsFlags

flags

)

[virtual]

Processes pending events that match flags until there are no more events to process. Returns true if an event was processed; otherwise returns false.

This function is especially useful if you have a long running operation and want to show its progress without allowing user input; i.e. by using the QEventLoop::ExcludeUserInputEvents flag.

If the QEventLoop::WaitForMoreEvents flag is set in flags, the behavior of this function is as follows:

If events are available, this function returns after processing them.

If no events are available, this function will wait until more are available and return after processing newly available events.

If the QEventLoop::WaitForMoreEvents flag is not set in flags, and no events are available, this function will return immediately.

{Note:} This function does not process events continuously; it returns after all available events are processed.

See also:

hasPendingEvents()

Reimplemented from QEventDispatcherUNIX.

Definition at line 50 of file qeventdispatcher_x11.cpp.

References ATOM, d, QObject::event(), QEventLoop::ExcludeSocketNotifiers, QEventLoop::ExcludeUserInputEvents, QAbstractEventDispatcher::filterEvent(), marker, QEventDispatcherUNIX::processEvents(), qApp, QCoreApplication::sendPostedEvents(), QEventLoop::WaitForMoreEvents, X11, QEventLoop::X11ExcludeTimers, XKeyPress, and XKeyRelease.

{
    Q_D(QEventDispatcherX11);

    d->interrupt = false;
    QApplication::sendPostedEvents();

    ulong marker = XNextRequest(X11->display);
    int nevents = 0;
    do {
        while (!d->interrupt) {
            XEvent event;
            if (!(flags & QEventLoop::ExcludeUserInputEvents)
                && !d->queuedUserInputEvents.isEmpty()) {
                // process a pending user input event
                event = d->queuedUserInputEvents.takeFirst();
            } else if (XEventsQueued(X11->display, QueuedAlready)) {
                // process events from the X server
                XNextEvent(X11->display, &event);

                if (flags & QEventLoop::ExcludeUserInputEvents) {
                    // queue user input events
                    switch (event.type) {
                    case ButtonPress:
                    case ButtonRelease:
                    case MotionNotify:
                    case XKeyPress:
                    case XKeyRelease:
                    case EnterNotify:
                    case LeaveNotify:
                        d->queuedUserInputEvents.append(event);
                        continue;

                    case ClientMessage:
                        // only keep the wm_take_focus and
                        // _qt_scrolldone protocols, queue all other
                        // client messages
                        if (event.xclient.format == 32) {
                            if (event.xclient.message_type == ATOM(WM_PROTOCOLS) ||
                                (Atom) event.xclient.data.l[0] == ATOM(WM_TAKE_FOCUS)) {
                                break;
                            } else if (event.xclient.message_type == ATOM(_QT_SCROLL_DONE)) {
                                break;
                            }
                        }
                        d->queuedUserInputEvents.append(event);
                        continue;

                    default:
                        break;
                    }
                }
            } else {
                // no event to process
                break;
            }

            // send through event filter
            if (filterEvent(&event))
                continue;

            nevents++;
            if (qApp->x11ProcessEvent(&event) == 1)
                return true;

            if (event.xany.serial >= marker) {
                if (XEventsQueued(X11->display, QueuedAfterFlush))
                    flags &= ~QEventLoop::WaitForMoreEvents;
                goto out;
            }
        }
    } while (!d->interrupt && XEventsQueued(X11->display, QueuedAfterFlush));

 out:
    if (!d->interrupt) {
        const uint exclude_all =
            QEventLoop::ExcludeSocketNotifiers | QEventLoop::X11ExcludeTimers | QEventLoop::WaitForMoreEvents;
        if (nevents > 0 && ((uint)flags & exclude_all) == exclude_all) {
            QApplication::sendPostedEvents();
            return nevents > 0;
        }
        // return true if we handled events, false otherwise
        return QEventDispatcherUNIX::processEvents(flags) ||  (nevents > 0);
    }
    return nevents > 0;
}

Here is the call graph for this function:

bool QEventDispatcherX11::hasPendingEvents

(

)

[virtual]

Returns true if there is an event waiting; otherwise returns false.

Reimplemented from QEventDispatcherUNIX.

Definition at line 137 of file qeventdispatcher_x11.cpp.

References qGlobalPostedEventsCount(), and X11.

{
    extern uint qGlobalPostedEventsCount(); // from qapplication.cpp
    return (qGlobalPostedEventsCount() || XPending(X11->display));
}

Here is the call graph for this function:

void QEventDispatcherX11::flush

(

)

[virtual]

Flushes the event queue. This normally returns almost immediately. Does nothing on platforms other than X11.

Reimplemented from QEventDispatcherUNIX.

Definition at line 143 of file qeventdispatcher_x11.cpp.

References X11.

{
    XFlush(X11->display);
}

void QEventDispatcherX11::startingUp

(

)

[virtual]

Reimplemented from QAbstractEventDispatcher.

Definition at line 148 of file qeventdispatcher_x11.cpp.

References d, and X11.

{
    Q_D(QEventDispatcherX11);
    d->xfd = XConnectionNumber(X11->display);
}

void QEventDispatcherX11::closingDown

(

)

[virtual]

Reimplemented from QAbstractEventDispatcher.

Definition at line 154 of file qeventdispatcher_x11.cpp.

References d.

{
    Q_D(QEventDispatcherX11);
    d->xfd = -1;
}

int QEventDispatcherX11::select	(	int	nfds,
		fd_set *	readfds,
		fd_set *	writefds,
		fd_set *	exceptfds,
		timeval *	timeout
	)			[protected, virtual]

Reimplemented from QEventDispatcherUNIX.

Definition at line 160 of file qeventdispatcher_x11.cpp.

References d, qMax(), and QEventDispatcherUNIX::select().

{
    Q_D(QEventDispatcherX11);
    if (d->xfd > 0) {
        nfds = qMax(nfds - 1, d->xfd) + 1;
        FD_SET(d->xfd, readfds);
    }
    return QEventDispatcherUNIX::select(nfds, readfds, writefds, exceptfds, timeout);
}

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• src/gui/kernel/qeventdispatcher_x11_p.h
• src/gui/kernel/qeventdispatcher_x11.cpp

---