diff options
Diffstat (limited to 'src/kernel/qapplication.cpp')
| -rw-r--r-- | src/kernel/qapplication.cpp | 4602 |
1 files changed, 4602 insertions, 0 deletions
diff --git a/src/kernel/qapplication.cpp b/src/kernel/qapplication.cpp new file mode 100644 index 000000000..437361f88 --- /dev/null +++ b/src/kernel/qapplication.cpp @@ -0,0 +1,4602 @@ +/**************************************************************************** +** +** Implementation of TQApplication class +** +** Created : 931107 +** +** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved. +** +** 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 retquirements 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 "qobjectlist.h" +#include "qapplication.h" +#include "qeventloop.h" +#include "qeventloop_p.h" +#include "qwidget.h" +#include "qwidgetlist.h" +#include "qwidgetintdict.h" +#include "qptrdict.h" +#include "qcleanuphandler.h" + +#include "qtranslator.h" +#include "qtextcodec.h" +#include "qsessionmanager.h" +#include "qdragobject.h" +#include "qclipboard.h" +#include "qcursor.h" +#include "qstyle.h" +#include "qstylefactory.h" +#include "qfile.h" +#include "qmessagebox.h" +#include "qdir.h" +#include "qfileinfo.h" +#ifdef Q_WS_WIN +#include "qinputcontext_p.h" +#endif +#include "qfontdata_p.h" + +#if defined(QT_THREAD_SUPPORT) +# include "qmutex.h" +# include "qthread.h" +#endif // QT_THREAD_SUPPORT + +#include <stdlib.h> + +#ifdef truncate +# undef truncate +#endif + +/*! + \class TQApplication qapplication.h + \brief The TQApplication class manages the GUI application's control + flow and main settings. + + \ingroup application + \mainclass + + It contains 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 + qApp. 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 + topLevelWidgets() 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> contains 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 -geometry 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(), + tquit(). + 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(), + topLevelWidgets(), + desktop(), + activePopupWidget(), + activeModalWidget(), + clipboard(), + focusWidget(), + 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 qnamespace.h + \headerfile qwindowdefs.h + \headerfile qglobal.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(Q_WS_X11) +void qt_init( Display* dpy, TQt::HANDLE, TQt::HANDLE ); +#endif +Q_EXPORT bool qt_tryModalHelper( TQWidget *widget, TQWidget **rettop ); + +TQApplication *qApp = 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 QT_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 QT_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 QT_NO_WHEELEVENT +int TQApplication::wheel_scroll_lines = 3; // number of lines to scroll +#endif +bool qt_is_gui_used; +bool Q_EXPORT qt_resolve_symlinks = TRUE; +bool Q_EXPORT qt_tab_all_widgets = TRUE; +TQRect qt_maxWindowRect; +static int drag_time = 500; +static int drag_distance = 4; +static bool reverse_layout = 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 QT_NO_COMPONENT +TQStringList *TQApplication::app_libpaths = 0; +#endif +bool TQApplication::metaComposeUnicode = FALSE; +int TQApplication::composedUnicode = 0; + +#ifdef QT_THREAD_SUPPORT +TQMutex *TQApplication::qt_mutex = 0; +static TQMutex *postevent_mutex = 0; +static TQt::HANDLE qt_application_thread_id = 0; +Q_EXPORT TQt::HANDLE qt_get_application_thread_id() +{ + return qt_application_thread_id; +} +#endif // QT_THREAD_SUPPORT + +TQEventLoop *TQApplication::eventloop = 0; // application event loop + +#ifndef QT_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(QT_TABLET_SUPPORT) +bool chokeMouse = FALSE; +#endif + +void qt_setMaxWindowRect(const TQRect& r) +{ + qt_maxWindowRect = r; + // Re-resize any maximized windows + TQWidgetList* l = TQApplication::topLevelWidgets(); + 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' parent-child delete mechanism may be better. Here is + an example of a private class which uses the parent-child mechanism + to call a cleanup function at the right time: + + \code + class MyPrivateInitStuff: public TQObject { + private: + MyPrivateInitStuff( TQObject * parent ): TQObject( parent) { + // initialization goes here + } + MyPrivateInitStuff * p; + + public: + static MyPrivateInitStuff * initStuff( TQObject * parent ) { + if ( !p ) + p = new MyPrivateInitStuff( parent ); + return p; + } + + ~MyPrivateInitStuff() { + // cleanup (the "post routine") goes here + } + } + \endcode + + By selecting the right parent widget/object, this can often be made + to clean up the module's data at the exact right moment. +*/ + +Q_EXPORT void qAddPostRoutine( TQtCleanUpFunction p) +{ + if ( !postRList ) { + postRList = new TQVFuncList; + Q_CHECK_PTR( postRList ); + } + postRList->prepend( p ); +} + + +Q_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 QT_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 QT_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 Q_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 Q_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 QT_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.find( "-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 QT_NO_SESSIONMANAGER + } else if ( qstrcmp(arg,"-session") == 0 && i < argc-1 ) { + TQCString s = argv[++i]; + if ( !s.isEmpty() ) { + session_id = TQString::fromLatin1( s ); + int p = session_id.find( '_' ); + 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 QT_NO_STYLE + if ( !s.isEmpty() ) { + setStyle( s ); + } +#endif + } + + if(j < argc) { +#ifdef Q_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 qApp pointer refers to this application object. Only + one application object should be created. + + This application object must be constructed before any \link + TQPaintDevice paint devices\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 qApp->argc() and \c qApp->argv(). + The documentation for argv() contains a detailed description of how + to process command line arguments. + + TQt debugging options (not available if TQt was compiled with the + QT_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 -geometry \e geometry, sets the client geometry 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 Q_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 ); +} + +Q_EXPORT void qt_ucm_initialize( TQApplication *theApp ) +{ + if ( qApp ) + return; + int argc = theApp->argc(); + char **argv = theApp->argv(); + theApp->construct( argc, argv, qApp->type() ); + + Q_ASSERT( qApp == 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 **)∅ // 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(Q_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 QT_CHECK_STATE + qWarning( "TQApplication: invalid Display* argument." ); +#endif // QT_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 QT_CHECK_STATE + qWarning( "TQApplication: invalid Display* argument." ); +#endif // QT_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 // Q_WS_X11 + + +void TQApplication::init_precmdline() +{ + translators = 0; + is_app_closing = FALSE; +#ifndef QT_NO_SESSIONMANAGER + is_session_restored = FALSE; +#endif +#if defined(QT_CHECK_STATE) + if ( qApp ) + qWarning( "TQApplication: There should be max one application object" ); +#endif + qApp = (TQApplication*)this; +} + +/*! + Initializes the TQApplication object, called from the constructors. +*/ + +void TQApplication::initialize( int argc, char **argv ) +{ +#ifdef QT_THREAD_SUPPORT + qt_mutex = new TQMutex( TRUE ); + postevent_mutex = new TQMutex( TRUE ); + qt_application_thread_id = TQThread::currentThread(); +#endif // QT_THREAD_SUPPORT + + app_argc = argc; + app_argv = argv; + tquit_now = FALSE; + tquit_code = 0; + TQWidget::createMapper(); // create widget mapper +#ifndef QT_NO_PALETTE + (void) palette(); // trigger creation of application palette +#endif + is_app_running = TRUE; // no longer starting up + +#ifndef QT_NO_SESSIONMANAGER + // connect to the session manager + if ( !session_key ) + session_key = new TQString; + session_manager = new TQSessionManager( qApp, 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(), topLevelWidgets() +*/ + +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(), topLevelWidgets() +*/ + +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 qApp to 0. +*/ + +TQApplication::~TQApplication() +{ +#ifndef QT_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 QT_NO_CLIPBOARD + delete qt_clipboard; + qt_clipboard = 0; +#endif + TQWidget::destroyMapper(); +#ifndef QT_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 QT_NO_STYLE + delete app_style; + app_style = 0; +#endif +#ifndef QT_NO_CURSOR + delete app_cursor; + app_cursor = 0; +#endif +#ifndef QT_NO_TRANSLATION + delete translators; +#endif + +#ifndef QT_NO_DRAGANDDROP + extern TQDragManager *qt_dnd_manager; + delete qt_dnd_manager; +#endif + + qt_cleanup(); + +#ifndef QT_NO_COMPONENT + delete app_libpaths; + app_libpaths = 0; +#endif + +#ifdef QT_THREAD_SUPPORT + delete qt_mutex; + qt_mutex = 0; + delete postevent_mutex; + postevent_mutex = 0; +#endif // QT_THREAD_SUPPORT + + if( qApp == this ) { + if ( postedEvents ) + removePostedEvents( this ); + qApp = 0; + } + is_app_running = FALSE; + + if ( widgetCount ) { + qDebug( "Widgets left: %i Max widgets: %i \n", TQWidget::instanceCounter, TQWidget::maxInstances ); + } +#ifndef QT_NO_SESSIONMANAGER + delete session_manager; + session_manager = 0; + delete session_key; + session_key = 0; +#endif //QT_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 QT_NO_WHEELEVENT + wheel_scroll_lines = 3; +#endif + drag_time = 500; + drag_distance = 4; + reverse_layout = 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 <qapplication.h> + #include <qlistbox.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 contains the three strings "showargs", + "hello" and "world". + + TQt provides a global pointer, \c qApp, 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 QT_NO_STYLE + +static TQString *qt_style_override = 0; + +/*! + Returns the application's style object. + + \sa setStyle(), TQStyle +*/ +TQStyle& TQApplication::style() +{ +#ifndef QT_NO_STYLE + if ( app_style ) + return *app_style; + if ( !qt_is_gui_used ) + qFatal( "No style available in non-gui applications!" ); + +#if defined(Q_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(Q_WS_WIN) && defined(Q_OS_TEMP) + style = "PocketPC"; +#elif defined(Q_WS_WIN) + if ( qWinVersion() >= TQt::WV_XP && qWinVersion() < TQt::WV_NT_based ) + style = "WindowsXP"; + else + style = "Windows"; // default styles for Windows +#elif defined(Q_WS_X11) && defined(Q_OS_SOLARIS) + style = "CDE"; // default style for X11 on Solaris +#elif defined(Q_WS_X11) && defined(Q_OS_IRIX) + style = "SGI"; // default style for X11 on IRIX +#elif defined(Q_WS_X11) + style = "Motif"; // default style for X11 +#elif defined(Q_WS_MAC) + style = "Macintosh"; // default style for all Mac's +#elif defined(Q_WS_QWS) + style = "Compact"; // default style for small devices +#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 QT_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::mapper) ); + register TQWidget *w; + while ( (w=it.current()) ) { // for all widgets... + ++it; + sendEvent( w, &e ); + } + } + + app_style->polish( qApp ); +#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 Q_WS_X11 + qt_explicit_app_style = TRUE; +#endif // Q_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::mapper) ); + 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( qApp ); + } + + // take care of possible palette retquirements 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( qApp ); + + // re-polish existing widgets if necessary + if (old) { + if ( is_app_running && !is_app_closing ) { + TQWidgetIntDictIt it( *((TQWidgetIntDict*)TQWidget::mapper) ); + 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 Q_WS_X11 + qt_explicit_app_style = TRUE; +#endif // Q_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 retquires 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(QT_CHECK_STATE) + if ( qApp ) { + 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-devices. + + Example: + \code + TQSize& WidgetClass::sizeHint() const + { + return TQSize( 80, 25 ).expandedTo( TQApplication::globalStrut() ); + } + \endcode + + \sa globalStrut() +*/ + +void TQApplication::setGlobalStrut( const TQSize& strut ) +{ + app_strut = strut; +} + +#if defined( Q_WS_WIN ) || defined( Q_WS_MAC ) +extern const char *qAppFileName(); +#endif + +#ifndef QT_NO_DIR +#ifndef Q_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.findRev('/')) != -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.findRev('/') + 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 // Q_WS_WIN + +/*! + Returns the directory that contains 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] contains 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] contains 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( Q_WS_WIN ) + TQFileInfo filePath; + QT_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( Q_WS_MAC ) + return TQDir::cleanDirPath( TQFile::decodeName( qAppFileName() ) ); +#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.find('/') != -1 ) { + /* + If argv0 contains 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 // QT_NO_DIR + +#ifndef QT_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 setLibraryPaths(), addLibraryPath(), removeLibraryPath(), TQLibrary +*/ +TQStringList TQApplication::libraryPaths() +{ + if ( !app_libpaths ) { + app_libpaths = new TQStringList; + TQString installPathPlugins = TQString::fromLocal8Bit(qInstallPathPlugins()); + if ( TQFile::exists(installPathPlugins) ) { +#ifdef Q_WS_WIN + installPathPlugins.replace('\\', '/'); +#endif + app_libpaths->append(installPathPlugins); + } + + TQString app_location; + if (qApp) + app_location = qApp->applicationFilePath(); +#ifdef Q_WS_WIN + else { + app_location = TQString(qAppFileName()); + app_location.replace('\\', '/'); + } +#endif + if (!app_location.isEmpty()) { + app_location.truncate( app_location.findRev( '/' ) ); + 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::setLibraryPaths( 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(), setLibraryPaths() + */ +void TQApplication::addLibraryPath( const TQString &path ) +{ + if ( path.isEmpty() ) + return; + + // make sure that library paths is initialized + libraryPaths(); + + if ( !app_libpaths->contains( 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(), setLibraryPaths() +*/ +void TQApplication::removeLibraryPath( const TQString &path ) +{ + if ( path.isEmpty() ) + return; + + // make sure that library paths is initialized + libraryPaths(); + + if ( app_libpaths->contains( path ) ) + app_libpaths->remove( path ); +} +#endif //QT_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 QT_NO_PALETTE +TQPalette TQApplication::palette(const TQWidget* w) +{ +#if defined(QT_CHECK_STATE) + if ( !qApp ) + 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->find( 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 QT_NO_STYLE + if ( !startingUp() ) // on startup this has been done already + qApp->style().polish( pal ); // NB: non-const reference +#endif + bool all = FALSE; + if ( !className ) { + if ( !app_pal ) { + app_pal = new TQPalette( pal ); + Q_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>; + Q_CHECK_PTR( app_palettes ); + app_palettes->setAutoDelete( TRUE ); + } + oldpal = app_palettes->find( 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::mapper) ); + 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 // QT_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->find( 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" ); + Q_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 ); + Q_CHECK_PTR( app_font ); + } else { + *app_font = font; + } + + // make sure the application font is complete + app_font->detach(); + app_font->d->mask = TQFontPrivate::Complete; + + all = app_fonts != 0; + delete app_fonts; + app_fonts = 0; + } else { + if (!app_fonts){ + app_fonts = new TQAsciiDict<TQFont>; + Q_CHECK_PTR( app_fonts ); + app_fonts->setAutoDelete( TRUE ); + } + TQFont* fnt = new TQFont(font); + Q_CHECK_PTR( fnt ); + app_fonts->insert(className, fnt); + } + if ( informWidgets && is_app_running && !is_app_closing ) { + TQEvent e( TQEvent::ApplicationFontChange ); + TQWidgetIntDictIt it( *((TQWidgetIntDict*)TQWidget::mapper) ); + 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 QT_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::topLevelWidgets(); + 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::topLevelWidgets() +{ + 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 qwidgetlist.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 topLevelWidgets(), TQWidget::isVisible(), TQPtrList::isEmpty(), +*/ + +TQWidgetList *TQApplication::allWidgets() +{ + return TQWidget::wList(); +} + +/*! + \fn TQWidget *TQApplication::focusWidget() 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 focusWidget(), + for example if no widget in that window accepts key events. + + \sa TQWidget::setFocus(), TQWidget::hasFocus(), focusWidget() +*/ + +/*! + 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 tquit(), and + you also often connect e.g. TQButton::clicked() or signals in + TQAction, TQPopupMenu or TQMenuBar to it. + + Example: + \code + TQPushButton *tquitButton = new TQPushButton( "Quit" ); + connect( tquitButton, SIGNAL(clicked()), qApp, SLOT(tquit()) ); + \endcode + + \sa exit() aboutToQuit() lastWindowClosed() TQAction +*/ + +void TQApplication::tquit() +{ + 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", qApp, SLOT(closeAllWindows()), CTRL+Key_Q ); + + // when the last window is closed, the application should tquit + connect( qApp, SIGNAL( lastWindowClosed() ), qApp, SLOT( tquit() ) ); + \endcode + + The windows are closed in random order, until one window does not + accept the close event. + + \sa TQWidget::close(), TQWidget::closeEvent(), lastWindowClosed(), + tquit(), topLevelWidgets(), 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::topLevelWidgets(); + for ( w = list->first(); did_close && w; ) { + if ( !w->isHidden() ) { + did_close = w->close(); + delete list; + list = TQApplication::topLevelWidgets(); + 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 QT_NO_MESSAGEBOX + TQMessageBox::aboutTQt( mainWidget() ); +#endif // QT_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 tquit() + slot. + + For convenience, this signal is \e not emitted for transient top level + widgets such as popup menus and dialogs. + + \sa mainWidget(), topLevelWidgets(), TQWidget::isTopLevel(), TQWidget::close() +*/ + +/*! + \fn void TQApplication::aboutToQuit() + + This signal is emitted when the application is about to tquit the + main event loop, e.g. when the event loop level drops to zero. + This may happen either after a call to tquit() 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 tquit() +*/ + + +/*! + \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 parent 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 qApp. + + \i Installing an event filter on qApp. 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(QT_CHECK_NULL) + qWarning( "TQApplication::notify: Unexpected null receiver" ); +#endif + return FALSE; + } + + if ( e->type() == TQEvent::ChildRemoved && receiver->postedEvents && globalPostedEvents) { + +#ifdef QT_THREAD_SUPPORT + TQMutexLocker locker( postevent_mutex ); +#endif // QT_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 QT_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)->topLevelWidget(), e ); + } + break; +#endif //QT_NO_ACCEL + case TQEvent::KeyPress: + case TQEvent::KeyRelease: + case TQEvent::AccelOverride: + { + TQWidget* w = (TQWidget*)receiver; + TQKeyEvent* key = (TQKeyEvent*) e; +#ifndef QT_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 QT_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 (QT_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->device(), + 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 = topLevelWidgets(); + 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) { + tquit(); + 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 QT_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 QT_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( qApp, "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 tquit()). + + 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 tquit(), 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 tquit(), exec() +*/ +void TQApplication::exit( int retcode ) +{ + qApp->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(Q_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 repaint 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(Q_OS_CYGWIN) +TQt::WindowsVersion TQApplication::winVersion() +{ + return qt_winver; +} +#endif + +#ifndef QT_NO_TRANSLATION + +bool qt_detectRTLLanguage() +{ + return TQApplication::tr( "QT_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 layout." ) == "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 QT_NO_TRANSLATION_BUILDER + if ( mf->isEmpty() ) + return; +#endif + + // hook to set the layout direction of dialogs + setReverseLayout( qt_detectRTLLanguage() ); + + TQWidgetList *list = topLevelWidgets(); + 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 ) && ! qApp->closingDown() ) { + setReverseLayout( qt_detectRTLLanguage() ); + + TQWidgetList *list = topLevelWidgets(); + TQWidgetListIt it( *list ); + TQWidget *w; + while ( ( w=it.current() ) != 0 ) { + ++it; + postEvent( w, new TQEvent( TQEvent::LanguageChange ) ); + } + delete list; + } +} + +#ifndef QT_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 //QT_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->findMessage( context, sourceText, comment ).translation(); + if ( !result.isNull() ) + return result; + } + } +#ifndef QT_NO_TEXTCODEC + if ( encoding == UnicodeUTF8 ) + return TQString::fromUtf8( sourceText ); + else if ( TQTextCodec::codecForTr() != 0 ) + return TQTextCodec::codecForTr()->toUnicode( sourceText ); + else +#endif + return TQString::fromLatin1( 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(QT_CHECK_NULL) + qWarning( "TQApplication::postEvent: Unexpected null receiver" ); +#endif + delete event; + return; + } + +#ifdef QT_THREAD_SUPPORT + TQMutexLocker locker( postevent_mutex ); +#endif // QT_THREAD_SUPPORT + + if ( !globalPostedEvents ) { // create list + globalPostedEvents = new TQPostEventList; + Q_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 !defined(QT_NO_IM) + // if this is one of the compressible IM events, do compression + else if ( event->type() == TQEvent::IMCompose ) { + l->last(); + TQPostEvent * cur = 0; + for ( ;; ) { + while ( (cur=l->current()) != 0 && + ( cur->receiver != receiver || + cur->event == 0 || + cur->event->type() != event->type() || + cur->event->type() != TQEvent::IMStart ) ) + l->prev(); + if ( l->current() != 0 ) { + // IMCompose must not be compressed with another one + // beyond its IMStart boundary + if ( cur->event->type() == TQEvent::IMStart ) { + break; + } else if ( cur->event->type() == TQEvent::IMCompose ) { + TQIMComposeEvent * e = (TQIMComposeEvent *)(cur->event); + *e = *(TQIMComposeEvent *)event; + delete event; + return; + } + } + break; + }; + } +#endif + + // 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 QT_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 receivers + || 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 QT_THREAD_SUPPORT + if ( locker.mutex() ) locker.mutex()->unlock(); +#endif // QT_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->repaint( p->reg, p->erase ); + } else { + sent = TRUE; + TQApplication::sendEvent( r, e ); + } +#ifdef QT_THREAD_SUPPORT + if ( locker.mutex() ) locker.mutex()->lock(); +#endif // QT_THREAD_SUPPORT + + delete e; + // careful when adding anything below this point - the + // sendEvent() call might invalidate 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 ) +{ + removePostedEvents( receiver, 0 ); +} + +/*! + Removes all events that have the event type \a event_type posted + using postEvent() for \a receiver. + + The events are \e not dispatched, instead they are removed from the + queue. + + If \a event_type is 0, all the events are removed from the queue. + + \threadsafe +*/ + +void TQApplication::removePostedEvents( TQObject *receiver, int event_type ) +{ + if ( !receiver ) + return; + +#ifdef QT_THREAD_SUPPORT + TQMutexLocker locker( postevent_mutex ); +#endif // QT_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; + l->first(); + TQPostEvent * pe; + while( (pe=l->current()) != 0 ) { + if ( !event_type || pe->event->type() == event_type ) { + if ( pe->event ) { + pe->event->posted = FALSE; + delete pe->event; + pe->event = 0; + } + l->remove(); + } else { + l->next(); + } + } + if ( !event_type || !l->count() ) { + receiver->postedEvents = 0; + 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(QT_DEBUG) + qDebug( "TQApplication::removePostedEvent: %p %d is posted: impossible", + (void*)event, event->type() ); + return; +#endif + } + +#ifdef QT_THREAD_SUPPORT + TQMutexLocker locker( postevent_mutex ); +#endif // QT_THREAD_SUPPORT + + TQPostEventListIt it( *globalPostedEvents ); + TQPostEvent * pe; + while( (pe = it.current()) != 0 ) { + ++it; + if ( pe->event == event ) { +#if defined(QT_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 QT_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 focusWidget() 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->topLevelWidget():0; + + if ( active_window == window ) + return; + + // first the activation/deactivation events + if ( active_window ) { + TQWidgetList deacts; +#ifndef QT_NO_STYLE + if ( style().styleHint(TQStyle::SH_Widget_ShareActivation, active_window ) ) { + TQWidgetList *list = topLevelWidgets(); + 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 QT_NO_STYLE + if ( style().styleHint(TQStyle::SH_Widget_ShareActivation, active_window ) ) { + TQWidgetList *list = topLevelWidgets(); + 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 Q_WS_WIN + TQInputContext::accept( tmp ); +#elif defined(Q_WS_X11) + tmp->unfocusInputContext(); +#endif + TQApplication::sendSpontaneousEvent( tmp, &out ); + } else if ( active_window ) { + TQWidget *w = active_window->focusWidget(); + 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. + */ +Q_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->topLevelWidget() == enter->topLevelWidget(); + 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 ( !qApp->activeModalWidget() || qt_tryModalHelper( w, 0 )) + TQApplication::sendEvent( w, &leaveEvent ); + } + TQEvent enterEvent( TQEvent::Enter ); + for ( w = enterList.first(); w; w = enterList.next() ) { + if ( !qApp->activeModalWidget() || qt_tryModalHelper( w, 0 )) + TQApplication::sendEvent( w, &enterEvent ); + } +} + + +#ifdef Q_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. + */ +Q_EXPORT bool qt_tryModalHelper( TQWidget *widget, TQWidget **rettop ) { + TQWidget *modal=0, *top=TQApplication::activeModalWidget(); + if ( rettop ) *rettop = top; + + if ( qApp->activePopupWidget() ) + return TRUE; + +#ifdef Q_WS_MACX + top = qt_tryModalHelperMac( top ); + if ( rettop ) *rettop = top; +#endif + + TQWidget* groupLeader = widget; + widget = widget->topLevelWidget(); + + 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 parent 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(); + Q_CHECK_PTR( qt_desktopWidget ); + } + return qt_desktopWidget; +} + +#ifndef QT_NO_CLIPBOARD +/*! + Returns a pointer to the application global clipboard. +*/ +TQClipboard *TQApplication::clipboard() +{ + if ( qt_clipboard == 0 ) { + qt_clipboard = new TQClipboard; + Q_CHECK_PTR( qt_clipboard ); + } + return qt_clipboard; +} +#endif // QT_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(QT_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 QT_NO_SESSIONMANAGER +void TQApplication::commitData( TQSessionManager& sm ) +{ + + if ( sm.allowsInteraction() ) { + TQWidgetList done; + TQWidgetList *list = TQApplication::topLevelWidgets(); + 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::topLevelWidgets(); + w = list->first(); + } else { + w = list->next(); + } + while ( w && done.containsRef( 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 //QT_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 find 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 retquired 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 relayout of already + instantiated widgets. + + \sa reverseLayout() +*/ +void TQApplication::setReverseLayout( bool b ) +{ + if ( reverse_layout == b ) + return; + + reverse_layout = b; + + TQWidgetList *list = topLevelWidgets(); + 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_layout; +} + + +/*! + \class TQSessionManager qsessionmanager.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 tquit.) + + \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 alignment flags and transforms an + alignment \a align of AlignAuto into AlignLeft or + AlignRight according to the language used. The other horizontal + alignment flags are left untouched. +*/ + + +/***************************************************************************** + Stubbed session management support + *****************************************************************************/ +#ifndef QT_NO_SESSIONMANAGER +#if defined( QT_NO_SM_SUPPORT ) || defined( Q_WS_WIN ) || defined( Q_WS_MAC ) || defined( Q_WS_QWS ) + +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(Q_WS_WIN) && !defined(Q_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(Q_WS_X11) || defined(Q_WS_MAC) +void* TQSessionManager::handle() const +{ + return 0; +} +#endif + +#if !defined(Q_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 // QT_NO_SM_SUPPORT +#endif //QT_NO_SESSIONMANAGER |