Added TQt4 HEAD

1 files changed, 5499 insertions, 0 deletions

diff --git a/tqtinterface/qt4/src/kernel/tqapplication.cpp b/tqtinterface/qt4/src/kernel/tqapplication.cpp
new file mode 100644
index 0000000..af193c9
--- /dev/null
+++ b/tqtinterface/qt4/src/kernel/tqapplication.cpp
@@ -0,0 +1,5499 @@
+/****************************************************************************
+**
+** Implementation of TQApplication class
+**
+** Created : 931107
+**
+** 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 "tqobjectlist.h"
+#include "tqapplication.h"
+#include "tqeventloop.h"
+#include "tqeventloop_p.h"
+#include "tqwidget.h"
+#include "tqwidgetlist.h"
+#include "tqwidgetintdict.h"
+#include "tqptrdict.h"
+#include "tqcleanuphandler.h"
+
+#include "tqtranslator.h"
+#include "tqtextcodec.h"
+#include "tqsessionmanager.h"
+#include "tqdragobject.h"
+#include "tqclipboard.h"
+#include "tqcursor.h"
+#include "tqstyle.h"
+#include "tqstylefactory.h"
+#include "tqfile.h"
+#include "tqmessagebox.h"
+#include "tqdir.h"
+#include "tqfileinfo.h"
+#ifdef TQ_WS_WIN
+#include "tqinputcontext_p.h"
+#endif
+#include "tqfontdata_p.h"
+
+#if defined(TQT_THREAD_SUPPORT)
+#  include "tqmutex.h"
+#  include "tqthread.h"
+#endif // TQT_THREAD_SUPPORT
+
+#include <stdlib.h>
+
+#ifdef truncate
+# undef truncate
+#endif
+
+#ifdef USE_QT4
+
+TQApplication *tqAppReal;				// global application object
+TQStyle *TQApplication::app_style = 0;			// default application style
+bool qt_explicit_app_style = FALSE;			// style explicitly set by programmer
+QWidget* TQApplication::current_app_main_widget = 0;	// current main widget
+
+int TQApplication::app_cspec = TQApplication::NormalColor;	// color mode (obsolete)
+
+TQWidgetList * qt_modal_stack=0;	// stack of modal widgets
+
+#ifndef TQT_NO_PALETTE
+TQPalette *TQApplication::app_pal	       = 0;	// default application palette
+#endif
+// TQFont	 *TQApplication::app_font       = 0;	// default application font
+bool	  qt_app_has_font	       = FALSE;
+
+bool	  qt_is_gui_used;
+bool      TQ_EXPORT qt_resolve_symlinks = TRUE;
+bool      TQ_EXPORT qt_tab_all_widgets  = TRUE;
+
+#if defined(TQ_WS_X11)
+extern void qt_init( Display* dpy, TQt::HANDLE, TQt::HANDLE );
+#endif
+extern void qt_init( int *argcptr, char **argv, TQApplication::Type );
+
+#ifndef TQT_NO_CLIPBOARD
+TQClipboard *tqt_clipboard = 0;	// global clipboard object
+#endif
+
+#ifdef TQT_THREAD_SUPPORT
+TQMutex *TQApplication::qt_mutex = 0;
+static TQMutex *postevent_mutex = 0;
+static TQt::HANDLE qt_application_thread_id = 0;
+TQ_EXPORT TQt::HANDLE qt_get_application_thread_id()
+{
+    return qt_application_thread_id;
+}
+#endif // TQT_THREAD_SUPPORT
+
+
+#ifdef TQT_THREAD_SUPPORT
+	#define TQAPPLICATION_MUTEX_INIT				\
+	qt_mutex = new TQMutex( TRUE );					\
+	postevent_mutex = new TQMutex( TRUE );				\
+	qt_application_thread_id = TQThread::currentThread();
+#else // TQT_THREAD_SUPPORT
+	#define TQAPPLICATION_MUTEX_INIT 
+#endif // TQT_THREAD_SUPPORT
+
+TQWidgetList TQApplication::tqt_all_widgets_list;
+
+TQApplication::TQApplication( int &argc, char **argv ) : QApplication( argc, argv )
+{
+	bool GUIenabled = true;
+	TQAPPLICATION_GUI_CONDITIONAL_VAR_INIT
+	TQAPPLICATION_XORG_CONDITIONAL_INIT
+	TQAPPLICATION_MUTEX_INIT
+	TQAPPLICATION_REGISTER_TQ_DATATYPES
+}
+TQApplication::TQApplication( int &argc, char **argv, bool GUIenabled ) : QApplication( argc, argv, GUIenabled )
+{
+	TQAPPLICATION_GUI_CONDITIONAL_VAR_INIT
+	TQAPPLICATION_XORG_CONDITIONAL_INIT
+	TQAPPLICATION_MUTEX_INIT
+	TQAPPLICATION_REGISTER_TQ_DATATYPES
+}
+TQApplication::TQApplication( int &argc, char **argv, Type t ) : QApplication( argc, argv, t )
+{
+	TQAPPLICATION_GUI_VAR_INIT
+	TQAPPLICATION_XORG_PARTIAL_INIT
+	TQAPPLICATION_MUTEX_INIT
+	TQAPPLICATION_REGISTER_TQ_DATATYPES
+}
+#if defined(TQ_WS_X11)
+TQApplication::TQApplication( Display* dpy, Qt::HANDLE visual, Qt::HANDLE cmap ) : QApplication( dpy, visual, cmap )
+{
+	TQAPPLICATION_GUI_VAR_INIT
+	TQAPPLICATION_XORG_FULL_INIT
+	TQAPPLICATION_MUTEX_INIT
+	TQAPPLICATION_REGISTER_TQ_DATATYPES
+}
+TQApplication::TQApplication( Display *dpy, int argc, char **argv, Qt::HANDLE visual, Qt::HANDLE cmap ) : QApplication( dpy, argc, argv, visual, cmap )
+{
+	TQAPPLICATION_GUI_VAR_INIT
+	TQAPPLICATION_XORG_FULL_INIT
+	TQAPPLICATION_MUTEX_INIT
+	TQAPPLICATION_REGISTER_TQ_DATATYPES
+}
+#endif
+
+// Qt4 session manager interconnect
+void TQApplication::commitData( QSessionManager& sm ) {
+	commitData(TQT_TQSESSIONMANAGER_OBJECT(sm));
+}
+void TQApplication::saveState( QSessionManager& sm ) {
+	saveState(TQT_TQSESSIONMANAGER_OBJECT(sm));
+}
+
+#ifndef TQT_NO_TRANSLATION
+
+bool qt_detectRTLLanguage()
+{
+    return TQApplication::tr( "TQT_LAYOUT_DIRECTION",
+	    "Translate this string to the string 'LTR' in left-to-right"
+	    " languages or to 'RTL' in right-to-left languages (such as Hebrew"
+	    " and Arabic) to get proper widget tqlayout." ) == "RTL";
+}
+
+#endif // TQT_NO_TRANSLATION
+
+TQEventLoop* TQApplication::eventloop;
+TQPtrList<QEventLoop> TQApplication::tqt_event_loop_stack;
+int TQApplication::composedUnicode;
+bool TQApplication::metaComposeUnicode;
+
+// static TQEventLoop eventLoop_private;		// Will this actually work, or do I need to call exec or something?
+//
+// TQEventLoop *TQApplication::eventLoop()
+// {
+//     return &eventLoop_private;
+// }
+
+TQEventLoop *TQApplication::eventLoop() {
+	if ( !eventloop )
+		(void) new TQEventLoop( TQT_TQOBJECT(tqApp), "default event loop" );
+	return eventloop;
+}
+
+/*!
+
+  Wakes up the GUI thread.
+
+  \sa guiThreadAwake() \link threads.html Thread Support in TQt\endlink
+*/
+void TQApplication::wakeUpGuiThread()
+{
+    eventLoop()->wakeUp();
+}
+
+#ifdef TQT_THREAD_SUPPORT
+void TQApplication::lock() {
+	qt_mutex->lock();
+}
+
+void TQApplication::unlock(bool wakeUpGui) {
+	qt_mutex->unlock();
+
+	if (wakeUpGui)
+		wakeUpGuiThread();
+}
+
+bool TQApplication::locked() {
+	return qt_mutex->locked();
+}
+
+bool TQApplication::tryLock() {
+	return qt_mutex->tryLock();
+}
+#endif // TQT_THREAD_SUPPORT
+
+#ifndef TQT_NO_PALETTE
+TQPalette *qt_std_pal = 0;
+
+void qt_create_std_palette()
+{
+    if ( qt_std_pal )
+	delete qt_std_pal;
+
+    TQColor standardLightGray( 192, 192, 192 );
+    TQColor light( 255, 255, 255 );
+    TQColor dark( standardLightGray.dark( 150 ) );
+    TQColorGroup std_act( TQt::black, standardLightGray,
+			 light, dark, TQt::gray,
+			 TQt::black, TQt::white );
+    TQColorGroup std_dis( TQt::darkGray, standardLightGray,
+			 light, dark, TQt::gray,
+			 TQt::darkGray, std_act.background() );
+    TQColorGroup std_inact( TQt::black, standardLightGray,
+			   light, dark, TQt::gray,
+			   TQt::black, TQt::white );
+    qt_std_pal = new TQPalette( std_act, std_dis, std_inact );
+}
+
+static void qt_fix_tooltips()
+{
+    // No resources for this yet (unlike on Windows).
+    TQColorGroup cg( TQt::black, TQColor(255,255,220),
+		    TQColor(96,96,96), TQt::black, TQt::black,
+		    TQt::black, TQColor(255,255,220) );
+    TQPalette pal( cg, cg, cg );
+    TQApplication::tqsetPalette( pal, TRUE, "TQTipLabel");
+}
+#endif
+
+// [FIXME] This needs to somehow connect to the Qt4 style mechanism
+// Possibly on calls to setStyle the Qt4 setStyle must also be called for the same style?
+
+static TQString *qt_style_override = 0;
+
+TQStyle& TQApplication::tqstyle()
+{
+#ifndef TQT_NO_STYLE
+    if ( app_style )
+	return *app_style;
+    if ( !qt_is_gui_used )
+	qFatal( "No style available in non-gui applications!" );
+
+#if defined(TQ_WS_X11)
+//     if(!qt_style_override)
+// 	x11_initialize_style(); // run-time search for default style
+#endif
+    if ( !app_style ) {
+// 	// Compile-time search for default style
+// 	//
+	TQString style;
+	if ( qt_style_override ) {
+	    style = *qt_style_override;
+	    delete qt_style_override;
+	    qt_style_override = 0;
+	} else {
+// #  if defined(TQ_WS_WIN) && defined(TQ_OS_TEMP)
+// 	    style = "PocketPC";
+// #elif defined(TQ_WS_WIN)
+// 	    if ( qWinVersion() >= TQt::WV_XP && qWinVersion() < TQt::WV_NT_based )
+// 		style = "WindowsXP";
+// 	    else
+// 		style = "Windows";		// default styles for Windows
+// #elif defined(TQ_WS_X11) && defined(TQ_OS_SOLARIS)
+// 	    style = "CDE";			// default style for X11 on Solaris
+// #elif defined(TQ_WS_X11) && defined(TQ_OS_IRIX)
+// 	    style = "SGI";			// default style for X11 on IRIX
+// #elif defined(TQ_WS_X11)
+		style = "Motif";		// default style for X11
+// #elif defined(TQ_WS_MAC)
+// 		style = "Macintosh";		// default style for all Mac's
+// #elif defined(TQ_WS_TQWS)
+// 	    style = "Compact";		// default style for small tqdevices
+// #endif
+	}
+	app_style = TQStyleFactory::create( style );
+	if ( !app_style &&		// platform default style not available, try alternatives
+	     !(app_style = TQStyleFactory::create( "Windows" ) ) &&
+	     !(app_style = TQStyleFactory::create( "Platinum" ) ) &&
+	     !(app_style = TQStyleFactory::create( "MotifPlus" ) ) &&
+	     !(app_style = TQStyleFactory::create( "Motif" ) ) &&
+	     !(app_style = TQStyleFactory::create( "CDE" ) ) &&
+	     !(app_style = TQStyleFactory::create( "Aqua" ) ) &&
+	     !(app_style = TQStyleFactory::create( "SGI" ) ) &&
+	     !(app_style = TQStyleFactory::create( "Compact" ) )
+#ifndef TQT_NO_STRINGLIST
+	    && !(app_style = TQStyleFactory::create( TQStyleFactory::keys()[0]  ) )
+#endif
+	)
+	    qFatal( "No %s style available!", style.latin1() );
+    }
+
+//     TQPalette app_pal_copy ( *app_pal );
+//     app_style->polish( *app_pal );
+
+//     if ( is_app_running && !is_app_closing && (*app_pal != app_pal_copy) ) {
+// 	TQEvent e( TQEvent::ApplicationPaletteChange );
+// 	TQWidgetIntDictIt it( *((TQWidgetIntDict*)TQWidget::wmapper()) );
+// 	register TQWidget *w;
+// 	while ( (w=it.current()) ) {		// for all widgets...
+// 	    ++it;
+// 	    sendEvent( w, &e );
+// 	}
+//     }
+
+    app_style->polish( tqApp );
+#endif
+    return *app_style;
+}
+
+/*!
+    Enters the main event loop and waits until exit() is called or the
+    main widget is destroyed, and returns the value that was set to
+    exit() (which is 0 if exit() is called via quit()).
+
+    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 quit(), exit(), processEvents(), setMainWidget()
+*/
+int TQApplication::exec()
+{
+    return eventLoop()->exec();
+}
+
+/*!
+  Sets the application's GUI style to \a style. Ownership of the style
+  object is transferred to TQApplication, so TQApplication will delete
+  the style object on application exit or when a new style is set.
+
+  Example usage:
+  \code
+    TQApplication::setStyle( new TQWindowsStyle );
+  \endcode
+
+  When switching application styles, the color palette is set back to
+  the initial colors or the system defaults. This is necessary since
+  certain styles have to adapt the color palette to be fully
+  style-guide compliant.
+
+  \sa style(), TQStyle, setPalette(), desktopSettingsAware()
+*/
+void TQApplication::setStyle( TQStyle *style )
+{
+    TQStyle* old = app_style;
+    app_style = style;
+#ifdef TQ_WS_X11
+    qt_explicit_app_style = TRUE;
+#endif // TQ_WS_X11
+
+    if ( startingUp() ) {
+	delete old;
+	return;
+    }
+
+    // clean up the old style
+    if (old) {
+// 	if ( is_app_running && !is_app_closing ) {
+// 	    TQWidgetIntDictIt it( *((TQWidgetIntDict*)TQWidget::wmapper()) );
+// 	    register TQWidget *w;
+// 	    while ( (w=it.current()) ) {		// for all widgets...
+// 		++it;
+// 		if ( !w->testWFlags(WType_Desktop) &&	// except desktop
+// 		     w->testWState(WState_Polished) ) { // has been polished
+// 		    old->unPolish(w);
+// 		}
+// 	    }
+// 	}
+// 	old->unPolish( tqApp );
+    }
+
+    // take care of possible palette requirements of certain gui
+    // styles. Do it before polishing the application since the style
+    // might call TQApplication::setStyle() itself
+    if ( !qt_std_pal )
+	qt_create_std_palette();
+    TQPalette tmpPal = *qt_std_pal;
+    tqsetPalette( tmpPal, TRUE );
+
+    // initialize the application with the new style
+    app_style->polish( tqApp );
+
+    // re-polish existing widgets if necessary
+    if (old) {
+// 	if ( is_app_running && !is_app_closing ) {
+// 	    TQWidgetIntDictIt it( *((TQWidgetIntDict*)TQWidget::wmapper()) );
+// 	    register TQWidget *w;
+// 	    while ( (w=it.current()) ) {		// for all widgets...
+// 		++it;
+// 		if ( !w->testWFlags(WType_Desktop) ) {	// except desktop
+// 		    if ( w->testWState(WState_Polished) )
+// 			app_style->polish(w);		// repolish
+// 		    w->styleChange( *old );
+// 		    if ( w->isVisible() ){
+// 			w->update();
+// 		    }
+// 		}
+// 	    }
+// 	}
+	delete old;
+    }
+}
+
+/*!
+  \overload
+
+  Requests a TQStyle object for \a style from the TQStyleFactory.
+
+  The string must be one of the TQStyleFactory::keys(), typically one
+  of "windows", "motif", "cde", "motifplus", "platinum", "sgi" and
+  "compact". Depending on the platform, "windowsxp", "aqua" or
+  "macintosh" may be available.
+
+  A later call to the TQApplication constructor will override the
+  requested style when a "-style" option is passed in as a commandline
+  parameter.
+
+  Returns 0 if an unknown \a style is passed, otherwise the TQStyle object
+  returned is set as the application's GUI style.
+*/
+TQStyle* TQApplication::setStyle( const TQString& style )
+{
+#ifdef TQ_WS_X11
+    qt_explicit_app_style = TRUE;
+#endif // TQ_WS_X11
+
+    if ( startingUp() ) {
+	if(qt_style_override)
+	    *qt_style_override = style;
+	else
+	    qt_style_override = new TQString(style);
+	return 0;
+    }
+    TQStyle *s = TQStyleFactory::create( style );
+    if ( !s )
+	return 0;
+
+    setStyle( s );
+    return s;
+}
+
+TQWidget *TQApplication::mainWidget()
+{
+    return TQT_TQWIDGET(current_app_main_widget);
+}
+
+const char *TQApplication::tqname() const {
+	if (dynamic_cast<const TQApplication*>(static_cast<const QApplication*>(static_cast<const QObject*>(this)))) {
+		static_object_name = TQT_OBJECT_NAME_HANDLER(objectName());
+		return static_object_name.ascii();
+	}
+	else {
+		printf("[WARNING] Attempted to call TQApplication::tqname() on an object without a constructed TQApplication object or base object.  Returning \"\"\n\r");
+		return "";
+	}
+}
+
+const char *TQApplication::name() const {
+	if (dynamic_cast<const TQApplication*>(static_cast<const QApplication*>(static_cast<const QObject*>(this)))) {
+		static_object_name = TQT_OBJECT_NAME_HANDLER(objectName());
+		return static_object_name.ascii();
+	}
+	else {
+		printf("[WARNING] Attempted to call TQApplication::name() on an object without a constructed TQApplication object or base object.  Returning \"\"\n\r");
+		return "";
+	}
+}
+
+/*!\internal
+
+  Called from qapplication_<platform>.cpp, returns TRUE
+  if the widget should accept the event.
+ */
+TQ_EXPORT bool qt_tryModalHelper( TQWidget *widget, TQWidget **rettop ) {
+    TQWidget *modal=0, *top=TQT_TQWIDGET(TQApplication::activeModalWidget());
+    if ( rettop ) *rettop = top;
+
+    if ( tqApp->activePopupWidget() )
+	return TRUE;
+
+#ifdef TQ_WS_MACX
+    top = qt_tryModalHelperMac( top );
+    if ( rettop ) *rettop = top;
+#endif
+
+    TQWidget* groupLeader = widget;
+    widget = widget->tqtopLevelWidget();
+
+    if ( widget->testWFlags(TQt::WShowModal) )	// widget is modal
+	modal = widget;
+    if ( !top || modal == top )			// don't block event
+	return TRUE;
+
+    TQWidget * p = widget->parentWidget(); // Check if the active modal widget is a tqparent of our widget
+    while ( p ) {
+	if ( p == top )
+	    return TRUE;
+	p = p->parentWidget();
+    }
+
+    while ( groupLeader && !groupLeader->testWFlags( TQt::WGroupLeader ) )
+	groupLeader = groupLeader->parentWidget();
+
+// [FIXME]
+printf("[WARNING] bool qt_tryModalHelper partially implemented\n\r");
+//     if ( groupLeader ) {
+// 	// Does groupLeader have a child in qt_modal_stack?
+// 	bool unrelated = TRUE;
+// 	modal = qt_modal_stack->first();
+// 	while (modal && unrelated) {
+// 	    TQWidget* p = modal->parentWidget();
+// 	    while ( p && p != groupLeader && !p->testWFlags( TQt::WGroupLeader) ) {
+// 		p = p->parentWidget();
+// 	    }
+// 	    modal = qt_modal_stack->next();
+// 	    if ( p == groupLeader ) unrelated = FALSE;
+// 	}
+// 
+// 	if ( unrelated )
+// 	    return TRUE;		// don't block event
+//     }
+
+    return FALSE;
+}
+
+/*!\internal
+
+  Creates the proper Enter/Leave event when widget \a enter is entered
+  and widget \a leave is left.
+ */
+TQ_EXPORT void qt_dispatchEnterLeave( TQWidget* enter, TQWidget* leave ) {
+#if 0
+    if ( leave ) {
+	TQEvent e( TQEvent::Leave );
+	TQApplication::sendEvent( leave, & e );
+    }
+    if ( enter ) {
+	TQEvent e( TQEvent::Enter );
+	TQApplication::sendEvent( enter, & e );
+    }
+    return;
+#endif
+
+    TQWidget* w ;
+    if ( !enter && !leave )
+	return;
+    TQWidgetList leaveList;
+    TQWidgetList enterList;
+
+    bool sameWindow = leave && enter && leave->tqtopLevelWidget() == enter->tqtopLevelWidget();
+    if ( leave && !sameWindow ) {
+	w = leave;
+	do {
+	    leaveList.append( w );
+	} while ( (w = w->parentWidget( TRUE ) ) );
+    }
+    if ( enter && !sameWindow ) {
+	w = enter;
+	do {
+	    enterList.prepend( w );
+	} while ( (w = w->parentWidget(TRUE) ) );
+    }
+    if ( sameWindow ) {
+	int enterDepth = 0;
+	int leaveDepth = 0;
+	w = enter;
+	while ( ( w = w->parentWidget( TRUE ) ) )
+	    enterDepth++;
+	w = leave;
+	while ( ( w = w->parentWidget( TRUE ) ) )
+	    leaveDepth++;
+	TQWidget* wenter = enter;
+	TQWidget* wleave = leave;
+	while ( enterDepth > leaveDepth ) {
+	    wenter = wenter->parentWidget();
+	    enterDepth--;
+	}
+	while ( leaveDepth > enterDepth ) {
+	    wleave = wleave->parentWidget();
+	    leaveDepth--;
+	}
+	while ( !wenter->isTopLevel() && wenter != wleave ) {
+	    wenter = wenter->parentWidget();
+	    wleave = wleave->parentWidget();
+	}
+
+	w = leave;
+	while ( w != wleave ) {
+	    leaveList.append( w );
+	    w = w->parentWidget();
+	}
+	w = enter;
+	while ( w != wenter ) {
+	    enterList.prepend( w );
+	    w = w->parentWidget();
+	}
+    }
+
+    TQEvent leaveEvent( TQEvent::Leave );
+    for ( w = leaveList.first(); w; w = leaveList.next() ) {
+	if ( !tqApp->activeModalWidget() || qt_tryModalHelper( w, 0 ))
+	    TQApplication::sendEvent( w, &leaveEvent );
+    }
+    TQEvent enterEvent( TQEvent::Enter );
+    for ( w = enterList.first(); w; w = enterList.next() ) {
+	if ( !tqApp->activeModalWidget() || qt_tryModalHelper( w, 0 ))
+	    TQApplication::sendEvent( w, &enterEvent );
+    }
+}
+
+#ifndef TQT_NO_CLIPBOARD
+/*!
+  Returns a pointer to the application global clipboard.
+*/
+TQClipboard *TQApplication::tqclipboard()
+{
+    if ( tqt_clipboard == 0 ) {
+	tqt_clipboard = new TQClipboard;
+	TQ_CHECK_PTR( tqt_clipboard );
+    }
+    return tqt_clipboard;
+}
+#endif // TQT_NO_CLIPBOARD
+
+/*!
+  \fn void TQApplication::commitData( TQSessionManager& sm )
+
+  This function deals with \link session.html session
+  management\endlink. It is invoked when the TQSessionManager wants the
+  application to commit all its data.
+
+  Usually this means saving all open files, after getting
+  permission from the user. Furthermore you may want to provide a means
+  by which the user can cancel the shutdown.
+
+  Note that you should not exit the application within this function.
+  Instead, the session manager may or may not do this afterwards,
+  depending on the context.
+
+  \warning Within this function, no user interaction is possible, \e
+  unless you ask the session manager \a sm for explicit permission.
+  See TQSessionManager::allowsInteraction() and
+  TQSessionManager::allowsErrorInteraction() for details and example
+  usage.
+
+  The default implementation requests interaction and sends a close
+  event to all visible top level widgets. If any event was
+  rejected, the shutdown is canceled.
+
+  \sa isSessionRestored(), sessionId(), saveState(), \link session.html the Session Management overview\endlink
+*/
+#ifndef TQT_NO_SESSIONMANAGER
+void TQApplication::commitData( TQSessionManager& sm  )
+{
+
+    if ( sm.allowsInteraction() ) {
+	TQWidgetList done;
+	TQWidgetList *list = TQApplication::tqtopLevelWidgets();
+	bool cancelled = FALSE;
+	TQWidget* w = list->first();
+	while ( !cancelled && w ) {
+	    if ( !w->isHidden() ) {
+		TQCloseEvent e;
+		sendEvent( w, &e );
+		cancelled = !e.isAccepted();
+		if ( !cancelled )
+		    done.append( w );
+		delete list; // one never knows...
+		list = TQApplication::tqtopLevelWidgets();
+		w = list->first();
+	    } else {
+		w = list->next();
+	    }
+	    while ( w && done.tqcontainsRef( w ) )
+		w = list->next();
+	}
+	delete list;
+	if ( cancelled )
+	    sm.cancel();
+    }
+}
+
+
+/*!
+  \fn void TQApplication::saveState( TQSessionManager& sm )
+
+  This function deals with \link session.html session
+  management\endlink. It is invoked when the
+  \link TQSessionManager session manager \endlink wants the application
+  to preserve its state for a future session.
+
+  For example, a text editor would create a temporary file that
+  includes the current contents of its edit buffers, the location of
+  the cursor and other aspects of the current editing session.
+
+  Note that you should never exit the application within this
+  function. Instead, the session manager may or may not do this
+  afterwards, depending on the context. Futhermore, most session
+  managers will very likely request a saved state immediately after
+  the application has been started. This permits the session manager
+  to learn about the application's restart policy.
+
+  \warning Within this function, no user interaction is possible, \e
+  unless you ask the session manager \a sm for explicit permission.
+  See TQSessionManager::allowsInteraction() and
+  TQSessionManager::allowsErrorInteraction() for details.
+
+  \sa isSessionRestored(), sessionId(), commitData(), \link session.html the Session Management overview\endlink
+*/
+
+void TQApplication::saveState( TQSessionManager& /* sm */ )
+{
+}
+#endif //TQT_NO_SESSIONMANAGER
+
+#if 1  /* OBSOLETE */
+
+TQApplication::ColorMode TQApplication::colorMode()
+{
+	return (TQApplication::ColorMode)app_cspec;
+}
+
+void TQApplication::setColorMode( TQApplication::ColorMode mode )
+{
+	printf("[WARNING] TQApplication::setColorMode() does nothing!\n\r");
+	app_cspec = mode;
+}
+#endif
+
+/*!
+  Initialization of the appearance of the widget \a w \e before it is first
+  shown.
+
+  Usually widgets call this automatically when they are polished. It
+  may be used to do some style-based central customization of widgets.
+
+  Note that you are not limited to the public functions of TQWidget.
+  Instead, based on meta information like TQObject::className() you are
+  able to customize any kind of widget.
+
+  \sa TQStyle::polish(), TQWidget::polish(), setPalette(), setFont()
+*/
+
+void TQApplication::polish( QWidget *w )
+{
+#ifndef TQT_NO_STYLE
+    TQT_TQWIDGET(w)->tqstyle().polish( TQT_TQWIDGET(w) );
+#endif
+}
+
+void TQApplication::exit_loop() {			// Does not exit in Qt4
+	printf("[WARNING] No runtime validation is performed within TQApplication::exit_loop; this may cause odd/obscure problems\n\r");
+// 	QThreadData *data = QThreadData::current();
+// 	if (!data->eventLoops.isEmpty())
+// 		data->eventLoops.top()->exit();
+	QEventLoop* eventLoop = tqt_event_loop_stack.getLast();
+	if (eventLoop) {
+		eventLoop->exit();
+	}
+	else {
+		printf("[WARNING] An attempt was made to exit a nonexistant event loop!\n\r");
+	}
+}
+int TQApplication::enter_loop() {		// Does not exit in Qt4
+	printf("[WARNING] No runtime validation is performed within TQApplication::enter_loop; this may cause odd/obscure problems\n\r");
+	QEventLoop* eventLoop = new QEventLoop();
+	tqt_event_loop_stack.append(eventLoop);
+	int returnCode = eventLoop->exec();	// This blocks until either QEventLoop::exit is called or the loop terminates normally
+	tqt_event_loop_stack.remove(eventLoop);
+	delete eventLoop;
+	return returnCode;
+}
+
+TQMetaObject *TQApplication::tqmetaObject() const {
+	return TQT_TQOBJECT_CONST(this)->tqmetaObject();
+}
+
+void TQApplication::processOneEvent() {
+	processEvents(QEventLoop::WaitForMoreEvents);
+}
+
+void TQApplication::tqprocessEvents() {
+	return processEvents();
+}
+
+void TQApplication::tqprocessEvents( int maxtime ) {
+	return processEvents(QEventLoop::AllEvents, maxtime);
+}
+
+/*!
+    \obsolete
+
+    Returns the current loop level.
+
+    Use TQApplication::eventLoop()->loopLevel() instead.
+
+*/
+int TQApplication::loopLevel() const
+{
+	return eventLoop()->loopLevel();
+}
+
+bool TQApplication::hasGlobalMouseTracking()
+{
+	printf("[WARNING] TQApplication::hasGlobalMouseTracking unimplemented!\n\r");
+	return true;
+}
+
+void TQApplication::setGlobalMouseTracking( bool enable )
+{
+	printf("[WARNING] TQApplication::setGlobalMouseTracking unimplemented!\n\r");
+}
+
+#if defined(TQ_WS_X11)
+void TQApplication::create_xim() {
+	printf("[WARNING] static void TQApplication::create_xim() unimplemented\n\r");	// [FIXME]
+}
+
+void TQApplication::close_xim() {
+	printf("[WARNING] static void TQApplication::close_xim() unimplemented\n\r");	// [FIXME]
+}
+
+bool TQApplication::x11_apply_settings() {
+	printf("[WARNING] static bool TQApplication::x11_apply_settings() unimplemented\n\r");
+	return false;	// [FIXME]
+}
+#endif
+
+#ifndef TQT_NO_TEXTCODEC
+void TQApplication::setDefaultCodec( TQTextCodec * ) {
+	printf("[WARNING] void TQApplication::setDefaultCodec( TQTextCodec * ) unimplemented\n\r");	// [FIXME]
+}
+
+TQTextCodec* TQApplication::defaultCodec() const
+{
+// 	return TQTextCodec::codecForTr();
+
+	printf("[WARNING] TQTextCodec* TQApplication::defaultCodec unimplemented\n\r");	// [FIXME]
+// 	return TQTextCodec();
+}
+#endif
+
+TQWidgetList *TQApplication::tqallWidgets() {
+	QWidgetList ql = allWidgets();
+	tqt_all_widgets_list.clear();
+	for (int i = 0; i < ql.size(); ++i) tqt_all_widgets_list.append(TQT_TQWIDGET(ql.at(i)));
+	return &tqt_all_widgets_list;
+}
+
+TQStringList TQApplication::libraryPaths() {
+	return TQT_TQSTRINGLIST_OBJECT(QApplication::libraryPaths());
+}
+
+void TQApplication::tqsetLibraryPaths( const QStringList &qsl ) {
+	setLibraryPaths(qsl);
+}
+
+TQWidgetList *TQApplication::tqtopLevelWidgets() {
+	// The end user of the list is expected to delete it, so create it with new...
+	TQWidgetList *tqwl = new TQWidgetList();
+	foreach (QWidget *widget, QApplication::topLevelWidgets()) {
+		tqwl->append(static_cast<TQWidget*>(widget));
+	}
+	return tqwl;
+	
+}
+
+TQDesktopWidget *TQApplication::desktop() {
+	return static_cast<TQDesktopWidget*>(QApplication::desktop());
+}
+
+const QColor &TQApplication::winStyleHighlightColor() {
+	return palette().color(QPalette::Active, QPalette::Highlight);
+}
+
+void TQApplication::setWinStyleHighlightColor( const QColor c ) {
+	TQPalette p( tqpalette() );
+	p.setColor( TQColorGroup::Highlight, c );
+	tqsetPalette( p, TRUE);
+}
+
+void TQApplication::tqsetPalette(const QPalette &pal, bool, const char* className) {
+	setPalette(pal, className);
+}
+
+void TQApplication::tqsetFont(const QFont &font, bool, const char* className) {
+	setFont(font, className);
+}
+
+void TQApplication::setReverseLayout(bool b) {
+	setLayoutDirection(b?Qt::RightToLeft:Qt::LeftToRight);
+}
+
+bool TQApplication::reverseLayout() {
+	return layoutDirection() == Qt::RightToLeft;
+}
+
+TQPalette TQApplication::tqpalette( const TQWidget* w ) {
+	return palette( w );
+}
+
+#ifndef TQT_NO_CURSOR
+//void TQApplication::setOverrideCursor( const QCursor &cur, bool tqreplace=FALSE ) {
+// 	TQ_UNUSED(tqreplace);
+// 	QApplication::setOverrideCursor( cur );
+// }
+
+void TQApplication::setOverrideCursor( const QCursor &cur, bool tqreplace ) {
+	TQ_UNUSED(tqreplace);
+	printf("[FIXME] TQApplication::setOverrideCursor( const QCursor &cur, bool tqreplace=FALSE ) unimplemented\n\r");
+}
+#endif
+
+void TQApplication::sendPostedEvents( QObject *receiver, int event_type ) {
+	QApplication::sendPostedEvents(receiver, event_type);
+	if (event_type == TQEvent::LayoutHint) {
+		QApplication::sendPostedEvents(receiver, TQEvent::LayoutRequest);;		// This one eats LayoutRequest/LayoutHint events for breakfast
+	}
+}
+
+void TQApplication::sendPostedEvents() {
+	QApplication::sendPostedEvents();
+}
+
+TQWidget *TQApplication::tqfocusWidget() const {
+	return static_cast<TQWidget*>(focusWidget());
+}
+
+TQWidget *TQApplication::widgetAt( const TQPoint &p, bool child ) {
+	TQ_UNUSED(child);
+	return static_cast<TQWidget*>(QApplication::widgetAt( p ));
+}
+
+TQWidget *TQApplication::widgetAt( int x, int y, bool child ) {
+	TQ_UNUSED(child);
+	return static_cast<TQWidget*>(QApplication::widgetAt( QPoint(x, y) ));
+}
+
+int TQApplication::horizontalAlignment( int align ) {
+	return QStyle::visualAlignment(layoutDirection(), (Qt::Alignment)align);
+}
+
+void TQApplication::flushX() {
+	flush();
+}
+
+const char *TQApplication::name(const char *defaultName) const {
+	TQString s = objectName();
+	return s.isEmpty()?defaultName:s.latin1();
+}
+
+void TQApplication::setName(const char *aName) {
+	TQT_TQOBJECT(this)->setName(aName);
+}
+
+/*!
+    Displays a simple message box about TQt. The message includes the
+    version number of TQt being used by the application.
+
+    This is useful for inclusion in the Help menu of an application.
+    See the examples/menu/menu.cpp example.
+
+    This function is a convenience slot for TQMessageBox::aboutTQt().
+*/
+void TQApplication::aboutTQt()
+{
+#ifndef TQT_NO_MESSAGEBOX
+	TQMessageBox::aboutTQt( mainWidget() );
+#endif // TQT_NO_MESSAGEBOX
+}
+
+#else // USE_QT4
+
+/*!
+  \class TQApplication tqapplication.h
+  \brief The TQApplication class manages the GUI application's control
+  flow and main settings.
+
+  \ingroup application
+  \mainclass
+
+  It tqcontains the main event loop, where all events from the window
+  system and other sources are processed and dispatched. It also
+  handles the application's initialization and finalization, and
+  provides session management. It also handles most system-wide and
+  application-wide settings.
+
+  For any GUI application that uses TQt, there is precisely one
+  TQApplication object, no matter whether the application has 0, 1, 2
+  or more windows at any time.
+
+  The TQApplication object is accessible through the global pointer \c
+  tqApp. Its main areas of responsibility are:
+  \list
+
+  \i It initializes the application with the user's desktop settings
+  such as palette(), font() and doubleClickInterval(). It keeps track
+  of these properties in case the user changes the desktop globally, for
+  example through some kind of control panel.
+
+  \i It performs event handling, meaning that it receives events
+  from the underlying window system and dispatches them to the relevant
+  widgets. By using sendEvent() and postEvent() you can send your own
+  events to widgets.
+
+  \i It parses common command line arguments and sets its internal
+  state accordingly. See the \link TQApplication::TQApplication()
+  constructor documentation\endlink below for more details about this.
+
+  \i It defines the application's look and feel, which is
+  encapsulated in a TQStyle object. This can be changed at runtime
+  with setStyle().
+
+  \i It specifies how the application is to allocate colors.
+  See setColorSpec() for details.
+
+  \i It provides localization of strings that are visible to the user
+  via translate().
+
+  \i It provides some magical objects like the desktop() and the
+  clipboard().
+
+  \i It knows about the application's windows. You can ask which
+  widget is at a certain position using widgetAt(), get a list of
+  tqtopLevelWidgets() and closeAllWindows(), etc.
+
+  \i It manages the application's mouse cursor handling,
+  see setOverrideCursor() and setGlobalMouseTracking().
+
+  \i On the X window system, it provides functions to flush and sync
+  the communication stream, see flushX() and syncX().
+
+  \i It provides support for sophisticated \link
+  session.html session management \endlink. This makes it possible
+  for applications to terminate gracefully when the user logs out, to
+  cancel a shutdown process if termination isn't possible and even to
+  preserve the entire application's state for a future session. See
+  isSessionRestored(), sessionId() and commitData() and saveState()
+  for details.
+
+  \endlist
+
+  The <a href="simple-application.html">Application walk-through
+  example</a> tqcontains a typical complete main() that does the usual
+  things with TQApplication.
+
+  Since the TQApplication object does so much initialization, it
+  <b>must</b> be created before any other objects related to the user
+  interface are created.
+
+  Since it also deals with common command line arguments, it is
+  usually a good idea to create it \e before any interpretation or
+  modification of \c argv is done in the application itself. (Note
+  also that for X11, setMainWidget() may change the main widget
+  according to the \c -tqgeometry option. To preserve this
+  functionality, you must set your defaults before setMainWidget() and
+  any overrides after.)
+
+  \table
+    \header \i21 Groups of functions
+    \row
+     \i System settings
+     \i
+	desktopSettingsAware(),
+	setDesktopSettingsAware(),
+	cursorFlashTime(),
+	setCursorFlashTime(),
+	doubleClickInterval(),
+	setDoubleClickInterval(),
+	wheelScrollLines(),
+	setWheelScrollLines(),
+	palette(),
+	setPalette(),
+	font(),
+	setFont(),
+	fontMetrics().
+
+    \row
+     \i Event handling
+     \i
+	exec(),
+	processEvents(),
+	enter_loop(),
+	exit_loop(),
+	exit(),
+	quit().
+	sendEvent(),
+	postEvent(),
+	sendPostedEvents(),
+	removePostedEvents(),
+	hasPendingEvents(),
+	notify(),
+	macEventFilter(),
+	qwsEventFilter(),
+	x11EventFilter(),
+	x11ProcessEvent(),
+	winEventFilter().
+
+    \row
+     \i GUI Styles
+     \i
+	style(),
+	setStyle(),
+	polish().
+
+    \row
+     \i Color usage
+     \i
+	colorSpec(),
+	setColorSpec(),
+	qwsSetCustomColors().
+
+    \row
+     \i Text handling
+     \i
+	installTranslator(),
+	removeTranslator()
+	translate().
+
+    \row
+     \i Widgets
+     \i
+	mainWidget(),
+	setMainWidget(),
+	allWidgets(),
+	tqtopLevelWidgets(),
+	desktop(),
+	activePopupWidget(),
+	activeModalWidget(),
+	clipboard(),
+	tqfocusWidget(),
+	winFocus(),
+	activeWindow(),
+	widgetAt().
+
+    \row
+     \i Advanced cursor handling
+     \i
+	hasGlobalMouseTracking(),
+	setGlobalMouseTracking(),
+	overrideCursor(),
+	setOverrideCursor(),
+	restoreOverrideCursor().
+
+    \row
+     \i X Window System synchronization
+     \i
+	flushX(),
+	syncX().
+
+    \row
+     \i Session management
+     \i
+	isSessionRestored(),
+	sessionId(),
+	commitData(),
+	saveState().
+
+    \row
+    \i Threading
+    \i
+	lock(), unlock(), locked(), tryLock(),
+	wakeUpGuiThread()
+
+    \row
+     \i Miscellaneous
+     \i
+	closeAllWindows(),
+	startingUp(),
+	closingDown(),
+	type().
+  \endtable
+
+  \e {Non-GUI programs:} While TQt is not optimized or
+  designed for writing non-GUI programs, it's possible to use
+  \link tools.html some of its classes \endlink without creating a
+  TQApplication. This can be useful if you wish to share code between
+  a non-GUI server and a GUI client.
+
+  \headerfile tqnamespace.h
+  \headerfile tqwindowdefs.h
+  \headerfile tqglobal.h
+*/
+
+/*! \enum TQt::HANDLE
+    \internal
+*/
+
+/*!
+    \enum TQApplication::Type
+
+    \value Tty a console application
+    \value GuiClient a GUI client application
+    \value GuiServer a GUI server application
+*/
+
+/*!
+    \enum TQApplication::ColorSpec
+
+    \value NormalColor the default color allocation policy
+    \value CustomColor the same as NormalColor for X11; allocates colors
+    to a palette on demand under Windows
+    \value ManyColor the right choice for applications that use thousands of
+    colors
+
+    See setColorSpec() for full details.
+*/
+
+/*
+  The qt_init() and qt_cleanup() functions are implemented in the
+  qapplication_xyz.cpp file.
+*/
+
+void qt_init( int *, char **, TQApplication::Type );
+void qt_cleanup();
+#if defined(TQ_WS_X11)
+void qt_init( Display* dpy, TQt::HANDLE, TQt::HANDLE );
+#endif
+TQ_EXPORT bool qt_tryModalHelper( TQWidget *widget, TQWidget **rettop );
+
+TQApplication *tqApp = 0;			// global application object
+
+TQStyle   *TQApplication::app_style      = 0;	// default application style
+bool      qt_explicit_app_style	       = FALSE; // style explicitly set by programmer
+
+int	  TQApplication::app_cspec      = TQApplication::NormalColor;
+#ifndef TQT_NO_PALETTE
+TQPalette *TQApplication::app_pal	       = 0;	// default application palette
+#endif
+TQFont	 *TQApplication::app_font       = 0;	// default application font
+bool	  qt_app_has_font	       = FALSE;
+#ifndef TQT_NO_CURSOR
+TQCursor	 *TQApplication::app_cursor     = 0;	// default application cursor
+#endif
+int	  TQApplication::app_tracking   = 0;	// global mouse tracking
+bool	  TQApplication::is_app_running = FALSE;	// app starting up if FALSE
+bool	  TQApplication::is_app_closing = FALSE;	// app closing down if TRUE
+int	  TQApplication::loop_level     = 0;	// event loop level
+TQWidget	 *TQApplication::main_widget    = 0;	// main application widget
+TQWidget	 *TQApplication::focus_widget   = 0;	// has keyboard input focus
+TQWidget	 *TQApplication::active_window  = 0;	// toplevel with keyboard focus
+bool	  TQApplication::obey_desktop_settings = TRUE;	// use winsys resources
+int	  TQApplication::cursor_flash_time = 1000;	// text caret flash time
+int	  TQApplication::mouse_double_click_time = 400;	// mouse dbl click limit
+#ifndef TQT_NO_WHEELEVENT
+int	  TQApplication::wheel_scroll_lines = 3;		// number of lines to scroll
+#endif
+bool	  qt_is_gui_used;
+bool      TQ_EXPORT qt_resolve_symlinks = TRUE;
+bool      TQ_EXPORT qt_tab_all_widgets  = TRUE;
+TQRect qt_maxWindowRect;
+static int drag_time = 500;
+static int drag_distance = 4;
+static bool reverse_tqlayout = FALSE;
+TQSize     TQApplication::app_strut	= TQSize( 0,0 ); // no default application strut
+bool	  TQApplication::animate_ui	= TRUE;
+bool	  TQApplication::animate_menu	= FALSE;
+bool	  TQApplication::fade_menu	= FALSE;
+bool	  TQApplication::animate_combo	= FALSE;
+bool	  TQApplication::animate_tooltip	= FALSE;
+bool	  TQApplication::fade_tooltip	= FALSE;
+bool	  TQApplication::animate_toolbox	= FALSE;
+bool	  TQApplication::widgetCount	= FALSE;
+TQApplication::Type qt_appType=TQApplication::Tty;
+#ifndef TQT_NO_COMPONENT
+TQStringList *TQApplication::app_libpaths = 0;
+#endif
+bool	  TQApplication::metaComposeUnicode = FALSE;
+int	  TQApplication::composedUnicode   = 0;
+
+#ifdef TQT_THREAD_SUPPORT
+TQMutex *TQApplication::qt_mutex		= 0;
+static TQMutex *postevent_mutex		= 0;
+static TQt::HANDLE qt_application_thread_id = 0;
+TQ_EXPORT TQt::HANDLE qt_get_application_thread_id()
+{
+    return qt_application_thread_id;
+}
+#endif // TQT_THREAD_SUPPORT
+
+TQEventLoop *TQApplication::eventloop = 0;	// application event loop
+
+#ifndef TQT_NO_ACCEL
+extern bool qt_dispatchAccelEvent( TQWidget*, TQKeyEvent* ); // def in qaccel.cpp
+extern bool qt_tryComposeUnicode( TQWidget*, TQKeyEvent* ); // def in qaccel.cpp
+#endif
+
+#if defined(TQT_TABLET_SUPPORT)
+bool chokeMouse = FALSE;
+#endif
+
+void qt_setMaxWindowRect(const TQRect& r)
+{
+    qt_maxWindowRect = r;
+    // Re-resize any maximized windows
+    TQWidgetList* l = TQApplication::tqtopLevelWidgets();
+    if ( l ) {
+	TQWidget *w = l->first();
+	while ( w ) {
+	    if ( w->isVisible() && w->isMaximized() )
+	    {
+		w->showNormal(); //#### flicker
+		w->showMaximized();
+	    }
+	    w = l->next();
+	}
+	delete l;
+    }
+}
+
+typedef void (*VFPTR)();
+typedef TQValueList<VFPTR> TQVFuncList;
+static TQVFuncList *postRList = 0;		// list of post routines
+
+/*!
+  \relates TQApplication
+
+  Adds a global routine that will be called from the TQApplication
+  destructor. This function is normally used to add cleanup routines
+  for program-wide functionality.
+
+  The function given by \a p should take no arguments and return
+  nothing, like this:
+  \code
+    static int *global_ptr = 0;
+
+    static void cleanup_ptr()
+    {
+	delete [] global_ptr;
+	global_ptr = 0;
+    }
+
+    void init_ptr()
+    {
+	global_ptr = new int[100];	// allocate data
+	qAddPostRoutine( cleanup_ptr );	// delete later
+    }
+  \endcode
+
+  Note that for an application- or module-wide cleanup,
+  qAddPostRoutine() is often not suitable. People have a tendency to
+  make such modules dynamically loaded, and then unload those modules
+  long before the TQApplication destructor is called, for example.
+
+  For modules and libraries, using a reference-counted initialization
+  manager or TQt' tqparent-child delete mechanism may be better. Here is
+  an example of a private class which uses the tqparent-child mechanism
+  to call a cleanup function at the right time:
+
+  \code
+    class MyPrivateInitStuff: public TQObject {
+    private:
+	MyPrivateInitStuff( TQObject * tqparent ): TQObject( tqparent) {
+	    // initialization goes here
+	}
+	MyPrivateInitStuff * p;
+
+    public:
+	static MyPrivateInitStuff * initStuff( TQObject * tqparent ) {
+	    if ( !p )
+		p = new MyPrivateInitStuff( tqparent );
+	    return p;
+	}
+
+	~MyPrivateInitStuff() {
+	    // cleanup (the "post routine") goes here
+	}
+    }
+  \endcode
+
+  By selecting the right tqparent widget/object, this can often be made
+  to clean up the module's data at the exact right moment.
+*/
+
+TQ_EXPORT void qAddPostRoutine( TQtCleanUpFunction p)
+{
+    if ( !postRList ) {
+	postRList = new TQVFuncList;
+	TQ_CHECK_PTR( postRList );
+    }
+    postRList->prepend( p );
+}
+
+
+TQ_EXPORT void qRemovePostRoutine( TQtCleanUpFunction p )
+{
+    if ( !postRList ) return;
+    TQVFuncList::Iterator it = postRList->begin();
+    while ( it != postRList->end() ) {
+	if ( *it == p ) {
+	    postRList->remove( it );
+	    it = postRList->begin();
+	} else {
+	    ++it;
+	}
+    }
+}
+
+// Default application palettes and fonts (per widget type)
+TQAsciiDict<TQPalette> *TQApplication::app_palettes = 0;
+TQAsciiDict<TQFont>    *TQApplication::app_fonts = 0;
+
+#ifndef TQT_NO_SESSIONMANAGER
+TQString *TQApplication::session_key = 0;		// ## session key. Should be a member in 4.0
+#endif
+TQWidgetList *TQApplication::popupWidgets = 0;	// has keyboard input focus
+
+TQDesktopWidget *qt_desktopWidget = 0;		// root window widgets
+#ifndef TQT_NO_CLIPBOARD
+TQClipboard	      *qt_clipboard = 0;	// global clipboard object
+#endif
+TQWidgetList * qt_modal_stack=0;		// stack of modal widgets
+
+// Definitions for posted events
+struct TQPostEvent {
+    TQPostEvent( TQObject *r, TQEvent *e ): receiver( r ), event( e ) {}
+   ~TQPostEvent()			{ delete event; }
+    TQObject  *receiver;
+    TQEvent   *event;
+};
+
+class TQ_EXPORT TQPostEventList : public TQPtrList<TQPostEvent>
+{
+public:
+    TQPostEventList() : TQPtrList<TQPostEvent>() {}
+    TQPostEventList( const TQPostEventList &list ) : TQPtrList<TQPostEvent>(list) {}
+   ~TQPostEventList() { clear(); }
+    TQPostEventList &operator=(const TQPostEventList &list)
+	{ return (TQPostEventList&)TQPtrList<TQPostEvent>::operator=(list); }
+};
+class TQ_EXPORT TQPostEventListIt : public TQPtrListIterator<TQPostEvent>
+{
+public:
+    TQPostEventListIt( const TQPostEventList &l ) : TQPtrListIterator<TQPostEvent>(l) {}
+    TQPostEventListIt &operator=(const TQPostEventListIt &i)
+{ return (TQPostEventListIt&)TQPtrListIterator<TQPostEvent>::operator=(i); }
+};
+
+static TQPostEventList *globalPostedEvents = 0;	// list of posted events
+
+uint qGlobalPostedEventsCount()
+{
+    if (!globalPostedEvents)
+	return 0;
+    return globalPostedEvents->count();
+}
+
+static TQSingleCleanupHandler<TQPostEventList> qapp_cleanup_events;
+
+#ifndef TQT_NO_PALETTE
+TQPalette *qt_std_pal = 0;
+
+void qt_create_std_palette()
+{
+    if ( qt_std_pal )
+	delete qt_std_pal;
+
+    TQColor standardLightGray( 192, 192, 192 );
+    TQColor light( 255, 255, 255 );
+    TQColor dark( standardLightGray.dark( 150 ) );
+    TQColorGroup std_act( TQt::black, standardLightGray,
+			 light, dark, TQt::gray,
+			 TQt::black, TQt::white );
+    TQColorGroup std_dis( TQt::darkGray, standardLightGray,
+			 light, dark, TQt::gray,
+			 TQt::darkGray, std_act.background() );
+    TQColorGroup std_inact( TQt::black, standardLightGray,
+			   light, dark, TQt::gray,
+			   TQt::black, TQt::white );
+    qt_std_pal = new TQPalette( std_act, std_dis, std_inact );
+}
+
+static void qt_fix_tooltips()
+{
+    // No resources for this yet (unlike on Windows).
+    TQColorGroup cg( TQt::black, TQColor(255,255,220),
+		    TQColor(96,96,96), TQt::black, TQt::black,
+		    TQt::black, TQColor(255,255,220) );
+    TQPalette pal( cg, cg, cg );
+    TQApplication::setPalette( pal, TRUE, "TQTipLabel");
+}
+#endif
+
+void TQApplication::process_cmdline( int* argcptr, char ** argv )
+{
+    // process platform-indep command line
+    if ( !qt_is_gui_used || !*argcptr)
+	return;
+
+    int argc = *argcptr;
+    int i, j;
+
+    j = 1;
+    for ( i=1; i<argc; i++ ) {
+	if ( argv[i] && *argv[i] != '-' ) {
+	    argv[j++] = argv[i];
+	    continue;
+	}
+	TQCString arg = argv[i];
+	TQCString s;
+	if ( arg == "-qdevel" || arg == "-qdebug") {
+	    // obsolete argument
+	} else if ( arg.tqfind( "-style=", 0, FALSE ) != -1 ) {
+	    s = arg.right( arg.length() - 7 );
+	} else if ( qstrcmp(arg,"-style") == 0 && i < argc-1 ) {
+	    s = argv[++i];
+	    s = s.lower();
+#ifndef TQT_NO_SESSIONMANAGER
+	} else if ( qstrcmp(arg,"-session") == 0 && i < argc-1 ) {
+	    TQCString s = argv[++i];
+	    if ( !s.isEmpty() ) {
+		session_id = TQString::tqfromLatin1( s );
+		int p = session_id.tqfind( '_' );
+		if ( p >= 0 ) {
+		    if ( !session_key )
+			session_key = new TQString;
+		    *session_key = session_id.mid( p +1 );
+		    session_id = session_id.left( p );
+		}
+		is_session_restored = TRUE;
+	    }
+#endif
+	} else if ( qstrcmp(arg, "-reverse") == 0 ) {
+	    setReverseLayout( TRUE );
+	} else if ( qstrcmp(arg, "-widgetcount") == 0 ) {
+	    widgetCount = TRUE;;
+	} else {
+	    argv[j++] = argv[i];
+	}
+#ifndef TQT_NO_STYLE
+	if ( !s.isEmpty() ) {
+	    setStyle( s );
+	}
+#endif
+    }
+
+    if(j < argc) {
+#ifdef TQ_WS_MACX
+	static char* empty = "\0";
+	argv[j] = empty;
+#else
+	argv[j] = 0;
+#endif
+	*argcptr = j;
+    }
+}
+
+/*!
+  Initializes the window system and constructs an application object
+  with \a argc command line arguments in \a argv.
+
+  The global \c tqApp pointer refers to this application object. Only
+  one application object should be created.
+
+  This application object must be constructed before any \link
+  TQPaintDevice paint tqdevices\endlink (including widgets, pixmaps, bitmaps
+  etc.).
+
+  Note that \a argc and \a argv might be changed. TQt removes command
+  line arguments that it recognizes. The modified \a argc and \a argv
+  can also be accessed later with \c tqApp->argc() and \c tqApp->argv().
+  The documentation for argv() tqcontains a detailed description of how
+  to process command line arguments.
+
+  TQt debugging options (not available if TQt was compiled with the
+  TQT_NO_DEBUG flag defined):
+  \list
+  \i -nograb, tells TQt that it must never grab the mouse or the keyboard.
+  \i -dograb (only under X11), running under a debugger can cause
+  an implicit -nograb, use -dograb to override.
+  \i -sync (only under X11), switches to synchronous mode for
+	debugging.
+  \endlist
+
+  See \link debug.html Debugging Techniques \endlink for a more
+  detailed explanation.
+
+  All TQt programs automatically support the following command line options:
+  \list
+  \i -reverse causes text to be formatted for right-to-left languages
+       rather than in the usual left-to-right direction.
+  \i -style= \e style, sets the application GUI style. Possible values
+       are \c motif, \c windows, and \c platinum. If you compiled TQt
+       with additional styles or have additional styles as plugins these
+       will be available to the \c -style command line option.
+  \i -style \e style, is the same as listed above.
+  \i -session= \e session, restores the application from an earlier
+       \link session.html session \endlink.
+  \i -session \e session, is the same as listed above.
+  \i -widgetcount, prints debug message at the end about number of widgets left
+       undestroyed and maximum number of widgets existed at the same time
+  \endlist
+
+  The X11 version of TQt also supports some traditional X11
+  command line options:
+  \list
+  \i -display \e display, sets the X display (default is $DISPLAY).
+  \i -tqgeometry \e tqgeometry, sets the client tqgeometry of the
+	\link setMainWidget() main widget\endlink.
+  \i -fn or \c -font \e font, defines the application font. The
+  font should be specified using an X logical font description.
+  \i -bg or \c -background \e color, sets the default background color
+	and an application palette (light and dark shades are calculated).
+  \i -fg or \c -foreground \e color, sets the default foreground color.
+  \i -btn or \c -button \e color, sets the default button color.
+  \i -name \e name, sets the application name.
+  \i -title \e title, sets the application title (caption).
+  \i -visual \c TrueColor, forces the application to use a TrueColor visual
+       on an 8-bit display.
+  \i -ncols \e count, limits the number of colors allocated in the
+       color cube on an 8-bit display, if the application is using the
+       \c TQApplication::ManyColor color specification. If \e count is
+       216 then a 6x6x6 color cube is used (i.e. 6 levels of red, 6 of green,
+       and 6 of blue); for other values, a cube
+       approximately proportional to a 2x3x1 cube is used.
+  \i -cmap, causes the application to install a private color map
+       on an 8-bit display.
+  \endlist
+
+  \sa argc(), argv()
+*/
+
+//######### BINARY COMPATIBILITY constructor
+TQApplication::TQApplication( int &argc, char **argv )
+{
+    construct( argc, argv, GuiClient );
+}
+
+
+/*!
+  Constructs an application object with \a argc command line arguments
+  in \a argv. If \a GUIenabled is TRUE, a GUI application is
+  constructed, otherwise a non-GUI (console) application is created.
+
+  Set \a GUIenabled to FALSE for programs without a graphical user
+  interface that should be able to run without a window system.
+
+  On X11, the window system is initialized if \a GUIenabled is TRUE.
+  If \a GUIenabled is FALSE, the application does not connect to the
+  X-server.
+  On Windows and Macintosh, currently the window system is always
+  initialized, regardless of the value of GUIenabled. This may change in
+  future versions of TQt.
+
+  The following example shows how to create an application that
+  uses a graphical interface when available.
+  \code
+  int main( int argc, char **argv )
+  {
+#ifdef TQ_WS_X11
+    bool useGUI = getenv( "DISPLAY" ) != 0;
+#else
+    bool useGUI = TRUE;
+#endif
+    TQApplication app(argc, argv, useGUI);
+
+    if ( useGUI ) {
+       //start GUI version
+       ...
+    } else {
+       //start non-GUI version
+       ...
+    }
+    return app.exec();
+  }
+\endcode
+*/
+
+TQApplication::TQApplication( int &argc, char **argv, bool GUIenabled  )
+{
+    construct( argc, argv, GUIenabled ? GuiClient : Tty );
+}
+
+/*!
+  Constructs an application object with \a argc command line arguments
+  in \a argv.
+
+  For TQt/Embedded, passing \c TQApplication::GuiServer for \a type
+  makes this application the server (equivalent to running with the
+  -qws option).
+*/
+TQApplication::TQApplication( int &argc, char **argv, Type type )
+{
+    construct( argc, argv, type );
+}
+
+TQ_EXPORT void qt_ucm_initialize( TQApplication *theApp )
+{
+    if ( tqApp )
+	return;
+    int argc = theApp->argc();
+    char **argv = theApp->argv();
+    theApp->construct( argc, argv, tqApp->type() );
+
+    TQ_ASSERT( tqApp == theApp );
+}
+
+void TQApplication::construct( int &argc, char **argv, Type type )
+{
+    qt_appType = type;
+    qt_is_gui_used = (type != Tty);
+    init_precmdline();
+    static const char *empty = "";
+    if ( argc == 0 || argv == 0 ) {
+	argc = 0;
+	argv = (char **)&empty; // ouch! careful with TQApplication::argv()!
+    }
+    app_argc = argc;
+    app_argv = argv;
+
+    qt_init( &argc, argv, type );   // Must be called before initialize()
+    process_cmdline( &argc, argv );
+    initialize( argc, argv );
+    if ( qt_is_gui_used )
+	qt_maxWindowRect = desktop()->rect();
+    if ( eventloop )
+	eventloop->appStartingUp();
+}
+
+/*!
+    Returns the type of application, Tty, GuiClient or GuiServer.
+*/
+
+TQApplication::Type TQApplication::type() const
+{
+    return qt_appType;
+}
+
+#if defined(TQ_WS_X11)
+/*!
+  Create an application, given an already open display \a dpy. If \a
+  visual and \a colormap are non-zero, the application will use those as
+  the default Visual and Colormap contexts.
+
+  \warning TQt only supports TrueColor visuals at depths higher than 8
+  bits-per-pixel.
+
+  This is available only on X11.
+*/
+
+TQApplication::TQApplication( Display* dpy, HANDLE visual, HANDLE colormap )
+{
+    static int aargc = 1;
+    // ### a string literal is a cont char*
+    // ### using it as a char* is wrong and could lead to segfaults
+    // ### if aargv is modified someday
+    static char *aargv[] = { (char*)"unknown", 0 };
+
+    app_argc = aargc;
+    app_argv = aargv;
+
+    qt_appType = GuiClient;
+    qt_is_gui_used = TRUE;
+    qt_appType = GuiClient;
+    init_precmdline();
+    // ... no command line.
+
+    if ( ! dpy ) {
+#ifdef TQT_CHECK_STATE
+	qWarning( "TQApplication: invalid Display* argument." );
+#endif // TQT_CHECK_STATE
+
+	qt_init( &aargc, aargv, GuiClient );
+    } else {
+	qt_init( dpy, visual, colormap );
+    }
+
+    initialize( aargc, aargv );
+
+    if ( qt_is_gui_used )
+	qt_maxWindowRect = desktop()->rect();
+    if ( eventloop )
+	eventloop->appStartingUp();
+}
+
+/*!
+  Create an application, given an already open display \a dpy and using
+  \a argc command line arguments in \a argv. If \a
+  visual and \a colormap are non-zero, the application will use those as
+  the default Visual and Colormap contexts.
+
+  \warning TQt only supports TrueColor visuals at depths higher than 8
+  bits-per-pixel.
+
+  This is available only on X11.
+
+*/
+TQApplication::TQApplication(Display *dpy, int argc, char **argv,
+			   HANDLE visual, HANDLE colormap)
+{
+    qt_appType = GuiClient;
+    qt_is_gui_used = TRUE;
+    qt_appType = GuiClient;
+    init_precmdline();
+
+    app_argc = argc;
+    app_argv = argv;
+
+    if ( ! dpy ) {
+#ifdef TQT_CHECK_STATE
+	qWarning( "TQApplication: invalid Display* argument." );
+#endif // TQT_CHECK_STATE
+
+	qt_init( &argc, argv, GuiClient );
+    } else {
+	qt_init(dpy, visual, colormap);
+    }
+
+    process_cmdline( &argc, argv );
+    initialize(argc, argv);
+
+    if ( qt_is_gui_used )
+	qt_maxWindowRect = desktop()->rect();
+    if ( eventloop )
+	eventloop->appStartingUp();
+}
+
+
+#endif // TQ_WS_X11
+
+
+void TQApplication::init_precmdline()
+{
+    translators = 0;
+    is_app_closing = FALSE;
+#ifndef TQT_NO_SESSIONMANAGER
+    is_session_restored = FALSE;
+#endif
+#if defined(TQT_CHECK_STATE)
+    if ( tqApp )
+	qWarning( "TQApplication: There should be max one application object" );
+#endif
+    tqApp = (TQApplication*)this;
+}
+
+/*!
+  Initializes the TQApplication object, called from the constructors.
+*/
+
+void TQApplication::initialize( int argc, char **argv )
+{
+#ifdef TQT_THREAD_SUPPORT
+    qt_mutex = new TQMutex( TRUE );
+    postevent_mutex = new TQMutex( TRUE );
+    qt_application_thread_id = TQThread::currentThread();
+#endif // TQT_THREAD_SUPPORT
+
+    app_argc = argc;
+    app_argv = argv;
+    quit_now = FALSE;
+    quit_code = 0;
+    TQWidget::createMapper(); // create widget mapper
+#ifndef TQT_NO_PALETTE
+    (void) palette();  // trigger creation of application palette
+#endif
+    is_app_running = TRUE; // no longer starting up
+
+#ifndef TQT_NO_SESSIONMANAGER
+    // connect to the session manager
+    if ( !session_key )
+	session_key = new TQString;
+    session_manager = new TQSessionManager( tqApp, session_id, *session_key );
+#endif
+
+}
+
+
+/*****************************************************************************
+  Functions returning the active popup and modal widgets.
+ *****************************************************************************/
+
+/*!
+  Returns the active popup widget.
+
+  A popup widget is a special top level widget that sets the \c
+  WType_Popup widget flag, e.g. the TQPopupMenu widget. When the
+  application opens a popup widget, all events are sent to the popup.
+  Normal widgets and modal widgets cannot be accessed before the popup
+  widget is closed.
+
+  Only other popup widgets may be opened when a popup widget is shown.
+  The popup widgets are organized in a stack. This function returns
+  the active popup widget at the top of the stack.
+
+  \sa activeModalWidget(), tqtopLevelWidgets()
+*/
+
+TQWidget *TQApplication::activePopupWidget()
+{
+    return popupWidgets ? popupWidgets->getLast() : 0;
+}
+
+
+/*!
+  Returns the active modal widget.
+
+  A modal widget is a special top level widget which is a subclass of
+  TQDialog that specifies the modal parameter of the constructor as
+  TRUE. A modal widget must be closed before the user can continue
+  with other parts of the program.
+
+  Modal widgets are organized in a stack. This function returns
+  the active modal widget at the top of the stack.
+
+  \sa activePopupWidget(), tqtopLevelWidgets()
+*/
+
+TQWidget *TQApplication::activeModalWidget()
+{
+    return qt_modal_stack ? qt_modal_stack->getFirst() : 0;
+}
+
+/*!
+  Cleans up any window system resources that were allocated by this
+  application. Sets the global variable \c tqApp to 0.
+*/
+
+TQApplication::~TQApplication()
+{
+#ifndef TQT_NO_CLIPBOARD
+    // flush clipboard contents
+    if ( qt_clipboard ) {
+	TQCustomEvent event( TQEvent::Clipboard );
+	TQApplication::sendEvent( qt_clipboard, &event );
+    }
+#endif
+
+    if ( eventloop )
+	eventloop->appClosingDown();
+    if ( postRList ) {
+	TQVFuncList::Iterator it = postRList->begin();
+	while ( it != postRList->end() ) {	// call post routines
+	    (**it)();
+	    postRList->remove( it );
+	    it = postRList->begin();
+	}
+	delete postRList;
+	postRList = 0;
+    }
+
+    TQObject *tipmanager = child( "toolTipManager", "TQTipManager", FALSE );
+    delete tipmanager;
+
+    delete qt_desktopWidget;
+    qt_desktopWidget = 0;
+    is_app_closing = TRUE;
+
+#ifndef TQT_NO_CLIPBOARD
+    delete qt_clipboard;
+    qt_clipboard = 0;
+#endif
+    TQWidget::destroyMapper();
+#ifndef TQT_NO_PALETTE
+    delete qt_std_pal;
+    qt_std_pal = 0;
+    delete app_pal;
+    app_pal = 0;
+    delete app_palettes;
+    app_palettes = 0;
+#endif
+    delete app_font;
+    app_font = 0;
+    delete app_fonts;
+    app_fonts = 0;
+#ifndef TQT_NO_STYLE
+    delete app_style;
+    app_style = 0;
+#endif
+#ifndef TQT_NO_CURSOR
+    delete app_cursor;
+    app_cursor = 0;
+#endif
+#ifndef TQT_NO_TRANSLATION
+    delete translators;
+#endif
+
+#ifndef TQT_NO_DRAGANDDROP
+    extern TQDragManager *qt_dnd_manager;
+    delete qt_dnd_manager;
+#endif
+
+    qt_cleanup();
+
+#ifndef TQT_NO_COMPONENT
+    delete app_libpaths;
+    app_libpaths = 0;
+#endif
+
+#ifdef TQT_THREAD_SUPPORT
+    delete qt_mutex;
+    qt_mutex = 0;
+    delete postevent_mutex;
+    postevent_mutex = 0;
+#endif // TQT_THREAD_SUPPORT
+
+    if( tqApp == this ) {
+	if ( postedEvents )
+	    removePostedEvents( this );
+	tqApp = 0;
+    }
+    is_app_running = FALSE;
+
+    if ( widgetCount ) {
+	qDebug( "Widgets left: %i    Max widgets: %i \n", TQWidget::instanceCounter, TQWidget::maxInstances );
+    }
+#ifndef TQT_NO_SESSIONMANAGER
+    delete session_manager;
+    session_manager = 0;
+    delete session_key;
+    session_key = 0;
+#endif //TQT_NO_SESSIONMANAGER
+
+    qt_explicit_app_style = FALSE;
+    qt_app_has_font = FALSE;
+    app_tracking = 0;
+    obey_desktop_settings = TRUE;
+    cursor_flash_time = 1000;
+    mouse_double_click_time = 400;
+#ifndef TQT_NO_WHEELEVENT
+    wheel_scroll_lines = 3;
+#endif
+    drag_time = 500;
+    drag_distance = 4;
+    reverse_tqlayout = FALSE;
+    app_strut = TQSize( 0, 0 );
+    animate_ui = TRUE;
+    animate_menu = FALSE;
+    fade_menu = FALSE;
+    animate_combo = FALSE;
+    animate_tooltip = FALSE;
+    fade_tooltip = FALSE;
+    widgetCount = FALSE;
+}
+
+
+/*!
+    \fn int TQApplication::argc() const
+
+    Returns the number of command line arguments.
+
+    The documentation for argv() describes how to process command line
+    arguments.
+
+    \sa argv(), TQApplication::TQApplication()
+*/
+
+/*!
+    \fn char **TQApplication::argv() const
+
+    Returns the command line argument vector.
+
+    \c argv()[0] is the program name, \c argv()[1] is the first
+    argument and \c argv()[argc()-1] is the last argument.
+
+    A TQApplication object is constructed by passing \e argc and \e
+    argv from the \c main() function. Some of the arguments may be
+    recognized as TQt options and removed from the argument vector. For
+    example, the X11 version of TQt knows about \c -display, \c -font
+    and a few more options.
+
+    Example:
+    \code
+	// showargs.cpp - displays program arguments in a list box
+
+	#include <tqapplication.h>
+	#include <tqlistbox.h>
+
+	int main( int argc, char **argv )
+	{
+	    TQApplication a( argc, argv );
+	    TQListBox b;
+	    a.setMainWidget( &b );
+	    for ( int i = 0; i < a.argc(); i++ )  // a.argc() == argc
+		b.insertItem( a.argv()[i] );      // a.argv()[i] == argv[i]
+	    b.show();
+	    return a.exec();
+	}
+    \endcode
+
+    If you run \c{showargs -display unix:0 -font 9x15bold hello world}
+    under X11, the list box tqcontains the three strings "showargs",
+    "hello" and "world".
+
+    TQt provides a global pointer, \c tqApp, that points to the
+    TQApplication object, and through which you can access argc() and
+    argv() in functions other than main().
+
+    \sa argc(), TQApplication::TQApplication()
+*/
+
+/*!
+    \fn void TQApplication::setArgs( int argc, char **argv )
+    \internal
+*/
+
+
+#ifndef TQT_NO_STYLE
+
+static TQString *qt_style_override = 0;
+
+/*!
+  Returns the application's style object.
+
+  \sa setStyle(), TQStyle
+*/
+TQStyle& TQApplication::tqstyle()
+{
+#ifndef TQT_NO_STYLE
+    if ( app_style )
+	return *app_style;
+    if ( !qt_is_gui_used )
+	qFatal( "No style available in non-gui applications!" );
+
+#if defined(TQ_WS_X11)
+    if(!qt_style_override)
+	x11_initialize_style(); // run-time search for default style
+#endif
+    if ( !app_style ) {
+	// Compile-time search for default style
+	//
+	TQString style;
+	if ( qt_style_override ) {
+	    style = *qt_style_override;
+	    delete qt_style_override;
+	    qt_style_override = 0;
+	} else {
+#  if defined(TQ_WS_WIN) && defined(TQ_OS_TEMP)
+	    style = "PocketPC";
+#elif defined(TQ_WS_WIN)
+	    if ( qWinVersion() >= TQt::WV_XP && qWinVersion() < TQt::WV_NT_based )
+		style = "WindowsXP";
+	    else
+		style = "Windows";		// default styles for Windows
+#elif defined(TQ_WS_X11) && defined(TQ_OS_SOLARIS)
+	    style = "CDE";			// default style for X11 on Solaris
+#elif defined(TQ_WS_X11) && defined(TQ_OS_IRIX)
+	    style = "SGI";			// default style for X11 on IRIX
+#elif defined(TQ_WS_X11)
+		style = "Motif";		// default style for X11
+#elif defined(TQ_WS_MAC)
+		style = "Macintosh";		// default style for all Mac's
+#elif defined(TQ_WS_TQWS)
+	    style = "Compact";		// default style for small tqdevices
+#endif
+	}
+	app_style = TQStyleFactory::create( style );
+	if ( !app_style &&		// platform default style not available, try alternatives
+	     !(app_style = TQStyleFactory::create( "Windows" ) ) &&
+	     !(app_style = TQStyleFactory::create( "Platinum" ) ) &&
+	     !(app_style = TQStyleFactory::create( "MotifPlus" ) ) &&
+	     !(app_style = TQStyleFactory::create( "Motif" ) ) &&
+	     !(app_style = TQStyleFactory::create( "CDE" ) ) &&
+	     !(app_style = TQStyleFactory::create( "Aqua" ) ) &&
+	     !(app_style = TQStyleFactory::create( "SGI" ) ) &&
+	     !(app_style = TQStyleFactory::create( "Compact" ) )
+#ifndef TQT_NO_STRINGLIST
+	    && !(app_style = TQStyleFactory::create( TQStyleFactory::keys()[0]  ) )
+#endif
+	)
+	    qFatal( "No %s style available!", style.latin1() );
+    }
+
+    TQPalette app_pal_copy ( *app_pal );
+    app_style->polish( *app_pal );
+
+    if ( is_app_running && !is_app_closing && (*app_pal != app_pal_copy) ) {
+	TQEvent e( TQEvent::ApplicationPaletteChange );
+	TQWidgetIntDictIt it( *((TQWidgetIntDict*)TQWidget::wmapper()) );
+	register TQWidget *w;
+	while ( (w=it.current()) ) {		// for all widgets...
+	    ++it;
+	    sendEvent( w, &e );
+	}
+    }
+
+    app_style->polish( tqApp );
+#endif
+    return *app_style;
+}
+
+/*!
+  Sets the application's GUI style to \a style. Ownership of the style
+  object is transferred to TQApplication, so TQApplication will delete
+  the style object on application exit or when a new style is set.
+
+  Example usage:
+  \code
+    TQApplication::setStyle( new TQWindowsStyle );
+  \endcode
+
+  When switching application styles, the color palette is set back to
+  the initial colors or the system defaults. This is necessary since
+  certain styles have to adapt the color palette to be fully
+  style-guide compliant.
+
+  \sa style(), TQStyle, setPalette(), desktopSettingsAware()
+*/
+void TQApplication::setStyle( TQStyle *style )
+{
+    TQStyle* old = app_style;
+    app_style = style;
+#ifdef TQ_WS_X11
+    qt_explicit_app_style = TRUE;
+#endif // TQ_WS_X11
+
+    if ( startingUp() ) {
+	delete old;
+	return;
+    }
+
+    // clean up the old style
+    if (old) {
+	if ( is_app_running && !is_app_closing ) {
+	    TQWidgetIntDictIt it( *((TQWidgetIntDict*)TQWidget::wmapper()) );
+	    register TQWidget *w;
+	    while ( (w=it.current()) ) {		// for all widgets...
+		++it;
+		if ( !w->testWFlags(WType_Desktop) &&	// except desktop
+		     w->testWState(WState_Polished) ) { // has been polished
+		    old->unPolish(w);
+		}
+	    }
+	}
+	old->unPolish( tqApp );
+    }
+
+    // take care of possible palette requirements of certain gui
+    // styles. Do it before polishing the application since the style
+    // might call TQApplication::setStyle() itself
+    if ( !qt_std_pal )
+	qt_create_std_palette();
+    TQPalette tmpPal = *qt_std_pal;
+    setPalette( tmpPal, TRUE );
+
+    // initialize the application with the new style
+    app_style->polish( tqApp );
+
+    // re-polish existing widgets if necessary
+    if (old) {
+	if ( is_app_running && !is_app_closing ) {
+	    TQWidgetIntDictIt it( *((TQWidgetIntDict*)TQWidget::wmapper()) );
+	    register TQWidget *w;
+	    while ( (w=it.current()) ) {		// for all widgets...
+		++it;
+		if ( !w->testWFlags(WType_Desktop) ) {	// except desktop
+		    if ( w->testWState(WState_Polished) )
+			app_style->polish(w);		// repolish
+		    w->styleChange( *old );
+		    if ( w->isVisible() ){
+			w->update();
+		    }
+		}
+	    }
+	}
+	delete old;
+    }
+}
+
+/*!
+  \overload
+
+  Requests a TQStyle object for \a style from the TQStyleFactory.
+
+  The string must be one of the TQStyleFactory::keys(), typically one
+  of "windows", "motif", "cde", "motifplus", "platinum", "sgi" and
+  "compact". Depending on the platform, "windowsxp", "aqua" or
+  "macintosh" may be available.
+
+  A later call to the TQApplication constructor will override the
+  requested style when a "-style" option is passed in as a commandline
+  parameter.
+
+  Returns 0 if an unknown \a style is passed, otherwise the TQStyle object
+  returned is set as the application's GUI style.
+*/
+TQStyle* TQApplication::setStyle( const TQString& style )
+{
+#ifdef TQ_WS_X11
+    qt_explicit_app_style = TRUE;
+#endif // TQ_WS_X11
+
+    if ( startingUp() ) {
+	if(qt_style_override)
+	    *qt_style_override = style;
+	else
+	    qt_style_override = new TQString(style);
+	return 0;
+    }
+    TQStyle *s = TQStyleFactory::create( style );
+    if ( !s )
+	return 0;
+
+    setStyle( s );
+    return s;
+}
+
+#endif
+
+
+#if 1  /* OBSOLETE */
+
+TQApplication::ColorMode TQApplication::colorMode()
+{
+    return (TQApplication::ColorMode)app_cspec;
+}
+
+void TQApplication::setColorMode( TQApplication::ColorMode mode )
+{
+    app_cspec = mode;
+}
+#endif
+
+
+/*!
+  Returns the color specification.
+  \sa TQApplication::setColorSpec()
+ */
+
+int TQApplication::colorSpec()
+{
+    return app_cspec;
+}
+
+/*!
+  Sets the color specification for the application to \a spec.
+
+  The color specification controls how the application allocates colors
+  when run on a display with a limited amount of colors, e.g. 8 bit / 256
+  color displays.
+
+  The color specification must be set before you create the TQApplication
+  object.
+
+  The options are:
+  \list
+  \i TQApplication::NormalColor.
+    This is the default color allocation strategy. Use this option if
+    your application uses buttons, menus, texts and pixmaps with few
+    colors. With this option, the application uses system global
+    colors. This works fine for most applications under X11, but on
+    Windows machines it may cause dithering of non-standard colors.
+  \i TQApplication::CustomColor.
+    Use this option if your application needs a small number of custom
+    colors. On X11, this option is the same as NormalColor. On Windows, TQt
+    creates a Windows palette, and allocates colors to it on demand.
+  \i TQApplication::ManyColor.
+    Use this option if your application is very color hungry
+    (e.g. it requires thousands of colors).
+    Under X11 the effect is:
+    \list
+    \i For 256-color displays which have at best a 256 color true color
+       visual, the default visual is used, and colors are allocated
+       from a color cube. The color cube is the 6x6x6 (216 color) "Web
+       palette"<sup>*</sup>, but the number of colors can be changed
+       by the \e -ncols option. The user can force the application to
+       use the true color visual with the \link
+       TQApplication::TQApplication() -visual \endlink option.
+    \i For 256-color displays which have a true color visual with more
+       than 256 colors, use that visual. Silicon Graphics X servers
+       have this feature, for example. They provide an 8 bit visual
+       by default but can deliver true color when asked.
+    \endlist
+    On Windows, TQt creates a Windows palette, and fills it with a color cube.
+  \endlist
+
+  Be aware that the CustomColor and ManyColor choices may lead to colormap
+  flashing: The foreground application gets (most) of the available
+  colors, while the background windows will look less attractive.
+
+  Example:
+  \code
+  int main( int argc, char **argv )
+  {
+      TQApplication::setColorSpec( TQApplication::ManyColor );
+      TQApplication a( argc, argv );
+      ...
+  }
+  \endcode
+
+  TQColor provides more functionality for controlling color allocation and
+  freeing up certain colors. See TQColor::enterAllocContext() for more
+  information.
+
+  To check what mode you end up with, call TQColor::numBitPlanes() once
+  the TQApplication object exists. A value greater than 8 (typically
+  16, 24 or 32) means true color.
+
+  <sup>*</sup> The color cube used by TQt has 216 colors whose red,
+  green, and blue components always have one of the following values:
+  0x00, 0x33, 0x66, 0x99, 0xCC, or 0xFF.
+
+  \sa colorSpec(), TQColor::numBitPlanes(), TQColor::enterAllocContext() */
+
+void TQApplication::setColorSpec( int spec )
+{
+#if defined(TQT_CHECK_STATE)
+    if ( tqApp ) {
+	qWarning( "TQApplication::setColorSpec: This function must be "
+		 "called before the TQApplication object is created" );
+    }
+#endif
+    app_cspec = spec;
+}
+
+/*!
+  \fn TQSize TQApplication::globalStrut()
+
+  Returns the application's global strut.
+
+  The strut is a size object whose dimensions are the minimum that any
+  GUI element that the user can interact with should have. For example
+  no button should be resized to be smaller than the global strut size.
+
+  \sa setGlobalStrut()
+*/
+
+/*!
+  Sets the application's global strut to \a strut.
+
+  The strut is a size object whose dimensions are the minimum that any
+  GUI element that the user can interact with should have. For example
+  no button should be resized to be smaller than the global strut size.
+
+  The strut size should be considered when reimplementing GUI controls
+  that may be used on touch-screens or similar IO-tqdevices.
+
+  Example:
+  \code
+  TQSize& WidgetClass::tqsizeHint() const
+  {
+      return TQSize( 80, 25 ).expandedTo( TQApplication::globalStrut() );
+  }
+  \endcode
+
+  \sa globalStrut()
+*/
+
+void TQApplication::setGlobalStrut( const TQSize& strut )
+{
+    app_strut = strut;
+}
+
+#if defined( TQ_WS_WIN ) || defined( TQ_WS_MAC )
+extern const char *tqAppFileName();
+#endif
+
+#ifndef TQT_NO_DIR
+#ifndef TQ_WS_WIN
+static TQString resolveSymlinks( const TQString& path, int depth = 0 )
+{
+    bool foundLink = FALSE;
+    TQString linkTarget;
+    TQString part = path;
+    int slashPos = path.length();
+
+    // too deep; we give up
+    if ( depth == 128 )
+	return TQString::null;
+
+    do {
+	part = part.left( slashPos );
+	TQFileInfo fileInfo( part );
+	if ( fileInfo.isSymLink() ) {
+	    foundLink = TRUE;
+	    linkTarget = fileInfo.readLink();
+	    break;
+	}
+    } while ( (slashPos = part.tqfindRev('/')) != -1 );
+
+    if ( foundLink ) {
+	TQString path2;
+	if ( linkTarget[0] == '/' ) {
+	    path2 = linkTarget;
+	    if ( slashPos < (int) path.length() )
+		path2 += "/" + path.right( path.length() - slashPos - 1 );
+	} else {
+	    TQString relPath;
+	    relPath = part.left( part.tqfindRev('/') + 1 ) + linkTarget;
+	    if ( slashPos < (int) path.length() ) {
+		if ( !linkTarget.endsWith( "/" ) )
+		    relPath += "/";
+		relPath += path.right( path.length() - slashPos - 1 );
+	    }
+	    path2 = TQDir::current().absFilePath( relPath );
+	}
+	path2 = TQDir::cleanDirPath( path2 );
+	return resolveSymlinks( path2, depth + 1 );
+    } else {
+	return path;
+    }
+}
+#endif // TQ_WS_WIN
+
+/*!
+    Returns the directory that tqcontains the application executable.
+
+    For example, if you have installed TQt in the \c{C:\Trolltech\TQt}
+    directory, and you run the \c{demo} example, this function will
+    return "C:/Trolltech/TQt/examples/demo".
+
+    On Mac OS X this will point to the directory actually containing the
+    executable, which may be inside of an application bundle (if the
+    application is bundled).
+
+    \warning On Unix, this function assumes that argv[0] tqcontains the file
+    name of the executable (which it normally does). It also assumes that
+    the current directory hasn't been changed by the application.
+
+    \sa applicationFilePath()
+*/
+TQString TQApplication::applicationDirPath()
+{
+    return TQFileInfo( applicationFilePath() ).dirPath();
+}
+
+/*!
+    Returns the file path of the application executable.
+
+    For example, if you have installed TQt in the \c{C:\Trolltech\TQt}
+    directory, and you run the \c{demo} example, this function will
+    return "C:/Trolltech/TQt/examples/demo/demo.exe".
+
+    \warning On Unix, this function assumes that argv[0] tqcontains the file
+    name of the executable (which it normally does). It also assumes that
+    the current directory hasn't been changed by the application.
+
+    \sa applicationDirPath()
+*/
+TQString TQApplication::applicationFilePath()
+{
+#if defined( TQ_WS_WIN )
+    TQFileInfo filePath;
+    TQT_WA({
+        WCHAR module_name[256];
+        GetModuleFileNameW(0, module_name, sizeof(module_name));
+        filePath = TQString::fromUcs2((const unsigned short *)module_name);
+    }, {
+        char module_name[256];
+        GetModuleFileNameA(0, module_name, sizeof(module_name));
+        filePath = TQString::fromLocal8Bit(module_name);
+    });
+
+    return filePath.filePath();
+#elif defined( TQ_WS_MAC )
+    return TQDir::cleanDirPath( TQFile::decodeName( tqAppFileName() ) );
+#else
+    TQString argv0 = TQFile::decodeName( argv()[0] );
+    TQString absPath;
+
+    if ( argv0[0] == '/' ) {
+	/*
+	  If argv0 starts with a slash, it is already an absolute
+	  file path.
+	*/
+	absPath = argv0;
+    } else if ( argv0.tqfind('/') != -1 ) {
+	/*
+	  If argv0 tqcontains one or more slashes, it is a file path
+	  relative to the current directory.
+	*/
+	absPath = TQDir::current().absFilePath( argv0 );
+    } else {
+	/*
+	  Otherwise, the file path has to be determined using the
+	  PATH environment variable.
+	*/
+	char *pEnv = getenv( "PATH" );
+	TQStringList paths( TQStringList::split(TQChar(':'), pEnv) );
+	TQStringList::const_iterator p = paths.begin();
+	while ( p != paths.end() ) {
+	    TQString candidate = TQDir::current().absFilePath( *p + "/" + argv0 );
+	    if ( TQFile::exists(candidate) ) {
+		absPath = candidate;
+		break;
+	    }
+	    ++p;
+	}
+    }
+
+    absPath = TQDir::cleanDirPath( absPath );
+    if ( TQFile::exists(absPath) ) {
+	return resolveSymlinks( absPath );
+    } else {
+	return TQString::null;
+    }
+#endif
+}
+#endif // TQT_NO_DIR
+
+#ifndef TQT_NO_COMPONENT
+
+/*!
+  Returns a list of paths that the application will search when
+  dynamically loading libraries.
+  The installation directory for plugins is the only entry if no
+  paths have been set.  The default installation directory for plugins
+  is \c INSTALL/plugins, where \c INSTALL is the directory where TQt was
+  installed. The directory of the application executable (NOT the
+  working directory) is also added to the plugin paths.
+
+  If you want to iterate over the list, you should iterate over a
+  copy, e.g.
+    \code
+    TQStringList list = app.libraryPaths();
+    TQStringList::Iterator it = list.begin();
+    while( it != list.end() ) {
+	myProcessing( *it );
+	++it;
+    }
+    \endcode
+
+  See the \link plugins-howto.html plugins documentation\endlink for a
+  description of how the library paths are used.
+
+  \sa tqsetLibraryPaths(), addLibraryPath(), removeLibraryPath(), TQLibrary
+*/
+TQStringList TQApplication::libraryPaths()
+{
+    if ( !app_libpaths ) {
+	app_libpaths = new TQStringList;
+	TQString installPathPlugins = TQString::fromLocal8Bit(qInstallPathPlugins());
+	if ( TQFile::exists(installPathPlugins) ) {
+#ifdef TQ_WS_WIN
+	    installPathPlugins.tqreplace('\\', '/');
+#endif
+	    app_libpaths->append(installPathPlugins);
+	}
+
+	TQString app_location;
+	if (tqApp)
+	    app_location = tqApp->applicationFilePath();
+#ifdef TQ_WS_WIN
+	else {
+	    app_location = TQString(tqAppFileName());
+	    app_location.tqreplace('\\', '/');
+	}
+#endif
+	if (!app_location.isEmpty()) {
+	    app_location.truncate( app_location.tqfindRev( '/' ) );
+	    if ( app_location != qInstallPathPlugins() && TQFile::exists( app_location ) )
+		app_libpaths->append( app_location );
+	}
+    }
+    return *app_libpaths;
+}
+
+
+/*!
+  Sets the list of directories to search when loading libraries to \a paths.
+  All existing paths will be deleted and the path list will consist of the
+  paths given in \a paths.
+
+  \sa libraryPaths(), addLibraryPath(), removeLibraryPath(), TQLibrary
+ */
+void TQApplication::tqsetLibraryPaths( const TQStringList &paths )
+{
+    delete app_libpaths;
+    app_libpaths = new TQStringList( paths );
+}
+
+/*!
+  Append \a path to the end of the library path list. If \a path is
+  empty or already in the path list, the path list is not changed.
+
+  The default path list consists of a single entry, the installation
+  directory for plugins.  The default installation directory for plugins
+  is \c INSTALL/plugins, where \c INSTALL is the directory where TQt was
+  installed.
+
+  \sa removeLibraryPath(), libraryPaths(), tqsetLibraryPaths()
+ */
+void TQApplication::addLibraryPath( const TQString &path )
+{
+    if ( path.isEmpty() )
+	return;
+
+    // make sure that library paths is initialized
+    libraryPaths();
+
+    if ( !app_libpaths->tqcontains( path ) )
+	app_libpaths->prepend( path );
+}
+
+/*!
+  Removes \a path from the library path list. If \a path is empty or not
+  in the path list, the list is not changed.
+
+  \sa addLibraryPath(), libraryPaths(), tqsetLibraryPaths()
+*/
+void TQApplication::removeLibraryPath( const TQString &path )
+{
+    if ( path.isEmpty() )
+	return;
+
+    // make sure that library paths is initialized
+    libraryPaths();
+
+    if ( app_libpaths->tqcontains( path ) )
+	app_libpaths->remove( path );
+}
+#endif //TQT_NO_COMPONENT
+
+/*!
+  Returns the application palette.
+
+  If a widget is passed in \a w, the default palette for the
+  widget's class is returned. This may or may not be the application
+  palette. In most cases there isn't a special palette for certain
+  types of widgets, but one notable exception is the popup menu under
+  Windows, if the user has defined a special background color for
+  menus in the display settings.
+
+  \sa setPalette(), TQWidget::palette()
+*/
+#ifndef TQT_NO_PALETTE
+TQPalette TQApplication::palette(const TQWidget* w)
+{
+#if defined(TQT_CHECK_STATE)
+    if ( !tqApp )
+	qWarning( "TQApplication::palette: This function can only be "
+		  "called after the TQApplication object has been created" );
+#endif
+    if ( !app_pal ) {
+	if ( !qt_std_pal )
+	    qt_create_std_palette();
+	app_pal = new TQPalette( *qt_std_pal );
+	qt_fix_tooltips();
+    }
+
+    if ( w && app_palettes ) {
+	TQPalette* wp = app_palettes->tqfind( w->className() );
+	if ( wp )
+	    return *wp;
+	TQAsciiDictIterator<TQPalette> it( *app_palettes );
+	const char* name;
+	while ( (name=it.currentKey()) != 0 ) {
+	    if ( w->inherits( name ) )
+		return *it.current();
+	    ++it;
+	}
+    }
+    return *app_pal;
+}
+
+/*!
+  Changes the default application palette to \a palette. If \a
+  informWidgets is TRUE, then existing widgets are informed about the
+  change and may adjust themselves to the new application
+  setting. If \a informWidgets is FALSE, the change only affects newly
+  created widgets.
+
+  If \a className is passed, the change applies only to widgets that
+  inherit \a className (as reported by TQObject::inherits()). If
+  \a className is left 0, the change affects all widgets, thus overriding
+  any previously set class specific palettes.
+
+  The palette may be changed according to the current GUI style in
+  TQStyle::polish().
+
+  \sa TQWidget::setPalette(), palette(), TQStyle::polish()
+*/
+
+void TQApplication::setPalette( const TQPalette &palette, bool informWidgets,
+			       const char* className )
+{
+    TQPalette pal = palette;
+    TQPalette *oldpal = 0;
+#ifndef TQT_NO_STYLE
+    if ( !startingUp() ) // on startup this has been done already
+	tqApp->style().polish( pal );	// NB: non-const reference
+#endif
+    bool all = FALSE;
+    if ( !className ) {
+	if ( !app_pal ) {
+	    app_pal = new TQPalette( pal );
+	    TQ_CHECK_PTR( app_pal );
+	} else {
+	    *app_pal = pal;
+	}
+	all = app_palettes != 0;
+	delete app_palettes;
+	app_palettes = 0;
+	qt_fix_tooltips();
+    } else {
+	if ( !app_palettes ) {
+	    app_palettes = new TQAsciiDict<TQPalette>;
+	    TQ_CHECK_PTR( app_palettes );
+	    app_palettes->setAutoDelete( TRUE );
+	}
+	oldpal = app_palettes->tqfind( className );
+	app_palettes->insert( className, new TQPalette( pal ) );
+    }
+    if ( informWidgets && is_app_running && !is_app_closing ) {
+	if ( !oldpal || ( *oldpal != pal ) ) {
+	    TQEvent e( TQEvent::ApplicationPaletteChange );
+	    TQWidgetIntDictIt it( *((TQWidgetIntDict*)TQWidget::wmapper()) );
+	    register TQWidget *w;
+	    while ( (w=it.current()) ) {		// for all widgets...
+		++it;
+		if ( all || (!className && w->isTopLevel() ) || w->inherits(className) ) // matching class
+		    sendEvent( w, &e );
+	    }
+	}
+    }
+}
+
+#endif // TQT_NO_PALETTE
+
+/*!
+  Returns the default font for the widget \a w, or the default
+  application font if \a w is 0.
+
+  \sa setFont(), fontMetrics(), TQWidget::font()
+*/
+
+TQFont TQApplication::font( const TQWidget *w )
+{
+    if ( w && app_fonts ) {
+	TQFont* wf = app_fonts->tqfind( w->className() );
+	if ( wf )
+	    return *wf;
+	TQAsciiDictIterator<TQFont> it( *app_fonts );
+	const char* name;
+	while ( (name=it.currentKey()) != 0 ) {
+	    if ( w->inherits( name ) )
+		return *it.current();
+	    ++it;
+	}
+    }
+    if ( !app_font ) {
+	app_font = new TQFont( "Helvetica" );
+	TQ_CHECK_PTR( app_font );
+    }
+    return *app_font;
+}
+
+/*! Changes the default application font to \a font. If \a
+  informWidgets is TRUE, then existing widgets are informed about the
+  change and may adjust themselves to the new application
+  setting. If \a informWidgets is FALSE, the change only affects newly
+  created widgets. If \a className is passed, the change applies only
+  to classes that inherit \a className (as reported by
+  TQObject::inherits()).
+
+  On application start-up, the default font depends on the window
+  system. It can vary depending on both the window system version and
+  the locale. This function lets you override the default font; but
+  overriding may be a bad idea because, for example, some locales need
+  extra-large fonts to support their special characters.
+
+  \sa font(), fontMetrics(), TQWidget::setFont()
+*/
+
+void TQApplication::setFont( const TQFont &font, bool informWidgets,
+			    const char* className )
+{
+    bool all = FALSE;
+    if ( !className ) {
+	qt_app_has_font = TRUE;
+	if ( !app_font ) {
+	    app_font = new TQFont( font );
+	    TQ_CHECK_PTR( app_font );
+	} else {
+	    *app_font = font;
+	}
+
+	// make sure the application font is complete
+	app_font->detach();
+	app_font->d->tqmask = TQFontPrivate::Complete;
+
+	all = app_fonts != 0;
+	delete app_fonts;
+	app_fonts = 0;
+    } else {
+	if (!app_fonts){
+	    app_fonts = new TQAsciiDict<TQFont>;
+	    TQ_CHECK_PTR( app_fonts );
+	    app_fonts->setAutoDelete( TRUE );
+	}
+	TQFont* fnt = new TQFont(font);
+	TQ_CHECK_PTR( fnt );
+	app_fonts->insert(className, fnt);
+    }
+    if ( informWidgets && is_app_running && !is_app_closing ) {
+	TQEvent e( TQEvent::ApplicationFontChange );
+	TQWidgetIntDictIt it( *((TQWidgetIntDict*)TQWidget::wmapper()) );
+	register TQWidget *w;
+	while ( (w=it.current()) ) {		// for all widgets...
+	    ++it;
+	    if ( all || (!className && w->isTopLevel() ) || w->inherits(className) ) // matching class
+		sendEvent( w, &e );
+	}
+    }
+}
+
+
+/*!
+  Initialization of the appearance of the widget \a w \e before it is first
+  shown.
+
+  Usually widgets call this automatically when they are polished. It
+  may be used to do some style-based central customization of widgets.
+
+  Note that you are not limited to the public functions of TQWidget.
+  Instead, based on meta information like TQObject::className() you are
+  able to customize any kind of widget.
+
+  \sa TQStyle::polish(), TQWidget::polish(), setPalette(), setFont()
+*/
+
+void TQApplication::polish( TQWidget *w )
+{
+#ifndef TQT_NO_STYLE
+    w->style().polish( w );
+#endif
+}
+
+
+/*!
+  Returns a list of the top level widgets in the application.
+
+  The list is created using \c new and must be deleted by the caller.
+
+  The list is empty (TQPtrList::isEmpty()) if there are no top level
+  widgets.
+
+  Note that some of the top level widgets may be hidden, for example
+  the tooltip if no tooltip is currently shown.
+
+  Example:
+  \code
+    // Show all hidden top level widgets.
+    TQWidgetList	 *list = TQApplication::tqtopLevelWidgets();
+    TQWidgetListIt it( *list );	// iterate over the widgets
+    TQWidget * w;
+    while ( (w=it.current()) != 0 ) {	// for each top level widget...
+	++it;
+	if ( !w->isVisible() )
+	    w->show();
+    }
+    delete list;		// delete the list, not the widgets
+  \endcode
+
+  \warning Delete the list as soon you have finished using it.
+  The widgets in the list may be deleted by someone else at any time.
+
+  \sa allWidgets(), TQWidget::isTopLevel(), TQWidget::isVisible(),
+      TQPtrList::isEmpty()
+*/
+
+TQWidgetList *TQApplication::tqtopLevelWidgets()
+{
+    return TQWidget::tlwList();
+}
+
+/*!
+  Returns a list of all the widgets in the application.
+
+  The list is created using \c new and must be deleted by the caller.
+
+  The list is empty (TQPtrList::isEmpty()) if there are no widgets.
+
+  Note that some of the widgets may be hidden.
+
+  Example that updates all widgets:
+  \code
+    TQWidgetList	 *list = TQApplication::allWidgets();
+    TQWidgetListIt it( *list );         // iterate over the widgets
+    TQWidget * w;
+    while ( (w=it.current()) != 0 ) {  // for each widget...
+	++it;
+	w->update();
+    }
+    delete list;                      // delete the list, not the widgets
+  \endcode
+
+  The TQWidgetList class is defined in the \c tqwidgetlist.h header
+  file.
+
+  \warning Delete the list as soon as you have finished using it.
+  The widgets in the list may be deleted by someone else at any time.
+
+  \sa tqtopLevelWidgets(), TQWidget::isVisible(), TQPtrList::isEmpty(),
+*/
+
+TQWidgetList *TQApplication::allWidgets()
+{
+    return TQWidget::wList();
+}
+
+/*!
+  \fn TQWidget *TQApplication::tqfocusWidget() const
+
+  Returns the application widget that has the keyboard input focus, or
+  0 if no widget in this application has the focus.
+
+  \sa TQWidget::setFocus(), TQWidget::hasFocus(), activeWindow()
+*/
+
+/*!
+  \fn TQWidget *TQApplication::activeWindow() const
+
+  Returns the application top-level window that has the keyboard input
+  focus, or 0 if no application window has the focus. Note that
+  there might be an activeWindow() even if there is no tqfocusWidget(),
+  for example if no widget in that window accepts key events.
+
+  \sa TQWidget::setFocus(), TQWidget::hasFocus(), tqfocusWidget()
+*/
+
+/*!
+  Returns display (screen) font metrics for the application font.
+
+  \sa font(), setFont(), TQWidget::fontMetrics(), TQPainter::fontMetrics()
+*/
+
+TQFontMetrics TQApplication::fontMetrics()
+{
+    return desktop()->fontMetrics();
+}
+
+
+
+/*!
+  Tells the application to exit with return code 0 (success).
+  Equivalent to calling TQApplication::exit( 0 ).
+
+  It's common to connect the lastWindowClosed() signal to quit(), and
+  you also often connect e.g. TQButton::clicked() or Q_SIGNALS in
+  TQAction, TQPopupMenu or TQMenuBar to it.
+
+  Example:
+  \code
+    TQPushButton *quitButton = new TQPushButton( "Quit" );
+    connect( quitButton, TQT_SIGNAL(clicked()), tqApp, TQT_SLOT(quit()) );
+  \endcode
+
+  \sa exit() aboutToQuit() lastWindowClosed() TQAction
+*/
+
+void TQApplication::quit()
+{
+    TQApplication::exit( 0 );
+}
+
+
+/*!
+  Closes all top-level windows.
+
+  This function is particularly useful for applications with many
+  top-level windows. It could, for example, be connected to a "Quit"
+  entry in the file menu as shown in the following code example:
+
+  \code
+    // the "Quit" menu entry should try to close all windows
+    TQPopupMenu* file = new TQPopupMenu( this );
+    file->insertItem( "&Quit", tqApp, TQT_SLOT(closeAllWindows()), CTRL+Key_Q );
+
+    // when the last window is closed, the application should quit
+    connect( tqApp, TQT_SIGNAL( lastWindowClosed() ), tqApp, TQT_SLOT( quit() ) );
+  \endcode
+
+  The windows are closed in random order, until one window does not
+  accept the close event.
+
+  \sa TQWidget::close(), TQWidget::closeEvent(), lastWindowClosed(),
+  quit(), tqtopLevelWidgets(), TQWidget::isTopLevel()
+
+ */
+void TQApplication::closeAllWindows()
+{
+    bool did_close = TRUE;
+    TQWidget *w;
+    while((w = activeModalWidget()) && did_close) {
+	if(w->isHidden())
+	    break;
+	did_close = w->close();
+    }
+    TQWidgetList *list = TQApplication::tqtopLevelWidgets();
+    for ( w = list->first(); did_close && w; ) {
+	if ( !w->isHidden() ) {
+	    did_close = w->close();
+	    delete list;
+	    list = TQApplication::tqtopLevelWidgets();
+	    w = list->first();
+	} else {
+	    w = list->next();
+	}
+    }
+    delete list;
+}
+
+/*!
+    Displays a simple message box about TQt. The message includes the
+    version number of TQt being used by the application.
+
+    This is useful for inclusion in the Help menu of an application.
+    See the examples/menu/menu.cpp example.
+
+    This function is a convenience slot for TQMessageBox::aboutTQt().
+*/
+void TQApplication::aboutTQt()
+{
+#ifndef TQT_NO_MESSAGEBOX
+    TQMessageBox::aboutTQt( mainWidget() );
+#endif // TQT_NO_MESSAGEBOX
+}
+
+
+/*!
+  \fn void TQApplication::lastWindowClosed()
+
+  This signal is emitted when the user has closed the last
+  top level window.
+
+  The signal is very useful when your application has many top level
+  widgets but no main widget. You can then connect it to the quit()
+  slot.
+
+  For convenience, this signal is \e not emitted for transient top level
+  widgets such as popup menus and dialogs.
+
+  \sa mainWidget(), tqtopLevelWidgets(), TQWidget::isTopLevel(), TQWidget::close()
+*/
+
+/*!
+  \fn void TQApplication::aboutToQuit()
+
+  This signal is emitted when the application is about to quit the
+  main event loop, e.g. when the event loop level drops to zero.
+  This may happen either after a call to quit() from inside the
+  application or when the users shuts down the entire desktop session.
+
+  The signal is particularly useful if your application has to do some
+  last-second cleanup. Note that no user interaction is possible in
+  this state.
+
+  \sa quit()
+*/
+
+
+/*!
+  \fn void TQApplication::guiThreadAwake()
+
+  This signal is emitted after the event loop returns from a function
+  that could block.
+
+  \sa wakeUpGuiThread()
+*/
+
+
+/*!
+  \fn bool TQApplication::sendEvent( TQObject *receiver, TQEvent *event )
+
+  Sends event \a event directly to receiver \a receiver, using the
+  notify() function. Returns the value that was returned from the event
+  handler.
+
+    The event is \e not deleted when the event has been sent. The normal
+    approach is to create the event on the stack, e.g.
+    \code
+    TQMouseEvent me( TQEvent::MouseButtonPress, pos, 0, 0 );
+    TQApplication::sendEvent( mainWindow, &me );
+    \endcode
+    If you create the event on the heap you must delete it.
+
+  \sa postEvent(), notify()
+*/
+
+/*!
+  Sends event \a e to \a receiver: \a {receiver}->event(\a e).
+  Returns the value that is returned from the receiver's event handler.
+
+  For certain types of events (e.g. mouse and key events),
+  the event will be propagated to the receiver's tqparent and so on up to
+  the top-level object if the receiver is not interested in the event
+  (i.e., it returns FALSE).
+
+  There are five different ways that events can be processed;
+  reimplementing this virtual function is just one of them. All five
+  approaches are listed below:
+  \list 1
+  \i Reimplementing this function. This is very powerful, providing
+  complete control; but only one subclass can be tqApp.
+
+  \i Installing an event filter on tqApp. Such an event filter is able
+  to process all events for all widgets, so it's just as powerful as
+  reimplementing notify(); furthermore, it's possible to have more
+  than one application-global event filter. Global event filters even
+  see mouse events for \link TQWidget::isEnabled() disabled
+  widgets, \endlink and if \link setGlobalMouseTracking() global mouse
+  tracking \endlink is enabled, as well as mouse move events for all
+  widgets.
+
+  \i Reimplementing TQObject::event() (as TQWidget does). If you do
+  this you get Tab key presses, and you get to see the events before
+  any widget-specific event filters.
+
+  \i Installing an event filter on the object. Such an event filter
+  gets all the events except Tab and Shift-Tab key presses.
+
+  \i Reimplementing paintEvent(), mousePressEvent() and so
+  on. This is the commonest, easiest and least powerful way.
+  \endlist
+
+  \sa TQObject::event(), installEventFilter()
+*/
+
+bool TQApplication::notify( TQObject *receiver, TQEvent *e )
+{
+    // no events are delivered after ~TQApplication() has started
+    if ( is_app_closing )
+	return FALSE;
+
+    if ( receiver == 0 ) {			// serious error
+#if defined(TQT_CHECK_NULL)
+	qWarning( "TQApplication::notify: Unexpected null receiver" );
+#endif
+	return FALSE;
+    }
+
+    if ( e->type() == TQEvent::ChildRemoved && receiver->postedEvents && globalPostedEvents) {
+
+#ifdef TQT_THREAD_SUPPORT
+	TQMutexLocker locker( postevent_mutex );
+#endif // TQT_THREAD_SUPPORT
+
+	// the TQObject destructor calls TQObject::removeChild, which calls
+	// TQApplication::sendEvent() directly.  this can happen while the event
+	// loop is in the middle of posting events, and when we get here, we may
+	// not have any more posted events for this object.
+	if ( receiver->postedEvents ) {
+	    // if this is a child remove event and the child insert
+	    // hasn't been dispatched yet, kill that insert
+	    TQPostEventList * l = receiver->postedEvents;
+	    TQObject * c = ((TQChildEvent*)e)->child();
+	    TQPostEvent * pe;
+	    l->first();
+	    while( ( pe = l->current()) != 0 ) {
+		if ( pe->event && pe->receiver == receiver &&
+		     pe->event->type() == TQEvent::ChildInserted &&
+		     ((TQChildEvent*)pe->event)->child() == c ) {
+		    pe->event->posted = FALSE;
+		    delete pe->event;
+		    pe->event = 0;
+		    l->remove();
+		    continue;
+		}
+		l->next();
+	    }
+	}
+    }
+
+    bool res = FALSE;
+    if ( !receiver->isWidgetType() )
+	res = internalNotify( receiver, e );
+    else switch ( e->type() ) {
+#ifndef TQT_NO_ACCEL
+    case TQEvent::Accel:
+	{
+	    TQKeyEvent* key = (TQKeyEvent*) e;
+	    res = internalNotify( receiver, e );
+
+	    if ( !res && !key->isAccepted() )
+		res = qt_dispatchAccelEvent( (TQWidget*)receiver, key );
+
+	    // next lines are for compatibility with TQt <= 3.0.x: old
+	    // TQAccel was listening on toplevel widgets
+	    if ( !res && !key->isAccepted() && !((TQWidget*)receiver)->isTopLevel() )
+		res = internalNotify( ((TQWidget*)receiver)->tqtopLevelWidget(), e );
+	}
+    break;
+#endif //TQT_NO_ACCEL
+    case TQEvent::KeyPress:
+    case TQEvent::KeyRelease:
+    case TQEvent::AccelOverride:
+	{
+	    TQWidget* w = (TQWidget*)receiver;
+	    TQKeyEvent* key = (TQKeyEvent*) e;
+#ifndef TQT_NO_ACCEL
+	    if ( qt_tryComposeUnicode( w, key ) )
+		break;
+#endif
+	    bool def = key->isAccepted();
+	    while ( w ) {
+		if ( def )
+		    key->accept();
+		else
+		    key->ignore();
+		res = internalNotify( w, e );
+		if ( res || key->isAccepted() )
+		    break;
+		w = w->parentWidget( TRUE );
+	    }
+	}
+    break;
+    case TQEvent::MouseButtonPress:
+	    if ( e->spontaneous() ) {
+		TQWidget* fw = (TQWidget*)receiver;
+		while ( fw->focusProxy() )
+		    fw = fw->focusProxy();
+		if ( fw->isEnabled() && fw->focusPolicy() & TQWidget::ClickFocus ) {
+		    TQFocusEvent::setReason( TQFocusEvent::Mouse);
+		    fw->setFocus();
+		    TQFocusEvent::resetReason();
+		}
+	    }
+	    // fall through intended
+    case TQEvent::MouseButtonRelease:
+    case TQEvent::MouseButtonDblClick:
+    case TQEvent::MouseMove:
+	{
+	    TQWidget* w = (TQWidget*)receiver;
+	    TQMouseEvent* mouse = (TQMouseEvent*) e;
+	    TQPoint relpos = mouse->pos();
+	    while ( w ) {
+		TQMouseEvent me(mouse->type(), relpos, mouse->globalPos(), mouse->button(), mouse->state());
+		me.spont = mouse->spontaneous();
+		res = internalNotify( w, w == receiver ? mouse : &me );
+		e->spont = FALSE;
+		if (res || w->isTopLevel() || w->testWFlags(WNoMousePropagation))
+		    break;
+
+		relpos += w->pos();
+		w = w->parentWidget();
+	    }
+	    if ( res )
+		mouse->accept();
+	    else
+		mouse->ignore();
+	}
+    break;
+#ifndef TQT_NO_WHEELEVENT
+    case TQEvent::Wheel:
+	{
+	    if ( e->spontaneous() ) {
+		TQWidget* fw = (TQWidget*)receiver;
+		while ( fw->focusProxy() )
+		    fw = fw->focusProxy();
+		if ( fw->isEnabled() && (fw->focusPolicy() & TQWidget::WheelFocus) == TQWidget::WheelFocus ) {
+		    TQFocusEvent::setReason( TQFocusEvent::Mouse);
+		    fw->setFocus();
+		    TQFocusEvent::resetReason();
+		}
+	    }
+
+	    TQWidget* w = (TQWidget*)receiver;
+	    TQWheelEvent* wheel = (TQWheelEvent*) e;
+	    TQPoint relpos = wheel->pos();
+	    while ( w ) {
+		TQWheelEvent we(relpos, wheel->globalPos(), wheel->delta(), wheel->state(), wheel->orientation());
+		we.spont = wheel->spontaneous();
+		res = internalNotify( w,  w == receiver ? wheel : &we );
+		e->spont = FALSE;
+		if (res || w->isTopLevel() || w->testWFlags(WNoMousePropagation))
+		    break;
+
+		relpos += w->pos();
+		w = w->parentWidget();
+	    }
+	    if ( res )
+		wheel->accept();
+	    else
+		wheel->ignore();
+	}
+    break;
+#endif
+    case TQEvent::ContextMenu:
+	{
+	    TQWidget* w = (TQWidget*)receiver;
+	    TQContextMenuEvent *context = (TQContextMenuEvent*) e;
+	    TQPoint relpos = context->pos();
+	    while ( w ) {
+		TQContextMenuEvent ce(context->reason(), relpos, context->globalPos(), context->state());
+		ce.spont = e->spontaneous();
+		res = internalNotify( w,  w == receiver ? context : &ce );
+		e->spont = FALSE;
+
+		if (res || w->isTopLevel() || w->testWFlags(WNoMousePropagation))
+		    break;
+
+		relpos += w->pos();
+		w = w->parentWidget();
+	    }
+	    if ( res )
+		context->accept();
+	    else
+		context->ignore();
+	}
+    break;
+#if defined (TQT_TABLET_SUPPORT)
+    case TQEvent::TabletMove:
+    case TQEvent::TabletPress:
+    case TQEvent::TabletRelease:
+	{
+	    TQWidget *w = (TQWidget*)receiver;
+	    TQTabletEvent *tablet = (TQTabletEvent*)e;
+	    TQPoint relpos = tablet->pos();
+	    while ( w ) {
+		TQTabletEvent te(tablet->pos(), tablet->globalPos(), tablet->tqdevice(),
+				tablet->pressure(), tablet->xTilt(), tablet->yTilt(),
+				tablet->uniqueId());
+		te.spont = e->spontaneous();
+		res = internalNotify( w, w == receiver ? tablet : &te );
+		e->spont = FALSE;
+		if (res || w->isTopLevel() || w->testWFlags(WNoMousePropagation))
+		    break;
+
+		relpos += w->pos();
+		w = w->parentWidget();
+	    }
+	    if ( res )
+		tablet->accept();
+	    else
+		tablet->ignore();
+	    chokeMouse = tablet->isAccepted();
+	}
+    break;
+#endif
+    default:
+	res = internalNotify( receiver, e );
+	break;
+    }
+
+    return res;
+}
+
+/*!\reimp
+
+*/
+bool TQApplication::event( TQEvent *e )
+{
+    if(e->type() == TQEvent::Close) {
+	TQCloseEvent *ce = (TQCloseEvent*)e;
+	ce->accept();
+	closeAllWindows();
+
+	TQWidgetList *list = tqtopLevelWidgets();
+	for(TQWidget *w = list->first(); w; w = list->next()) {
+	    if ( !w->isHidden() && !w->isDesktop() && !w->isPopup() &&
+		 (!w->isDialog() || !w->parentWidget())) {
+		ce->ignore();
+		break;
+	    }
+	}
+	if(ce->isAccepted())
+	    return TRUE;
+    } else if (e->type() == TQEvent::Quit) {
+	quit();
+	return TRUE;
+    }
+    return TQObject::event(e);
+}
+
+/*!\internal
+
+  Helper function called by notify()
+ */
+bool TQApplication::internalNotify( TQObject *receiver, TQEvent * e)
+{
+    if ( eventFilters ) {
+	TQObjectListIt it( *eventFilters );
+	register TQObject *obj;
+	while ( (obj=it.current()) != 0 ) {	// send to all filters
+	    ++it;				//   until one returns TRUE
+	    if ( obj->eventFilter(receiver,e) )
+		return TRUE;
+	}
+    }
+
+    bool consumed = FALSE;
+    bool handled = FALSE;
+    if ( receiver->isWidgetType() ) {
+	TQWidget *widget = (TQWidget*)receiver;
+
+	// toggle HasMouse widget state on enter and leave
+	if ( e->type() == TQEvent::Enter || e->type() == TQEvent::DragEnter )
+	    widget->setWState( WState_HasMouse );
+	else if ( e->type() == TQEvent::Leave || e->type() == TQEvent::DragLeave )
+	    widget->clearWState( WState_HasMouse );
+
+	// throw away any mouse-tracking-only mouse events
+	if ( e->type() == TQEvent::MouseMove &&
+	     (((TQMouseEvent*)e)->state()&TQMouseEvent::MouseButtonMask) == 0 &&
+	     !widget->hasMouseTracking() ) {
+	    handled = TRUE;
+	    consumed = TRUE;
+	} else if ( !widget->isEnabled() ) { // throw away mouse events to disabled widgets
+	    switch(e->type()) {
+	    case TQEvent::MouseButtonPress:
+	    case TQEvent::MouseButtonRelease:
+	    case TQEvent::MouseButtonDblClick:
+	    case TQEvent::MouseMove:
+		( (TQMouseEvent*) e)->ignore();
+		handled = TRUE;
+		consumed = TRUE;
+		break;
+#ifndef TQT_NO_DRAGANDDROP
+	    case TQEvent::DragEnter:
+	    case TQEvent::DragMove:
+		( (TQDragMoveEvent*) e)->ignore();
+		handled = TRUE;
+		break;
+
+	    case TQEvent::DragLeave:
+	    case TQEvent::DragResponse:
+		handled = TRUE;
+		break;
+
+	    case TQEvent::Drop:
+		( (TQDropEvent*) e)->ignore();
+		handled = TRUE;
+		break;
+#endif
+#ifndef TQT_NO_WHEELEVENT
+	    case TQEvent::Wheel:
+		( (TQWheelEvent*) e)->ignore();
+		handled = TRUE;
+		break;
+#endif
+	    case TQEvent::ContextMenu:
+		( (TQContextMenuEvent*) e)->ignore();
+		handled = TRUE;
+		break;
+	    default:
+		break;
+	    }
+	}
+
+    }
+
+    if (!handled)
+	consumed = receiver->event( e );
+    e->spont = FALSE;
+    return consumed;
+}
+
+/*!
+  Returns TRUE if an application object has not been created yet;
+  otherwise returns FALSE.
+
+  \sa closingDown()
+*/
+
+bool TQApplication::startingUp()
+{
+    return !is_app_running;
+}
+
+/*!
+  Returns TRUE if the application objects are being destroyed;
+  otherwise returns FALSE.
+
+  \sa startingUp()
+*/
+
+bool TQApplication::closingDown()
+{
+    return is_app_closing;
+}
+
+
+/*!
+    Processes pending events, for 3 seconds or until there are no more
+    events to process, whichever is shorter.
+
+    You can call this function occasionally when your program is busy
+    performing a long operation (e.g. copying a file).
+
+    \sa exec(), TQTimer, TQEventLoop::processEvents()
+*/
+
+void TQApplication::processEvents()
+{
+    processEvents( 3000 );
+}
+
+/*!
+    \overload
+
+    Processes pending events for \a maxtime milliseconds or until
+    there are no more events to process, whichever is shorter.
+
+    You can call this function occasionally when you program is busy
+    doing a long operation (e.g. copying a file).
+
+    \sa exec(), TQTimer, TQEventLoop::processEvents()
+*/
+void TQApplication::processEvents( int maxtime )
+{
+    eventLoop()->processEvents( TQEventLoop::AllEvents, maxtime );
+}
+
+/*! \obsolete
+  Waits for an event to occur, processes it, then returns.
+
+  This function is useful for adapting TQt to situations where the
+  event processing must be grafted onto existing program loops.
+
+  Using this function in new applications may be an indication of design
+  problems.
+
+  \sa processEvents(), exec(), TQTimer
+*/
+
+void TQApplication::processOneEvent()
+{
+    eventLoop()->processEvents( TQEventLoop::AllEvents |
+				TQEventLoop::WaitForMore );
+}
+
+/*****************************************************************************
+  Main event loop wrappers
+ *****************************************************************************/
+
+/*!
+    Returns the application event loop. This function will return
+    zero if called during and after destroying TQApplication.
+
+    To create your own instance of TQEventLoop or TQEventLoop subclass create
+    it before you create the TQApplication object.
+
+    \sa TQEventLoop
+*/
+TQEventLoop *TQApplication::eventLoop()
+{
+    if ( !eventloop && !is_app_closing )
+	(void) new TQEventLoop( tqApp, "default event loop" );
+    return eventloop;
+}
+
+
+/*!
+    Enters the main event loop and waits until exit() is called or the
+    main widget is destroyed, and returns the value that was set to
+    exit() (which is 0 if exit() is called via quit()).
+
+    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 quit(), exit(), processEvents(), setMainWidget()
+*/
+int TQApplication::exec()
+{
+    return eventLoop()->exec();
+}
+
+/*!
+  Tells the application to exit with a return code.
+
+  After this function has been called, the application leaves the main
+  event loop and 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 quit(), exec()
+*/
+void TQApplication::exit( int retcode )
+{
+    tqApp->eventLoop()->exit( retcode );
+}
+
+/*!
+    \obsolete
+
+    This function enters the main event loop (recursively). Do not call
+    it unless you really know what you are doing.
+
+    Use TQApplication::eventLoop()->enterLoop() instead.
+
+*/
+int TQApplication::enter_loop()
+{
+    return eventLoop()->enterLoop();
+}
+
+/*!
+    \obsolete
+
+    This function exits from a recursive call to the main event loop.
+    Do not call it unless you are an expert.
+
+    Use TQApplication::eventLoop()->exitLoop() instead.
+
+*/
+void TQApplication::exit_loop()
+{
+    eventLoop()->exitLoop();
+}
+
+/*!
+    \obsolete
+
+    Returns the current loop level.
+
+    Use TQApplication::eventLoop()->loopLevel() instead.
+
+*/
+int TQApplication::loopLevel() const
+{
+    return eventLoop()->loopLevel();
+}
+
+/*!
+
+  Wakes up the GUI thread.
+
+  \sa guiThreadAwake() \link threads.html Thread Support in TQt\endlink
+*/
+void TQApplication::wakeUpGuiThread()
+{
+    eventLoop()->wakeUp();
+}
+
+/*!
+    This function returns TRUE if there are pending events; otherwise
+    returns FALSE. Pending events can be either from the window system
+    or posted events using TQApplication::postEvent().
+*/
+bool TQApplication::hasPendingEvents()
+{
+    return eventLoop()->hasPendingEvents();
+}
+
+#if !defined(TQ_WS_X11)
+
+// The doc and X implementation of these functions is in qapplication_x11.cpp
+
+void TQApplication::flushX()	{}		// do nothing
+
+void TQApplication::syncX()	{}		// do nothing
+
+#endif
+
+/*!
+  \fn void TQApplication::setWinStyleHighlightColor( const TQColor & )
+  \obsolete
+
+  Sets the color used to mark selections in windows style for all widgets
+  in the application. Will tqrepaint all widgets if the color is changed.
+
+  The default color is \c darkBlue.
+  \sa winStyleHighlightColor()
+*/
+
+/*!
+  \fn const TQColor& TQApplication::winStyleHighlightColor()
+  \obsolete
+
+  Returns the color used to mark selections in windows style.
+
+  \sa setWinStyleHighlightColor()
+*/
+
+/*!
+  Returns the version of the Windows operating system that is running:
+
+  \list
+  \i TQt::WV_95 - Windows 95
+  \i TQt::WV_98 - Windows 98
+  \i TQt::WV_Me - Windows Me
+  \i TQt::WV_NT - Windows NT 4.x
+  \i TQt::WV_2000 - Windows 2000 (NT5)
+  \i TQt::WV_XP - Windows XP
+  \i TQt::WV_2003 - Windows Server 2003 family
+  \i TQt::WV_CE - Windows CE
+  \i TQt::WV_CENET - Windows CE.NET
+  \endlist
+
+  Note that this function is implemented for the Windows version
+  of TQt only.
+*/
+
+#if defined(TQ_OS_CYGWIN)
+TQt::WindowsVersion TQApplication::winVersion()
+{
+    return qt_winver;
+}
+#endif
+
+#ifndef TQT_NO_TRANSLATION
+
+bool qt_detectRTLLanguage()
+{
+    return TQApplication::tr( "TQT_LAYOUT_DIRECTION",
+	    "Translate this string to the string 'LTR' in left-to-right"
+	    " languages or to 'RTL' in right-to-left languages (such as Hebrew"
+	    " and Arabic) to get proper widget tqlayout." ) == "RTL";
+}
+
+/*!
+  Adds the message file \a mf to the list of message files to be used
+  for translations.
+
+  Multiple message files can be installed. Translations are searched
+  for in the last installed message file, then the one from last, and
+  so on, back to the first installed message file. The search stops as
+  soon as a matching translation is found.
+
+  \sa removeTranslator() translate() TQTranslator::load()
+*/
+
+void TQApplication::installTranslator( TQTranslator * mf )
+{
+    if ( !mf )
+	return;
+    if ( !translators )
+	translators = new TQValueList<TQTranslator*>;
+
+    translators->prepend( mf );
+
+#ifndef TQT_NO_TRANSLATION_BUILDER
+    if ( mf->isEmpty() )
+	return;
+#endif
+
+    // hook to set the tqlayout direction of dialogs
+    setReverseLayout( qt_detectRTLLanguage() );
+
+    TQWidgetList *list = tqtopLevelWidgets();
+    TQWidgetListIt it( *list );
+    TQWidget *w;
+    while ( ( w=it.current() ) != 0 ) {
+	++it;
+	if (!w->isDesktop())
+	    postEvent( w, new TQEvent( TQEvent::LanguageChange ) );
+    }
+    delete list;
+}
+
+/*!
+  Removes the message file \a mf from the list of message files used by
+  this application. (It does not delete the message file from the file
+  system.)
+
+  \sa installTranslator() translate(), TQObject::tr()
+*/
+
+void TQApplication::removeTranslator( TQTranslator * mf )
+{
+    if ( !translators || !mf )
+	return;
+
+    if ( translators->remove( mf ) && ! tqApp->closingDown() ) {
+	setReverseLayout( qt_detectRTLLanguage() );
+
+	TQWidgetList *list = tqtopLevelWidgets();
+	TQWidgetListIt it( *list );
+	TQWidget *w;
+	while ( ( w=it.current() ) != 0 ) {
+	    ++it;
+	    postEvent( w, new TQEvent( TQEvent::LanguageChange ) );
+	}
+	delete list;
+    }
+}
+
+#ifndef TQT_NO_TEXTCODEC
+/*! \obsolete
+  This is the same as TQTextCodec::setCodecForTr().
+*/
+void TQApplication::setDefaultCodec( TQTextCodec* codec )
+{
+    TQTextCodec::setCodecForTr( codec );
+}
+
+/*! \obsolete
+  Returns TQTextCodec::codecForTr().
+*/
+TQTextCodec* TQApplication::defaultCodec() const
+{
+    return TQTextCodec::codecForTr();
+}
+#endif //TQT_NO_TEXTCODEC
+
+/*! \enum TQApplication::Encoding
+
+  This enum type defines the 8-bit encoding of character string
+  arguments to translate():
+
+  \value DefaultCodec - the encoding specified by
+  TQTextCodec::codecForTr() (Latin-1 if none has been set)
+  \value UnicodeUTF8 - UTF-8
+
+  \sa TQObject::tr(), TQObject::trUtf8(), TQString::fromUtf8()
+*/
+
+/*! \reentrant
+  Returns the translation text for \a sourceText, by querying the
+  installed messages files. The message files are searched from the most
+  recently installed message file back to the first installed message
+  file.
+
+  TQObject::tr() and TQObject::trUtf8() provide this functionality more
+  conveniently.
+
+  \a context is typically a class name (e.g., "MyDialog") and
+  \a sourceText is either English text or a short identifying text, if
+  the output text will be very long (as for help texts).
+
+  \a comment is a disambiguating comment, for when the same \a
+  sourceText is used in different roles within the same context. By
+  default, it is null. \a encoding indicates the 8-bit encoding of
+  character stings
+
+  See the \l TQTranslator documentation for more information about
+  contexts and comments.
+
+  If none of the message files contain a translation for \a
+  sourceText in \a context, this function returns a TQString
+  equivalent of \a sourceText. The encoding of \a sourceText is
+  specified by \e encoding; it defaults to \c DefaultCodec.
+
+  This function is not virtual. You can use alternative translation
+  techniques by subclassing \l TQTranslator.
+
+  \warning This method is reentrant only if all translators are
+  installed \e before calling this method.  Installing or removing
+  translators while performing translations is not supported.  Doing
+  so will most likely result in crashes or other undesirable behavior.
+
+  \sa TQObject::tr() installTranslator() defaultCodec()
+*/
+
+TQString TQApplication::translate( const char * context, const char * sourceText,
+				 const char * comment, Encoding encoding ) const
+{
+    if ( !sourceText )
+	return TQString::null;
+
+    if ( translators ) {
+	TQValueList<TQTranslator*>::iterator it;
+	TQTranslator * mf;
+	TQString result;
+	for ( it = translators->begin(); it != translators->end(); ++it ) {
+	    mf = *it;
+	    result = mf->tqfindMessage( context, sourceText, comment ).translation();
+	    if ( !result.isNull() )
+		return result;
+	}
+    }
+#ifndef TQT_NO_TEXTCODEC
+    if ( encoding == UnicodeUTF8 )
+	return TQString::fromUtf8( sourceText );
+    else if ( TQTextCodec::codecForTr() != 0 )
+	return TQTextCodec::codecForTr()->toUnicode( sourceText );
+    else
+#endif
+	return TQString::tqfromLatin1( sourceText );
+}
+
+#endif
+
+/*****************************************************************************
+  TQApplication management of posted events
+ *****************************************************************************/
+
+//see also notify(), which does the removal of ChildInserted when ChildRemoved.
+
+/*!
+  Adds the event \a event with the object \a receiver as the receiver of the
+  event, to an event queue and returns immediately.
+
+  The event must be allocated on the heap since the post event queue
+  will take ownership of the event and delete it once it has been posted.
+
+  When control returns to the main event loop, all events that are
+  stored in the queue will be sent using the notify() function.
+
+  \threadsafe
+
+  \sa sendEvent(), notify()
+*/
+
+void TQApplication::postEvent( TQObject *receiver, TQEvent *event )
+{
+    if ( receiver == 0 ) {
+#if defined(TQT_CHECK_NULL)
+	qWarning( "TQApplication::postEvent: Unexpected null receiver" );
+#endif
+	delete event;
+	return;
+    }
+
+#ifdef TQT_THREAD_SUPPORT
+    TQMutexLocker locker( postevent_mutex );
+#endif // TQT_THREAD_SUPPORT
+
+    if ( !globalPostedEvents ) {			// create list
+	globalPostedEvents = new TQPostEventList;
+	TQ_CHECK_PTR( globalPostedEvents );
+	globalPostedEvents->setAutoDelete( TRUE );
+	qapp_cleanup_events.set( &globalPostedEvents );
+    }
+
+    if ( !receiver->postedEvents )
+	receiver->postedEvents = new TQPostEventList;
+    TQPostEventList * l = receiver->postedEvents;
+
+    // if this is one of the compressible events, do compression
+    if ( event->type() == TQEvent::Paint ||
+	 event->type() == TQEvent::LayoutHint ||
+	 event->type() == TQEvent::Resize ||
+	 event->type() == TQEvent::Move ||
+	 event->type() == TQEvent::LanguageChange ) {
+	l->first();
+	TQPostEvent * cur = 0;
+	for ( ;; ) {
+	    while ( (cur=l->current()) != 0 &&
+		    ( cur->receiver != receiver ||
+		      cur->event == 0 ||
+		      cur->event->type() != event->type() ) )
+		l->next();
+	    if ( l->current() != 0 ) {
+		if ( cur->event->type() == TQEvent::Paint ) {
+		    TQPaintEvent * p = (TQPaintEvent*)(cur->event);
+		    if ( p->erase != ((TQPaintEvent*)event)->erase ) {
+			l->next();
+			continue;
+		    }
+		    p->reg = p->reg.unite( ((TQPaintEvent *)event)->reg );
+		    p->rec = p->rec.unite( ((TQPaintEvent *)event)->rec );
+		    delete event;
+		    return;
+		} else if ( cur->event->type() == TQEvent::LayoutHint ) {
+		    delete event;
+		    return;
+		} else if ( cur->event->type() == TQEvent::Resize ) {
+		    ((TQResizeEvent *)(cur->event))->s = ((TQResizeEvent *)event)->s;
+		    delete event;
+		    return;
+		} else if ( cur->event->type() == TQEvent::Move ) {
+		    ((TQMoveEvent *)(cur->event))->p = ((TQMoveEvent *)event)->p;
+		    delete event;
+		    return;
+		} else if ( cur->event->type() == TQEvent::LanguageChange ) {
+		    delete event;
+		    return;
+		}
+	    }
+	    break;
+	};
+    }
+
+    // if no compression could be done, just append something
+    event->posted = TRUE;
+    TQPostEvent * pe = new TQPostEvent( receiver, event );
+    l->append( pe );
+    globalPostedEvents->append( pe );
+
+    if (eventloop)
+	eventloop->wakeUp();
+}
+
+
+/*! \overload
+
+    Dispatches all posted events, i.e. empties the event queue.
+*/
+void TQApplication::sendPostedEvents()
+{
+    sendPostedEvents( 0, 0 );
+}
+
+
+
+/*!
+  Immediately dispatches all events which have been previously queued
+  with TQApplication::postEvent() and which are for the object \a receiver
+  and have the event type \a event_type.
+
+  Note that events from the window system are \e not dispatched by this
+  function, but by processEvents().
+
+  If \a receiver is null, the events of \a event_type are sent for all
+  objects. If \a event_type is 0, all the events are sent for \a receiver.
+*/
+
+void TQApplication::sendPostedEvents( TQObject *receiver, int event_type )
+{
+    // Make sure the object hierarchy is stable before processing events
+    // to avoid endless loops
+    if ( receiver == 0 && event_type == 0 )
+	sendPostedEvents( 0, TQEvent::ChildInserted );
+
+    if ( !globalPostedEvents || ( receiver && !receiver->postedEvents ) )
+	return;
+
+#ifdef TQT_THREAD_SUPPORT
+    TQMutexLocker locker( postevent_mutex );
+#endif
+
+    bool sent = TRUE;
+    while ( sent ) {
+	sent = FALSE;
+
+	if ( !globalPostedEvents || ( receiver && !receiver->postedEvents ) )
+	    return;
+
+	// if we have a receiver, use the local list. Otherwise, use the
+	// global list
+	TQPostEventList * l = receiver ? receiver->postedEvents : globalPostedEvents;
+
+	// okay. here is the tricky loop. be careful about optimizing
+	// this, it looks the way it does for good reasons.
+	TQPostEventListIt it( *l );
+	TQPostEvent *pe;
+	while ( (pe=it.current()) != 0 ) {
+	    ++it;
+	    if ( pe->event // hasn't been sent yet
+		 && ( receiver == 0 // we send to all tqreceivers
+		      || receiver == pe->receiver ) // we send to THAT receiver
+		 && ( event_type == 0 // we send all types
+		      || event_type == pe->event->type() ) ) { // we send THAT type
+		// first, we diddle the event so that we can deliver
+		// it, and that noone will try to touch it later.
+		pe->event->posted = FALSE;
+		TQEvent * e = pe->event;
+		TQObject * r = pe->receiver;
+		pe->event = 0;
+
+		// next, update the data structure so that we're ready
+		// for the next event.
+
+		// look for the local list, and take whatever we're
+		// delivering out of it. r->postedEvents maybe *l
+		if ( r->postedEvents ) {
+		    r->postedEvents->removeRef( pe );
+		    // if possible, get rid of that list. this is not
+		    // ideal - we will create and delete a list for
+		    // each update() call. it would be better if we'd
+		    // leave the list empty here, and delete it
+		    // somewhere else if it isn't being used.
+		    if ( r->postedEvents->isEmpty() ) {
+			delete r->postedEvents;
+			r->postedEvents = 0;
+		    }
+		}
+
+#ifdef TQT_THREAD_SUPPORT
+		if ( locker.mutex() ) locker.mutex()->unlock();
+#endif // TQT_THREAD_SUPPORT
+		// after all that work, it's time to deliver the event.
+		if ( e->type() == TQEvent::Paint && r->isWidgetType() ) {
+		    TQWidget * w = (TQWidget*)r;
+		    TQPaintEvent * p = (TQPaintEvent*)e;
+		    if ( w->isVisible() )
+			w->tqrepaint( p->reg, p->erase );
+		} else {
+		    sent = TRUE;
+		    TQApplication::sendEvent( r, e );
+		}
+#ifdef TQT_THREAD_SUPPORT
+		if ( locker.mutex() ) locker.mutex()->lock();
+#endif // TQT_THREAD_SUPPORT
+
+		delete e;
+		// careful when adding anything below this point - the
+		// sendEvent() call might tqinvalidate any invariants this
+		// function depends on.
+	    }
+	}
+
+	// clear the global list, i.e. remove everything that was
+	// delivered.
+	if ( l == globalPostedEvents ) {
+	    globalPostedEvents->first();
+	    while( (pe=globalPostedEvents->current()) != 0 ) {
+		if ( pe->event )
+		    globalPostedEvents->next();
+		else
+		    globalPostedEvents->remove();
+	    }
+	}
+    }
+}
+
+/*!
+  Removes all events posted using postEvent() for \a receiver.
+
+  The events are \e not dispatched, instead they are removed from the
+  queue. You should never need to call this function. If you do call it,
+  be aware that killing events may cause \a receiver to break one or
+  more invariants.
+
+  \threadsafe
+*/
+
+void TQApplication::removePostedEvents( TQObject *receiver )
+{
+    if ( !receiver )
+	return;
+
+#ifdef TQT_THREAD_SUPPORT
+    TQMutexLocker locker( postevent_mutex );
+#endif // TQT_THREAD_SUPPORT
+
+    // the TQObject destructor calls this function directly.  this can
+    // happen while the event loop is in the middle of posting events,
+    // and when we get here, we may not have any more posted events
+    // for this object.
+    if ( !receiver->postedEvents )
+	return;
+
+    // iterate over the object-specifc list and delete the events.
+    // leave the TQPostEvent objects; they'll be deleted by
+    // sendPostedEvents().
+    TQPostEventList * l = receiver->postedEvents;
+    receiver->postedEvents = 0;
+    l->first();
+    TQPostEvent * pe;
+    while( (pe=l->current()) != 0 ) {
+	if ( pe->event ) {
+	    pe->event->posted = FALSE;
+	    delete pe->event;
+	    pe->event = 0;
+	}
+	l->remove();
+    }
+    delete l;
+}
+
+
+/*!
+  Removes \a event from the queue of posted events, and emits a
+  warning message if appropriate.
+
+  \warning This function can be \e really slow. Avoid using it, if
+  possible.
+
+  \threadsafe
+*/
+
+void TQApplication::removePostedEvent( TQEvent *  event )
+{
+    if ( !event || !event->posted )
+	return;
+
+    if ( !globalPostedEvents ) {
+#if defined(TQT_DEBUG)
+	qDebug( "TQApplication::removePostedEvent: %p %d is posted: impossible",
+		(void*)event, event->type() );
+	return;
+#endif
+    }
+
+#ifdef TQT_THREAD_SUPPORT
+    TQMutexLocker locker( postevent_mutex );
+#endif // TQT_THREAD_SUPPORT
+
+    TQPostEventListIt it( *globalPostedEvents );
+    TQPostEvent * pe;
+    while( (pe = it.current()) != 0 ) {
+	++it;
+	if ( pe->event == event ) {
+#if defined(TQT_DEBUG)
+	    const char *n;
+	    switch ( event->type() ) {
+	    case TQEvent::Timer:
+		n = "Timer";
+		break;
+	    case TQEvent::MouseButtonPress:
+		n = "MouseButtonPress";
+		break;
+	    case TQEvent::MouseButtonRelease:
+		n = "MouseButtonRelease";
+		break;
+	    case TQEvent::MouseButtonDblClick:
+		n = "MouseButtonDblClick";
+		break;
+	    case TQEvent::MouseMove:
+		n = "MouseMove";
+		break;
+#ifndef TQT_NO_WHEELEVENT
+	    case TQEvent::Wheel:
+		n = "Wheel";
+		break;
+#endif
+	    case TQEvent::KeyPress:
+		n = "KeyPress";
+		break;
+	    case TQEvent::KeyRelease:
+		n = "KeyRelease";
+		break;
+	    case TQEvent::FocusIn:
+		n = "FocusIn";
+		break;
+	    case TQEvent::FocusOut:
+		n = "FocusOut";
+		break;
+	    case TQEvent::Enter:
+		n = "Enter";
+		break;
+	    case TQEvent::Leave:
+		n = "Leave";
+		break;
+	    case TQEvent::Paint:
+		n = "Paint";
+		break;
+	    case TQEvent::Move:
+		n = "Move";
+		break;
+	    case TQEvent::Resize:
+		n = "Resize";
+		break;
+	    case TQEvent::Create:
+		n = "Create";
+		break;
+	    case TQEvent::Destroy:
+		n = "Destroy";
+		break;
+	    case TQEvent::Close:
+		n = "Close";
+		break;
+	    case TQEvent::Quit:
+		n = "Quit";
+		break;
+	    default:
+		n = "<other>";
+		break;
+	    }
+	    qWarning("TQEvent: Warning: %s event deleted while posted to %s %s",
+		     n,
+		     pe->receiver ? pe->receiver->className() : "null",
+		     pe->receiver ? pe->receiver->name() : "object" );
+	    // note the beautiful uglehack if !pe->receiver :)
+#endif
+	    event->posted = FALSE;
+	    delete pe->event;
+	    pe->event = 0;
+	    return;
+	}
+    }
+}
+
+/*!\internal
+
+  Sets the active window in reaction to a system event. Call this
+  from the platform specific event handlers.
+
+  It sets the activeWindow() and tqfocusWidget() attributes and sends
+  proper WindowActivate/WindowDeactivate and FocusIn/FocusOut events
+  to all appropriate widgets.
+
+  \sa activeWindow()
+ */
+void TQApplication::setActiveWindow( TQWidget* act )
+{
+    TQWidget* window = act?act->tqtopLevelWidget():0;
+
+    if ( active_window == window )
+	return;
+
+    // first the activation/deactivation events
+    if ( active_window ) {
+	TQWidgetList deacts;
+#ifndef TQT_NO_STYLE
+	if ( style().tqstyleHint(TQStyle::SH_Widget_ShareActivation, active_window ) ) {
+	    TQWidgetList *list = tqtopLevelWidgets();
+	    if ( list ) {
+		for ( TQWidget *w = list->first(); w; w = list->next() ) {
+		    if ( w->isVisible() && w->isActiveWindow() )
+			deacts.append(w);
+		}
+		delete list;
+	    }
+	} else
+#endif
+	    deacts.append(active_window);
+	active_window = 0;
+	TQEvent e( TQEvent::WindowDeactivate );
+	for(TQWidget *w = deacts.first(); w; w = deacts.next())
+	    TQApplication::sendSpontaneousEvent( w, &e );
+    }
+
+    active_window = window;
+    if ( active_window ) {
+	TQEvent e( TQEvent::WindowActivate );
+	TQWidgetList acts;
+#ifndef TQT_NO_STYLE
+	if ( style().tqstyleHint(TQStyle::SH_Widget_ShareActivation, active_window ) ) {
+	    TQWidgetList *list = tqtopLevelWidgets();
+	    if ( list ) {
+		for ( TQWidget *w = list->first(); w; w = list->next() ) {
+		    if ( w->isVisible() && w->isActiveWindow() )
+			acts.append(w);
+		}
+		delete list;
+	    }
+	} else
+#endif
+	    acts.append(active_window);
+	for(TQWidget *w = acts.first(); w; w = acts.next())
+	    TQApplication::sendSpontaneousEvent( w, &e );
+    }
+
+    // then focus events
+    TQFocusEvent::setReason( TQFocusEvent::ActiveWindow );
+    if ( !active_window && focus_widget ) {
+	TQFocusEvent out( TQEvent::FocusOut );
+	TQWidget *tmp = focus_widget;
+	focus_widget = 0;
+#ifdef TQ_WS_WIN
+	TQInputContext::accept( tmp );
+#endif
+	TQApplication::sendSpontaneousEvent( tmp, &out );
+    } else if ( active_window ) {
+	TQWidget *w = active_window->tqfocusWidget();
+	if ( w && w->focusPolicy() != TQWidget::NoFocus )
+	    w->setFocus();
+	else
+	    active_window->focusNextPrevChild( TRUE );
+    }
+    TQFocusEvent::resetReason();
+}
+
+
+/*!\internal
+
+  Creates the proper Enter/Leave event when widget \a enter is entered
+  and widget \a leave is left.
+ */
+TQ_EXPORT void qt_dispatchEnterLeave( TQWidget* enter, TQWidget* leave ) {
+#if 0
+    if ( leave ) {
+	TQEvent e( TQEvent::Leave );
+	TQApplication::sendEvent( leave, & e );
+    }
+    if ( enter ) {
+	TQEvent e( TQEvent::Enter );
+	TQApplication::sendEvent( enter, & e );
+    }
+    return;
+#endif
+
+    TQWidget* w ;
+    if ( !enter && !leave )
+	return;
+    TQWidgetList leaveList;
+    TQWidgetList enterList;
+
+    bool sameWindow = leave && enter && leave->tqtopLevelWidget() == enter->tqtopLevelWidget();
+    if ( leave && !sameWindow ) {
+	w = leave;
+	do {
+	    leaveList.append( w );
+	} while ( (w = w->parentWidget( TRUE ) ) );
+    }
+    if ( enter && !sameWindow ) {
+	w = enter;
+	do {
+	    enterList.prepend( w );
+	} while ( (w = w->parentWidget(TRUE) ) );
+    }
+    if ( sameWindow ) {
+	int enterDepth = 0;
+	int leaveDepth = 0;
+	w = enter;
+	while ( ( w = w->parentWidget( TRUE ) ) )
+	    enterDepth++;
+	w = leave;
+	while ( ( w = w->parentWidget( TRUE ) ) )
+	    leaveDepth++;
+	TQWidget* wenter = enter;
+	TQWidget* wleave = leave;
+	while ( enterDepth > leaveDepth ) {
+	    wenter = wenter->parentWidget();
+	    enterDepth--;
+	}
+	while ( leaveDepth > enterDepth ) {
+	    wleave = wleave->parentWidget();
+	    leaveDepth--;
+	}
+	while ( !wenter->isTopLevel() && wenter != wleave ) {
+	    wenter = wenter->parentWidget();
+	    wleave = wleave->parentWidget();
+	}
+
+	w = leave;
+	while ( w != wleave ) {
+	    leaveList.append( w );
+	    w = w->parentWidget();
+	}
+	w = enter;
+	while ( w != wenter ) {
+	    enterList.prepend( w );
+	    w = w->parentWidget();
+	}
+    }
+
+    TQEvent leaveEvent( TQEvent::Leave );
+    for ( w = leaveList.first(); w; w = leaveList.next() ) {
+	if ( !tqApp->activeModalWidget() || qt_tryModalHelper( w, 0 ))
+	    TQApplication::sendEvent( w, &leaveEvent );
+    }
+    TQEvent enterEvent( TQEvent::Enter );
+    for ( w = enterList.first(); w; w = enterList.next() ) {
+	if ( !tqApp->activeModalWidget() || qt_tryModalHelper( w, 0 ))
+	    TQApplication::sendEvent( w, &enterEvent );
+    }
+}
+
+
+#ifdef TQ_WS_MACX
+extern TQWidget *qt_tryModalHelperMac( TQWidget * top ); //qapplication_mac.cpp
+#endif
+
+
+/*!\internal
+
+  Called from qapplication_<platform>.cpp, returns TRUE
+  if the widget should accept the event.
+ */
+TQ_EXPORT bool qt_tryModalHelper( TQWidget *widget, TQWidget **rettop ) {
+    TQWidget *modal=0, *top=TQApplication::activeModalWidget();
+    if ( rettop ) *rettop = top;
+
+    if ( tqApp->activePopupWidget() )
+	return TRUE;
+
+#ifdef TQ_WS_MACX
+    top = qt_tryModalHelperMac( top );
+    if ( rettop ) *rettop = top;
+#endif
+
+    TQWidget* groupLeader = widget;
+    widget = widget->tqtopLevelWidget();
+
+    if ( widget->testWFlags(TQt::WShowModal) )	// widget is modal
+	modal = widget;
+    if ( !top || modal == top )			// don't block event
+	return TRUE;
+
+    TQWidget * p = widget->parentWidget(); // Check if the active modal widget is a tqparent of our widget
+    while ( p ) {
+	if ( p == top )
+	    return TRUE;
+	p = p->parentWidget();
+    }
+
+    while ( groupLeader && !groupLeader->testWFlags( TQt::WGroupLeader ) )
+	groupLeader = groupLeader->parentWidget();
+
+    if ( groupLeader ) {
+	// Does groupLeader have a child in qt_modal_stack?
+	bool unrelated = TRUE;
+	modal = qt_modal_stack->first();
+	while (modal && unrelated) {
+	    TQWidget* p = modal->parentWidget();
+	    while ( p && p != groupLeader && !p->testWFlags( TQt::WGroupLeader) ) {
+		p = p->parentWidget();
+	    }
+	    modal = qt_modal_stack->next();
+	    if ( p == groupLeader ) unrelated = FALSE;
+	}
+
+	if ( unrelated )
+	    return TRUE;		// don't block event
+    }
+    return FALSE;
+}
+
+
+/*!
+  Returns the desktop widget (also called the root window).
+
+  The desktop widget is useful for obtaining the size of the screen.
+  It may also be possible to draw on the desktop. We recommend against
+  assuming that it's possible to draw on the desktop, since this does
+  not work on all operating systems.
+
+  \code
+    TQDesktopWidget *d = TQApplication::desktop();
+    int w = d->width();	    // returns desktop width
+    int h = d->height();    // returns desktop height
+  \endcode
+*/
+
+TQDesktopWidget *TQApplication::desktop()
+{
+    if ( !qt_desktopWidget || // not created yet
+	 !qt_desktopWidget->isDesktop() ) { // reparented away
+	qt_desktopWidget = new TQDesktopWidget();
+	TQ_CHECK_PTR( qt_desktopWidget );
+    }
+    return qt_desktopWidget;
+}
+
+#ifndef TQT_NO_CLIPBOARD
+/*!
+  Returns a pointer to the application global clipboard.
+*/
+TQClipboard *TQApplication::clipboard()
+{
+    if ( qt_clipboard == 0 ) {
+	qt_clipboard = new TQClipboard;
+	TQ_CHECK_PTR( qt_clipboard );
+    }
+    return qt_clipboard;
+}
+#endif // TQT_NO_CLIPBOARD
+
+/*!
+  By default, TQt will try to use the current standard colors, fonts
+  etc., from the underlying window system's desktop settings,
+  and use them for all relevant widgets. This behavior can be switched off
+  by calling this function with \a on set to FALSE.
+
+  This static function must be called before creating the TQApplication
+  object, like this:
+
+  \code
+  int main( int argc, char** argv ) {
+    TQApplication::setDesktopSettingsAware( FALSE ); // I know better than the user
+    TQApplication myApp( argc, argv ); // Use default fonts & colors
+    ...
+  }
+  \endcode
+
+  \sa desktopSettingsAware()
+*/
+
+void TQApplication::setDesktopSettingsAware( bool on )
+{
+    obey_desktop_settings = on;
+}
+
+/*!
+  Returns the value set by setDesktopSettingsAware(); by default TRUE.
+
+  \sa setDesktopSettingsAware()
+*/
+
+bool TQApplication::desktopSettingsAware()
+{
+    return obey_desktop_settings;
+}
+
+/*! \fn void TQApplication::lock()
+
+  Lock the TQt Library Mutex. If another thread has already locked the
+  mutex, the calling thread will block until the other thread has
+  unlocked the mutex.
+
+  \sa unlock() locked() \link threads.html Thread Support in TQt\endlink
+*/
+
+
+/*! \fn void TQApplication::unlock(bool wakeUpGui)
+
+  Unlock the TQt Library Mutex. If \a wakeUpGui is TRUE (the default),
+  then the GUI thread will be woken with TQApplication::wakeUpGuiThread().
+
+  \sa lock(), locked() \link threads.html Thread Support in TQt\endlink
+*/
+
+
+/*! \fn bool TQApplication::locked()
+
+  Returns TRUE if the TQt Library Mutex is locked by a different thread;
+  otherwise returns FALSE.
+
+  \warning Due to different implementations of recursive mutexes on
+  the supported platforms, calling this function from the same thread
+  that previously locked the mutex will give undefined results.
+
+  \sa lock() unlock() \link threads.html Thread Support in TQt\endlink
+*/
+
+/*! \fn bool TQApplication::tryLock()
+
+  Attempts to lock the TQt Library Mutex, and returns immediately. If
+  the lock was obtained, this function returns TRUE. If another thread
+  has locked the mutex, this function returns FALSE, instead of
+  waiting for the lock to become available.
+
+  The mutex must be unlocked with unlock() before another thread can
+  successfully lock it.
+
+  \sa lock(), unlock() \link threads.html Thread Support in TQt\endlink
+*/
+
+#if defined(TQT_THREAD_SUPPORT)
+void TQApplication::lock()
+{
+    qt_mutex->lock();
+}
+
+void TQApplication::unlock(bool wakeUpGui)
+{
+    qt_mutex->unlock();
+
+    if (wakeUpGui)
+	wakeUpGuiThread();
+}
+
+bool TQApplication::locked()
+{
+    return qt_mutex->locked();
+}
+
+bool TQApplication::tryLock()
+{
+    return qt_mutex->tryLock();
+}
+#endif
+
+
+/*!
+  \fn bool TQApplication::isSessionRestored() const
+
+  Returns TRUE if the application has been restored from an earlier
+  \link session.html session\endlink; otherwise returns FALSE.
+
+  \sa sessionId(), commitData(), saveState()
+*/
+
+
+/*!
+  \fn TQString TQApplication::sessionId() const
+
+  Returns the current \link session.html session's\endlink identifier.
+
+  If the application has been restored from an earlier session, this
+  identifier is the same as it was in that previous session.
+
+  The session identifier is guaranteed to be unique both for different
+  applications and for different instances of the same application.
+
+  \sa isSessionRestored(), sessionKey(), commitData(), saveState()
+ */
+
+/*!
+  \fn TQString TQApplication::sessionKey() const
+
+  Returns the session key in the current \link session.html
+  session\endlink.
+
+  If the application has been restored from an earlier session, this
+  key is the same as it was when the previous session ended.
+
+  The session key changes with every call of commitData() or
+  saveState().
+
+  \sa isSessionRestored(), sessionId(), commitData(), saveState()
+ */
+
+
+/*!
+  \fn void TQApplication::commitData( TQSessionManager& sm )
+
+  This function deals with \link session.html session
+  management\endlink. It is invoked when the TQSessionManager wants the
+  application to commit all its data.
+
+  Usually this means saving all open files, after getting
+  permission from the user. Furthermore you may want to provide a means
+  by which the user can cancel the shutdown.
+
+  Note that you should not exit the application within this function.
+  Instead, the session manager may or may not do this afterwards,
+  depending on the context.
+
+  \warning Within this function, no user interaction is possible, \e
+  unless you ask the session manager \a sm for explicit permission.
+  See TQSessionManager::allowsInteraction() and
+  TQSessionManager::allowsErrorInteraction() for details and example
+  usage.
+
+  The default implementation requests interaction and sends a close
+  event to all visible top level widgets. If any event was
+  rejected, the shutdown is canceled.
+
+  \sa isSessionRestored(), sessionId(), saveState(), \link session.html the Session Management overview\endlink
+*/
+#ifndef TQT_NO_SESSIONMANAGER
+void TQApplication::commitData( TQSessionManager& sm  )
+{
+
+    if ( sm.allowsInteraction() ) {
+	TQWidgetList done;
+	TQWidgetList *list = TQApplication::tqtopLevelWidgets();
+	bool cancelled = FALSE;
+	TQWidget* w = list->first();
+	while ( !cancelled && w ) {
+	    if ( !w->isHidden() ) {
+		TQCloseEvent e;
+		sendEvent( w, &e );
+		cancelled = !e.isAccepted();
+		if ( !cancelled )
+		    done.append( w );
+		delete list; // one never knows...
+		list = TQApplication::tqtopLevelWidgets();
+		w = list->first();
+	    } else {
+		w = list->next();
+	    }
+	    while ( w && done.tqcontainsRef( w ) )
+		w = list->next();
+	}
+	delete list;
+	if ( cancelled )
+	    sm.cancel();
+    }
+}
+
+
+/*!
+  \fn void TQApplication::saveState( TQSessionManager& sm )
+
+  This function deals with \link session.html session
+  management\endlink. It is invoked when the
+  \link TQSessionManager session manager \endlink wants the application
+  to preserve its state for a future session.
+
+  For example, a text editor would create a temporary file that
+  includes the current contents of its edit buffers, the location of
+  the cursor and other aspects of the current editing session.
+
+  Note that you should never exit the application within this
+  function. Instead, the session manager may or may not do this
+  afterwards, depending on the context. Futhermore, most session
+  managers will very likely request a saved state immediately after
+  the application has been started. This permits the session manager
+  to learn about the application's restart policy.
+
+  \warning Within this function, no user interaction is possible, \e
+  unless you ask the session manager \a sm for explicit permission.
+  See TQSessionManager::allowsInteraction() and
+  TQSessionManager::allowsErrorInteraction() for details.
+
+  \sa isSessionRestored(), sessionId(), commitData(), \link session.html the Session Management overview\endlink
+*/
+
+void TQApplication::saveState( TQSessionManager& /* sm */ )
+{
+}
+#endif //TQT_NO_SESSIONMANAGER
+/*!
+  Sets the time after which a drag should start to \a ms ms.
+
+  \sa startDragTime()
+*/
+
+void TQApplication::setStartDragTime( int ms )
+{
+    drag_time = ms;
+}
+
+/*!
+  If you support drag and drop in you application and a drag should
+  start after a mouse click and after a certain time elapsed, you
+  should use the value which this method returns as the delay (in ms).
+
+  TQt also uses this delay internally, e.g. in TQTextEdit and TQLineEdit,
+  for starting a drag.
+
+  The default value is 500 ms.
+
+  \sa setStartDragTime(), startDragDistance()
+*/
+
+int TQApplication::startDragTime()
+{
+    return drag_time;
+}
+
+/*!
+  Sets the distance after which a drag should start to \a l pixels.
+
+  \sa startDragDistance()
+*/
+
+void TQApplication::setStartDragDistance( int l )
+{
+    drag_distance = l;
+}
+
+/*!
+  If you support drag and drop in you application and a drag should
+  start after a mouse click and after moving the mouse a certain
+  distance, you should use the value which this method returns as the
+  distance.
+
+  For example, if the mouse position of the click is stored in \c
+  startPos and the current position (e.g. in the mouse move event) is
+  \c currPos, you can tqfind out if a drag should be started with code
+  like this:
+  \code
+  if ( ( startPos - currPos ).manhattanLength() >
+       TQApplication::startDragDistance() )
+    startTheDrag();
+  \endcode
+
+  TQt uses this value internally, e.g. in TQFileDialog.
+
+  The default value is 4 pixels.
+
+  \sa setStartDragDistance(), startDragTime(), TQPoint::manhattanLength()
+*/
+
+int TQApplication::startDragDistance()
+{
+    return drag_distance;
+}
+
+/*!
+  If \a b is TRUE, all dialogs and widgets will be laid out in a
+  mirrored fashion, as required by right to left languages such as
+  Arabic and Hebrew. If \a b is FALSE, dialogs and widgets are laid
+  out left to right.
+
+  Changing this flag in runtime does not cause a retqlayout of already
+  instantiated widgets.
+
+  \sa reverseLayout()
+*/
+void TQApplication::setReverseLayout( bool b )
+{
+    if ( reverse_tqlayout == b )
+	return;
+
+    reverse_tqlayout = b;
+
+    TQWidgetList *list = tqtopLevelWidgets();
+    TQWidgetListIt it( *list );
+    TQWidget *w;
+    while ( ( w=it.current() ) != 0 ) {
+	++it;
+	postEvent( w, new TQEvent( TQEvent::LayoutDirectionChange ) );
+    }
+    delete list;
+}
+
+/*!
+    Returns TRUE if all dialogs and widgets will be laid out in a
+    mirrored (right to left) fashion. Returns FALSE if dialogs and
+    widgets will be laid out left to right.
+
+  \sa setReverseLayout()
+*/
+bool TQApplication::reverseLayout()
+{
+    return reverse_tqlayout;
+}
+
+
+/*!
+  \class TQSessionManager tqsessionmanager.h
+  \brief The TQSessionManager class provides access to the session manager.
+
+  \ingroup application
+  \ingroup environment
+
+  The session manager is responsible for session management, most
+  importantly for interruption and resumption. A "session" is a kind
+  of record of the state of the system, e.g. which applications were
+  run at start up and which applications are currently running. The
+  session manager is used to save the session, e.g. when the machine
+  is shut down; and to restore a session, e.g. when the machine is
+  started up. Use TQSettings to save and restore an individual
+  application's settings, e.g. window positions, recently used files,
+  etc.
+
+  TQSessionManager provides an interface between the application and
+  the session manager so that the program can work well with the
+  session manager. In TQt, session management requests for action
+  are handled by the two virtual functions TQApplication::commitData()
+  and TQApplication::saveState(). Both provide a reference to
+  a session manager object as argument, to allow the application
+  to communicate with the session manager.
+
+  During a session management action (i.e. within commitData() and
+  saveState()), no user interaction is possible \e unless the
+  application got explicit permission from the session manager. You
+  ask for permission by calling allowsInteraction() or, if it's really
+  urgent, allowsErrorInteraction(). TQt does not enforce this, but the
+  session manager may.
+
+  You can try to abort the shutdown process by calling cancel(). The
+  default commitData() function does this if some top-level window
+  rejected its closeEvent().
+
+  For sophisticated session managers provided on Unix/X11, TQSessionManager
+  offers further possibilites to fine-tune an application's session
+  management behavior: setRestartCommand(), setDiscardCommand(),
+  setRestartHint(), setProperty(), requestPhase2(). See the respective
+  function descriptions for further details.
+*/
+
+/*! \enum TQSessionManager::RestartHint
+
+  This enum type defines the circumstances under which this
+  application wants to be restarted by the session manager. The
+  current values are
+
+  \value RestartIfRunning  if the application is still running when
+  the session is shut down, it wants to be restarted at the start of
+  the next session.
+
+  \value RestartAnyway  the application wants to be started at the
+  start of the next session, no matter what. (This is useful for
+  utilities that run just after startup and then quit.)
+
+  \value RestartImmediately  the application wants to be started
+  immediately whenever it is not running.
+
+  \value RestartNever  the application does not want to be restarted
+  automatically.
+
+  The default hint is \c RestartIfRunning.
+*/
+
+
+/*!
+  \fn TQString TQSessionManager::sessionId() const
+
+  Returns the identifier of the current session.
+
+  If the application has been restored from an earlier session, this
+  identifier is the same as it was in that earlier session.
+
+  \sa sessionKey(), TQApplication::sessionId()
+ */
+
+/*!
+  \fn TQString TQSessionManager::sessionKey() const
+
+  Returns the session key in the current session.
+
+  If the application has been restored from an earlier session, this
+  key is the same as it was when the previous session ended.
+
+  The session key changes with every call of commitData() or
+  saveState().
+
+  \sa sessionId(), TQApplication::sessionKey()
+ */
+
+// ### Note: This function is undocumented, since it is #ifdef'd.
+
+/*!
+  \fn void* TQSessionManager::handle() const
+
+  X11 only: returns a handle to the current \c SmcConnection.
+*/
+
+
+/*!
+  \fn bool TQSessionManager::allowsInteraction()
+
+  Asks the session manager for permission to interact with the
+  user. Returns TRUE if interaction is permitted; otherwise
+  returns FALSE.
+
+  The rationale behind this mechanism is to make it possible to
+  synchronize user interaction during a shutdown. Advanced session
+  managers may ask all applications simultaneously to commit their
+  data, resulting in a much faster shutdown.
+
+  When the interaction is completed we strongly recommend releasing the
+  user interaction semaphore with a call to release(). This way, other
+  applications may get the chance to interact with the user while your
+  application is still busy saving data. (The semaphore is implicitly
+  released when the application exits.)
+
+  If the user decides to cancel the shutdown process during the
+  interaction phase, you must tell the session manager that this has
+  happened by calling cancel().
+
+  Here's an example of how an application's TQApplication::commitData()
+  might be implemented:
+
+\code
+void MyApplication::commitData( TQSessionManager& sm ) {
+    if ( sm.allowsInteraction() ) {
+	switch ( TQMessageBox::warning(
+		    yourMainWindow,
+		    tr("Application Name"),
+		    tr("Save changes to document Foo?"),
+		    tr("&Yes"),
+		    tr("&No"),
+		    tr("Cancel"),
+		    0, 2) ) {
+	case 0: // yes
+	    sm.release();
+	    // save document here; if saving fails, call sm.cancel()
+	    break;
+	case 1: // continue without saving
+	    break;
+	default: // cancel
+	    sm.cancel();
+	    break;
+	}
+    } else {
+	// we did not get permission to interact, then
+	// do something reasonable instead.
+    }
+}
+\endcode
+
+  If an error occurred within the application while saving its data,
+  you may want to try allowsErrorInteraction() instead.
+
+  \sa TQApplication::commitData(), release(), cancel()
+*/
+
+
+/*!
+  \fn bool TQSessionManager::allowsErrorInteraction()
+
+  This is similar to allowsInteraction(), but also tells the session
+  manager that an error occurred. Session managers may give error
+  interaction request higher priority, which means that it is more likely
+  that an error interaction is permitted. However, you are still not
+  guaranteed that the session manager will allow interaction.
+
+  \sa allowsInteraction(), release(), cancel()
+*/
+
+/*!
+  \fn void TQSessionManager::release()
+
+  Releases the session manager's interaction semaphore after an
+  interaction phase.
+
+  \sa allowsInteraction(), allowsErrorInteraction()
+*/
+
+/*!
+  \fn void TQSessionManager::cancel()
+
+  Tells the session manager to cancel the shutdown process.  Applications
+  should not call this function without first asking the user.
+
+  \sa allowsInteraction(), allowsErrorInteraction()
+
+*/
+
+/*!
+  \fn void TQSessionManager::setRestartHint( RestartHint hint )
+
+  Sets the application's restart hint to \a hint. On application
+  startup the hint is set to \c RestartIfRunning.
+
+  Note that these flags are only hints, a session manager may or may
+  not respect them.
+
+  We recommend setting the restart hint in TQApplication::saveState()
+  because most session managers perform a checkpoint shortly after an
+  application's startup.
+
+  \sa restartHint()
+*/
+
+/*!
+  \fn TQSessionManager::RestartHint TQSessionManager::restartHint() const
+
+  Returns the application's current restart hint. The default is
+  \c RestartIfRunning.
+
+  \sa setRestartHint()
+*/
+
+/*!
+  \fn void TQSessionManager::setRestartCommand( const TQStringList& command )
+
+  If the session manager is capable of restoring sessions it will
+  execute \a command in order to restore the application. The command
+  defaults to
+
+  \code
+	appname -session id
+  \endcode
+
+  The \c -session option is mandatory; otherwise TQApplication cannot
+  tell whether it has been restored or what the current session
+  identifier is. See TQApplication::isSessionRestored() and
+  TQApplication::sessionId() for details.
+
+  If your application is very simple, it may be possible to store the
+  entire application state in additional command line options. This
+  is usually a very bad idea because command lines are often limited
+  to a few hundred bytes. Instead, use TQSettings, or temporary files
+  or a database for this purpose. By marking the data with the unique
+  sessionId(), you will be able to restore the application in a future
+  session.
+
+  \sa restartCommand(), setDiscardCommand(), setRestartHint()
+*/
+
+/*!
+  \fn TQStringList TQSessionManager::restartCommand() const
+
+  Returns the currently set restart command.
+
+  Note that if you want to iterate over the list, you should
+  iterate over a copy, e.g.
+    \code
+    TQStringList list = mySession.restartCommand();
+    TQStringList::Iterator it = list.begin();
+    while( it != list.end() ) {
+	myProcessing( *it );
+	++it;
+    }
+    \endcode
+
+  \sa setRestartCommand(), restartHint()
+*/
+
+/*!
+  \fn void TQSessionManager::setDiscardCommand( const TQStringList& )
+
+  \sa discardCommand(), setRestartCommand()
+*/
+
+
+/*!
+  \fn TQStringList TQSessionManager::discardCommand() const
+
+  Returns the currently set discard command.
+
+  Note that if you want to iterate over the list, you should
+  iterate over a copy, e.g.
+    \code
+    TQStringList list = mySession.discardCommand();
+    TQStringList::Iterator it = list.begin();
+    while( it != list.end() ) {
+	myProcessing( *it );
+	++it;
+    }
+    \endcode
+
+  \sa setDiscardCommand(), restartCommand(), setRestartCommand()
+*/
+
+/*!
+  \overload void TQSessionManager::setManagerProperty( const TQString& name,
+						      const TQString& value )
+
+  Low-level write access to the application's identification and state
+  records are kept in the session manager.
+
+    The property called \a name has its value set to the string \a value.
+*/
+
+/*!
+  \fn void TQSessionManager::setManagerProperty( const TQString& name,
+						const TQStringList& value )
+
+  Low-level write access to the application's identification and state
+  record are kept in the session manager.
+
+    The property called \a name has its value set to the string list \a value.
+*/
+
+/*!
+  \fn bool TQSessionManager::isPhase2() const
+
+  Returns TRUE if the session manager is currently performing a second
+  session management phase; otherwise returns FALSE.
+
+  \sa requestPhase2()
+*/
+
+/*!
+  \fn void TQSessionManager::requestPhase2()
+
+  Requests a second session management phase for the application. The
+  application may then return immediately from the
+  TQApplication::commitData() or TQApplication::saveState() function,
+  and they will be called again once most or all other applications have
+  finished their session management.
+
+  The two phases are useful for applications such as the X11 window manager
+  that need to store information about another application's windows
+  and therefore have to wait until these applications have completed their
+  respective session management tasks.
+
+  Note that if another application has requested a second phase it
+  may get called before, simultaneously with, or after your
+  application's second phase.
+
+  \sa isPhase2()
+*/
+
+/*!
+  \fn int TQApplication::horizontalAlignment( int align )
+
+  Strips out vertical tqalignment flags and transforms an
+  tqalignment \a align of AlignAuto into AlignLeft or
+  AlignRight according to the language used. The other horizontal
+  tqalignment flags are left untouched.
+*/
+
+
+/*****************************************************************************
+  Stubbed session management support
+ *****************************************************************************/
+#ifndef TQT_NO_SESSIONMANAGER
+#if defined( TQT_NO_SM_SUPPORT ) || defined( TQ_WS_WIN ) || defined( TQ_WS_MAC ) || defined( TQ_WS_TQWS )
+
+class TQSessionManagerData
+{
+public:
+    TQStringList restartCommand;
+    TQStringList discardCommand;
+    TQString sessionId;
+    TQString sessionKey;
+    TQSessionManager::RestartHint restartHint;
+};
+
+TQSessionManager* qt_session_manager_self = 0;
+TQSessionManager::TQSessionManager( TQApplication * app, TQString &id, TQString &key )
+    : TQObject( app, "qt_sessionmanager" )
+{
+    qt_session_manager_self = this;
+    d = new TQSessionManagerData;
+#if defined(TQ_WS_WIN) && !defined(TQ_OS_TEMP)
+    wchar_t guidstr[40];
+    GUID guid;
+    CoCreateGuid( &guid );
+    StringFromGUID2(guid, guidstr, 40);
+    id = TQString::fromUcs2((ushort*)guidstr);
+    CoCreateGuid( &guid );
+    StringFromGUID2(guid, guidstr, 40);
+    key = TQString::fromUcs2((ushort*)guidstr);
+#endif
+    d->sessionId = id;
+    d->sessionKey = key;
+    d->restartHint = RestartIfRunning;
+}
+
+TQSessionManager::~TQSessionManager()
+{
+    delete d;
+    qt_session_manager_self = 0;
+}
+
+TQString TQSessionManager::sessionId() const
+{
+    return d->sessionId;
+}
+
+TQString TQSessionManager::sessionKey() const
+{
+    return d->sessionKey;
+}
+
+
+#if defined(TQ_WS_X11) || defined(TQ_WS_MAC)
+void* TQSessionManager::handle() const
+{
+    return 0;
+}
+#endif
+
+#if !defined(TQ_WS_WIN)
+bool TQSessionManager::allowsInteraction()
+{
+    return TRUE;
+}
+
+bool TQSessionManager::allowsErrorInteraction()
+{
+    return TRUE;
+}
+void TQSessionManager::release()
+{
+}
+
+void TQSessionManager::cancel()
+{
+}
+#endif
+
+
+void TQSessionManager::setRestartHint( TQSessionManager::RestartHint hint)
+{
+    d->restartHint = hint;
+}
+
+TQSessionManager::RestartHint TQSessionManager::restartHint() const
+{
+    return d->restartHint;
+}
+
+void TQSessionManager::setRestartCommand( const TQStringList& command)
+{
+    d->restartCommand = command;
+}
+
+TQStringList TQSessionManager::restartCommand() const
+{
+    return d->restartCommand;
+}
+
+void TQSessionManager::setDiscardCommand( const TQStringList& command)
+{
+    d->discardCommand = command;
+}
+
+TQStringList TQSessionManager::discardCommand() const
+{
+    return d->discardCommand;
+}
+
+void TQSessionManager::setManagerProperty( const TQString&, const TQString&)
+{
+}
+
+void TQSessionManager::setManagerProperty( const TQString&, const TQStringList& )
+{
+}
+
+bool TQSessionManager::isPhase2() const
+{
+    return FALSE;
+}
+
+void TQSessionManager::requestPhase2()
+{
+}
+
+#endif // TQT_NO_SM_SUPPORT
+#endif //TQT_NO_SESSIONMANAGER
+
+#endif // USE_QT4