Actually move the kde files that were renamed in the last commit

1 files changed, 1620 insertions, 0 deletions

diff --git a/tdecore/kapplication.h b/tdecore/kapplication.h
new file mode 100644
index 000000000..f1be3bfb8
--- /dev/null
+++ b/tdecore/kapplication.h
@@ -0,0 +1,1620 @@
+/* This file is part of the KDE libraries
+    Copyright (C) 1997 Matthias Kalle Dalheimer (kalle@kde.org)
+    Copyright (c) 1998, 1999 KDE Team
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#ifndef _KAPP_H
+#define _KAPP_H
+
+// Version macros. Never put this further down.
+#include "kdeversion.h"
+#include "kdelibs_export.h"
+
+class KConfig;
+class KCharsets;
+class DCOPClient;
+class DCOPObject;
+
+#include <tqtglobaldefines.h>
+
+typedef unsigned long Atom;
+#if !defined(Q_WS_X11)
+typedef void Display;
+#endif
+
+#include <tqapplication.h>
+#include <tqpixmap.h>
+#include <kinstance.h>
+
+struct _IceConn;
+class TQPopupMenu;
+class TQStrList;
+class KSessionManaged;
+class KStyle;
+class KURL;
+
+#define kapp KApplication::kApplication()
+
+class KApplicationPrivate;
+
+/**
+* Controls and provides information to all KDE applications.
+*
+* Only one object of this class can be instantiated in a single app.
+* This instance is always accessible via the 'kapp' global variable.
+* See cut() for an example.
+*
+* This class provides the following services to all KDE applications.
+*
+* @li It controls the event queue (see TQApplication ).
+* @li It provides the application with KDE resources such as
+* accelerators, common menu entries, a KConfig object. session
+* management events, help invocation etc.
+* @li Installs a signal handler for the SIGCHLD signal in order to
+* avoid zombie children. If you want to catch this signal yourself or
+* don't want it to be caught at all, you have set a new signal handler
+* (or SIG_IGN) after KApplication's constructor has run.
+* @li Installs an empty signal handler for the SIGPIPE signal using
+* installSigpipeHandler(). If you want to catch this signal
+* yourself, you have set a new signal handler after KApplication's
+* constructor has run.
+* @li It can start new services
+*
+*
+* The way a service gets started depends on the 'X-DCOP-ServiceType'
+* entry in the desktop file of the service:
+*
+* There are three possibilities:
+* @li X-DCOP-ServiceType=None (default)
+*    Always start a new service,
+*    don't wait till the service registers with dcop.
+* @li X-DCOP-ServiceType=Multi
+*    Always start a new service,
+*    wait until the service has registered with dcop.
+* @li X-DCOP-ServiceType=Unique
+*    Only start the service if it isn't already running,
+*    wait until the service has registered with dcop.
+*
+* @short Controls and provides information to all KDE applications.
+* @author Matthias Kalle Dalheimer <kalle@kde.org>
+*/
+class KDECORE_EXPORT KApplication : public TQApplication, public KInstance
+{
+
+  Q_OBJECT
+public:
+  /** Position of the caption (presumably in the application window's
+  *   title bar). This enum appears to be unused.
+  *
+  * @todo Find out if this is used anywhere.
+  */
+  enum CaptionLayout {
+    CaptionAppLast=1 /**< Display the application name last (before document name). */, 
+    CaptionAppFirst /**< Display the application name first. */ , 
+    CaptionNoApp  /**< Do not display application name at all. */
+  };
+
+  /**
+   * This constructor takes aboutData and command line
+   *  arguments from KCmdLineArgs.
+   *
+   * If ARGB (transparent) widgets are to be used in your application,
+   * please use
+   * KApplication app(KApplication::openX11RGBADisplay());
+   * or
+   * KApplication app(KApplication::openX11RGBADisplay(), useStyles);
+   *
+   * @param allowStyles Set to false to disable the loading on plugin based
+   * styles. This is only useful to applications that do not display a GUI
+   * normally. If you do create an application with @p allowStyles set to false
+   * it normally runs in the background but under special circumstances
+   * displays widgets.  Call enableStyles() before displaying any widgets.
+   *
+   * @param GUIenabled Set to false to disable all GUI stuff. This implies
+   * no styles either.
+   */
+  KApplication( bool allowStyles=true, bool GUIenabled=true);
+
+#ifdef Q_WS_X11
+  /**
+   * Constructor. Parses command-line arguments. Use this constructor when you
+   * you want ARGB support to be automatically detected and enabled.
+   *
+   * @param display Will be passed to Qt as the X display. The display must be
+   * valid and already opened.
+   *
+   * @param allowStyles Set to false to disable the loading on plugin based
+   * styles. This is only useful to applications that do not display a GUI
+   * normally. If you do create an application with @p allowStyles set to false
+   * that normally runs in the background but under special circumstances
+   * displays widgets call enableStyles() before displaying any widgets.
+   *
+   * @since KDE 3.5
+   * 
+   * @see RGBADisplay()
+   */
+  KApplication(Display *display, bool allowStyles);
+
+  /**
+   * Constructor. Parses command-line arguments. Use this constructor when you
+   * you want ARGB support to be automatically detected and enabled.
+   *
+   * @param display Will be passed to Qt as the X display. The display must be
+   * valid and already opened.
+   *
+   * @param disable_argb Set to true to disable ARGB visuals in this application.
+   *
+   * @param display Will be passed to Qt as the X display. The display must be
+   * valid and already opened.
+   *
+   * @param visual A pointer to the X11 visual that should be used by the
+   * appliction. Note that only TrueColor visuals are supported on depths
+   * greater than 8 bpp. If this parameter is NULL, the default visual will
+   * be used instead.
+   *
+   * @param allowStyles Set to false to disable the loading on plugin based
+   * styles. This is only useful to applications that do not display a GUI
+   * normally. If you do create an application with @p allowStyles set to false
+   * that normally runs in the background but under special circumstances
+   * displays widgets call enableStyles() before displaying any widgets.
+   *
+   * @since KDE 3.5
+   * 
+   * @see RGBADisplay()
+   */
+  KApplication(Display *display, bool disable_argb, Qt::HANDLE visual, Qt::HANDLE colormap, bool allowStyles);
+
+  /**
+   * Constructor. Parses command-line arguments. Use this constructor when you
+   * you need to use a non-default visual or colormap. 
+   *
+   * @param display Will be passed to Qt as the X display. The display must be
+   * valid and already opened.
+   *
+   * @param visual A pointer to the X11 visual that should be used by the
+   * appliction. Note that only TrueColor visuals are supported on depths
+   * greater than 8 bpp. If this parameter is NULL, the default visual will
+   * be used instead.
+   *
+   * @param colormap The colormap that should be used by the application. If
+   * this parameter is 0, the default colormap will be used instead.
+   *
+   * @param allowStyles Set to false to disable the loading on plugin based
+   * styles. This is only useful to applications that do not display a GUI
+   * normally. If you do create an application with @p allowStyles set to false
+   * that normally runs in the background but under special circumstances
+   * displays widgets call enableStyles() before displaying any widgets.
+   *
+   * @since KDE 3.3
+   */
+  KApplication(Display *display, Qt::HANDLE visual = 0, Qt::HANDLE colormap = 0,
+               bool allowStyles=true);
+
+  /**
+   * Constructor. Parses command-line arguments. Use this constructor to use KApplication
+   * in a Motif or Xt program.
+   *
+   * @param display Will be passed to Qt as the X display. The display must be valid and already
+   * opened.
+   *
+   * @param argc command line argument count
+   *
+   * @param argv command line argument value(s)
+   *
+   * @param rAppName application name. Will be used for finding the
+   * associated message files and icon files, and as the default
+   * registration name for DCOP. This is a mandatory parameter.
+   *
+   * @param allowStyles Set to false to disable the loading on plugin based
+   * styles. This is only useful to applications that do not display a GUI
+   * normally. If you do create an application with @p allowStyles set to false
+   * that normally runs in the background but under special circumstances
+   * displays widgets call enableStyles() before displaying any widgets.
+   *
+   * @param GUIenabled Set to false to disable all GUI stuff. This implies
+   * no styles either.
+   */
+  KApplication(Display *display, int& argc, char** argv, const TQCString& rAppName,
+               bool allowStyles=true, bool GUIenabled=true);
+#endif
+
+  /**
+   * @deprecated do not use it at all, it will make your application crash, use KCmdLineArgs
+   *
+   * Constructor. Parses command-line arguments.
+   *
+   * @param argc command line argument count
+   *
+   * @param argv command line argument value(s)
+   *
+   * @param rAppName application name. Will be used for finding the
+   * associated message files and icon files, and as the default
+   * registration name for DCOP. This is a mandatory parameter.
+   *
+   * @param allowStyles Set to false to disable the loading on plugin based
+   * styles. This is only useful to applications that do not display a GUI
+   * normally. If you do create an application with @p allowStyles set to false
+   * that normally runs in the background but under special circumstances
+   * displays widgets call enableStyles() before displaying any widgets.
+   *
+   * @param GUIenabled Set to false to disable all GUI stuff. This implies
+   * no styles either.
+   */
+  // REMOVE FOR KDE 4.0 - using it only gives crashing applications because
+  // KCmdLineArgs::init isn't called
+ KApplication(int& argc, char** argv,
+              const TQCString& rAppName, bool allowStyles=true, bool GUIenabled=true) KDE_DEPRECATED;
+
+  /**
+    * Add Qt and KDE command line options to KCmdLineArgs.
+    */
+  static void addCmdLineOptions();
+
+  virtual ~KApplication();
+
+  /**
+   * Returns the current application object.
+   *
+   * This is similar to the global TQApplication pointer tqApp. It
+   * allows access to the single global KApplication object, since
+   * more than one cannot be created in the same application. It
+   * saves you the trouble of having to pass the pointer explicitly
+   * to every function that may require it.
+   * @return the current application object
+   */
+  static KApplication* kApplication() { return KApp; }
+
+  /**
+   * Returns the application session config object.
+   *
+   * @return A pointer to the application's instance specific
+   * KConfig object.
+   * @see KConfig
+   */
+  KConfig* sessionConfig();
+
+  /**
+   * Is the application restored from the session manager?
+   *
+   * @return If true, this application was restored by the session manager.
+   *    Note that this may mean the config object returned by
+   * sessionConfig() contains data saved by a session closedown.
+   * @see sessionConfig()
+   */
+  bool isRestored() const { return TQApplication::isSessionRestored(); }
+
+  /**
+   * Disables session management for this application.
+   *
+   * Useful in case  your application is started by the
+   * initial "startkde" script.
+   */
+  void disableSessionManagement();
+
+  /**
+   * Enables again session management for this application, formerly
+   * disabled by calling disableSessionManagement(). You usually
+   * shouldn't call this function, as the session management is enabled
+   * by default.
+   */
+  void enableSessionManagement();
+
+  /**
+   * The possible values for the @p confirm parameter of requestShutDown().
+   */
+  enum ShutdownConfirm {
+    /**
+     * Obey the user's confirmation setting.
+     */
+    ShutdownConfirmDefault = -1,
+    /**
+     * Don't confirm, shutdown without asking.
+     */
+    ShutdownConfirmNo = 0,
+    /**
+     * Always confirm, ask even if the user turned it off.
+     */
+    ShutdownConfirmYes = 1
+  };
+
+  /**
+   * The possible values for the @p sdtype parameter of requestShutDown().
+   */
+  enum ShutdownType {
+    /**
+     * Select previous action or the default if it's the first time.
+     */
+    ShutdownTypeDefault = -1,
+    /**
+     * Only log out.
+     */
+    ShutdownTypeNone = 0,
+    /**
+     * Log out and reboot the machine.
+     */
+    ShutdownTypeReboot = 1,
+    /**
+     * Log out and halt the machine.
+     */
+    ShutdownTypeHalt = 2
+  };
+
+  /**
+   * The possible values for the @p sdmode parameter of requestShutDown().
+   */
+  enum ShutdownMode {
+    /**
+     * Select previous mode or the default if it's the first time.
+     */
+    ShutdownModeDefault = -1,
+    /**
+     * Schedule a shutdown (halt or reboot) for the time all active sessions
+     * have exited.
+     */
+    ShutdownModeSchedule = 0,
+    /**
+     * Shut down, if no sessions are active. Otherwise do nothing.
+     */
+    ShutdownModeTryNow = 1,
+    /**
+     * Force shutdown. Kill any possibly active sessions.
+     */
+    ShutdownModeForceNow = 2,
+    /**
+     * Pop up a dialog asking the user what to do if sessions are still active.
+     */
+    ShutdownModeInteractive = 3
+  };
+
+  /**
+   * Asks the session manager to shut the session down.
+   *
+   * Using @p confirm == ShutdownConfirmYes or @p sdtype != ShutdownTypeDefault or
+   * @p sdmode != ShutdownModeDefault causes the use of ksmserver's DCOP
+   * interface. The remaining two combinations use the standard XSMP and
+   * will work with any session manager compliant with it.
+   *
+   * @param confirm Whether to ask the user if he really wants to log out.
+   * ShutdownConfirm
+   * @param sdtype The action to take after logging out. ShutdownType
+   * @param sdmode If/When the action should be taken. ShutdownMode
+   * @return true on success, false if the session manager could not be
+   * contacted.
+   */
+  bool requestShutDown( ShutdownConfirm confirm = ShutdownConfirmDefault,
+                        ShutdownType sdtype = ShutdownTypeDefault,
+			ShutdownMode sdmode = ShutdownModeDefault );
+
+  /**
+   * Propagates the network address of the session manager in the
+   * SESSION_MANAGER environment variable so that child processes can
+   * pick it up.
+   *
+   * If SESSION_MANAGER isn't defined yet, the address is searched in
+   * $HOME/.KSMserver.
+   *
+   * This function is called by clients that are started outside the
+   * session ( i.e. before ksmserver is started), but want to launch
+   * other processes that should participate in the session.  Examples
+   * are kdesktop or kicker.
+   */
+    void propagateSessionManager();
+
+    /**
+     * Reimplemented for internal purposes, mainly the highlevel
+     *  handling of session management with KSessionManaged.
+     * @internal
+     */
+  void commitData( TQSessionManager& sm );
+
+    /**
+     * Reimplemented for internal purposes, mainly the highlevel
+     *  handling of session management with KSessionManaged.
+     * @internal
+     */
+  void saveState( TQSessionManager& sm );
+
+  /**
+   * Returns true if the application is currently saving its session
+   * data (most probably before KDE logout). This is intended for use
+   * mainly in KMainWindow::queryClose() and KMainWindow::queryExit().
+   *
+   * @see KMainWindow::queryClose
+   * @see KMainWindow::queryExit
+   * @since 3.1.1
+   */
+  bool sessionSaving() const;
+
+  /**
+   * Returns a pointer to a DCOPClient for the application.
+   * If a client does not exist yet, it is created when this
+   * function is called.
+   * @return the DCOPClient for the application
+   */
+  static DCOPClient *dcopClient();
+
+  /**
+   * Disable automatic dcop registration
+   * Must be called before creating a KApplication instance to have an effect.
+   */
+  static void disableAutoDcopRegistration();
+
+  /**
+   * Returns a TQPixmap with the application icon.
+   * @return the application icon
+   */
+  TQPixmap icon() const;
+
+  /**
+   * Returns the name of the application icon.
+   * @return the icon's name
+   */
+  TQString iconName() const;
+
+  /**
+   * Returns the mini-icon for the application as a TQPixmap.
+   * @return the application's mini icon
+   */
+  TQPixmap miniIcon() const;
+
+  /**
+   * Returns the name of the mini-icon for the application.
+   * @return the mini icon's name
+   */
+  TQString miniIconName() const;
+
+  /**
+   *  Sets the top widget of the application.
+   *  This means basically applying the right window caption and
+   *  icon. An application may have several top widgets. You don't
+   *  need to call this function manually when using KMainWindow.
+   *
+   *  @param topWidget A top widget of the application.
+   *
+   *  @see icon(), caption()
+   **/
+  void setTopWidget( TQWidget *topWidget );
+
+  /**
+   * Invokes the KHelpCenter HTML help viewer from docbook sources.
+   *
+   * @param anchor      This has to be a defined anchor in your
+   *                    docbook sources. If empty the main index
+   *                    is loaded
+   * @param appname     This allows you to show the help of another
+   *                    application. If empty the current name() is
+   *                    used
+   * @param startup_id for app startup notification, "0" for none,
+   *           "" ( empty string ) is the default
+   */
+  void invokeHelp( const TQString& anchor,
+                   const TQString& appname,
+                   const TQCString& startup_id ) const;
+
+  // KDE4 merge with above with startup_id = ""
+  void invokeHelp( const TQString& anchor = TQString::null,
+                   const TQString& appname = TQString::null ) const;
+
+  /**
+   * @deprecated
+   * Invoke the khelpcenter HTML help viewer from HTML sources.
+   * Please use invokeHelp() instead.
+   *
+   * @param aFilename  The filename that is to be loaded. Its
+   *                   location is computed automatically
+   *                   according to the KFSSTND.  If @p aFilename
+   *                   is empty, the logical appname with .html
+   *                   appended to it is used.
+   * @param aTopic     This allows context-sensitive help. Its
+   *                   value will be appended to the filename,
+   *                   prefixed with a "#" (hash) character.
+   */
+  void invokeHTMLHelp( const TQString& aFilename, const TQString& aTopic = TQString::null ) const KDE_DEPRECATED;
+
+  /**
+   * Convenience method; invokes the standard email application.
+   *
+   * @param address The destination address
+   * @param subject Subject string. Can be TQString::null.
+   * @param startup_id for app startup notification, "0" for none,
+   *           "" ( empty string ) is the default
+   */
+  void invokeMailer( const TQString &address, const TQString &subject, const TQCString& startup_id );
+  // KDE4 merge with above with startup_id = ""
+  void invokeMailer( const TQString &address, const TQString &subject );
+
+  /**
+   * Invokes the standard email application.
+   *
+   * @param mailtoURL A mailto URL.
+   * @param startup_id for app startup notification, "0" for none,
+   *           "" ( empty string ) is the default
+   * @param allowAttachments whether attachments specified in mailtoURL should be honoured.
+               The default is false; do not honour requests for attachments.
+   */
+  void invokeMailer( const KURL &mailtoURL, const TQCString& startup_id, bool allowAttachments );
+  // KDE4 merge with above with allowAttachments = false
+  void invokeMailer( const KURL &mailtoURL, const TQCString& startup_id );
+  // KDE4 merge with above with startup_id = ""
+  void invokeMailer( const KURL &mailtoURL );
+
+  /**
+   * Convenience method; invokes the standard email application.
+   *
+   * All parameters are optional.
+   *
+   * @param to          The destination address.
+   * @param cc          The Cc field
+   * @param bcc         The Bcc field
+   * @param subject     Subject string
+   * @param body        A string containing the body of the mail (exclusive with messageFile)
+   * @param messageFile A file (URL) containing the body of the mail (exclusive with body) - currently unsupported
+   * @param attachURLs  List of URLs to be attached to the mail.
+   * @param startup_id for app startup notification, "0" for none,
+   *           "" ( empty string ) is the default
+   */
+  void invokeMailer(const TQString &to, const TQString &cc, const TQString &bcc,
+                    const TQString &subject, const TQString &body,
+                    const TQString &messageFile, const TQStringList &attachURLs,
+                    const TQCString& startup_id );
+  // KDE4 merge with above with startup_id = ""
+  void invokeMailer(const TQString &to, const TQString &cc, const TQString &bcc,
+                    const TQString &subject, const TQString &body,
+                    const TQString &messageFile = TQString::null, const TQStringList &attachURLs = TQStringList());
+
+public slots:
+  /**
+   * Invokes the standard browser.
+   * Note that you should only do this when you know for sure that the browser can
+   * handle the URL (i.e. its mimetype). In doubt, if the URL can point to an image
+   * or anything else than directory or HTML, prefer to use new KRun( url ).
+   *
+   * @param url The destination address
+   * @param startup_id for app startup notification, "0" for none,
+   *           "" ( empty string ) is the default
+   */
+  void invokeBrowser( const TQString &url, const TQCString& startup_id );
+  // KDE4 merge with above with startup_id = ""
+  /**
+  * Invoke the standard browser. Uses a @p startup_id of "" (empty)
+  * and is otherwise the same as the above function.
+  */
+  void invokeBrowser( const TQString &url );
+
+  /**
+   * If the widget with focus provides a cut() slot, call that slot.  Thus for a
+   * simple application cut can be implemented as:
+   * \code
+   * KStdAction::cut( kapp, TQT_SLOT( cut() ), actionCollection() );
+   * \endcode
+   */
+  void cut();
+
+  /**
+   * If the widget with focus provides a copy() slot, call that slot.  Thus for a
+   * simple application copy can be implemented as:
+   * \code
+   * KStdAction::copy( kapp, TQT_SLOT( copy() ), actionCollection() );
+   * \endcode
+   */
+  void copy();
+
+  /**
+   * If the widget with focus provides a paste() slot, call that slot.  Thus for a
+   * simple application copy can be implemented as:
+   * \code
+   * KStdAction::paste( kapp, TQT_SLOT( paste() ), actionCollection() );
+   * \endcode
+   */
+  void paste();
+
+  /**
+   * If the widget with focus provides a clear() slot, call that slot.  Thus for a
+   * simple application clear() can be implemented as:
+   * \code
+   * new KAction( i18n( "Clear" ), "editclear", 0, kapp, TQT_SLOT( clear() ), actionCollection(), "clear" );
+   * \endcode
+   *
+   * Note that for some widgets, this may not provide the intended bahavior.  For
+   * example if you make use of the code above and a KListView has the focus, clear()
+   * will clear all of the items in the list.  If this is not the intened behavior
+   * and you want to make use of this slot, you can subclass KListView and reimplement
+   * this slot.  For example the following code would implement a KListView without this
+   * behavior:
+   *
+   * \code
+   * class MyListView : public KListView {
+   *   Q_OBJECT
+   * public:
+   *   MyListView( TQWidget * parent = 0, const char * name = 0, WFlags f = 0 ) : KListView( parent, name, f ) {}
+   *   virtual ~MyListView() {}
+   * public slots:
+   *   virtual void clear() {}
+   * };
+   * \endcode
+   */
+  void clear();
+
+  /**
+   * If the widget with focus provides a selectAll() slot, call that slot.  Thus for a
+   * simple application select all can be implemented as:
+   * \code
+   * KStdAction::selectAll( kapp, TQT_SLOT( selectAll() ), actionCollection() );
+   * \endcode
+   */
+  void selectAll();
+
+  /**
+   * Broadcast a received keycode to all listening KDE applications
+   * The primary use for this feature is to connect hotkeys such as
+   * XF86Display to their respective KGlobalAccel functions while
+   * the screen is locked by kdesktop_lock.
+   */
+  void broadcastKeyCode(unsigned int keyCode);
+
+public:
+  /**
+   * Returns the DCOP name of the service launcher. This will be something like
+   * klaucher_$host_$uid.
+   * @return the name of the service launcher
+   */
+  static TQCString launcher();
+
+  /**
+   * Starts a service based on the (translated) name of the service.
+   * E.g. "Web Browser"
+   *
+   * @param _name the name of the service
+   * @param URL if not empty this URL is passed to the service
+   * @param error On failure, @p error contains a description of the error
+   *         that occurred. If the pointer is 0, the argument will be
+   *         ignored
+   * @param dcopService On success, @p dcopService contains the DCOP name
+   *         under which this service is available. If empty, the service does
+   *         not provide DCOP services. If the pointer is 0 the argument
+   *         will be ignored
+   * @param pid On success, the process id of the new service will be written
+   *        here. If the pointer is 0, the argument will be ignored.
+   * @param startup_id for app startup notification, "0" for none,
+   *           "" ( empty string ) is the default
+   * @param noWait if set, the function does not wait till the service is running.
+   * @return an error code indicating success (== 0) or failure (> 0).
+   */
+  static int startServiceByName( const TQString& _name, const TQString &URL,
+                TQString *error=0, TQCString *dcopService=0, int *pid=0, const TQCString &startup_id = "", bool noWait = false );
+
+  /**
+   * Starts a service based on the (translated) name of the service.
+   * E.g. "Web Browser"
+   *
+   * @param _name the name of the service
+   * @param URLs if not empty these URLs will be passed to the service
+   * @param error On failure, @p error contains a description of the error
+   *         that occurred. If the pointer is 0, the argument will be
+   *         ignored
+   * @param dcopService On success, @p dcopService contains the DCOP name
+   *         under which this service is available. If empty, the service does
+   *         not provide DCOP services. If the pointer is 0 the argument
+   *         will be ignored
+   * @param pid On success, the process id of the new service will be written
+   *        here. If the pointer is 0, the argument will be ignored.
+   * @param startup_id for app startup notification, "0" for none,
+   *           "" ( empty string ) is the default
+   * @param noWait if set, the function does not wait till the service is running.
+   * @return an error code indicating success (== 0) or failure (> 0).
+   */
+  static int startServiceByName( const TQString& _name, const TQStringList &URLs=TQStringList(),
+                TQString *error=0, TQCString *dcopService=0, int *pid=0, const TQCString &startup_id = "", bool noWait = false );
+
+  /**
+   * Starts a service based on the desktop path of the service.
+   * E.g. "Applications/konqueror.desktop" or "/home/user/bla/myfile.desktop"
+   *
+   * @param _name the path of the desktop file
+   * @param URL if not empty this URL is passed to the service
+   * @param error On failure, @p error contains a description of the error
+   *         that occurred. If the pointer is 0, the argument will be
+   *         ignored
+   * @param dcopService On success, @p dcopService contains the DCOP name
+   *         under which this service is available. If empty, the service does
+   *         not provide DCOP services. If the pointer is 0 the argument
+   *         will be ignored
+   * @param pid On success, the process id of the new service will be written
+   *        here. If the pointer is 0, the argument will be ignored.
+   * @param startup_id for app startup notification, "0" for none,
+   *           "" ( empty string ) is the default
+   * @param noWait if set, the function does not wait till the service is running.
+   * @return an error code indicating success (== 0) or failure (> 0).
+   */
+  static int startServiceByDesktopPath( const TQString& _name, const TQString &URL,
+                TQString *error=0, TQCString *dcopService=0, int *pid = 0, const TQCString &startup_id = "", bool noWait = false );
+
+  /**
+   * Starts a service based on the desktop path of the service.
+   * E.g. "Applications/konqueror.desktop" or "/home/user/bla/myfile.desktop"
+   *
+   * @param _name the path of the desktop file
+   * @param URLs if not empty these URLs will be passed to the service
+   * @param error On failure, @p error contains a description of the error
+   *         that occurred. If the pointer is 0, the argument will be
+   *         ignored
+   * @param dcopService On success, @p dcopService contains the DCOP name
+   *         under which this service is available. If empty, the service does
+   *         not provide DCOP services. If the pointer is 0 the argument
+   *         will be ignored
+   * @param pid On success, the process id of the new service will be written
+   *        here. If the pointer is 0, the argument will be ignored.
+   * @param startup_id for app startup notification, "0" for none,
+   *           "" ( empty string ) is the default
+   * @param noWait if set, the function does not wait till the service is running.
+   * @return an error code indicating success (== 0) or failure (> 0).
+   */
+  static int startServiceByDesktopPath( const TQString& _name, const TQStringList &URLs=TQStringList(),
+                TQString *error=0, TQCString *dcopService=0, int *pid = 0, const TQCString &startup_id = "", bool noWait = false );
+
+  /**
+   * Starts a service based on the desktop name of the service.
+   * E.g. "konqueror"
+   *
+   * @param _name the desktop name of the service
+   * @param URL if not empty this URL is passed to the service
+   * @param error On failure, @p error contains a description of the error
+   *         that occurred. If the pointer is 0, the argument will be
+   *         ignored
+   * @param dcopService On success, @p dcopService contains the DCOP name
+   *         under which this service is available. If empty, the service does
+   *         not provide DCOP services. If the pointer is 0 the argument
+   *         will be ignored
+   * @param pid On success, the process id of the new service will be written
+   *        here. If the pointer is 0, the argument will be ignored.
+   * @param startup_id for app startup notification, "0" for none,
+   *           "" ( empty string ) is the default
+   * @param noWait if set, the function does not wait till the service is running.
+   * @return an error code indicating success (== 0) or failure (> 0).
+   */
+  static int startServiceByDesktopName( const TQString& _name, const TQString &URL,
+                TQString *error=0, TQCString *dcopService=0, int *pid = 0, const TQCString &startup_id = "", bool noWait = false );
+
+  /**
+   * Starts a service based on the desktop name of the service.
+   * E.g. "konqueror"
+   *
+   * @param _name the desktop name of the service
+   * @param URLs if not empty these URLs will be passed to the service
+   * @param error On failure, @p error contains a description of the error
+   *         that occurred. If the pointer is 0, the argument will be
+   *         ignored
+   * @param dcopService On success, @p dcopService contains the DCOP name
+   *         under which this service is available. If empty, the service does
+   *         not provide DCOP services. If the pointer is 0 the argument
+   *         will be ignored
+   * @param pid On success, the process id of the new service will be written
+   *        here. If the pointer is 0, the argument will be ignored.
+   * @param startup_id for app startup notification, "0" for none,
+   *           "" ( empty string ) is the default
+   * @param noWait if set, the function does not wait till the service is running.
+   * @return an error code indicating success (== 0) or failure (> 0).
+   */
+  static int startServiceByDesktopName( const TQString& _name, const TQStringList &URLs=TQStringList(),
+                TQString *error=0, TQCString *dcopService=0, int *pid = 0, const TQCString &startup_id = "", bool noWait = false );
+
+  /**
+   * Starts a program via tdeinit.
+   *
+   * program name and arguments are converted to according to the
+   * local encoding and passed as is to tdeinit.
+   *
+   * @param name Name of the program to start
+   * @param args Arguments to pass to the program
+   * @param error On failure, @p error contains a description of the error
+   *         that occurred. If the pointer is 0, the argument will be
+   *         ignored
+   * @param pid On success, the process id of the new service will be written
+   *        here. If the pointer is 0, the argument will be ignored.
+   * @param startup_id for app startup notification, "0" for none,
+   *           "" ( empty string ) is the default
+   * @return an error code indicating success (== 0) or failure (> 0).
+   */
+  static int tdeinitExec( const TQString& name, const TQStringList &args,
+                TQString *error, int *pid, const TQCString& startup_id );
+  // KDE4 merge with above with startup_id = ""
+  static int tdeinitExec( const TQString& name, const TQStringList &args=TQStringList(),
+                TQString *error=0, int *pid = 0 );
+
+  /**
+   * Starts a program via tdeinit and wait for it to finish.
+   *
+   * Like tdeinitExec(), but it waits till the program is finished.
+   * As such it behaves similar to the system(...) function.
+   *
+   * @param name Name of the program to start
+   * @param args Arguments to pass to the program
+   * @param error On failure, @p error contains a description of the error
+   *         that occurred. If the pointer is 0, the argument will be
+   *         ignored
+   * @param pid On success, the process id of the new service will be written
+   *        here. If the pointer is 0, the argument will be ignored.
+   * @param startup_id for app startup notification, "0" for none,
+   *           "" ( empty string ) is the default
+   * @return an error code indicating success (== 0) or failure (> 0).
+   */
+  static int tdeinitExecWait( const TQString& name, const TQStringList &args,
+                TQString *error, int *pid, const TQCString& startup_id );
+  // KDE4 merge with above with startup_id = ""
+  static int tdeinitExecWait( const TQString& name, const TQStringList &args=TQStringList(),
+                TQString *error=0, int *pid = 0 );
+
+  /**
+   * Returns a text for the window caption.
+   *
+   * This may be set by
+   * "-caption", otherwise it will be equivalent to the name of the
+   * executable.
+   * @return the text for the window caption
+   */
+  TQString caption() const;
+
+  /**
+   * @deprecated
+   */
+  KDE_DEPRECATED KStyle* kstyle() const { return 0; }
+
+  /**
+   * Builds a caption that contains the application name along with the
+   * userCaption using a standard layout.
+   *
+   * To make a compliant caption
+   * for your window, simply do: @p setCaption(kapp->makeStdCaption(yourCaption));
+   *
+   * @param userCaption The caption string you want to display in the
+   * window caption area. Do not include the application name!
+   * @param withAppName Indicates that the method shall include or ignore
+   * the application name when making the caption string. You are not
+   * compliant if you set this to @p false.
+   * @param modified If true, a 'modified' sign will be included in the
+   * returned string. This is useful when indicating that a file is
+   * modified, i.e., it contains data that has not been saved.
+   * @return the created caption
+   */
+  TQString makeStdCaption( const TQString &userCaption,
+                          bool withAppName=true, bool modified=false ) const;
+
+  /**
+   * Get a file name in order to make a temporary copy of your document.
+   *
+   * @param pFilename The full path to the current file of your
+   * document.
+   * @return A new filename for auto-saving.
+   */
+  TQString tempSaveName( const TQString& pFilename ) const;
+
+  /**
+   * Check whether  an auto-save file exists for the document you want to
+   * open.
+   *
+   * @param pFilename The full path to the document you want to open.
+   * @param bRecover  This gets set to true if there was a recover
+   * file.
+   * @return The full path of the file to open.
+   */
+  TQString checkRecoverFile( const TQString& pFilename, bool& bRecover ) const;
+
+#if defined(Q_WS_X11)
+  /**
+   * @internal
+   * Get the X11 display
+   * @return the X11 Display
+   */
+   Display *getDisplay() { return display; }
+#endif
+
+  /**
+   * @internal
+   * Gets X11 composition information
+   */
+   void getX11RGBAInformation(Display *dpy);
+
+  /**
+   * Gets the availability of a composition manager such as kompmgr
+   * Note that at least one application must have called detectCompositionManagerAvailable
+   * while the current X display was active in order for this method to return valid results.
+   * @see detectCompositionManagerAvailable()
+   * @return whether the composition manager is enabled
+   */
+   static bool isCompositionManagerAvailable();
+
+  /**
+   * Detects the availability of a composition manager such as kompmgr
+   * Note that calling this method will probably cause the screen to flicker.
+   * @see isCompositionManagerAvailable()
+   * @param force_available If set, force TDE to assume a composition manager is available
+   * @param available Whether or not the composition manager is available (only used if force_available is TRUE)
+   * @return whether the composition manager is enabled
+   */
+   bool detectCompositionManagerAvailable(bool force_available=false, bool available=true);
+
+  /**
+   * @internal
+   * Opens the display
+   * This can be used to initialize a KApplication with RGBA support like this:
+   * KApplication app(KApplication::openX11RGBADisplay());
+   * or
+   * KApplication app(KApplication::openX11RGBADisplay(), useStyles);
+   */
+   static Display* openX11RGBADisplay();
+
+  /**
+   * Returns the X11 display visual
+   *
+   * @return A pointer to the X11 display visual
+   */
+   Qt::HANDLE getX11RGBAVisual(Display *dpy);
+
+  /**
+   * Returns the X11 display colormap
+   *
+   * @return An X11 display colormap object
+   */
+   Qt::HANDLE getX11RGBAColormap(Display *dpy);
+
+  /**
+   * Returns whether or not X11 composition is available
+   * 
+   * You must first call getX11RGBAInformation()
+   * 
+   * Note that getX11RGBAInformation() has already
+   * been called if you used the default KApplication
+   * constructor.
+   *
+   * Additionally, at least one application must have called
+   * detectCompositionManagerAvailable while the current X 
+   * display was active in order for this method to return
+   * valid results.
+   *
+   * @return true if composition is available
+   */
+   bool isX11CompositionAvailable();
+
+  /**
+   * Enables style plugins.
+   *
+   * This is useful only to applications that normally
+   * do not display a GUI and create the KApplication with
+   * allowStyles set to false.
+   */
+  void enableStyles();
+
+  /**
+   * Disables style plugins.
+   *
+   * Current style plugins do not get unloaded.
+   *
+   * This is only useful when used in combination with enableStyles().
+   */
+  void disableStyles();
+
+  /**
+   *  Installs widget filter as global X11 event filter.
+   *
+   * The widget
+   *  filter receives XEvents in its standard TQWidget::x11Event() function.
+   *
+   *  Warning: Only do this when absolutely necessary. An installed X11 filter
+   *  can slow things down.
+   **/
+  void installX11EventFilter( TQWidget* filter );
+
+  /**
+   * Removes global X11 event filter previously installed by
+   * installX11EventFilter().
+   */
+  void removeX11EventFilter( const TQWidget* filter );
+
+  /**
+   * Generates a uniform random number.
+   * @return A truly unpredictable number in the range [0, RAND_MAX)
+   */
+  static int random();
+
+  /**
+   * Generates a random string.  It operates in the range [A-Za-z0-9]
+   * @param length Generate a string of this length.
+   * @return the random string
+   */
+  static TQString randomString(int length);
+
+  /**
+   * Adds a message type to the KIPC event mask. You can only add "system
+   * messages" to the event mask. These are the messages with id < 32.
+   * Messages with id >= 32 are user messages.
+   * @param id The message id. See KIPC::Message.
+   * @see KIPC
+   * @see removeKipcEventMask()
+   * @see kipcMessage()
+   */
+  void addKipcEventMask(int id);
+
+  /**
+   * Removes a message type from the KIPC event mask. This message will
+   * not be handled anymore.
+   * @param id The message id.
+   * @see KIPC
+   * @see addKipcEventMask()
+   * @see kipcMessage()
+   */
+  void removeKipcEventMask(int id);
+
+  /**
+   * Returns the app startup notification identifier for this running
+   * application.
+   * @return the startup notification identifier
+   */
+  TQCString startupId() const;
+
+  /**
+   * @internal
+   * Sets a new value for the application startup notification window property for newly
+   * created toplevel windows. 
+   * @param startup_id the startup notification identifier
+   * @see KStartupInfo::setNewStartupId
+   */
+  void setStartupId( const TQCString& startup_id );
+
+  /**
+   * Updates the last user action timestamp to the given time, or to the current time,
+   * if 0 is given. Do not use unless you're really sure what you're doing.
+   * Consult focus stealing prevention section in kdebase/kwin/README.
+   * @since 3.2
+   */
+  void updateUserTimestamp( unsigned long time = 0 );
+  
+  /**
+   * Returns the last user action timestamp or 0 if no user activity has taken place yet.
+   * @since 3.2.3
+   * @see updateuserTimestamp
+   */
+  unsigned long userTimestamp() const;
+
+  /**
+   * Updates the last user action timestamp in the application registered to DCOP with dcopId
+   * to the given time, or to this application's user time, if 0 is given.
+   * Use before causing user interaction in the remote application, e.g. invoking a dialog
+   * in the application using a DCOP call.
+   * Consult focus stealing prevention section in kdebase/kwin/README.
+   * @since 3.3
+   */
+  void updateRemoteUserTimestamp( const TQCString& dcopId, unsigned long time = 0 );
+  
+    /**
+    * Returns the argument to --geometry if any, so the geometry can be set
+    * wherever necessary
+    * @return the geometry argument, or TQString::null if there is none
+    */
+  TQString geometryArgument() const;
+
+  /**
+   * Install a Qt SQL property map with entries for all KDE widgets
+   * Call this in any application using KDE widgets in TQSqlForm or TQDataView.
+   */
+  void installKDEPropertyMap();
+
+  /**
+   * Returns whether a certain action is authorized
+   * @param genericAction The name of a generic  action
+   * @return true if the action is authorized
+   */
+  bool authorize(const TQString &genericAction);
+
+  /**
+   * Returns whether a certain KAction is authorized.
+   *
+   * @param action The name of a KAction action. The name is prepended
+   * with "action/" before being passed to authorize()
+   * @return true if the KAction is authorized
+   */
+  bool authorizeKAction(const char *action);
+
+  /**
+   * Returns whether a certain URL related action is authorized.
+   *
+   * @param action The name of the action. Known actions are
+   * list (may be listed (e.g. in file selection dialog)),
+   * link (may be linked to),
+   * open (may open) and
+   * redirect (may be redirected to)
+   * @param baseURL The url where the action originates from
+   * @param destURL The object of the action
+   * @return true when the action is authorized, false otherwise.
+   * @since 3.1
+   */
+  bool authorizeURLAction(const TQString &action, const KURL &baseURL, const KURL &destURL);
+
+  /**
+   * Allow a certain URL action. This can be useful if your application
+   * needs to ensure access to an application specific directory that may 
+   * otherwise be subject to KIOSK restrictions.
+   * @param action The name of the action.
+   * @param _baseURL The url where the action originates from
+   * @param _destURL The object of the action
+   * @since 3.2
+   */
+  void allowURLAction(const TQString &action, const KURL &_baseURL, const KURL &_destURL);
+
+  /**
+   * Returns whether access to a certain control module is authorized.
+   *
+   * @param menuId identifying the control module, e.g. kde-mouse.desktop
+   * @return true if access to the module is authorized, false otherwise.
+   * @since 3.2
+   */
+  bool authorizeControlModule(const TQString &menuId);
+  
+  /**
+   * Returns whether access to a certain control modules is authorized.
+   *
+   * @param menuIds list of menu-ids of control module, 
+   * an example of a menu-id is kde-mouse.desktop.
+   * @return Those control modules for which access has been authorized.
+   * @since 3.2
+   */
+  TQStringList authorizeControlModules(const TQStringList &menuIds);
+
+  /**
+   * Returns the state of the currently pressed keyboard modifiers (e.g. shift, control, etc.)
+   * and mouse buttons, similarly to TQKeyEvent::state() and TQMouseEvent::state().
+   * You usually should simply use the information provided by TQKeyEvent and TQMouseEvent,
+   * but it can be useful to query for the status of the modifiers at another moment
+   * (e.g. some KDE apps do that upon a drop event).
+   * @return the keyboard modifiers and mouse buttons state
+   * @since 3.4
+   */
+  static ButtonState keyboardMouseState();
+
+  // Same values as ShiftMask etc. in X.h
+  enum { ShiftModifier = 1<<0,
+         LockModifier = 1<<1,
+         ControlModifier = 1<<2,
+         Modifier1 = 1<<3,
+         Modifier2 = 1<<4,
+         Modifier3 = 1<<5,
+         Modifier4 = 1<<6,
+         Modifier5 = 1<<7 };
+  /**
+   * @deprecated Use keyboardMouseState()
+   * @since 3.1
+   */
+  static uint keyboardModifiers() KDE_DEPRECATED;
+
+  /** @deprecated Same values as Button1Mask etc. in X.h */
+  enum { Button1Pressed = 1<<8,
+         Button2Pressed = 1<<9,
+         Button3Pressed = 1<<10,
+         Button4Pressed = 1<<11,
+         Button5Pressed = 1<<12 };
+  /**
+   * @deprecated Use keyboardMouseState()
+   * @since 3.1
+   */
+  static uint mouseState() KDE_DEPRECATED;
+
+
+public slots:
+  /**
+   * Tells KApplication about one more operation that should be finished
+   * before the application exits. The standard behavior is to exit on the
+   * "last window closed" event, but some events should outlive the last window closed
+   * (e.g. a file copy for a file manager, or 'compacting folders on exit' for a mail client).
+   */
+  void ref();
+
+  /**
+   * Tells KApplication that one operation such as those described in ref() just finished.
+   * The application exits if the counter is back to 0.
+   */
+  void deref();
+
+protected:
+  /**
+   * @internal Used by KUniqueApplication
+   */
+  KApplication( bool allowStyles, bool GUIenabled, KInstance* _instance );
+
+#ifdef Q_WS_X11
+  /**
+   * @internal Used by KUniqueApplication
+   */
+  KApplication( Display *display, Qt::HANDLE visual, Qt::HANDLE colormap,
+		  bool allowStyles, KInstance* _instance );
+
+  /**
+   * Used to catch X11 events
+   */
+  bool x11EventFilter( XEvent * );
+
+  Display *display;
+#endif
+  Atom kipcCommAtom;
+  int kipcEventMask;
+
+  /// Current application object.
+  static KApplication *KApp;
+  int pArgc;
+
+  /**
+   * This method is used internally to determine which edit slots are implemented
+   * by the widget that has the focus, and to invoke those slots if available.
+   *
+   * @param slot is the slot as returned using the TQT_SLOT() macro, for example TQT_SLOT( cut() )
+   *
+   * This method can be used in KApplication subclasses to implement application wide
+   * edit actions not supported by the KApplication class.  For example (in your subclass):
+   *
+   * \code
+   * void MyApplication::deselect()
+   * {
+   *   invokeEditSlot( TQT_SLOT( deselect() ) );
+   * }
+   * \endcode
+   *
+   * Now in your application calls to MyApplication::deselect() will call this slot on the
+   * focused widget if it provides this slot.  You can combine this with KAction with:
+   *
+   * \code
+   * KStdAction::deselect( static_cast<MyApplication *>( kapp ), TQT_SLOT( cut() ), actionCollection() );
+   * \endcode
+   *
+   * @see cut()
+   * @see copy()
+   * @see paste()
+   * @see clear()
+   * @see selectAll()
+   *
+   * @since 3.2
+   */
+  void invokeEditSlot( const char *slot );
+
+private slots:
+  void dcopFailure(const TQString &);
+  void dcopBlockUserInput( bool );
+  void x11FilterDestroyed();
+  void checkAppStartedSlot();
+
+private:
+  TQString sessionConfigName() const;
+  KConfig* pSessionConfig; //instance specific application config object
+  static DCOPClient *s_DCOPClient; // app specific application communication client
+  static bool s_dcopClientNeedsPostInit;
+  TQString aCaption; // the name for the window title
+  bool bSessionManagement;
+  struct oldPixmapType { TQPixmap a, b; };
+  mutable union {
+    struct {
+      TQPixmap *icon, *miniIcon;
+    } pm;
+    char unused[sizeof(oldPixmapType)];
+  } aIconPixmap; // KDE4: remove me
+  TQString aIconName;
+  TQString aMiniIconName;
+  bool useStyles;
+  TQWidget *smw;
+
+  void init( bool GUIenabled );
+
+  void parseCommandLine( ); // Handle KDE arguments (Using KCmdLineArgs)
+
+  void read_app_startup_id();
+
+  void dcopAutoRegistration();
+  void dcopClientPostInit();
+  void initUrlActionRestrictions();
+
+  bool argb_visual;
+#if defined(Q_WS_X11)
+  Qt::HANDLE argb_x11_visual;
+  Qt::HANDLE argb_x11_colormap;
+#endif
+
+public:
+  /**
+   * @internal
+   */
+  bool notify(TQObject *receiver, TQEvent *event);
+
+  /**
+      @internal
+    */
+  int xErrhandler( Display*, void* );
+
+  /**
+      @internal
+    */
+  int xioErrhandler( Display* );
+
+  /**
+   * @internal
+   */
+  void iceIOErrorHandler( _IceConn *conn );
+
+  /**
+   * @internal
+   */
+  static bool loadedByKdeinit;
+
+  /**
+   * @internal
+   */
+  static void startKdeinit();
+
+  /**
+   * Valid values for the settingsChanged signal
+   */
+  enum SettingsCategory { SETTINGS_MOUSE, SETTINGS_COMPLETION, SETTINGS_PATHS,
+         SETTINGS_POPUPMENU, SETTINGS_QT, SETTINGS_SHORTCUTS };
+
+  /**
+   * Used to obtain the TQPalette that will be used to set the application palette.
+   *
+   * This is only useful for configuration modules such as krdb and should not be
+   * used in normal circumstances.
+   * @return the QPalette
+   * @since 3.1
+   */
+  static TQPalette createApplicationPalette();
+
+  /**
+   * @internal
+   * Raw access for use by KDM.
+   */
+  static TQPalette createApplicationPalette( KConfig *config, int contrast );
+
+  /**
+   * Installs a handler for the SIGPIPE signal. It is thrown when you write to
+   * a pipe or socket that has been closed.
+   * The handler is installed automatically in the constructor, but you may
+   * need it if your application or component does not have a KApplication
+   * instance.
+   */
+  static void installSigpipeHandler();
+
+  /**
+   * @internal
+   * Whether widgets can be used. 
+   *
+   * @since 3.2
+   */
+  static bool guiEnabled();
+
+signals:
+  /**
+   * Emitted when KApplication has changed its palette due to a KControl request.
+   *
+   * Normally, widgets will update their palette automatically, but you
+   * should connect to this to program special behavior.
+   */
+  void kdisplayPaletteChanged();
+
+  /**
+   * Emitted when KApplication has changed its GUI style in response to a KControl request.
+   *
+   * Normally, widgets will update their styles automatically (as they would
+   * respond to an explicit setGUIStyle() call), but you should connect to
+   * this to program special behavior.
+   */
+  void kdisplayStyleChanged();
+
+  /**
+   * Emitted when KApplication has changed its font in response to a KControl request.
+   *
+   * Normally widgets will update their fonts automatically, but you should
+   * connect to this to monitor global font changes, especially if you are
+   * using explicit fonts.
+   *
+   * Note: If you derive from a QWidget-based class, a faster method is to
+   *       reimplement TQWidget::fontChange(). This is the preferred way
+   *       to get informed about font updates.
+   */
+  void kdisplayFontChanged();
+
+  /**
+   * Emitted when KApplication has changed either its GUI style, its font or its palette
+   * in response to a kdisplay request. Normally, widgets will update their styles
+   * automatically, but you should connect to this to program special
+   * behavior. */
+  void appearanceChanged();
+
+  /**
+   * Emitted when the settings for toolbars have been changed. KToolBar will know what to do.
+   */
+  void toolbarAppearanceChanged(int);
+
+  /**
+   * Emitted when the desktop background has been changed by @p kcmdisplay.
+   *
+   * @param desk The desktop whose background has changed.
+   */
+  void backgroundChanged(int desk);
+
+  /**
+   * Emitted when the global settings have been changed - see KGlobalSettings
+   * KApplication takes care of calling reparseConfiguration on KGlobal::config()
+   * so that applications/classes using this only have to re-read the configuration
+   * @param category the category among the enum above
+   */
+  void settingsChanged(int category);
+
+  /**
+   * Emitted when the global icon settings have been changed.
+   * @param group the new group
+   */
+  void iconChanged(int group);
+
+  /**
+   * Emitted when a KIPC user message has been received.
+   * @param id the message id
+   * @param data the data
+   * @see KIPC
+   * @see KIPC::Message
+   * @see addKipcEventMask
+   * @see removeKipcEventMask
+   */
+  void kipcMessage(int id, int data);
+
+  /**
+      Session management asks you to save the state of your application.
+
+     This signal is provided for compatibility only. For new
+     applications, simply use KMainWindow. By reimplementing 
+     KMainWindow::queryClose(), KMainWindow::saveProperties() and
+ KMainWindow::readProperties() you can simply handle session
+     management for applications with multiple toplevel windows.
+
+     For purposes without KMainWindow, create an instance of
+     KSessionManaged and reimplement the functions 
+     KSessionManaged::commitData() and/or 
+     KSessionManaged::saveState()
+
+     If you still want to use this signal, here is what you should do:
+
+     Connect to this signal in order to save your data. Do NOT
+     manipulate the UI in that slot, it is blocked by the session
+     manager.
+
+     Use the sessionConfig() KConfig object to store all your
+     instance specific data.
+
+     Do not do any closing at this point! The user may still select
+     Cancel  wanting to continue working with your
+     application. Cleanups could be done after shutDown() (see
+     the following).
+
+  */
+  void saveYourself();
+
+  /** Your application is killed. Either by your program itself,
+      @p xkill or (the usual case) by KDE's logout.
+
+      The signal is particularly useful if your application has to do some
+      last-second cleanups. Note that no user interaction is possible at
+      this state.
+   */
+  void shutDown();
+
+  /**
+   * @internal
+   * Used to notify KIconLoader objects that they need to reload.
+   */
+  void updateIconLoaders();
+
+  /**
+   * @internal
+   * Used to send KGlobalAccel objects a new keypress from physical hotkeys.
+   */
+  void coreFakeKeyPress(unsigned int keyCode);
+
+private:
+  void propagateSettings(SettingsCategory category);
+  void kdisplaySetPalette();
+  void kdisplaySetStyle();
+  void kdisplaySetFont();
+  void applyGUIStyle();
+  static void sigpipeHandler(int);
+
+  int captionLayout;
+
+  KApplication(const KApplication&);
+  KApplication& operator=(const KApplication&);
+protected:
+  virtual void virtual_hook( int id, void* data );
+private:
+  KApplicationPrivate* d;
+};
+
+
+/**
+ * \relates KGlobal
+ * Check, if a file may be accessed in a given mode.
+ * This is a wrapper around the access() system call.
+ * checkAccess() calls access() with the given parameters.
+ * If this is OK, checkAccess() returns true. If not, and W_OK
+ * is part of mode, it is checked if there is write access to
+ * the directory. If yes, checkAccess() returns true.
+ * In all other cases checkAccess() returns false.
+ *
+ * Other than access() this function EXPLICITLY ignores non-existant
+ * files if checking for write access.
+ *
+ * @param pathname The full path of the file you want to test
+ * @param mode     The access mode, as in the access() system call.
+ * @return Whether the access is allowed, true = Access allowed
+ */
+KDECORE_EXPORT bool checkAccess(const TQString& pathname, int mode);
+
+class KSessionManagedPrivate;
+
+/**
+   Provides highlevel access to session management on a per-object
+   base.
+
+   KSessionManaged makes it possible to provide implementations for
+ TQApplication::commitData() and TQApplication::saveState(), without
+   subclassing KApplication. KMainWindow internally makes use of this.
+
+   You don't need to do anything with this class when using
+   KMainWindow. Instead, use KMainWindow::saveProperties(),
+ KMainWindow::readProperties(), KMainWindow::queryClose(),
+ KMainWindow::queryExit() and friends.
+
+  @short Highlevel access to session management.
+  @author Matthias Ettrich <ettrich@kde.org>
+ */
+class KDECORE_EXPORT KSessionManaged
+{
+public:
+  KSessionManaged();
+  virtual ~KSessionManaged();
+
+    /**
+       See TQApplication::saveState() for documentation.
+
+       This function is just a convenience version to avoid subclassing KApplication.
+
+       Return true to indicate a successful state save or false to
+       indicate a problem and to halt the shutdown process (will
+       implicitly call sm.cancel() ).
+     */
+  virtual bool saveState( TQSessionManager& sm );
+    /**
+       See TQApplication::commitData() for documentation.
+
+       This function is just a convenience version to avoid subclassing KApplication.
+
+       Return true to indicate a successful commit of data or false to
+       indicate a problem and to halt the shutdown process (will
+       implicitly call sm.cancel() ).
+     */
+  virtual bool commitData( TQSessionManager& sm );
+
+protected:
+  virtual void virtual_hook( int id, void* data );
+private:
+  KSessionManagedPrivate *d;
+};
+
+
+#endif
+