Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
openSUSE:Leap:42.2:Ports
qt3-devel-doc
qt3-trident-add-glib-mainloop-support.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File qt3-trident-add-glib-mainloop-support.patch of Package qt3-devel-doc
From ddcf1f3156d8c95b78dd351c2bb8b611fe7ea815 Mon Sep 17 00:00:00 2001 From: Serghei Amelian <serghei.amelian@gmail.com> Date: Mon, 27 Jan 2014 15:40:27 +0200 Subject: [PATCH] added glib mainloop support --- configure | 29 +- src/kernel/qeventloop.h | 20 ++ src/kernel/qeventloop_glib_p.h | 130 ++++++++ src/kernel/qeventloop_p.h | 6 + src/kernel/qeventloop_unix_glib.cpp | 593 ++++++++++++++++++++++++++++++++++ src/kernel/qeventloop_x11_glib.cpp | 618 ++++++++++++++++++++++++++++++++++++ src/kernel/qt_kernel.pri | 22 +- src/qt.pro | 8 + 8 files changed, 1421 insertions(+), 5 deletions(-) create mode 100644 src/kernel/qeventloop_glib_p.h create mode 100644 src/kernel/qeventloop_unix_glib.cpp create mode 100644 src/kernel/qeventloop_x11_glib.cpp diff --git a/configure b/configure index 63011d0..bf5b462 100755 --- a/configure +++ b/configure @@ -284,6 +284,8 @@ CFG_USER_BUILD_KEY= CFG_ACCESSIBILITY=auto CFG_DLOPEN_OPENGL=no CFG_ENDIAN=auto +CFG_GLIBMAINLOOP=no +CFG_LIBGLIBMAINLOOP= D_FLAGS= I_FLAGS= L_FLAGS= @@ -365,7 +367,7 @@ while [ "$#" -gt 0 ]; do VAL=no ;; #Qt style yes options - -incremental|-qvfb|-profile|-shared|-static|-sm|-thread|-xinerama|-xshape|-tablet|-pch|-stl|-ipv6|-freetype|-big-codecs|-xcursor|-xrandr|-xrender|-xft|-xkb|-nis|-cups|-largefile|-h|-help|-v|-verbose|-debug|-release|-fast|-version-script|-dlopen-opengl) + -incremental|-qvfb|-profile|-shared|-static|-sm|-thread|-xinerama|-xshape|-tablet|-pch|-stl|-ipv6|-freetype|-big-codecs|-xcursor|-xrandr|-xrender|-xft|-xkb|-nis|-cups|-largefile|-h|-help|-v|-verbose|-debug|-release|-fast|-version-script|-dlopen-opengl|-glibmainloop) VAR=`echo $1 | sed "s,^-\(.*\),\1,"` VAL=yes ;; @@ -864,6 +866,13 @@ while [ "$#" -gt 0 ]; do UNKNOWN_OPT=yes fi ;; + glibmainloop) + if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then + CFG_GLIBMAINLOOP="$VAL" + else + UNKNOWN_OPT=yes + fi + ;; nis) if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then CFG_NIS="$VAL" @@ -2928,6 +2937,19 @@ if [ "$CFG_PNG" = "no" ]; then elif [ "$CFG_PNG" = "yes" ]; then QMAKE_CONFIG="$QMAKE_CONFIG png" fi +if [ "$CFG_GLIBMAINLOOP" = "no" ]; then + QMAKE_CONFIG="$QMAKE_CONFIG no-glibmainloop" +elif [ "$CFG_GLIBMAINLOOP" = "yes" ]; then + QMAKE_CONFIG="$QMAKE_CONFIG glibmainloop" + + GLIB_CFLAGS="`pkg-config --cflags glib-2.0`" + QMAKE_VARS="$QMAKE_VARS \"QMAKE_CFLAGS_GLIB=$GLIB_CFLAGS\"" + + GLIB_LINKFLAG="`pkg-config --libs glib-2.0`" + QMAKE_VARS="$QMAKE_VARS \"QMAKE_LIBS_GLIB=$GLIB_LINKFLAG\"" + + +fi if [ "$CFG_GIF" = "no" ]; then QMAKE_CONFIG="$QMAKE_CONFIG no-gif" elif [ "$CFG_GIF" = "yes" ]; then @@ -3481,6 +3503,11 @@ if [ "$CFG_PNG" = "no" ]; then else echo "PNG support ......... $CFG_PNG ($CFG_LIBPNG)" fi +if [ "$CFG_GLIBMAINLOOP" = "no" ]; then + echo "Glib main loop support ......... $CFG_GLIBMAINLOOP" +else + echo "Glib main loop support ......... $CFG_GLIBMAINLOOP ($CFG_LIBGLIBMAINLOOP)" +fi echo "zlib support ........ $CFG_ZLIB" if [ "$PLATFORM_QWS" = "yes" ]; then echo "Embedded support .... $CFG_EMBEDDED" diff --git a/src/kernel/qeventloop.h b/src/kernel/qeventloop.h index 8d45c43..9a79f6c 100644 --- a/src/kernel/qeventloop.h +++ b/src/kernel/qeventloop.h @@ -44,6 +44,10 @@ #include "qsocketnotifier.h" #endif // QT_H +#if defined(QT_USE_GLIBMAINLOOP) +#include <glib.h> +#endif // QT_USE_GLIBMAINLOOP + class QEventLoopPrivate; class QSocketNotifier; class QTimer; @@ -95,6 +99,22 @@ class Q_EXPORT QEventLoop : public QObject virtual void wakeUp(); +#if defined(QT_USE_GLIBMAINLOOP) + + // glib main loop support + + /* internal: used to fit glib-main-loop gsource concept */ + + bool gsourcePrepare(GSource *gs, int * timeout); + bool gsourceCheck(GSource * gs); + bool gsourceDispatch(GSource * gs); + + bool processX11Events(); + + // end glib main loop support + +#endif //QT_USE_GLIBMAINLOOP + signals: void awake(); void aboutToBlock(); diff --git a/src/kernel/qeventloop_glib_p.h b/src/kernel/qeventloop_glib_p.h new file mode 100644 index 0000000..8d1ead9 --- /dev/null +++ b/src/kernel/qeventloop_glib_p.h @@ -0,0 +1,130 @@ +/** +** Qt->glib main event loop integration by Norbert Frese 2005 +** code based on qeventloop_p.h 3.3.5 +** +*/ + +/**************************************************************************** +** $Id: qt/qeventloop_glib_p.h +** +** Definition of QEventLoop class +** +** Copyright (C) 1992-2005 Trolltech AS. All rights reserved. +** +** This file is part of the kernel module of the Qt GUI Toolkit. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition +** licenses for Qt/Embedded may use this file in accordance with the +** Qt Embedded Commercial License Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about Qt Commercial License Agreements. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef QEVENTLOOP_GLIB_P_H +#define QEVENTLOOP_GLIB_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. This header file may +// change from version to version without notice, or even be +// removed. +// +// We mean it. +// +// + +#ifndef QT_H +#include "qplatformdefs.h" +#endif // QT_H + +// SCO OpenServer redefines raise -> kill +#if defined(raise) +# undef raise +#endif + +#include "qeventloop.h" +#include "qwindowdefs.h" + +class QSocketNotifier; + +#include "qptrlist.h" + +#include <glib.h> + +// uncomment this for main loop related debug-output + +// #define DEBUG_QT_GLIBMAINLOOP 1 + +// Wrapper for QSocketNotifier Object and GPollFD + +struct QSockNotGPollFD +{ + QSocketNotifier *obj; + GPollFD gPollFD; + gushort events; // save events + bool pending; +}; + +class QEventLoopPrivate +{ +public: + QEventLoopPrivate() + { + reset(); + } + + void reset() { + looplevel = 0; + quitcode = 0; + quitnow = FALSE; + exitloop = FALSE; + shortcut = FALSE; + } + + int looplevel; + int quitcode; + unsigned int quitnow : 1; + unsigned int exitloop : 1; + unsigned int shortcut : 1; + +#if defined(Q_WS_X11) + int xfd; + + GPollFD x_gPollFD; + +#endif // Q_WS_X11 + + int thread_pipe[2]; + + GPollFD threadPipe_gPollFD; + + QPtrList<QSockNotGPollFD> sn_list; + // pending socket notifiers list + QPtrList<QSockNotGPollFD> sn_pending_list; + + // store flags for one iteration + uint pev_flags; + + // My GSource + + GSource * gSource; + +}; + +#endif // QEVENTLOOP_GLIB_P_H diff --git a/src/kernel/qeventloop_p.h b/src/kernel/qeventloop_p.h index 4e7e365..7935d73 100644 --- a/src/kernel/qeventloop_p.h +++ b/src/kernel/qeventloop_p.h @@ -49,6 +49,10 @@ // // +#if defined(QT_USE_GLIBMAINLOOP) +#include "qeventloop_glib_p.h" // use a different header file!!! +#else + #ifndef QT_H #include "qplatformdefs.h" #endif // QT_H @@ -147,4 +151,6 @@ class QEventLoopPrivate }; +#endif // !QT_USE_GLIBMAINLOOP + #endif // QEVENTLOOP_P_H diff --git a/src/kernel/qeventloop_unix_glib.cpp b/src/kernel/qeventloop_unix_glib.cpp new file mode 100644 index 0000000..6852f6b --- /dev/null +++ b/src/kernel/qeventloop_unix_glib.cpp @@ -0,0 +1,593 @@ +/** +** Qt->glib main event loop integration by Norbert Frese 2005 +** code based on qeventloop_unix.cpp 3.3.5 +** +*/ + +/**************************************************************************** +** $Id: qt/qeventloop_unix_glib.cpp +** +** Implementation of QEventLoop class +** +** Copyright (C) 2000-2005 Trolltech AS. All rights reserved. +** +** This file is part of the kernel module of the Qt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.QPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition +** licenses for Unix/X11 or for Qt/Embedded may use this file in accordance +** with the Qt Commercial License Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about Qt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for QPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + + +#include "qeventloop_glib_p.h" // includes qplatformdefs.h +#include "qeventloop.h" +#include "qapplication.h" +#include "qbitarray.h" +#include <stdlib.h> +#include <sys/types.h> + +#include <glib.h> + +/***************************************************************************** + Timer handling; UNIX has no application timer support so we'll have to + make our own from scratch. + + NOTE: These functions are for internal use. QObject::startTimer() and + QObject::killTimer() are for public use. + The QTimer class provides a high-level interface which translates + timer events into signals. + + qStartTimer( interval, obj ) + Starts a timer which will run until it is killed with qKillTimer() + Arguments: + int interval timer interval in milliseconds + QObject *obj where to send the timer event + Returns: + int timer identifier, or zero if not successful + + qKillTimer( timerId ) + Stops a timer specified by a timer identifier. + Arguments: + int timerId timer identifier + Returns: + bool TRUE if successful + + qKillTimer( obj ) + Stops all timers that are sent to the specified object. + Arguments: + QObject *obj object receiving timer events + Returns: + bool TRUE if successful + *****************************************************************************/ + +// +// Internal data structure for timers +// + +struct TimerInfo { // internal timer info + int id; // - timer identifier + timeval interval; // - timer interval + timeval timeout; // - when to sent event + QObject *obj; // - object to receive event +}; + +typedef QPtrList<TimerInfo> TimerList; // list of TimerInfo structs + +static QBitArray *timerBitVec; // timer bit vector +static TimerList *timerList = 0; // timer list + +static void initTimers(); +void cleanupTimers(); +static timeval watchtime; // watch if time is turned back +timeval *qt_wait_timer(); +timeval *qt_wait_timer_max = 0; + +// +// Internal operator functions for timevals +// + +static inline bool operator<( const timeval &t1, const timeval &t2 ) +{ + return t1.tv_sec < t2.tv_sec || + (t1.tv_sec == t2.tv_sec && t1.tv_usec < t2.tv_usec); +} + +static inline bool operator==( const timeval &t1, const timeval &t2 ) +{ + return t1.tv_sec == t2.tv_sec && t1.tv_usec == t2.tv_usec; +} + +static inline timeval &operator+=( timeval &t1, const timeval &t2 ) +{ + t1.tv_sec += t2.tv_sec; + if ( (t1.tv_usec += t2.tv_usec) >= 1000000 ) { + t1.tv_sec++; + t1.tv_usec -= 1000000; + } + return t1; +} + +static inline timeval operator+( const timeval &t1, const timeval &t2 ) +{ + timeval tmp; + tmp.tv_sec = t1.tv_sec + t2.tv_sec; + if ( (tmp.tv_usec = t1.tv_usec + t2.tv_usec) >= 1000000 ) { + tmp.tv_sec++; + tmp.tv_usec -= 1000000; + } + return tmp; +} + +static inline timeval operator-( const timeval &t1, const timeval &t2 ) +{ + timeval tmp; + tmp.tv_sec = t1.tv_sec - t2.tv_sec; + if ( (tmp.tv_usec = t1.tv_usec - t2.tv_usec) < 0 ) { + tmp.tv_sec--; + tmp.tv_usec += 1000000; + } + return tmp; +} + + +// +// Internal functions for manipulating timer data structures. +// The timerBitVec array is used for keeping track of timer identifiers. +// + +static int allocTimerId() // find avail timer identifier +{ + int i = timerBitVec->size()-1; + while ( i >= 0 && (*timerBitVec)[i] ) + i--; + if ( i < 0 ) { + i = timerBitVec->size(); + timerBitVec->resize( 4 * i ); + for( int j=timerBitVec->size()-1; j > i; j-- ) + timerBitVec->clearBit( j ); + } + timerBitVec->setBit( i ); + return i+1; +} + +static void insertTimer( const TimerInfo *ti ) // insert timer info into list +{ + TimerInfo *t = timerList->first(); + int index = 0; +#if defined(QT_DEBUG) + int dangerCount = 0; +#endif + while ( t && t->timeout < ti->timeout ) { // list is sorted by timeout +#if defined(QT_DEBUG) + if ( t->obj == ti->obj ) + dangerCount++; +#endif + t = timerList->next(); + index++; + } + timerList->insert( index, ti ); // inserts sorted +#if defined(QT_DEBUG) + if ( dangerCount > 16 ) + qDebug( "QObject: %d timers now exist for object %s::%s", + dangerCount, ti->obj->className(), ti->obj->name() ); +#endif +} + +static inline void getTime( timeval &t ) // get time of day +{ + gettimeofday( &t, 0 ); + while ( t.tv_usec >= 1000000 ) { // NTP-related fix + t.tv_usec -= 1000000; + t.tv_sec++; + } + while ( t.tv_usec < 0 ) { + if ( t.tv_sec > 0 ) { + t.tv_usec += 1000000; + t.tv_sec--; + } else { + t.tv_usec = 0; + break; + } + } +} + +static void repairTimer( const timeval &time ) // repair broken timer +{ + timeval diff = watchtime - time; + register TimerInfo *t = timerList->first(); + while ( t ) { // repair all timers + t->timeout = t->timeout - diff; + t = timerList->next(); + } +} + +// +// Timer activation functions (called from the event loop) +// + +/* + Returns the time to wait for the next timer, or null if no timers are + waiting. + + The result is bounded to qt_wait_timer_max if this exists. +*/ + +timeval *qt_wait_timer() +{ + static timeval tm; + bool first = TRUE; + timeval currentTime; + if ( timerList && timerList->count() ) { // there are waiting timers + getTime( currentTime ); + if ( first ) { + if ( currentTime < watchtime ) // clock was turned back + repairTimer( currentTime ); + first = FALSE; + watchtime = currentTime; + } + TimerInfo *t = timerList->first(); // first waiting timer + if ( currentTime < t->timeout ) { // time to wait + tm = t->timeout - currentTime; + } else { + tm.tv_sec = 0; // no time to wait + tm.tv_usec = 0; + } + if ( qt_wait_timer_max && *qt_wait_timer_max < tm ) + tm = *qt_wait_timer_max; + return &tm; + } + if ( qt_wait_timer_max ) { + tm = *qt_wait_timer_max; + return &tm; + } + return 0; // no timers +} + +// Timer initialization +static void initTimers() // initialize timers +{ + timerBitVec = new QBitArray( 128 ); + Q_CHECK_PTR( timerBitVec ); + int i = timerBitVec->size(); + while( i-- > 0 ) + timerBitVec->clearBit( i ); + timerList = new TimerList; + Q_CHECK_PTR( timerList ); + timerList->setAutoDelete( TRUE ); + gettimeofday( &watchtime, 0 ); +} + +// Timer cleanup +void cleanupTimers() +{ + delete timerList; + timerList = 0; + delete timerBitVec; + timerBitVec = 0; +} + +// Main timer functions for starting and killing timers +int qStartTimer( int interval, QObject *obj ) +{ + if ( !timerList ) // initialize timer data + initTimers(); + int id = allocTimerId(); // get free timer id + if ( id <= 0 || + id > (int)timerBitVec->size() || !obj )// cannot create timer + return 0; + timerBitVec->setBit( id-1 ); // set timer active + TimerInfo *t = new TimerInfo; // create timer + Q_CHECK_PTR( t ); + t->id = id; + t->interval.tv_sec = interval/1000; + t->interval.tv_usec = (interval%1000)*1000; + timeval currentTime; + getTime( currentTime ); + t->timeout = currentTime + t->interval; + t->obj = obj; + insertTimer( t ); // put timer in list + return id; +} + +bool qKillTimer( int id ) +{ + register TimerInfo *t; + if ( !timerList || id <= 0 || + id > (int)timerBitVec->size() || !timerBitVec->testBit( id-1 ) ) + return FALSE; // not init'd or invalid timer + t = timerList->first(); + while ( t && t->id != id ) // find timer info in list + t = timerList->next(); + if ( t ) { // id found + timerBitVec->clearBit( id-1 ); // set timer inactive + return timerList->remove(); + } + else // id not found + return FALSE; +} + +bool qKillTimer( QObject *obj ) +{ + register TimerInfo *t; + if ( !timerList ) // not initialized + return FALSE; + t = timerList->first(); + while ( t ) { // check all timers + if ( t->obj == obj ) { // object found + timerBitVec->clearBit( t->id-1 ); + timerList->remove(); + t = timerList->current(); + } else { + t = timerList->next(); + } + } + return TRUE; +} + + + + +/***************************************************************************** + QEventLoop implementations for Glib-Main-Loop + *****************************************************************************/ + + + + +void QEventLoop::registerSocketNotifier( QSocketNotifier *notifier ) +{ + + + + int sockfd = notifier->socket(); + int type = notifier->type(); + if ( sockfd < 0 || type < 0 || type > 2 || notifier == 0 ) { +#if defined(QT_CHECK_RANGE) + qWarning( "QSocketNotifier: Internal error" ); +#endif + return; + } + + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("register socket notifier %d\n", sockfd); + #endif + + QPtrList<QSockNotGPollFD> *list = &d->sn_list; + QSockNotGPollFD *sn; + + /* + if ( ! list ) { + // create new list, the QSockNotType destructor will delete it for us + list = new QPtrList<QSockNot>; + Q_CHECK_PTR( list ); + list->setAutoDelete( TRUE ); + d->sn_list = list; + } + */ + + gushort events=0; + switch (type) { + case 0: + events = G_IO_IN | G_IO_HUP; + break; + case 1: + events = G_IO_OUT; + break; + case 2: + events = G_IO_PRI | G_IO_ERR | G_IO_NVAL; + break; + } + + sn = new QSockNotGPollFD; + Q_CHECK_PTR( sn ); + sn->obj = notifier; + sn->gPollFD.fd = sockfd; + sn->gPollFD.events = events; + sn->events = events; // save events! + sn->pending = FALSE; + + list->append( sn ); + + g_source_add_poll(d->gSource, &sn->gPollFD); + +} + +void QEventLoop::unregisterSocketNotifier( QSocketNotifier *notifier ) +{ + int sockfd = notifier->socket(); + int type = notifier->type(); + if ( sockfd < 0 || type < 0 || type > 2 || notifier == 0 ) { +#if defined(QT_CHECK_RANGE) + qWarning( "QSocketNotifier: Internal error" ); +#endif + return; + } + + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("unregister socket notifier %d\n", sockfd); + #endif + + QPtrList<QSockNotGPollFD> *list = &d->sn_list; + QSockNotGPollFD *sn; + if ( ! list ) + return; + sn = list->first(); + while ( sn && !(sn->obj == notifier) ) + sn = list->next(); + if ( !sn ) // not found + return; + + d->sn_pending_list.removeRef( sn ); + list->remove(); // remove notifier found above + g_source_remove_poll(d->gSource, &sn->gPollFD); + + delete sn; // we don't autodelete - lets do it manually + +} + +void QEventLoop::setSocketNotifierPending( QSocketNotifier *notifier ) +{ + int sockfd = notifier->socket(); + int type = notifier->type(); + if ( sockfd < 0 || type < 0 || type > 2 || notifier == 0 ) { +#if defined(QT_CHECK_RANGE) + qWarning( "QSocketNotifier: Internal error" ); +#endif + return; + } + + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("set socket notifier pending %d\n", sockfd); + #endif + + QPtrList<QSockNotGPollFD> *list = &d->sn_list; + QSockNotGPollFD *sn; + if ( ! list ) + return; + sn = list->first(); + while ( sn && !(sn->obj == notifier) ) + sn = list->next(); + if ( ! sn ) { // not found + return; + } + + // We choose a random activation order to be more fair under high load. + // If a constant order is used and a peer early in the list can + // saturate the IO, it might grab our attention completely. + // Also, if we're using a straight list, the callback routines may + // delete other entries from the list before those other entries are + // processed. + if ( !sn->pending ) { + d->sn_pending_list.insert( (rand() & 0xff) % + (d->sn_pending_list.count()+1), sn ); + sn->pending = TRUE; // add it only once! + } +} + +void QEventLoop::wakeUp() +{ + /* + Apparently, there is not consistency among different operating + systems on how to use FIONREAD. + + FreeBSD, Linux and Solaris all expect the 3rd argument to + ioctl() to be an int, which is normally 32-bit even on 64-bit + machines. + + IRIX, on the other hand, expects a size_t, which is 64-bit on + 64-bit machines. + + So, the solution is to use size_t initialized to zero to make + sure all bits are set to zero, preventing underflow with the + FreeBSD/Linux/Solaris ioctls. + */ + size_t nbytes = 0; + char c = 0; + if ( ::ioctl( d->thread_pipe[0], FIONREAD, (char*)&nbytes ) >= 0 && nbytes == 0 ) { + ::write( d->thread_pipe[1], &c, 1 ); + } +} + +int QEventLoop::timeToWait() const +{ + timeval *tm = qt_wait_timer(); + if ( ! tm ) // no active timers + return -1; + return (tm->tv_sec*1000) + (tm->tv_usec/1000); +} + +int QEventLoop::activateTimers() +{ + if ( !timerList || !timerList->count() ) // no timers + return 0; + bool first = TRUE; + timeval currentTime; + int n_act = 0, maxCount = timerList->count(); + TimerInfo *begin = 0; + register TimerInfo *t; + + for ( ;; ) { + if ( ! maxCount-- ) + break; + getTime( currentTime ); // get current time + if ( first ) { + if ( currentTime < watchtime ) // clock was turned back + repairTimer( currentTime ); + first = FALSE; + watchtime = currentTime; + } + t = timerList->first(); + if ( !t || currentTime < t->timeout ) // no timer has expired + break; + if ( ! begin ) { + begin = t; + } else if ( begin == t ) { + // avoid sending the same timer multiple times + break; + } else if ( t->interval < begin->interval || t->interval == begin->interval ) { + begin = t; + } + timerList->take(); // unlink from list + t->timeout += t->interval; + if ( t->timeout < currentTime ) + t->timeout = currentTime + t->interval; + insertTimer( t ); // relink timer + if ( t->interval.tv_usec > 0 || t->interval.tv_sec > 0 ) + n_act++; + QTimerEvent e( t->id ); + QApplication::sendEvent( t->obj, &e ); // send event + if ( timerList->findRef( begin ) == -1 ) + begin = 0; + } + return n_act; +} + +int QEventLoop::activateSocketNotifiers() +{ + if ( d->sn_pending_list.isEmpty() ) + return 0; + + // activate entries + int n_act = 0; + QEvent event( QEvent::SockAct ); + QPtrListIterator<QSockNotGPollFD> it( d->sn_pending_list ); + QSockNotGPollFD *sn; + while ( (sn=it.current()) ) { + ++it; + d->sn_pending_list.removeRef( sn ); + if ( sn->pending ) { + + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("activate sn : send event fd=%d\n", sn->gPollFD.fd ); + #endif + + + sn->pending = FALSE; + QApplication::sendEvent( sn->obj, &event ); + n_act++; + } + } + + return n_act; +} diff --git a/src/kernel/qeventloop_x11_glib.cpp b/src/kernel/qeventloop_x11_glib.cpp new file mode 100644 index 0000000..10ee007 --- /dev/null +++ b/src/kernel/qeventloop_x11_glib.cpp @@ -0,0 +1,618 @@ +/** +** Qt->glib main event loop integration by Norbert Frese 2005 +** code based on qeventloop_x11.cpp 3.3.5 +** +*/ + +/**************************************************************************** +** $Id: qt/qeventloop_x11_glib.cpp +** +** Implementation of QEventLoop class +** +** Copyright (C) 2000-2005 Trolltech AS. All rights reserved. +** +** This file is part of the kernel module of the Qt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.QPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition +** licenses for Unix/X11 may use this file in accordance with the Qt Commercial +** License Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about Qt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for QPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + + +#include "qeventloop_glib_p.h" // includes qplatformdefs.h +#include "qeventloop.h" +#include "qapplication.h" +#include "qbitarray.h" +#include "qcolor_p.h" +#include "qt_x11_p.h" + +#if defined(QT_THREAD_SUPPORT) +# include "qmutex.h" +#endif // QT_THREAD_SUPPORT + +#include <errno.h> + +#include <glib.h> + +// Qt-GSource Structure and Callbacks + +typedef struct { + GSource source; + QEventLoop * qeventLoop; +} QtGSource; + +static gboolean qt_gsource_prepare ( GSource *source, + gint *timeout ); +static gboolean qt_gsource_check ( GSource *source ); +static gboolean qt_gsource_dispatch ( GSource *source, + GSourceFunc callback, gpointer user_data ); + +static GSourceFuncs qt_gsource_funcs = { + qt_gsource_prepare, + qt_gsource_check, + qt_gsource_dispatch, + NULL, + NULL, + NULL +}; + +// forward main loop callbacks to QEventLoop methods! + +static gboolean qt_gsource_prepare ( GSource *source, + gint *timeout ) +{ + QtGSource * qtGSource; + qtGSource = (QtGSource*) source; + return qtGSource->qeventLoop->gsourcePrepare(source, timeout); +} + +static gboolean qt_gsource_check ( GSource *source ) +{ + QtGSource * qtGSource = (QtGSource*) source; + return qtGSource->qeventLoop->gsourceCheck(source); +} + +static gboolean qt_gsource_dispatch ( GSource *source, + GSourceFunc callback, gpointer user_data ) +{ + QtGSource * qtGSource = (QtGSource*) source; + return qtGSource->qeventLoop->gsourceDispatch(source); +} + + +// ------------------------------------------------- + +// resolve the conflict between X11's FocusIn and QEvent::FocusIn +#undef FocusOut +#undef FocusIn + +static const int XKeyPress = KeyPress; +static const int XKeyRelease = KeyRelease; +#undef KeyPress +#undef KeyRelease + +// from qapplication.cpp +extern bool qt_is_gui_used; + +// from qeventloop_unix.cpp +extern timeval *qt_wait_timer(); +extern void cleanupTimers(); + +// ### this needs to go away at some point... +typedef void (*VFPTR)(); +typedef QValueList<VFPTR> QVFuncList; +void qt_install_preselect_handler( VFPTR ); +void qt_remove_preselect_handler( VFPTR ); +static QVFuncList *qt_preselect_handler = 0; +void qt_install_postselect_handler( VFPTR ); +void qt_remove_postselect_handler( VFPTR ); +static QVFuncList *qt_postselect_handler = 0; + +void qt_install_preselect_handler( VFPTR handler ) +{ + if ( !qt_preselect_handler ) + qt_preselect_handler = new QVFuncList; + qt_preselect_handler->append( handler ); +} +void qt_remove_preselect_handler( VFPTR handler ) +{ + if ( qt_preselect_handler ) { + QVFuncList::Iterator it = qt_preselect_handler->find( handler ); + if ( it != qt_preselect_handler->end() ) + qt_preselect_handler->remove( it ); + } +} +void qt_install_postselect_handler( VFPTR handler ) +{ + if ( !qt_postselect_handler ) + qt_postselect_handler = new QVFuncList; + qt_postselect_handler->prepend( handler ); +} +void qt_remove_postselect_handler( VFPTR handler ) +{ + if ( qt_postselect_handler ) { + QVFuncList::Iterator it = qt_postselect_handler->find( handler ); + if ( it != qt_postselect_handler->end() ) + qt_postselect_handler->remove( it ); + } +} + + +void QEventLoop::init() +{ + // initialize ProcessEventFlags (all events & wait for more) + + d->pev_flags = AllEvents | WaitForMore; + + // initialize the common parts of the event loop + pipe( d->thread_pipe ); + fcntl(d->thread_pipe[0], F_SETFD, FD_CLOEXEC); + fcntl(d->thread_pipe[1], F_SETFD, FD_CLOEXEC); + + // intitialize the X11 parts of the event loop + d->xfd = -1; + if ( qt_is_gui_used ) + d->xfd = XConnectionNumber( QPaintDevice::x11AppDisplay() ); + + // new GSource + + QtGSource * qtGSource = (QtGSource*) g_source_new(&qt_gsource_funcs, + sizeof(QtGSource)); + + g_source_set_can_recurse ((GSource*)qtGSource, TRUE); + + qtGSource->qeventLoop = this; + + // init main loop and attach gsource + + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("inside init(1)\n"); + #endif + + g_main_loop_new (NULL, 1); + + g_source_attach( (GSource*)qtGSource, NULL ); + + d->gSource = (GSource*) qtGSource; + + // poll for X11 events + + if ( qt_is_gui_used ) { + + + d->x_gPollFD.fd = d->xfd; + d->x_gPollFD.events = G_IO_IN | G_IO_HUP; + g_source_add_poll(d->gSource, &d->x_gPollFD); + } + + // poll thread-pipe + + d->threadPipe_gPollFD.fd = d->thread_pipe[0]; + d->threadPipe_gPollFD.events = G_IO_IN | G_IO_HUP; + + g_source_add_poll(d->gSource, &d->threadPipe_gPollFD); + + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("inside init(2)\n"); + #endif + +} + +void QEventLoop::cleanup() +{ + // cleanup the common parts of the event loop + close( d->thread_pipe[0] ); + close( d->thread_pipe[1] ); + cleanupTimers(); + + // cleanup the X11 parts of the event loop + d->xfd = -1; + + // todo: destroy gsource +} + +bool QEventLoop::processEvents( ProcessEventsFlags flags ) +{ + + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("inside processEvents(1) looplevel=%d\n", d->looplevel ); + #endif + ProcessEventsFlags save_flags; + int rval; + save_flags = d->pev_flags; + + d->pev_flags = flags; + + rval = g_main_context_iteration(NULL, flags & WaitForMore ? TRUE : FALSE); + + d->pev_flags = save_flags; + + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("inside processEvents(2) looplevel=%d rval=%d\n", d->looplevel, rval ); + #endif + + return rval; // were events processed? +} + + +bool QEventLoop::processX11Events() +{ + ProcessEventsFlags flags = d->pev_flags; + // process events from the X server + XEvent event; + int nevents = 0; + +#if defined(QT_THREAD_SUPPORT) + QMutexLocker locker( QApplication::qt_mutex ); +#endif + + // handle gui and posted events + if ( qt_is_gui_used ) { + QApplication::sendPostedEvents(); + + // Two loops so that posted events accumulate + while ( XPending( QPaintDevice::x11AppDisplay() ) ) { + // also flushes output buffer + while ( XPending( QPaintDevice::x11AppDisplay() ) ) { + if ( d->shortcut ) { + return FALSE; + } + + XNextEvent( QPaintDevice::x11AppDisplay(), &event ); + + if ( flags & ExcludeUserInput ) { + switch ( event.type ) { + case ButtonPress: + case ButtonRelease: + case MotionNotify: + case XKeyPress: + case XKeyRelease: + case EnterNotify: + case LeaveNotify: + continue; + + case ClientMessage: + { + // from qapplication_x11.cpp + extern Atom qt_wm_protocols; + extern Atom qt_wm_take_focus; + extern Atom qt_qt_scrolldone; + + // only keep the wm_take_focus and + // qt_qt_scrolldone protocols, discard all + // other client messages + if ( event.xclient.format != 32 ) + continue; + + if ( event.xclient.message_type == qt_wm_protocols || + (Atom) event.xclient.data.l[0] == qt_wm_take_focus ) + break; + if ( event.xclient.message_type == qt_qt_scrolldone ) + break; + } + + default: break; + } + } + + nevents++; + if ( qApp->x11ProcessEvent( &event ) == 1 ) + return TRUE; + } + } + } + + if ( d->shortcut ) { + return FALSE; + } + + QApplication::sendPostedEvents(); + + const uint exclude_all = ExcludeSocketNotifiers | 0x08; + // 0x08 == ExcludeTimers for X11 only + if ( nevents > 0 && ( flags & exclude_all ) == exclude_all && + ( flags & WaitForMore ) ) { + return TRUE; + } + return FALSE; +} + + +bool QEventLoop::gsourcePrepare(GSource *gs, int * timeout) +{ + + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("inside gsourcePrepare(1)\n"); + #endif + + ProcessEventsFlags flags = d->pev_flags; + +#if defined(QT_THREAD_SUPPORT) + QMutexLocker locker( QApplication::qt_mutex ); +#endif + + // don't block if exitLoop() or exit()/quit() has been called. + bool canWait = d->exitloop || d->quitnow ? FALSE : (flags & WaitForMore); + + // Process timers and socket notifiers - the common UNIX stuff + + // return the maximum time we can wait for an event. + static timeval zerotm; + timeval *tm = 0; + if ( ! ( flags & 0x08 ) ) { // 0x08 == ExcludeTimers for X11 only + tm = qt_wait_timer(); // wait for timer or X event + if ( !canWait ) { + if ( !tm ) + tm = &zerotm; + tm->tv_sec = 0; // no time to wait + tm->tv_usec = 0; + } + } + + // include or exclude SocketNotifiers (by setting or cleaning poll events) + + if ( ! ( flags & ExcludeSocketNotifiers ) ) { + QPtrListIterator<QSockNotGPollFD> it( d->sn_list ); + QSockNotGPollFD *sn; + while ( (sn=it.current()) ) { + ++it; + sn->gPollFD.events = sn->events; // restore poll events + } + } else { + QPtrListIterator<QSockNotGPollFD> it( d->sn_list ); + QSockNotGPollFD *sn; + while ( (sn=it.current()) ) { + ++it; + sn->gPollFD.events = 0; // delete poll events + } + } + + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("inside gsourcePrepare(2) canwait=%d\n", canWait); + #endif + + if ( canWait ) + emit aboutToBlock(); + + + if ( qt_preselect_handler ) { + QVFuncList::Iterator it, end = qt_preselect_handler->end(); + for ( it = qt_preselect_handler->begin(); it != end; ++it ) + (**it)(); + } + + // unlock the GUI mutex and select. when we return from this function, there is + // something for us to do +#if defined(QT_THREAD_SUPPORT) + locker.mutex()->unlock(); +#endif + + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("inside gsourcePrepare(2.1) canwait=%d\n", canWait); + #endif + + // do we have to dispatch events? + if (hasPendingEvents()) { + *timeout = 0; // no time to stay in poll + + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("inside gsourcePrepare(3a)\n"); + #endif + + return FALSE; + } + + // stay in poll until something happens? + if (!tm) { // fixme + *timeout = -1; // wait forever + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("inside gsourcePrepare(3b) timeout=%d \n", *timeout); + #endif + + + return FALSE; + } + + // else timeout >=0 + *timeout = tm->tv_sec * 1000 + tm->tv_usec/1000; + + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("inside gsourcePrepare(3c) timeout=%d \n", *timeout); + #endif + + + return FALSE; +} + + +bool QEventLoop::gsourceCheck(GSource *gs) { + + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("inside gsourceCheck(1)\n"); + #endif + + + // Socketnotifier events? + + QPtrList<QSockNotGPollFD> *list = &d->sn_list; + + //if ( list ) { + + + QSockNotGPollFD *sn = list->first(); + while ( sn ) { + if ( sn->gPollFD.revents ) + return TRUE; + sn = list->next(); + } + //} + + if (d->x_gPollFD.revents) { + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("inside gsourceCheck(2) xfd!\n"); + #endif + + return TRUE; // we got events! + } + if (d->threadPipe_gPollFD.revents) { + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("inside gsourceCheck(2) threadpipe!!\n"); + #endif + + return TRUE; // we got events! + } + if (hasPendingEvents()) { + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("inside gsourceCheck(2) pendingEvents!\n"); + #endif + + return TRUE; // we got more X11 events! + } + // check if we have timers to activate? + + timeval * tm =qt_wait_timer(); + + if (tm && (tm->tv_sec == 0 && tm->tv_usec == 0 )) { + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("inside gsourceCheck(2) qtwaittimer!\n"); + #endif + + return TRUE; + } + + // nothing to dispatch + + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("inside gsourceCheck(2) nothing to dispatch!\n"); + #endif + + return FALSE; +} + + +bool QEventLoop::gsourceDispatch(GSource *gs) { + + // relock the GUI mutex before processing any pending events +#if defined(QT_THREAD_SUPPORT) + QMutexLocker locker( QApplication::qt_mutex ); +#endif +#if defined(QT_THREAD_SUPPORT) + locker.mutex()->lock(); +#endif + + int nevents=0; + + ProcessEventsFlags flags = d->pev_flags; + + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("inside gsourceDispatch(1)\n"); + #endif + + // we are awake, broadcast it + emit awake(); + emit qApp->guiThreadAwake(); + + // some other thread woke us up... consume the data on the thread pipe so that + // select doesn't immediately return next time + + if ( d->threadPipe_gPollFD.revents) { + char c; + ::read( d->thread_pipe[0], &c, 1 ); + } + + if ( qt_postselect_handler ) { + QVFuncList::Iterator it, end = qt_postselect_handler->end(); + for ( it = qt_postselect_handler->begin(); it != end; ++it ) + (**it)(); + } + + // activate socket notifiers + if ( ! ( flags & ExcludeSocketNotifiers )) { + // if select says data is ready on any socket, then set the socket notifier + // to pending + // if ( &d->sn_list ) { + + + QPtrList<QSockNotGPollFD> *list = &d->sn_list; + QSockNotGPollFD *sn = list->first(); + while ( sn ) { + if ( sn->gPollFD.revents ) + setSocketNotifierPending( sn->obj ); + sn = list->next(); + } + // } + + nevents += activateSocketNotifiers(); + } + + // activate timers + if ( ! ( flags & 0x08 ) ) { + // 0x08 == ExcludeTimers for X11 only + nevents += activateTimers(); + } + + + + // return true if we handled events, false otherwise + //return (nevents > 0); + + // now process x11 events! + + #ifdef DEBUG_QT_GLIBMAINLOOP + printf("inside gsourceDispatch(2) hasPendingEvents=%d\n", hasPendingEvents()); + #endif + + if (hasPendingEvents()) { + + // color approx. optimization - only on X11 + qt_reset_color_avail(); + + processX11Events(); + + } + +#if defined(QT_THREAD_SUPPORT) + locker.mutex()->unlock(); +#endif + + return TRUE; + +} + +bool QEventLoop::hasPendingEvents() const +{ + extern uint qGlobalPostedEventsCount(); // from qapplication.cpp + return ( qGlobalPostedEventsCount() || ( qt_is_gui_used ? XPending( QPaintDevice::x11AppDisplay() ) : 0)); +} + +void QEventLoop::appStartingUp() +{ + if ( qt_is_gui_used ) + d->xfd = XConnectionNumber( QPaintDevice::x11AppDisplay() ); +} + +void QEventLoop::appClosingDown() +{ + d->xfd = -1; +} diff --git a/src/kernel/qt_kernel.pri b/src/kernel/qt_kernel.pri index c4beeda..1ea0767 100644 --- a/src/kernel/qt_kernel.pri +++ b/src/kernel/qt_kernel.pri @@ -21,7 +21,7 @@ kernel { $$KERNEL_H/qdrawutil.h \ $$KERNEL_H/qdropsite.h \ $$KERNEL_H/qevent.h \ - $$KERNEL_H/qeventloop.h\ + $$KERNEL_H/qeventloop.h \ $$KERNEL_P/qeventloop_p.h \ $$KERNEL_H/qfocusdata.h \ $$KERNEL_H/qfont.h \ @@ -99,6 +99,10 @@ kernel { $$KERNEL_CPP/qfontengine_p.h \ $$KERNEL_CPP/qtextlayout_p.h + glibmainloop { + HEADERS+=$$KERNEL_P/qeventloop_glib_p.h + } + win32:SOURCES += $$KERNEL_CPP/qapplication_win.cpp \ $$KERNEL_CPP/qclipboard_win.cpp \ $$KERNEL_CPP/qcolor_win.cpp \ @@ -128,7 +132,6 @@ kernel { $$KERNEL_CPP/qcursor_x11.cpp \ $$KERNEL_CPP/qdnd_x11.cpp \ $$KERNEL_CPP/qdesktopwidget_x11.cpp \ - $$KERNEL_CPP/qeventloop_x11.cpp \ $$KERNEL_CPP/qfont_x11.cpp \ $$KERNEL_CPP/qinputcontext_x11.cpp \ $$KERNEL_CPP/qmotifdnd_x11.cpp \ @@ -140,6 +143,12 @@ kernel { $$KERNEL_CPP/qwidget_x11.cpp \ $$KERNEL_CPP/qwidgetcreate_x11.cpp \ $$KERNEL_CPP/qfontengine_x11.cpp + glibmainloop { + SOURCES += $$KERNEL_CPP/qeventloop_x11_glib.cpp + } else { + SOURCES += $$KERNEL_CPP/qeventloop_x11.cpp + } + } !x11:mac { @@ -166,8 +175,13 @@ kernel { DEFINES += QMAC_ONE_PIXEL_LOCK } else:unix { SOURCES += $$KERNEL_CPP/qprinter_unix.cpp \ - $$KERNEL_CPP/qpsprinter.cpp \ - $$KERNEL_CPP/qeventloop_unix.cpp + $$KERNEL_CPP/qpsprinter.cpp + glibmainloop { + SOURCES += $$KERNEL_CPP/qeventloop_unix_glib.cpp + } else { + SOURCES += $$KERNEL_CPP/qeventloop_unix.cpp + } + } unix:SOURCES += $$KERNEL_CPP/qprocess_unix.cpp \ $$KERNEL_CPP/qthread_unix.cpp diff --git a/src/qt.pro b/src/qt.pro index 36dfe5c..58a1b6b 100644 --- a/src/qt.pro +++ b/src/qt.pro @@ -191,3 +191,11 @@ wince-* { $$CODECS_CPP/qtextcodecplugin.cpp \ $$WIDGETS_CPP/qwidgetplugin.cpp } + +glibmainloop { + DEFINES += QT_USE_GLIBMAINLOOP + QMAKE_CFLAGS += $$QMAKE_CFLAGS_GLIB + QMAKE_CXXFLAGS += $$QMAKE_CFLAGS_GLIB + LIBS += $$QMAKE_LIBS_GLIB +} + -- 1.8.5.1
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
