Home Man
Search
Today's Posts
Register

Linux & Unix Commands - Search Man Pages

RedHat 9 (Linux i386) - man page for qeventloop (redhat section 3qt)

QEventLoop(3qt) 								  QEventLoop(3qt)

NAME
       QEventLoop - Manages the event queue

SYNOPSIS
       #include <qeventloop.h>

       Inherits QObject.

       Inherited by QMotif.

   Public Members
       QEventLoop ( QObject * parent = 0, const char * name = 0 )
       ~QEventLoop ()
       enum ProcessEvents { AllEvents = 0x00, ExcludeUserInput = 0x01, ExcludeSocketNotifiers =
	   0x02, WaitForMore = 0x04 }
       typedef uint ProcessEventsFlags
       void processEvents ( ProcessEventsFlags flags, int maxTime )
       virtual bool processEvents ( ProcessEventsFlags flags )
       virtual bool hasPendingEvents () const
       virtual void registerSocketNotifier ( QSocketNotifier * notifier )
       virtual void unregisterSocketNotifier ( QSocketNotifier * notifier )
       void setSocketNotifierPending ( QSocketNotifier * notifier )
       int activateSocketNotifiers ()
       int activateTimers ()
       int timeToWait () const
       virtual int exec ()
       virtual void exit ( int retcode = 0 )
       virtual int enterLoop ()
       virtual void exitLoop ()
       virtual int loopLevel () const
       virtual void wakeUp ()

   Signals
       void awake ()
       void aboutToBlock ()

DESCRIPTION
       The QEventLoop class manages the event queue.

       It receives events from the window system and other sources. It then sends them to
       QApplication for prcoessing and delivery.

       QEventLoop 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.

       QEventLoop also allows the integration of an external event loop with the Qt event loop.
       The Motif Extension included with Qt includes a reimplementation of QEventLoop for merging
       Qt and Motif events together.

       See also Main Window and Related Classes and Event Classes.

   Member Type Documentation
QEventLoop::ProcessEvents
       This enum controls the types of events processed by the processEvents() functions.

       QEventLoop::AllEvents - All events are processed

       QEventLoop::ExcludeUserInput - Do not process user input events. ( ButtonPress, KeyPress,
       etc. )

       QEventLoop::ExcludeSocketNotifiers - Do not process socket notifier events.

       QEventLoop::WaitForMore - Wait for events if no pending events are available.

       See also processEvents().

QEventLoop::ProcessEventsFlags
       A typedef to allow various ProcessEvents values to be OR'ed together.

       See also ProcessEvents.

MEMBER FUNCTION DOCUMENTATION
QEventLoop::QEventLoop ( QObject * parent = 0, const char * name = 0 )
       Creates a QEventLoop object. The parent and name arguments are passed on to the QObject
       constructor.

QEventLoop::~QEventLoop ()
       Destructs the QEventLoop object.

void QEventLoop::aboutToBlock () [signal]
       This signal is emitted before the event loop calls a function that could block.

       See also awake().

int QEventLoop::activateSocketNotifiers ()
       Activates all pending socket notifiers and returns the number of socket notifiers that
       were activated.

int QEventLoop::activateTimers ()
       Activates all Qt timers and returns the number of timers that were activated.

       QEventLoop 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 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.

void QEventLoop::awake () [signal]
       This signal is emitted after the event loop returns from a function that could block.

       See also wakeUp() and aboutToBlock().

int QEventLoop::enterLoop () [virtual]
       This function enters the main event loop (recursively). Do not call it unless you really
       know what you are doing.

int QEventLoop::exec () [virtual]
       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 QMessageBox 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 QTimer with 0 timeout. More advanced idle
       processing schemes can be achieved using processEvents().

       See also QApplication::quit(), exit(), and processEvents().

void QEventLoop::exit ( int retcode = 0 ) [virtual]
       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 retcode.

       By convention, 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 does return to the
       caller -- it is event processing that stops.

       See also QApplication::quit() and exec().

void QEventLoop::exitLoop () [virtual]
       This function exits from a recursive call to the main event loop. Do not call it unless
       you really know what you are doing.

bool QEventLoop::hasPendingEvents () const [virtual]
       Returns TRUE if there is an event waiting, otherwise it returns FALSE.

int QEventLoop::loopLevel () const [virtual]
       Returns the current loop level.

void QEventLoop::processEvents ( ProcessEventsFlags flags, int maxTime )
       Process pending events that match flags for a maximum of maxTime milliseconds, or until
       there are no more events to process, which ever is shorter. If this function is called
       without any arguments, then all event types are processed for a maximum of 3 seconds (3000
       milliseconds).

       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 ExcludeUserInput flag.

       NOTE: Specifying the WaitForMore flag makes no sense, and will be ignored.

bool QEventLoop::processEvents ( ProcessEventsFlags flags ) [virtual]
       This is an overloaded member function, provided for convenience. It behaves essentially
       like the above function.

       Processes pending events that match flags. If no events matching flags are available, this
       function will wait for the next event if the WaitForMore flag is set in flags, otherwise
       it returns immediately.

       Returns TRUE if an event was processed; otherwise returns FALSE.

       See also ProcessEvents.

void QEventLoop::registerSocketNotifier ( QSocketNotifier * notifier ) [virtual]
       Registers notifier with the event loop. Subclasses need to reimplement this method to tie
       a socket notifier into another event loop. Reimplementations MUST call the base
       implementation.

void QEventLoop::setSocketNotifierPending ( QSocketNotifier * notifier )
       Marks notifier as pending. The socket notifier will be activated the next time
       activateSocketNotifiers() is called.

int QEventLoop::timeToWait () const
       Returns the number of milliseconds that Qt needs to handle its timers or -1 if there are
       no timers running.

       QEventLoop subclasses that do their own timer handling need to use this to make sure that
       Qt's timers continue to work.

       Note: This function is only useful on systems where 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.

void QEventLoop::unregisterSocketNotifier ( QSocketNotifier * notifier ) [virtual]
       Unregisters notifier from the event loop. Subclasses need to reimplement this method to
       tie a socket notifier into another event loop. Reimplementations MUST call the base
       implementation.

void QEventLoop::wakeUp () [virtual]
       Note: This function is thread-safe when Qt is built withthread support.</p>

       Wakes up the event loop.

       See also awake().

SEE ALSO
       http://doc.trolltech.com/qeventloop.html http://www.trolltech.com/faq/tech.html

COPYRIGHT
       Copyright 1992-2001 Trolltech AS, http://www.trolltech.com.  See the license file included
       in the distribution for a complete license statement.

AUTHOR
       Generated automatically from the source code.

BUGS
       If you find a bug in Qt, please report it as described in
       http://doc.trolltech.com/bughowto.html.	Good bug reports help us to help you. Thank you.

       The definitive Qt documentation is provided in HTML format; it is located at
       $QTDIR/doc/html and can be read using Qt Assistant or with a web browser. This man page is
       provided as a convenience for those users who prefer man pages, although this format is
       not officially supported by Trolltech.

       If you find errors in this manual page, please report them to qt-bugs@trolltech.com.
       Please include the name of the manual page (qeventloop.3qt) and the Qt version (3.1.1).

Trolltech AS				 9 December 2002			  QEventLoop(3qt)


All times are GMT -4. The time now is 12:43 AM.

Unix & Linux Forums Content Copyrightę1993-2018. All Rights Reserved.
UNIX.COM Login
Username:
Password:  
Show Password