summaryrefslogtreecommitdiffstats
path: root/tqtinterface/qt4/src/kernel/tqeventloop.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tqtinterface/qt4/src/kernel/tqeventloop.cpp')
-rw-r--r--tqtinterface/qt4/src/kernel/tqeventloop.cpp394
1 files changed, 394 insertions, 0 deletions
diff --git a/tqtinterface/qt4/src/kernel/tqeventloop.cpp b/tqtinterface/qt4/src/kernel/tqeventloop.cpp
new file mode 100644
index 0000000..704fc43
--- /dev/null
+++ b/tqtinterface/qt4/src/kernel/tqeventloop.cpp
@@ -0,0 +1,394 @@
+/****************************************************************************
+**
+** Implementation of TQEventLoop class
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the kernel module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file. Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqeventloop_p.h" // includes qplatformdefs.h
+#include "tqeventloop.h"
+#include "tqapplication.h"
+#include "tqdatetime.h"
+
+/*!
+ \class TQEventLoop
+ \brief The TQEventLoop class manages the event queue.
+
+ \ingroup application
+ \ingroup events
+
+ It receives events from the window system and other sources. It
+ then sends them to TQApplication for processing and delivery.
+
+ TQEventLoop allows the application programmer to have more control
+ over event delivery. Programs that perform long operations can
+ call either processOneEvent() or processEvents() with various
+ ProcessEvent values OR'ed together to control which events should
+ be delivered.
+
+ TQEventLoop also allows the integration of an external event loop
+ with the TQt event loop. The Motif Extension included with TQt
+ includes a reimplementation of TQEventLoop for merging TQt and Motif
+ events together.
+
+ To use your own instance of TQEventLoop or TQEventLoop subclass create
+ it before you create the TQApplication object.
+*/
+
+/*! \enum TQEventLoop::ProcessEvents
+
+ This enum controls the types of events processed by the
+ processEvents() functions.
+
+ \value AllEvents - All events are processed
+ \value ExcludeUserInput - Do not process user input events.
+ ( ButtonPress, KeyPress, etc. )
+ \value ExcludeSocketNotifiers - Do not process socket notifier
+ events.
+ \value WaitForMore - Wait for events if no pending events
+ are available.
+
+ \sa processEvents()
+*/
+
+/*! \enum TQEventLoop::ProcessEventsFlags
+ A \c typedef to allow various ProcessEvents values to be OR'ed together.
+
+ \sa ProcessEvents
+ */
+
+/*!
+ Creates a TQEventLoop object, this object becomes the global event loop object.
+ There can only be one event loop object. The TQEventLoop is usually constructed
+ by calling TQApplication::eventLoop(). To create your own event loop object create
+ it before you instantiate the TQApplication object.
+
+ The \a tqparent and \a name arguments are passed on to the TQObject constructor.
+*/
+TQEventLoop::TQEventLoop( TQObject *tqparent, const char *name )
+ : TQObject( tqparent, name )
+{
+#if defined(TQT_CHECK_STATE)
+ if ( TQApplication::eventloop )
+ qFatal( "TQEventLoop: there must be only one event loop object. \nConstruct it before TQApplication." );
+ // for now ;)
+#endif // TQT_CHECK_STATE
+
+ d = new TQEventLoopPrivate;
+
+ init();
+ TQApplication::eventloop = this;
+}
+
+/*!
+ Destructs the TQEventLoop object.
+*/
+TQEventLoop::~TQEventLoop()
+{
+ cleanup();
+ delete d;
+ TQApplication::eventloop = 0;
+}
+
+/*!
+ Enters the main event loop and waits until exit() is called, and
+ returns the value that was set to exit().
+
+ It is necessary to call this function to start event handling. The
+ main event loop receives events from the window system and
+ dispatches these to the application widgets.
+
+ Generally speaking, no user interaction can take place before
+ calling exec(). As a special case, modal widgets like TQMessageBox
+ can be used before calling exec(), because modal widgets call
+ exec() to start a local event loop.
+
+ To make your application perform idle processing, i.e. executing a
+ special function whenever there are no pending events, use a
+ TQTimer with 0 timeout. More advanced idle processing schemes can
+ be achieved using processEvents().
+
+ \sa TQApplication::quit(), exit(), processEvents()
+*/
+int TQEventLoop::exec()
+{
+ d->reset();
+
+ enterLoop();
+
+ // cleanup
+ d->looplevel = 0;
+ d->quitnow = FALSE;
+ d->exitloop = FALSE;
+ d->shortcut = FALSE;
+ // don't reset quitcode!
+
+ return d->quitcode;
+}
+
+/*! \fn void TQEventLoop::exit( int retcode = 0 )
+
+ Tells the event loop to exit with a return code.
+
+ After this function has been called, the event loop returns from
+ the call to exec(). The exec() function returns \a retcode.
+
+ By convention, a \a retcode of 0 means success, and any non-zero
+ value indicates an error.
+
+ Note that unlike the C library function of the same name, this
+ function \e does return to the caller -- it is event processing that
+ stops.
+
+ \sa TQApplication::quit(), exec()
+*/
+void TQEventLoop::exit( int retcode )
+{
+ if ( d->quitnow ) // preserve existing quitcode
+ return;
+ d->quitcode = retcode;
+ d->quitnow = TRUE;
+ d->exitloop = TRUE;
+ d->shortcut = TRUE;
+}
+
+
+/*! \fn int TQEventLoop::enterLoop()
+
+ This function enters the main event loop (recursively). Do not call
+ it unless you really know what you are doing.
+ */
+int TQEventLoop::enterLoop()
+{
+ // save the current exitloop state
+ bool old_exitloop = d->exitloop;
+ d->exitloop = FALSE;
+ d->shortcut = FALSE;
+
+ d->looplevel++;
+ while ( ! d->exitloop )
+ processEvents( AllEvents | WaitForMore );
+ d->looplevel--;
+
+ // restore the exitloop state, but if quitnow is TRUE, we need to keep
+ // exitloop set so that all other event loops drop out.
+ d->exitloop = old_exitloop || d->quitnow;
+ d->shortcut = d->quitnow;
+
+ if ( d->looplevel < 1 ) {
+ d->quitnow = FALSE;
+ d->exitloop = FALSE;
+ d->shortcut = FALSE;
+ emit tqApp->aboutToQuit();
+
+ // send deferred deletes
+ TQApplication::sendPostedEvents( 0, TQEvent::DeferredDelete );
+ }
+
+ return d->looplevel;
+}
+
+/*! \fn void TQEventLoop::exitLoop()
+
+ This function exits from a recursive call to the main event loop.
+ Do not call it unless you really know what you are doing.
+*/
+void TQEventLoop::exitLoop()
+{
+ d->exitloop = TRUE;
+ d->shortcut = TRUE;
+}
+
+/*! \fn void TQEventLoop::loopLevel() const
+
+ Returns the current loop level.
+*/
+int TQEventLoop::loopLevel() const
+{
+ return d->looplevel;
+}
+
+/*!
+ Process pending events that match \a flags for a maximum of \a
+ maxTime milliseconds, or until there are no more events to
+ process, which ever is shorter.
+
+ 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 \c ExcludeUserInput flag.
+
+ NOTE: This function will not process events continuously; it
+ returns after all available events are processed.
+
+ NOTE: Specifying the \c WaitForMore flag makes no sense and will
+ be ignored.
+*/
+void TQEventLoop::processEvents( ProcessEventsFlags flags, int maxTime )
+{
+ TQTime start = TQTime::currentTime();
+ TQTime now;
+ while ( ! d->quitnow && processEvents( flags & ~WaitForMore ) ) {
+ now = TQTime::currentTime();
+ if ( start.msecsTo( now ) > maxTime )
+ break;
+ }
+}
+
+/*!
+ \fn bool TQEventLoop::processEvents( ProcessEventsFlags flags )
+ \overload
+
+ Processes pending events that match \a flags until there are no
+ more events to process.
+
+ 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 \c ExcludeUserInput flag.
+
+ If the \c WaitForMore flag is set in \a flags, the behavior of
+ this function is as follows:
+
+ \list
+
+ \i If events are available, this function returns after processing
+ them.
+
+ \i If no events are available, this function will wait until more
+ are available and return after processing newly available events.
+
+ \endlist
+
+ If the \c WaitForMore flag is \e not set in \a flags, and no
+ events are available, this function will return immediately.
+
+ NOTE: This function will not process events continuously; it
+ returns after all available events are processed.
+
+ This function returns TRUE if an event was processed; otherwise it
+ returns FALSE.
+
+ \sa ProcessEvents hasPendingEvents()
+*/
+
+/*! \fn bool TQEventLoop::hasPendingEvents() const
+
+ Returns TRUE if there is an event waiting, otherwise it returns FALSE.
+*/
+
+/*! \fn void TQEventLoop::registerSocketNotifier( TQSocketNotifier *notifier )
+
+ Registers \a notifier with the event loop. Subclasses need to
+ reimplement this method to tie a socket notifier into another
+ event loop. Reimplementations \e MUST call the base
+ implementation.
+*/
+
+/*! \fn void TQEventLoop::unregisterSocketNotifier( TQSocketNotifier *notifier )
+
+ Unregisters \a notifier from the event loop. Subclasses need to
+ reimplement this method to tie a socket notifier into another
+ event loop. Reimplementations \e MUST call the base
+ implementation.
+*/
+
+/*! \fn void TQEventLoop::setSocketNotifierPending( TQSocketNotifier *notifier )
+
+ Marks \a notifier as pending. The socket notifier will be
+ activated the next time activateSocketNotifiers() is called.
+*/
+
+/*! \fn int TQEventLoop::activateSocketNotifiers()
+
+ Activates all pending socket notifiers and returns the number of
+ socket notifiers that were activated.
+*/
+
+/*! \fn int TQEventLoop::activateTimers()
+
+ Activates all TQt timers and returns the number of timers that were
+ activated.
+
+ TQEventLoop subclasses that do their own timer handling need to
+ call this after the time returned by timeToWait() has elapsed.
+
+ Note: This function is only useful on systems where \c select() is
+ used to block the eventloop. On Windows, this function always
+ returns 0. On MacOS X, this function always returns 0 when the
+ GUI is enabled. On MacOS X, this function returns the documented
+ value when the GUI is disabled.
+*/
+
+/*! \fn int TQEventLoop::timeToWait() const
+
+ Returns the number of milliseconds that TQt needs to handle its
+ timers or -1 if there are no timers running.
+
+ TQEventLoop subclasses that do their own timer handling need to use
+ this to make sure that TQt's timers continue to work.
+
+ Note: This function is only useful on systems where \c select() is
+ used to block the eventloop. On Windows, this function always
+ returns -1. On MacOS X, this function always returns -1 when the
+ GUI is enabled. On MacOS X, this function returns the documented
+ value when the GUI is disabled.
+*/
+
+/*! \fn void TQEventLoop::wakeUp()
+ \threadsafe
+
+ Wakes up the event loop.
+
+ \sa awake()
+*/
+
+/*! \fn void TQEventLoop::awake()
+
+ This signal is emitted after the event loop returns from a
+ function that could block.
+
+ \sa wakeUp() aboutToBlock()
+*/
+
+/*! \fn void TQEventLoop::aboutToBlock()
+
+ This signal is emitted before the event loop calls a function that
+ could block.
+
+ \sa awake()
+*/
+
+#if !defined(TQ_WS_X11)
+void TQEventLoop::appStartingUp(){}
+void TQEventLoop::appClosingDown(){}
+#endif // TQ_WS_X11