class TApplication: public TObject, public TQObject

 Default ctor. Can be used by classes deriving from TApplication.

 Create an application environment. The application environment
 provides an interface to the graphics system and eventloop
 (be it X, Windoze, MacOS or BeOS). After creating the application
 object start the eventloop by calling its Run() method. The command
 line options recogized by TApplication are described in the GetOptions()
 method. The recognized options are removed from the argument array.
 The original list of argument options can be retrieved via the Argc()
 and Argv() methods. The appClassName "proofserv" is reserved for the
 PROOF system. The "options" and "numOptions" arguments are not used,
 except if you want to by-pass the argv processing by GetOptions()
 in which case you should specify numOptions<0. All options will
 still be available via the Argv() method for later use.

 TApplication dtor.

 Static method. This method should be called from static library
 initializers if the library needs the low level graphics system.

 Initialize the graphics environment.

 Clear list containing macro files passed as program arguments.
 This method is called from TRint::Run() to ensure that the macro
 files are only executed the first time Run() is called.

 Return specified argument.

 Get and handle command line options. Arguments handled are removed
 from the argument array. The following arguments are handled:
    -b : run in batch mode without graphics
    -n : do not execute logon and logoff macros as specified in .rootrc
    -q : exit after processing command line macro files
    -l : do not show splash screen
 The last three options are only relevant in conjunction with TRint.
 The following help and info arguments are supported:
    -?      : print usage
    -h      : print usage
    --help  : print usage
    -config : print ./configure options
 In addition to the above options the arguments that are not options,
 i.e. they don't start with - or + are treated as follows:
   <file>.root are considered ROOT files and added to the InputFiles() list
   <macro>.C   are considered ROOT macros and also added to the InputFiles() list
   <dir>       is considered the desired working directory and available
               via WorkingDirectory(), if more than one dir is specified the
               last one will prevail
 In TRint we set the working directory to the <dir>, the ROOT files are
 connected, and the macros are executed. If your main TApplication is not
 TRint you have to decide yourself what to do whith these options.

 Handle idle timeout. When this timer expires the registered idle command
 will be executed by this routine and a signal will be emitted.

 Handle exceptions (kSigBus, kSigSegmentationViolation,
 kSigIllegalInstruction and kSigFloatingException) trapped in TSystem.
 Specific TApplication implementations may want something different here.

 Print help on interpreter.

 Load shared libs neccesary for graphics. These libraries are only
 loaded when gROOT->IsBatch() is kFALSE.

 Switch to batch mode.

 Parse the content of a line starting with ".R" (already stripped-off)
 The format is
      [user@]host[:dir] [-l user] [-d dbg] [script]
 The variable 'dir' is the remote directory to be used as working dir.
 The username can be specified in two ways, "-l" having the priority
 (as in ssh).
 A 'dbg' value > 0 gives increasing verbosity.
 The last argument 'script' allows to specify an alternative script to
 be executed remotely to startup the session.

 Process the content of a line starting with ".R" (already stripped-off)
 The format is
      [user@]host[:dir] [-l user] [-d dbg] [script] | [host] -close
 The variable 'dir' is the remote directory to be used as working dir.
 The username can be specified in two ways, "-l" having the priority
 (as in ssh).
 A 'dbg' value > 0 gives increasing verbosity.
 The last argument 'script' allows to specify an alternative script to
 be executed remotely to startup the session.

 Process a single command line, either a C++ statement or an interpreter
 command starting with a ".".
 Return the return value of the command casted to a long.

 Process a file containing a C++ macro.

 Execute a file containing a C++ macro (static method). Can be used
 while TApplication is not yet created.

 Main application eventloop. Calls system dependent eventloop via gSystem.

 Set the command to be executed after the system has been idle for
 idleTimeInSec seconds. Normally called via TROOT::Idle(...).

 Remove idle timer. Normally called via TROOT::Idle(0).

 Called when system starts idleing.

 Called when system stops idleing.

 Terminate the application by call TSystem::Exit() unless application has
 been told to return from Run(), by a call to SetReturnFromRun().

 Emit signal when a line has been processed.

 Emit signal when console keyboard key was pressed.

 Emit signal when return key was pressed.

 Set console echo mode:

  mode = kTRUE  - echo input symbols
  mode = kFALSE - noecho input symbols

 Static function used to create a default application environment.

 Static function used to attach to an existing remote application
 or to start one.

 Static function used to close a remote application

 Show available sessions

 Static method returning the list of available applications