The following parameters apply to the Java application:
- Main application class. The name of the Java class which
is the application entry point. This class must have a
main() method. This field is required.
- Static application arguments. Static arguments are
always passed to main() if present. They are silently
prepended to the default application arguments (or user
- Default application arguments. The default arguments to
pass to main(). These arguments will be replaced by
arguments entered directly from the command-line, if any.
- Working directory. The default working directory is the
directory where the EXE resides. This parameter allows you to
change the working directory. For example, if your program creates
a log file, that log file will be created in the working
- Use current directory. If you select this option, the
working directory will be set to the current directory. For
example, if the EXE resides in C:\Program Files\MyApp, but
the user starts the EXE in C:\My Documents, then the working
directory is C:\My Documents. This is useful for
applications which must process files in the current directory eg.
a utility that automatically creates thumbnails for all JPEG files
in the current directory.
- Set runtime and classpath relative to working directory.
By default, the working directory does not affect the runtime and
classpath i.e. the JVM DLL and the classpath will still be relative
to the EXE directory, even if the working directory is changed.
However, setting this option will cause the runtime and classpath
to be relative to the working directory instead.
- Application configuration file. This allows you to
specify the filename of a configuration file from which parameters
will be read when the executable is run. The configuration file has
the following format:
This allows you to modify the runtime characteristics of your
program without regenerating the executable. Currently, the
following parameters are supported:
JvmOptions = -Xms8m -Xmx32m
StdOutFile = stdout.log
StdErrFile = stderr.log
|Specify the desired JVM
version. Enclose value in double quotes if required.
|Specify the path to the JVM DLL. Enclose value in double quotes
|Options to pass to the JVM.
|Options to append to JVM options, allowing for the modification
of existing values.
|Arguments to pass to the Java application.
|This is the name of the mutex used to detect if another
instance of the application is already running. This is normally
set to the main class name. You can change it if you want use
another mutex name.
|Static arguments to pass to the Java application.
|Override executable defaults and redirect stdout to a
specified file. This can be the same as StdErrFile.
|Override executable defaults and redirect stderr to a
specified file. This can be the same as StdOutFile.
|"1" appends to stdout log file, "0" (default)
|"1" appends to stderr log file, "0" (default)
|"1" displays a console window for GUI applications, while "0"
removes the console window. This option overrides any executable
defaults. It also overrides StdOutFile and
StdErrFile if set to "1". For console applications, it
hides the console if set to "0".
If you are not using a configuration file, simply leave the field
Note that the configuration file will always be relative to the
executable directory, regardless of the working directory setting.
You can specify a subdirectory for the configuration file eg.
To include an argument with spaces, double qoutes must be used, and
each double quote must be escape by a preceding double quote as per
standard INI file convention. For example including two paths with
spaces in a parameter will look like ""C:\Path One\File1.txt""
Th string %APPNAME% will be substituted with the executable
name. For example, if the configuration file is
%APPNAME%.ini and the executable is myapp.exe, it
will look for myapp.ini as the application configuration
- Allow multiple instances of the application? Applies to
GUI applications only. Specifies whether to allow multiple
instances of the sample application.
- If another instance is detected: If multiple instances
are not allowed, decide what happens when a second instance is run.
The second instance could display an error message (customizable
under Messages), or it could call the
application class main()
For example, if the launcher is configured to called
main()-activate when run as a second instance, running the
launcher a second time:
will result in the main() method being called with:
The main() method needs to detect this argument and send a
request to the first instance to activate itself via IPC
(inter-process communication). A code sample is available in
args = -activate
args = doc.txt