1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qeventdispatcher_x11_p.h"

    43 

    44 #include "qapplication.h"

    45 #include "qx11info_x11.h"

    46 

    47 #include "qt_x11_p.h"

    48 #include <private/qeventdispatcher_unix_p.h>

    49 

    50 QT_BEGIN_NAMESPACE

    51 

    52 class QEventDispatcherX11Private : public QEventDispatcherUNIXPrivate

    53 {

    54     Q_DECLARE_PUBLIC(QEventDispatcherX11)

    55 public:

    56     inline QEventDispatcherX11Private()

    57         : xfd(-1)

    58     { }

    59     int xfd;

    60     QList<XEvent> queuedUserInputEvents;

    61 };

    62 

    63 QEventDispatcherX11::QEventDispatcherX11(QObject *parent)

    64     : QEventDispatcherUNIX(*new QEventDispatcherX11Private, parent)

    65 { }

    66 

    67 QEventDispatcherX11::~QEventDispatcherX11()

    68 { }

    69 

    70 bool QEventDispatcherX11::processEvents(QEventLoop::ProcessEventsFlags flags)

    71 {

    72     Q_D(QEventDispatcherX11);

    73 

    74     d->interrupt = false;

    75     QApplication::sendPostedEvents();

    76 

    77     ulong marker = XNextRequest(X11->display);

    78     int nevents = 0;

    79     do {

    80         while (!d->interrupt) {

    81             XEvent event;

    82             if (!(flags & QEventLoop::ExcludeUserInputEvents)

    83                 && !d->queuedUserInputEvents.isEmpty()) {

    84                 // process a pending user input event

    85                 event = d->queuedUserInputEvents.takeFirst();

    86             } else if (XEventsQueued(X11->display, QueuedAlready)) {

    87                 // process events from the X server

    88                 XNextEvent(X11->display, &event);

    89 

    90                 if (flags & QEventLoop::ExcludeUserInputEvents) {

    91                     // queue user input events

    92                     switch (event.type) {

    93                     case ButtonPress:

    94                     case ButtonRelease:

    95                     case MotionNotify:

    96                     case XKeyPress:

    97                     case XKeyRelease:

    98                     case EnterNotify:

    99                     case LeaveNotify:

   100                         d->queuedUserInputEvents.append(event);

   101                         continue;

   102 

   103                     case ClientMessage:

   104                         // only keep the wm_take_focus and

   105                         // _qt_scrolldone protocols, queue all other

   106                         // client messages

   107                         if (event.xclient.format == 32) {

   108                             if (event.xclient.message_type == ATOM(WM_PROTOCOLS) &&

   109                                 (Atom) event.xclient.data.l[0] == ATOM(WM_TAKE_FOCUS)) {

   110                                 break;

   111                             } else if (event.xclient.message_type == ATOM(_QT_SCROLL_DONE)) {

   112                                 break;

   113                             }

   114                         }

   115                         d->queuedUserInputEvents.append(event);

   116                         continue;

   117 

   118                     default:

   119                         break;

   120                     }

   121                 }

   122             } else {

   123                 // no event to process

   124                 break;

   125             }

   126 

   127             // send through event filter

   128             if (filterEvent(&event))

   129                 continue;

   130 

   131             nevents++;

   132             if (qApp->x11ProcessEvent(&event) == 1)

   133                 return true;

   134 

   135             if (event.xany.serial >= marker) {

   136                 if (XEventsQueued(X11->display, QueuedAfterFlush))

   137                     flags &= ~QEventLoop::WaitForMoreEvents;

   138                 goto out;

   139             }

   140         }

   141     } while (!d->interrupt && XEventsQueued(X11->display, QueuedAfterFlush));

   142 

   143  out:

   144     if (!d->interrupt) {

   145         const uint exclude_all =

   146             QEventLoop::ExcludeSocketNotifiers | QEventLoop::X11ExcludeTimers | QEventLoop::WaitForMoreEvents;

   147         if (nevents > 0 && ((uint)flags & exclude_all) == exclude_all) {

   148             QApplication::sendPostedEvents();

   149             return nevents > 0;

   150         }

   151         // return true if we handled events, false otherwise

   152         return QEventDispatcherUNIX::processEvents(flags) ||  (nevents > 0);

   153     }

   154     return nevents > 0;

   155 }

   156 

   157 bool QEventDispatcherX11::hasPendingEvents()

   158 {

   159     extern uint qGlobalPostedEventsCount(); // from qapplication.cpp

   160     return (qGlobalPostedEventsCount() || XPending(X11->display));

   161 }

   162 

   163 void QEventDispatcherX11::flush()

   164 {

   165     XFlush(X11->display);

   166 }

   167 

   168 void QEventDispatcherX11::startingUp()

   169 {

   170     Q_D(QEventDispatcherX11);

   171     d->xfd = XConnectionNumber(X11->display);

   172 }

   173 

   174 void QEventDispatcherX11::closingDown()

   175 {

   176     Q_D(QEventDispatcherX11);

   177     d->xfd = -1;

   178 }

   179 

   180 int QEventDispatcherX11::select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,

   181                                 timeval *timeout)

   182 {

   183     Q_D(QEventDispatcherX11);

   184     if (d->xfd > 0) {

   185         nfds = qMax(nfds - 1, d->xfd) + 1;

   186         FD_SET(d->xfd, readfds);

   187     }

   188     return QEventDispatcherUNIX::select(nfds, readfds, writefds, exceptfds, timeout);

   189 }

   190 

   191 QT_END_NAMESPACE