.TH "KCmdLineArgs" kde3 "11 Jun 2005" "Version Version 3.4.1" "kdecore Library" \" -*- nroff -*-
.ad l
.nh
.SH NAME
KCmdLineArgs \- A class for command-line argument handling.  

.PP
.SH SYNOPSIS
.br
.PP
\fC#include <kcmdlineargs.h>\fP
.PP
.SS "Public Member Functions"

.in +1c
.ti -1c
.RI "\fBQCString\fP \fBgetOption\fP (const char *option) const "
.br
.ti -1c
.RI "\fBQCStringList\fP \fBgetOptionList\fP (const char *option) const "
.br
.ti -1c
.RI "bool \fBisSet\fP (const char *option) const "
.br
.ti -1c
.RI "int \fBcount\fP () const "
.br
.ti -1c
.RI "const char * \fBarg\fP (int n) const "
.br
.ti -1c
.RI "\fBKURL\fP \fBurl\fP (int n) const "
.br
.ti -1c
.RI "void \fBclear\fP ()"
.br
.in -1c
.SS "Static Public Member Functions"

.in +1c
.ti -1c
.RI "static void \fBinit\fP (int _argc, char **_argv, const char *_appname, const char *programName, const char *_description, const char *_version, bool noKApp=false)"
.br
.ti -1c
.RI "static void \fBinit\fP (int _argc, char **_argv, const char *_appname, const char *_description, const char *_version, bool noKApp=false) KDE_DEPRECATED"
.br
.ti -1c
.RI "static void \fBinit\fP (int _argc, char **_argv, const \fBKAboutData\fP *about, bool noKApp=false)"
.br
.ti -1c
.RI "static void \fBinit\fP (const \fBKAboutData\fP *about)"
.br
.ti -1c
.RI "static void \fBaddCmdLineOptions\fP (const \fBKCmdLineOptions\fP *options, const char *name=0, const char *id=0, const char *afterId=0)"
.br
.ti -1c
.RI "static \fBKCmdLineArgs\fP * \fBparsedArgs\fP (const char *id=0)"
.br
.ti -1c
.RI "static \fBQString\fP \fBcwd\fP ()"
.br
.ti -1c
.RI "static const char * \fBappName\fP ()"
.br
.ti -1c
.RI "static void \fBusage\fP (const char *id=0)"
.br
.ti -1c
.RI "static void \fBusage\fP (const \fBQString\fP &error)"
.br
.ti -1c
.RI "static void \fBenable_i18n\fP ()"
.br
.ti -1c
.RI "static \fBKURL\fP \fBmakeURL\fP (const char *urlArg)"
.br
.ti -1c
.RI "static void \fBsetCwd\fP (char *cwd)"
.br
.ti -1c
.RI "static void \fBreset\fP ()"
.br
.ti -1c
.RI "static void \fBloadAppArgs\fP (\fBQDataStream\fP &)"
.br
.ti -1c
.RI "static void \fBaddTempFileOption\fP ()"
.br
.ti -1c
.RI "static bool \fBisTempFileSet\fP ()"
.br
.in -1c
.SS "Protected Member Functions"

.in +1c
.ti -1c
.RI "\fBKCmdLineArgs\fP (const \fBKCmdLineOptions\fP *_options, const char *_name, const char *_id)"
.br
.ti -1c
.RI "\fB~KCmdLineArgs\fP ()"
.br
.in -1c
.SS "Friends"

.in +1c
.ti -1c
.RI "class \fBKApplication\fP"
.br
.ti -1c
.RI "class \fBKUniqueApplication\fP"
.br
.ti -1c
.RI "class \fBQPtrList<KCmdLineArgs>\fP"
.br
.in -1c
.SH "Detailed Description"
.PP 
A class for command-line argument handling. 

KCmdLineArgs provides simple access to the command-line arguments for an application. It takes into account Qt-specific options, KDE-specific options and application specific options.
.PP
This class is used in main() via the static method \fBinit()\fP.
.PP
A typical KDE application using KCmdLineArgs should look like this:
.PP
.PP
.nf
  int main(int argc, char *argv[])
  {
     // Initialize command line args
     KCmdLineArgs::init(argc, argv, appName, programName, description, version);

     // Tell which options are supported
     KCmdLineArgs::addCmdLineOptions( options );

     // Add options from other components
     KUniqueApplication::addCmdLineOptions();

     ....

     // Create application object without passing 'argc' and 'argv' again.
     KUniqueApplication app;

     ....

     // Handle our own options/arguments
     // A KApplication will usually do this in main but this is not
     // necessary.
     // A KUniqueApplication might want to handle it in newInstance().

     KCmdLineArgs *args = KCmdLineArgs::parsedArgs();

     // A binary option (on / off)
     if (args->isSet('some-option'))
        ....

     // An option which takes an additional argument
     QCString anotherOptionArg = args->getOption('another-option');

     // Arguments (e.g. files to open)
     for(int i = 0; i < args->count(); i++) // Counting start at 0!
     {
        // don't forget to convert to Unicode!
        openFile( QFile::decodeName( args->arg(i)));
        // Or more convenient:
        // openURL( args->url(i));

     }

     args->clear(); // Free up some memory.
     ....
  }
.fi
.PP
.PP
The options that an application supports are configured using the \fBKCmdLineOptions\fP class. An example is shown below:
.PP
.PP
.nf
  static const KCmdLineOptions options[] =
  {
     { 'a', I18N_NOOP('A short binary option'), 0 },
     { 'b \<file>', I18N_NOOP('A short option which takes an argument'), 0 },
     { 'c \<speed>', I18N_NOOP('As above but with a default value'), '9600' },
     { 'option1', I18N_NOOP('A long binary option, off by default'), 0 },
     { 'nooption2', I18N_NOOP('A long binary option, on by default'), 0 },
     { ':', I18N_NOOP('Extra options:'), 0 },
     { 'option3 \<file>', I18N_NOOP('A long option which takes an argument'), 0 },
     { 'option4 \<speed>', I18N_NOOP('A long option which takes an argument, defaulting to 9600'), '9600' },
     { 'd', 0, 0 },
     { 'option5', I18N_NOOP('A long option which has a short option as alias'), 0 },
     { 'e', 0, 0 },
     { 'nooption6', I18N_NOOP('Another long option with an alias'), 0 },
     { 'f', 0, 0 },
     { 'option7 \<speed>', I18N_NOOP(''--option7 speed' is the same as '-f speed''), 0 },
     { '!option8 \<cmd>', I18N_NOOP('All options following this one will be treated as arguments'), 0 },
     { '+file', I18N_NOOP('A required argument 'file''), 0 },
     { '+[arg1]', I18N_NOOP('An optional argument 'arg1''), 0 },
     { '!+command', I18N_NOOP('A required argument 'command', that can contain multiple words, even starting with '-''), 0 },
     { '', I18N_NOOP('Additional help text not associated with any particular option') 0 },
     KCmdLineLastOption // End of options.
  };
.fi
.PP
.PP
The I18N_NOOP macro is used to indicate that these strings should be marked for translation. The actual translation is done by KCmdLineArgs. You can't use i18n() here because we are setting up a static data structure and can't do translations at compile time.
.PP
Note that a program should define the options before any arguments.
.PP
When a long option has a short option as an alias, a program should only test for the long option.
.PP
With the above options a command line could look like: 
.PP
.nf
     myapp -a -c 4800 --display localhost:0.0 --nooption5 -d /tmp/file

.fi
.PP
.PP
Long binary options can be in the form 'option' and 'nooption'. A command line may contain the same binary option multiple times, the last option determines the outcome: 
.PP
.nf
     myapp --nooption4 --option4 --nooption4

.fi
.PP
 is the same as: 
.PP
.nf
     myapp --nooption4

.fi
.PP
.PP
If an option value is provided multiple times, normally only the last value is used: 
.PP
.nf
     myapp -c 1200 -c 2400 -c 4800

.fi
.PP
 is usually the same as: 
.PP
.nf
     myapp -c 4800

.fi
.PP
.PP
However, an application can choose to use all values specified as well. As an example of this, consider that you may wish to specify a number of directories to use: 
.PP
.nf
     myapp -I /usr/include -I /opt/kde/include -I /usr/X11/include

.fi
.PP
 When an application does this it should mention this in the description of the option. To access these options, use \fBgetOptionList()\fP
.PP
Tips for end-users:
.PP
.PD 0
.IP "\(bu" 2
Single char options like '-a -b -c' may be combined into '-abc' 
.IP "\(bu" 2
The option '--foo bar' may also be written '--foo=bar' 
.IP "\(bu" 2
The option '-P lp1' may also be written '-P=lp1' or '-Plp1' 
.IP "\(bu" 2
The option '--foo bar' may also be written '-foo bar'
.PP
\fBAuthor:\fP
.RS 4
Waldo Bastian 
.RE
.PP
\fBVersion:\fP
.RS 4
0.0.4 
.RE
.PP

.PP
Definition at line 222 of file kcmdlineargs.h.
.SH "Constructor & Destructor Documentation"
.PP 
.SS "KCmdLineArgs::KCmdLineArgs (const \fBKCmdLineOptions\fP * _options, const char * _name, const char * _id)\fC [protected]\fP"
.PP
Constructor. 
.PP
The given arguments are assumed to be constants. 
.PP
Definition at line 974 of file kcmdlineargs.cpp.
.PP
Referenced by addCmdLineOptions().
.SS "KCmdLineArgs::~\fBKCmdLineArgs\fP ()\fC [protected]\fP"
.PP
Destructor. 
.PP
Definition at line 986 of file kcmdlineargs.cpp.
.SH "Member Function Documentation"
.PP 
.SS "void KCmdLineArgs::init (int _argc, char ** _argv, const char * _appname, const char * programName, const char * _description, const char * _version, bool noKApp = \fCfalse\fP)\fC [static]\fP"
.PP
Initialize class. 
.PP
This function should be called as the very first thing in your application. 
.PP
\fBParameters:\fP
.RS 4
\fI_argc\fP As passed to \fCmain\fP(...). 
.br
\fI_argv\fP As passed to \fCmain\fP(...). 
.br
\fI_appname\fP The untranslated name of your application. This should match with \fCargv\fP[0]. 
.br
\fIprogramName\fP A program name string to be used for display purposes. This string should be marked for translation. Example: I18N_NOOP('KEdit') 
.br
\fI_description\fP A short description of what your application is about. 
.br
\fI_version\fP A version. 
.br
\fInoKApp\fP Set this true to not add commandline options for \fBQApplication\fP / \fBKApplication\fP
.RE
.PP
\fBSince:\fP
.RS 4
3.2 
.RE
.PP

.PP
Definition at line 127 of file kcmdlineargs.cpp.
.PP
Referenced by init().
.SS "void KCmdLineArgs::init (int _argc, char ** _argv, const char * _appname, const char * _description, const char * _version, bool noKApp = \fCfalse\fP)\fC [static]\fP"
.PP
\fBDeprecated\fP
.RS 4
You should convert any calls to this method to use the one above, by adding in the program name to be used for display purposes. Do not forget to mark it for translation using I18N_NOOP. 
.RE
.PP

.PP
Definition at line 136 of file kcmdlineargs.cpp.
.PP
References init().
.SS "void KCmdLineArgs::init (int _argc, char ** _argv, const \fBKAboutData\fP * about, bool noKApp = \fCfalse\fP)\fC [static]\fP"
.PP
Initialize class. 
.PP
This function should be called as the very first thing in your application. It uses \fBKAboutData\fP to replace some of the arguments that would otherwise be required.
.PP
\fBParameters:\fP
.RS 4
\fI_argc\fP As passed to \fCmain\fP(...). 
.br
\fI_argv\fP As passed to \fCmain\fP(...). 
.br
\fIabout\fP A \fBKAboutData\fP object describing your program. 
.br
\fInoKApp\fP Set this true to not add commandline options for \fBQApplication\fP / \fBKApplication\fP 
.RE
.PP

.PP
Definition at line 162 of file kcmdlineargs.cpp.
.PP
References KApplication::addCmdLineOptions(), and KStaticDeleter< type >::setObject().
.SS "void KCmdLineArgs::init (const \fBKAboutData\fP * about)\fC [static]\fP"
.PP
Initialize Class. 
.PP
This function should be called as the very first thing in your application. This method will rarely be used, since it doesn't provide any argument parsing. It does provide access to the \fBKAboutData\fP information. This method is exactly the same as calling init(0,0, const KAboutData *about, true).
.PP
\fBParameters:\fP
.RS 4
\fIabout\fP the about data. 
.RE
.PP
\fBSee also:\fP
.RS 4
\fBKAboutData\fP 
.RE
.PP

.PP
Definition at line 153 of file kcmdlineargs.cpp.
.PP
References KAboutData::appName(), and init().
.SS "void KCmdLineArgs::addCmdLineOptions (const \fBKCmdLineOptions\fP * options, const char * name = \fC0\fP, const char * id = \fC0\fP, const char * afterId = \fC0\fP)\fC [static]\fP"
.PP
Add options to your application. 
.PP
You must make sure that all possible options have been added before any class uses the command line arguments.
.PP
The list of options should look like this:
.PP
.PP
.nf
 static KCmdLineOptions options[] =
 {
    { 'option1 \<argument>', I18N_NOOP('Description 1'), 'my_extra_arg' },
    { 'o', 0, 0 },
    { 'option2', I18N_NOOP('Description 2'), 0 },
    { 'nooption3', I18N_NOOP('Description 3'), 0 },
    KCmdLineLastOption
 }
.fi
.PP
.PP
.PD 0
.IP "\(bu" 2
'option1' is an option that requires an additional argument, but if one is not provided, it uses 'my_extra_arg'. 
.IP "\(bu" 2
'option2' is an option that can be turned on. The default is off. 
.IP "\(bu" 2
'option3' is an option that can be turned off. The default is on. 
.IP "\(bu" 2
'o' does not have a description. It is an alias for the option that follows. In this case 'option2'. 
.IP "\(bu" 2
'+file' specifies an argument. The '+' is removed. If your program doesn't specify that it can use arguments your program will abort when an argument is passed to it. Note that the reverse is not true. If required, you must check yourself the number of arguments specified by the user: 
.PP
.nf
       KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
       if (args->count() == 0) KCmdLineArgs::usage(i18n('No file specified!'));

.fi
.PP

.PP
In BNF: 
.PP
.nf
 cmd = myapp [options] file
 options = (option)*
 option = --option1 \<argument> |
          (-o | --option2 | --nooption2) |
          ( --option3 | --nooption3 )

.fi
.PP
.PP
Instead of '--option3' one may also use '-option3'
.PP
Usage examples:
.PP
.PD 0
.IP "\(bu" 2
'myapp --option1 test' 
.IP "\(bu" 2
'myapp' (same as 'myapp --option1 my_extra_arg') 
.IP "\(bu" 2
'myapp --option2' 
.IP "\(bu" 2
'myapp --nooption2' (same as 'myapp', since it is off by default) 
.IP "\(bu" 2
'myapp -o' (same as 'myapp --option2') 
.IP "\(bu" 2
'myapp --nooption3' 
.IP "\(bu" 2
'myapp --option3 (same as 'myapp', since it is on by default) 
.IP "\(bu" 2
'myapp --option2 --nooption2' (same as 'myapp', because it option2 is off by default, and the last usage applies) 
.IP "\(bu" 2
'myapp /tmp/file'
.PP
\fBParameters:\fP
.RS 4
\fIoptions\fP A list of options that your code supplies. 
.br
\fIname\fP the name of the option, can be 0. 
.br
\fIid\fP A name with which these options can be identified, can be 0. 
.br
\fIafterId\fP The options are inserted after this set of options, can be 0. 
.RE
.PP

.PP
Definition at line 206 of file kcmdlineargs.cpp.
.PP
References id, and KCmdLineArgs().
.PP
Referenced by KUniqueApplication::addCmdLineOptions(), KApplication::addCmdLineOptions(), and addTempFileOption().
.SS "\fBKCmdLineArgs\fP * KCmdLineArgs::parsedArgs (const char * id = \fC0\fP)\fC [static]\fP"
.PP
Access parsed arguments. 
.PP
This function returns all command line arguments that your code handles. If unknown command-line arguments are encountered the program is aborted and usage information is shown.
.PP
\fBParameters:\fP
.RS 4
\fIid\fP The name of the options you are interested in, can be 0. 
.RE
.PP

.PP
Definition at line 308 of file kcmdlineargs.cpp.
.PP
References id.
.PP
Referenced by KApplication::dcopClient(), isTempFileSet(), and KUniqueApplication::start().
.SS "\fBQString\fP KCmdLineArgs::cwd ()\fC [static]\fP"
.PP
Get the CWD (Current Working Directory) associated with the current command line arguments. 
.PP
Typically this is needed in \fBKUniqueApplication::newInstance()\fP since the CWD of the process may be different from the CWD where the user started a second instance. 
.PP
\fBReturns:\fP
.RS 4
the current working directory 
.RE
.PP

.PP
Definition at line 194 of file kcmdlineargs.cpp.
.PP
References QFile::decodeName().
.PP
Referenced by makeURL().
.SS "const char * KCmdLineArgs::appName ()\fC [static]\fP"
.PP
Get the appname according to argv[0]. 
.PP
\fBReturns:\fP
.RS 4
the name of the application 
.RE
.PP

.PP
Definition at line 199 of file kcmdlineargs.cpp.
.SS "void KCmdLineArgs::usage (const char * id = \fC0\fP)\fC [static]\fP"
.PP
Print the usage help to stdout and exit. 
.PP
\fBParameters:\fP
.RS 4
\fIid\fP if 0, print all options. If id is set, only print the option specified by id. The id is the value set by #ref \fBaddCmdLineOptions()\fP. 
.RE
.PP

.PP
Definition at line 757 of file kcmdlineargs.cpp.
.PP
References QString::append(), arg(), QString::arg(), KCmdLineOptions::def, KCmdLineOptions::description, enable_i18n(), QString::endsWith(), id, QCString::length(), QCString::mid(), name, KCmdLineOptions::name, options, KAboutData::shortDescription(), QStringList::split(), and usage().
.PP
Referenced by usage().
.SS "void KCmdLineArgs::usage (const \fBQString\fP & error)\fC [static]\fP"
.PP
Print an error to stderr and the usage help to stdout and exit. 
.PP
\fBParameters:\fP
.RS 4
\fIerror\fP the error to print 
.RE
.PP

.PP
Definition at line 742 of file kcmdlineargs.cpp.
.PP
References QCString::left(), QCString::length(), and QString::local8Bit().
.SS "void KCmdLineArgs::enable_i18n ()\fC [static]\fP"
.PP
Enable i18n to be able to print a translated error message. 
.PP
N.B.: This function leaks memory, therefore you are expected to exit afterwards (e.g., by calling \fBusage()\fP). 
.PP
Definition at line 728 of file kcmdlineargs.cpp.
.PP
References KInstance::config().
.PP
Referenced by usage().
.SS "\fBQCString\fP KCmdLineArgs::getOption (const char * option) const"
.PP
Read out a string option. 
.PP
The option must have a corresponding \fBKCmdLineOptions\fP entry of the form: 
.PP
.nf
    { 'option \<argument>', I18N_NOOP('Description'), 'default' }

.fi
.PP
 You cannot test for the presence of an alias - you must always test for the full option.
.PP
\fBParameters:\fP
.RS 4
\fIoption\fP The name of the option without '-'.
.RE
.PP
\fBReturns:\fP
.RS 4
The value of the option. If the option was not present on the command line the default is returned. If the option was present more than the value of the last occurrence is used. 
.RE
.PP

.PP
Definition at line 1102 of file kcmdlineargs.cpp.
.PP
References QCString::find().
.PP
Referenced by KApplication::dcopClient().
.SS "\fBQCStringList\fP KCmdLineArgs::getOptionList (const char * option) const"
.PP
Read out all occurrences of a string option. 
.PP
The option must have a corresponding \fBKCmdLineOptions\fP entry of the form: 
.PP
.nf
    { 'option \<argument>', I18N_NOOP('Description'), 'default' }

.fi
.PP
 You cannot test for the presence of an alias - you must always test for the full option.
.PP
\fBParameters:\fP
.RS 4
\fIoption\fP The name of the option, without '-' or '-no'.
.RE
.PP
\fBReturns:\fP
.RS 4
A list of all option values. If no option was present on the command line, an empty list is returned. 
.RE
.PP

.PP
Definition at line 1134 of file kcmdlineargs.cpp.
.PP
References QValueList::begin(), QValueList::end(), QCString::insert(), and QValueList::prepend().
.SS "bool KCmdLineArgs::isSet (const char * option) const"
.PP
Read out a boolean option or check for the presence of string option. 
.PP
\fBParameters:\fP
.RS 4
\fIoption\fP The name of the option without '-' or '-no'.
.RE
.PP
\fBReturns:\fP
.RS 4
The value of the option. It will be true if the option was specifically turned on in the command line, or if the option is turned on by default (in the \fBKCmdLineOptions\fP list) and was not specifically turned off in the command line. Equivalently, it will be false if the option was specifically turned off in the command line, or if the option is turned off by default (in the \fBKCmdLineOptions\fP list) and was not specifically turned on in the command line. 
.RE
.PP

.PP
Definition at line 1164 of file kcmdlineargs.cpp.
.PP
References QCString::find().
.PP
Referenced by KApplication::dcopClient(), isTempFileSet(), and KUniqueApplication::start().
.SS "int KCmdLineArgs::count () const"
.PP
Read the number of arguments that aren't options (but, for example, filenames). 
.PP
\fBReturns:\fP
.RS 4
The number of arguments that aren't options 
.RE
.PP

.PP
Definition at line 1207 of file kcmdlineargs.cpp.
.PP
Referenced by loadAppArgs().
.SS "const char * KCmdLineArgs::arg (int n) const"
.PP
Read out an argument. 
.PP
\fBParameters:\fP
.RS 4
\fIn\fP The argument to read. 0 is the first argument. \fBcount()\fP-1 is the last argument.
.RE
.PP
\fBReturns:\fP
.RS 4
A \fCconst\fP \fCchar\fP \fC*\fP pointer to the n'th argument. 
.RE
.PP

.PP
Definition at line 1215 of file kcmdlineargs.cpp.
.PP
Referenced by url(), and usage().
.SS "\fBKURL\fP KCmdLineArgs::url (int n) const"
.PP
Read out an argument representing a URL. 
.PP
The argument can be 
.PD 0

.IP "\(bu" 2
an absolute filename 
.IP "\(bu" 2
a relative filename 
.IP "\(bu" 2
a URL
.PP
\fBParameters:\fP
.RS 4
\fIn\fP The argument to read. 0 is the first argument. \fBcount()\fP-1 is the last argument.
.RE
.PP
\fBReturns:\fP
.RS 4
a URL representing the n'th argument. 
.RE
.PP

.PP
Definition at line 1231 of file kcmdlineargs.cpp.
.PP
References arg(), and makeURL().
.SS "\fBKURL\fP KCmdLineArgs::makeURL (const char * urlArg)\fC [static]\fP"
.PP
Used by \fBurl()\fP. 
.PP
Made public for apps that don't use KCmdLineArgs 
.PP
\fBParameters:\fP
.RS 4
\fIurlArg\fP the argument 
.RE
.PP
\fBReturns:\fP
.RS 4
the url. 
.RE
.PP

.PP
Definition at line 1236 of file kcmdlineargs.cpp.
.PP
References KURL::cleanPath(), cwd(), QFile::decodeName(), and KURL::setPath().
.PP
Referenced by url().
.SS "static void KCmdLineArgs::setCwd (char * cwd)\fC [inline, static]\fP"
.PP
Made public for apps that don't use KCmdLineArgs To be done before makeURL, to set the current working directory in case makeURL needs it. 
.PP
\fBParameters:\fP
.RS 4
\fIcwd\fP the new working directory 
.RE
.PP

.PP
Definition at line 516 of file kcmdlineargs.h.
.SS "void KCmdLineArgs::clear ()"
.PP
Clear all options and arguments. 
.PP
Definition at line 995 of file kcmdlineargs.cpp.
.PP
Referenced by loadAppArgs(), and reset().
.SS "void KCmdLineArgs::reset ()\fC [static]\fP"
.PP
Reset all option definitions, i.e. 
.PP
cancel all addCmdLineOptions calls. Note that KApplication's options are removed too, you might want to call \fBKApplication::addCmdLineOptions\fP if you want them back.
.PP
You usually don't want to call this method. 
.PP
Definition at line 1004 of file kcmdlineargs.cpp.
.PP
References clear().
.SS "void KCmdLineArgs::loadAppArgs (\fBQDataStream\fP &)\fC [static]\fP"
.PP
Load arguments from a stream. 
.PP
Definition at line 264 of file kcmdlineargs.cpp.
.PP
References clear(), count(), id, load(), and KStaticDeleter< type >::setObject().
.SS "void KCmdLineArgs::addTempFileOption ()\fC [static]\fP"
.PP
Add standard option --tempfile 
.PP
\fBSince:\fP
.RS 4
3.4. 
.RE
.PP

.PP
Definition at line 1271 of file kcmdlineargs.cpp.
.PP
References addCmdLineOptions().
.SS "bool KCmdLineArgs::isTempFileSet ()\fC [static]\fP"
.PP
\fBReturns:\fP
.RS 4
true if --tempfile was set 
.RE
.PP
\fBSince:\fP
.RS 4
3.4 
.RE
.PP

.PP
Definition at line 1276 of file kcmdlineargs.cpp.
.PP
References isSet(), and parsedArgs().

.SH "Author"
.PP 
Generated automatically by Doxygen for kdecore Library from the source code.
