1998-08-17 18:45:47 -04:00
|
|
|
\section{\class{wxConfigBase}}\label{wxconfigbase}
|
|
|
|
|
|
|
|
wxConfigBase class defines the basic interface of all config classes. It can
|
2000-07-15 15:51:35 -04:00
|
|
|
not be used by itself (it is an abstract base class) and you will always use one
|
2005-02-07 19:04:14 -05:00
|
|
|
of its derivations: \helpref{wxFileConfig}{wxfileconfig},
|
2004-10-03 18:55:08 -04:00
|
|
|
wxRegConfig or any other.
|
1998-08-17 18:45:47 -04:00
|
|
|
|
|
|
|
However, usually you don't even need to know the precise nature of the class
|
|
|
|
you're working with but you would just use the wxConfigBase methods. This
|
|
|
|
allows you to write the same code regardless of whether you're working with
|
|
|
|
the registry under Win32 or text-based config files under Unix (or even
|
|
|
|
Windows 3.1 .INI files if you're really unlucky). To make writing the portable
|
2004-05-04 04:27:20 -04:00
|
|
|
code even easier, wxWidgets provides a typedef wxConfig
|
1998-08-17 18:45:47 -04:00
|
|
|
which is mapped onto the native wxConfigBase implementation on the given
|
2005-02-07 19:04:14 -05:00
|
|
|
platform: i.e. wxRegConfig under Win32 and
|
1998-08-17 18:45:47 -04:00
|
|
|
wxFileConfig otherwise.
|
|
|
|
|
1998-09-17 16:57:08 -04:00
|
|
|
See \helpref{config overview}{wxconfigoverview} for the descriptions of all
|
|
|
|
features of this class.
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2000-01-17 12:18:27 -05:00
|
|
|
It is highly recommended to use static functions {\it Get()} and/or {\it Set()},
|
|
|
|
so please have a \helpref{look at them.}{wxconfigstaticfunctions}
|
|
|
|
|
1998-08-17 18:45:47 -04:00
|
|
|
\wxheading{Derived from}
|
|
|
|
|
2007-03-10 13:16:10 -05:00
|
|
|
\helpref{wxObject}{wxobject}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
1999-02-15 15:41:29 -05:00
|
|
|
\wxheading{Include files}
|
|
|
|
|
2004-05-04 04:27:20 -04:00
|
|
|
<wx/config.h> (to let wxWidgets choose a wxConfig class for your platform)\\
|
1999-02-15 15:41:29 -05:00
|
|
|
<wx/confbase.h> (base config class)\\
|
2003-04-28 06:37:08 -04:00
|
|
|
<wx/fileconf.h> (wxFileConfig class)\\
|
2005-02-07 19:04:14 -05:00
|
|
|
<wx/msw/regconf.h> (wxRegConfig class)
|
1999-02-15 15:41:29 -05:00
|
|
|
|
1998-08-17 18:45:47 -04:00
|
|
|
\wxheading{Example}
|
|
|
|
|
|
|
|
Here is how you would typically use this class:
|
|
|
|
|
|
|
|
\begin{verbatim}
|
|
|
|
// using wxConfig instead of writing wxFileConfig or wxRegConfig enhances
|
|
|
|
// portability of the code
|
|
|
|
wxConfig *config = new wxConfig("MyAppName");
|
|
|
|
|
|
|
|
wxString str;
|
1998-08-27 17:10:49 -04:00
|
|
|
if ( config->Read("LastPrompt", &str) ) {
|
1998-08-18 10:54:21 -04:00
|
|
|
// last prompt was found in the config file/registry and its value is now
|
1998-08-17 18:45:47 -04:00
|
|
|
// in str
|
|
|
|
...
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// no last prompt...
|
|
|
|
}
|
|
|
|
|
|
|
|
// another example: using default values and the full path instead of just
|
|
|
|
// key name: if the key is not found , the value 17 is returned
|
2007-08-15 16:23:01 -04:00
|
|
|
long value = config->ReadLong("/LastRun/CalculatedValues/MaxValue", 17);
|
1998-08-17 18:45:47 -04:00
|
|
|
...
|
|
|
|
...
|
|
|
|
...
|
|
|
|
// at the end of the program we would save everything back
|
|
|
|
config->Write("LastPrompt", str);
|
|
|
|
config->Write("/LastRun/CalculatedValues/MaxValue", value);
|
|
|
|
|
|
|
|
// the changes will be written back automatically
|
|
|
|
delete config;
|
|
|
|
\end{verbatim}
|
|
|
|
|
|
|
|
This basic example, of course, doesn't show all wxConfig features, such as
|
|
|
|
enumerating, testing for existence and deleting the entries and groups of
|
1998-08-18 10:54:21 -04:00
|
|
|
entries in the config file, its abilities to automatically store the default
|
1998-08-17 18:45:47 -04:00
|
|
|
values or expand the environment variables on the fly. However, the main idea
|
|
|
|
is that using this class is easy and that it should normally do what you
|
|
|
|
expect it to.
|
|
|
|
|
|
|
|
NB: in the documentation of this class, the words "config file" also mean
|
|
|
|
"registry hive" for wxRegConfig and, generally speaking, might mean any
|
1998-08-18 10:54:21 -04:00
|
|
|
physical storage where a wxConfigBase-derived class stores its data.
|
1998-08-17 18:45:47 -04:00
|
|
|
|
1998-08-18 10:54:21 -04:00
|
|
|
\latexignore{\rtfignore{\wxheading{Function groups}}}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
2000-01-17 12:18:27 -05:00
|
|
|
\membersection{Static functions}\label{wxconfigstaticfunctions}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
These functions deal with the "default" config object. Although its usage is
|
1998-08-17 18:45:47 -04:00
|
|
|
not at all mandatory it may be convenient to use a global config object
|
|
|
|
instead of creating and deleting the local config objects each time you need
|
|
|
|
one (especially because creating a wxFileConfig object might be a time
|
|
|
|
consuming operation). In this case, you may create this global config object
|
|
|
|
in the very start of the program and {\it Set()} it as the default. Then, from
|
2001-11-25 13:39:55 -05:00
|
|
|
anywhere in your program, you may access it using the {\it Get()} function.
|
2006-06-03 10:49:23 -04:00
|
|
|
This global wxConfig object will be deleted by wxWidgets automatically if it
|
|
|
|
exists. Note that this implies that if you do delete this object yourself
|
|
|
|
(usually in \helpref{wxApp::OnExit}{wxapponexit}) you must use {\it Set(NULL)}
|
|
|
|
to prevent wxWidgets from deleting it the second time.
|
1998-08-17 18:45:47 -04:00
|
|
|
|
|
|
|
As it happens, you may even further simplify the procedure described above:
|
|
|
|
you may forget about calling {\it Set()}. When {\it Get()} is called and there
|
|
|
|
is no current object, it will create one using {\it Create()} function. To
|
|
|
|
disable this behaviour {\it DontCreateOnDemand()} is provided.
|
|
|
|
|
2004-05-04 04:27:20 -04:00
|
|
|
{\bf Note:} You should use either {\it Set()} or {\it Get()} because wxWidgets
|
2000-01-17 12:18:27 -05:00
|
|
|
library itself would take advantage of it and could save various information
|
|
|
|
in it. For example \helpref{wxFontMapper}{wxfontmapper} or Unix version
|
2005-04-08 10:34:30 -04:00
|
|
|
of \helpref{wxFileDialog}{wxfiledialog} have the ability to use wxConfig class.
|
2000-01-17 12:18:27 -05:00
|
|
|
|
1998-08-18 10:54:21 -04:00
|
|
|
\helpref{Set}{wxconfigbaseset}\\
|
|
|
|
\helpref{Get}{wxconfigbaseget}\\
|
|
|
|
\helpref{Create}{wxconfigbasecreate}\\
|
|
|
|
\helpref{DontCreateOnDemand}{wxconfigbasedontcreateondemand}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
2004-10-04 11:13:52 -04:00
|
|
|
\membersection{Constructor and destructor}\label{congigconstructordestructor}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
1998-08-18 10:54:21 -04:00
|
|
|
\helpref{wxConfigBase}{wxconfigbasector}\\
|
|
|
|
\helpref{\destruct{wxConfigBase}}{wxconfigbasedtor}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
2004-10-04 11:13:52 -04:00
|
|
|
\membersection{Path management}\label{configpathmanagement}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
1998-09-17 16:57:08 -04:00
|
|
|
As explained in \helpref{config overview}{wxconfigoverview}, the config classes
|
|
|
|
support a file system-like hierarchy of keys (files) and groups (directories).
|
1998-08-17 18:45:47 -04:00
|
|
|
As in the file system case, to specify a key in the config class you must use
|
|
|
|
a path to it. Config classes also support the notion of the current group,
|
|
|
|
which makes it possible to use the relative paths. To clarify all this, here
|
2000-07-15 15:51:35 -04:00
|
|
|
is an example (it is only for the sake of demonstration, it doesn't do anything
|
1998-08-17 18:45:47 -04:00
|
|
|
sensible!):
|
|
|
|
|
|
|
|
\begin{verbatim}
|
|
|
|
wxConfig *config = new wxConfig("FooBarApp");
|
|
|
|
|
|
|
|
// right now the current path is '/'
|
|
|
|
conf->Write("RootEntry", 1);
|
|
|
|
|
|
|
|
// go to some other place: if the group(s) don't exist, they will be created
|
|
|
|
conf->SetPath("/Group/Subgroup");
|
|
|
|
|
|
|
|
// create an entry in subgroup
|
|
|
|
conf->Write("SubgroupEntry", 3);
|
1999-02-24 03:17:50 -05:00
|
|
|
|
1998-08-17 18:45:47 -04:00
|
|
|
// '..' is understood
|
|
|
|
conf->Write("../GroupEntry", 2);
|
|
|
|
conf->SetPath("..");
|
|
|
|
|
2007-08-15 16:23:01 -04:00
|
|
|
wxASSERT( conf->ReadLong("Subgroup/SubgroupEntry", 0) == 3 );
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2000-07-15 15:51:35 -04:00
|
|
|
// use absolute path: it is allowed, too
|
2007-08-15 16:23:01 -04:00
|
|
|
wxASSERT( conf->ReadLong("/RootEntry", 0) == 1 );
|
1998-08-17 18:45:47 -04:00
|
|
|
\end{verbatim}
|
|
|
|
|
2000-07-15 15:51:35 -04:00
|
|
|
{\it Warning}: it is probably a good idea to always restore the path to its
|
1998-08-17 18:45:47 -04:00
|
|
|
old value on function exit:
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-08-17 18:45:47 -04:00
|
|
|
\begin{verbatim}
|
|
|
|
void foo(wxConfigBase *config)
|
|
|
|
{
|
|
|
|
wxString strOldPath = config->GetPath();
|
|
|
|
|
|
|
|
config->SetPath("/Foo/Data");
|
|
|
|
...
|
|
|
|
|
|
|
|
config->SetPath(strOldPath);
|
|
|
|
}
|
|
|
|
\end{verbatim}
|
|
|
|
|
|
|
|
because otherwise the assert in the following example will surely fail
|
|
|
|
(we suppose here that {\it foo()} function is the same as above except that it
|
|
|
|
doesn't save and restore the path):
|
|
|
|
|
|
|
|
\begin{verbatim}
|
|
|
|
void bar(wxConfigBase *config)
|
|
|
|
{
|
|
|
|
config->Write("Test", 17);
|
1999-02-24 03:17:50 -05:00
|
|
|
|
1998-08-17 18:45:47 -04:00
|
|
|
foo(config);
|
|
|
|
|
|
|
|
// we're reading "/Foo/Data/Test" here! -1 will probably be returned...
|
2007-08-15 16:23:01 -04:00
|
|
|
wxASSERT( config->ReadLong("Test", -1) == 17 );
|
1998-08-17 18:45:47 -04:00
|
|
|
}
|
|
|
|
\end{verbatim}
|
|
|
|
|
|
|
|
Finally, the path separator in wxConfigBase and derived classes is always '/',
|
2000-07-15 15:51:35 -04:00
|
|
|
regardless of the platform (i.e. it is {\bf not} '$\backslash\backslash$' under Windows).
|
1998-08-17 18:45:47 -04:00
|
|
|
|
1998-08-18 10:54:21 -04:00
|
|
|
\helpref{SetPath}{wxconfigbasesetpath}\\
|
|
|
|
\helpref{GetPath}{wxconfigbasegetpath}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
2004-10-04 11:13:52 -04:00
|
|
|
\membersection{Enumeration}\label{configenumeration}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
|
|
|
The functions in this section allow to enumerate all entries and groups in the
|
2005-04-08 10:34:30 -04:00
|
|
|
config file. All functions here return \false when there are no more items.
|
1998-08-17 18:45:47 -04:00
|
|
|
|
1998-08-18 10:54:21 -04:00
|
|
|
You must pass the same index to GetNext and GetFirst (don't modify it).
|
2000-07-15 15:51:35 -04:00
|
|
|
Please note that it is {\bf not} the index of the current item (you will have
|
2002-06-07 16:15:28 -04:00
|
|
|
some great surprises with wxRegConfig if you assume this) and you shouldn't
|
2000-07-15 15:51:35 -04:00
|
|
|
even look at it: it is just a "cookie" which stores the state of the
|
1998-08-17 18:45:47 -04:00
|
|
|
enumeration. It can't be stored inside the class because it would prevent you
|
|
|
|
from running several enumerations simultaneously, that's why you must pass it
|
|
|
|
explicitly.
|
|
|
|
|
|
|
|
Having said all this, enumerating the config entries/groups is very simple:
|
|
|
|
|
|
|
|
\begin{verbatim}
|
2005-02-20 20:56:35 -05:00
|
|
|
wxConfigBase *config = ...;
|
1998-08-17 18:45:47 -04:00
|
|
|
wxArrayString aNames;
|
|
|
|
|
|
|
|
// enumeration variables
|
|
|
|
wxString str;
|
|
|
|
long dummy;
|
|
|
|
|
|
|
|
// first enum all entries
|
|
|
|
bool bCont = config->GetFirstEntry(str, dummy);
|
|
|
|
while ( bCont ) {
|
|
|
|
aNames.Add(str);
|
|
|
|
|
|
|
|
bCont = GetConfig()->GetNextEntry(str, dummy);
|
|
|
|
}
|
|
|
|
|
|
|
|
... we have all entry names in aNames...
|
|
|
|
|
|
|
|
// now all groups...
|
|
|
|
bCont = GetConfig()->GetFirstGroup(str, dummy);
|
|
|
|
while ( bCont ) {
|
|
|
|
aNames.Add(str);
|
|
|
|
|
|
|
|
bCont = GetConfig()->GetNextGroup(str, dummy);
|
|
|
|
}
|
|
|
|
|
|
|
|
... we have all group (and entry) names in aNames...
|
|
|
|
|
|
|
|
\end{verbatim}
|
|
|
|
|
1998-08-18 10:54:21 -04:00
|
|
|
There are also functions to get the number of entries/subgroups without
|
1998-08-17 18:45:47 -04:00
|
|
|
actually enumerating them, but you will probably never need them.
|
|
|
|
|
1998-08-18 10:54:21 -04:00
|
|
|
\helpref{GetFirstGroup}{wxconfigbasegetfirstgroup}\\
|
|
|
|
\helpref{GetNextGroup}{wxconfigbasegetnextgroup}\\
|
|
|
|
\helpref{GetFirstEntry}{wxconfigbasegetfirstentry}\\
|
|
|
|
\helpref{GetNextEntry}{wxconfigbasegetnextentry}\\
|
|
|
|
\helpref{GetNumberOfEntries}{wxconfigbasegetnumberofentries}\\
|
|
|
|
\helpref{GetNumberOfGroups}{wxconfigbasegetnumberofgroups}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
2004-10-04 11:13:52 -04:00
|
|
|
\membersection{Tests of existence}\label{configtestsofexistence}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
1998-08-18 10:54:21 -04:00
|
|
|
\helpref{HasGroup}{wxconfigbasehasgroup}\\
|
|
|
|
\helpref{HasEntry}{wxconfigbasehasentry}\\
|
1999-04-06 06:23:31 -04:00
|
|
|
\helpref{Exists}{wxconfigbaseexists}\\
|
|
|
|
\helpref{GetEntryType}{wxconfigbasegetentrytype}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
2004-10-04 11:13:52 -04:00
|
|
|
\membersection{Miscellaneous functions}\label{configmiscellaneous}
|
1998-08-27 17:10:49 -04:00
|
|
|
|
|
|
|
\helpref{GetAppName}{wxconfigbasegetappname}\\
|
2000-07-15 15:51:35 -04:00
|
|
|
\helpref{GetVendorName}{wxconfigbasegetvendorname}\\
|
|
|
|
\helpref{SetUmask}{wxfileconfigsetumask}
|
1998-08-27 17:10:49 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
2004-10-04 11:13:52 -04:00
|
|
|
\membersection{Key access}\label{configkeyaccess}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
|
|
|
These function are the core of wxConfigBase class: they allow you to read and
|
|
|
|
write config file data. All {\it Read} function take a default value which
|
|
|
|
will be returned if the specified key is not found in the config file.
|
|
|
|
|
2007-07-21 19:47:22 -04:00
|
|
|
Currently, supported types of data are:
|
|
|
|
\helpref{wxString}{wxstring}, {\it long}, {\it double}, {\it bool},
|
|
|
|
\helpref{wxColour}{wxcolour} and any other types,
|
|
|
|
for which functions \helpref{wxToString}{wxtostring}
|
|
|
|
and \helpref{wxFromString}{wxfromstring} are defined.
|
1998-08-17 18:45:47 -04:00
|
|
|
|
|
|
|
Try not to read long values into string variables and vice versa: although it
|
|
|
|
just might work with wxFileConfig, you will get a system error with
|
|
|
|
wxRegConfig because in the Windows registry the different types of entries are
|
|
|
|
indeed used.
|
|
|
|
|
|
|
|
Final remark: the {\it szKey} parameter for all these functions can contain an
|
|
|
|
arbitrary path (either relative or absolute), not just the key name.
|
|
|
|
|
1998-08-18 10:54:21 -04:00
|
|
|
\helpref{Read}{wxconfigbaseread}\\
|
|
|
|
\helpref{Write}{wxconfigbasewrite}\\
|
|
|
|
\helpref{Flush}{wxconfigbaseflush}
|
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
2004-10-04 11:13:52 -04:00
|
|
|
\membersection{Rename entries/groups}\label{configrenaming}
|
1999-01-20 14:54:17 -05:00
|
|
|
|
|
|
|
The functions in this section allow to rename entries or subgroups of the
|
2005-04-08 10:34:30 -04:00
|
|
|
current group. They will return \false on error. typically because either the
|
1999-01-20 14:54:17 -05:00
|
|
|
entry/group with the original name doesn't exist, because the entry/group with
|
|
|
|
the new name already exists or because the function is not supported in this
|
|
|
|
wxConfig implementation.
|
|
|
|
|
|
|
|
\helpref{RenameEntry}{wxconfigbaserenameentry}\\
|
|
|
|
\helpref{RenameGroup}{wxconfigbaserenamegroup}
|
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
2004-10-04 11:13:52 -04:00
|
|
|
\membersection{Delete entries/groups}\label{configdeleting}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
|
|
|
The functions in this section delete entries and/or groups of entries from the
|
|
|
|
config file. {\it DeleteAll()} is especially useful if you want to erase all
|
|
|
|
traces of your program presence: for example, when you uninstall it.
|
|
|
|
|
|
|
|
\helpref{DeleteEntry}{wxconfigbasedeleteentry}\\
|
|
|
|
\helpref{DeleteGroup}{wxconfigbasedeletegroup}\\
|
|
|
|
\helpref{DeleteAll}{wxconfigbasedeleteall}
|
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
2004-10-04 11:13:52 -04:00
|
|
|
\membersection{Options}\label{configoptions}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
|
|
|
Some aspects of wxConfigBase behaviour can be changed during run-time. The
|
|
|
|
first of them is the expansion of environment variables in the string values
|
|
|
|
read from the config file: for example, if you have the following in your
|
|
|
|
config file:
|
|
|
|
|
|
|
|
\begin{verbatim}
|
|
|
|
# config file for my program
|
|
|
|
UserData = $HOME/data
|
|
|
|
|
|
|
|
# the following syntax is valud only under Windows
|
|
|
|
UserData = %windir%\\data.dat
|
|
|
|
\end{verbatim}
|
2002-02-15 16:50:50 -05:00
|
|
|
% $ % help EMACS syntax highlighting...
|
2002-05-05 10:24:07 -04:00
|
|
|
the call to {\tt config->Read("UserData")} will return something like
|
|
|
|
{\tt "/home/zeitlin/data"} if you're lucky enough to run a Linux system ;-)
|
1998-08-18 10:54:21 -04:00
|
|
|
|
|
|
|
Although this feature is very useful, it may be annoying if you read a value
|
|
|
|
which containts '\$' or '\%' symbols (\% is used for environment variables
|
|
|
|
expansion under Windows) which are not used for environment variable
|
2003-01-17 19:16:34 -05:00
|
|
|
expansion. In this situation you may call SetExpandEnvVars(false) just before
|
|
|
|
reading this value and SetExpandEnvVars(true) just after. Another solution
|
1998-08-18 10:54:21 -04:00
|
|
|
would be to prefix the offending symbols with a backslash.
|
|
|
|
|
|
|
|
The following functions control this option:
|
|
|
|
|
|
|
|
\helpref{IsExpandingEnvVars}{wxconfigbaseisexpandingenvvars}\\
|
2000-07-15 15:51:35 -04:00
|
|
|
\helpref{SetExpandEnvVars}{wxconfigbasesetexpandenvvars}\\
|
1998-08-18 10:54:21 -04:00
|
|
|
\helpref{SetRecordDefaults}{wxconfigbasesetrecorddefaults}\\
|
|
|
|
\helpref{IsRecordingDefaults}{wxconfigbaseisrecordingdefaults}
|
|
|
|
|
|
|
|
%%%%% MEMBERS HERE %%%%%
|
|
|
|
\helponly{\insertatlevel{2}{
|
|
|
|
|
|
|
|
\wxheading{Members}
|
|
|
|
|
|
|
|
}}
|
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::wxConfigBase}\label{wxconfigbasector}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\func{}{wxConfigBase}{\param{const wxString\& }{appName = wxEmptyString},
|
|
|
|
\param{const wxString\& }{vendorName = wxEmptyString},
|
|
|
|
\param{const wxString\& }{localFilename = wxEmptyString},
|
|
|
|
\param{const wxString\& }{globalFilename = wxEmptyString},
|
2003-02-23 14:01:41 -05:00
|
|
|
\param{long}{ style = 0},
|
2007-05-11 16:55:24 -04:00
|
|
|
\param{const wxMBConv\&}{ conv = wxConvAuto()}}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-09-17 16:57:08 -04:00
|
|
|
This is the default and only constructor of the wxConfigBase class, and
|
|
|
|
derived classes.
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\wxheading{Parameters}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-09-17 16:57:08 -04:00
|
|
|
\docparam{appName}{The application name. If this is empty, the class will
|
|
|
|
normally use \helpref{wxApp::GetAppName}{wxappgetappname} to set it. The
|
|
|
|
application name is used in the registry key on Windows, and can be used to
|
|
|
|
deduce the local filename parameter if that is missing.}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\docparam{vendorName}{The vendor name. If this is empty, it is assumed that
|
|
|
|
no vendor name is wanted, if this is optional for the current config class.
|
|
|
|
The vendor name is appended to the application name for wxRegConfig.}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-09-17 16:57:08 -04:00
|
|
|
\docparam{localFilename}{Some config classes require a local filename. If this
|
|
|
|
is not present, but required, the application name will be used instead.}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-09-17 16:57:08 -04:00
|
|
|
\docparam{globalFilename}{Some config classes require a global filename. If
|
|
|
|
this is not present, but required, the application name will be used instead.}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-09-17 16:57:08 -04:00
|
|
|
\docparam{style}{Can be one of wxCONFIG\_USE\_LOCAL\_FILE and
|
|
|
|
wxCONFIG\_USE\_GLOBAL\_FILE. The style interpretation depends on the config
|
2007-01-18 17:38:21 -05:00
|
|
|
class and is ignored by some implementations. For wxFileConfig, these styles
|
2007-06-22 18:19:38 -04:00
|
|
|
determine whether a local or global config file is created or used: if
|
|
|
|
wxCONFIG\_USE\_GLOBAL\_FILE is used, then settings are read from the global
|
|
|
|
config file and if wxCONFIG\_USE\_LOCAL\_FILE is used, settings are read from
|
|
|
|
and written to local config file (if they are both set, global file is read
|
|
|
|
first, then local file, overwriting global settings). If the
|
2007-01-18 17:38:21 -05:00
|
|
|
flag is present but the parameter is empty, the parameter will be set to a
|
|
|
|
default. If the parameter is present but the style flag not, the relevant flag
|
|
|
|
will be added to the style. For wxRegConfig, thie GLOBAL flag refers to HKLM
|
|
|
|
key while LOCAL one is for the usual HKCU one.
|
|
|
|
|
|
|
|
For wxFileConfig you can also add wxCONFIG\_USE\_RELATIVE\_PATH by logically
|
|
|
|
or'ing it to either of the \_FILE options to tell wxFileConfig to use relative
|
|
|
|
instead of absolute paths.
|
|
|
|
|
|
|
|
On non-VMS Unix systems, the default local configuration file is \tt{~/.appname}.
|
|
|
|
However, this path may be also used as user data directory
|
|
|
|
(see \helpref{wxStandardPaths::GetUserDataDir}{wxstandardpathsgetuserdatadir}) if
|
|
|
|
the application has several data files. In this case wxCONFIG\_USE\_SUBDIR
|
|
|
|
flag, which changes the default local configuration file to \tt{~/.appname/appname}
|
2007-03-18 13:34:11 -04:00
|
|
|
should be used. Notice that this flag is ignored if \textit{localFilename} is
|
|
|
|
provided. \newsince{2.8.2}
|
2007-01-18 17:38:21 -05:00
|
|
|
|
|
|
|
For wxFileConfig, you can also add wxCONFIG\_USE\_NO\_ESCAPE\_CHARACTERS which
|
|
|
|
will turn off character escaping for the values of entries stored in the config
|
|
|
|
file: for example a {\it foo} key with some backslash characters will be stored
|
|
|
|
as {\tt foo=C:$\backslash$mydir} instead of the usual storage of {\tt
|
|
|
|
foo=C:$\backslash\backslash$mydir}.
|
2002-12-04 09:11:26 -05:00
|
|
|
|
2002-08-20 10:29:22 -04:00
|
|
|
The wxCONFIG\_USE\_NO\_ESCAPE\_CHARACTERS style can be helpful if your config
|
2004-05-04 04:27:20 -04:00
|
|
|
file must be read or written to by a non-wxWidgets program (which might not
|
2002-08-20 10:29:22 -04:00
|
|
|
understand the escape characters). Note, however, that if
|
|
|
|
wxCONFIG\_USE\_NO\_ESCAPE\_CHARACTERS style is used, it is is now
|
|
|
|
your application's responsibility to ensure that there is no newline or
|
|
|
|
other illegal characters in a value, before writing that value to the file.}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
2003-04-21 07:23:02 -04:00
|
|
|
\docparam{conv}{This parameter is only used by wxFileConfig when compiled
|
2004-12-11 16:33:17 -05:00
|
|
|
in Unicode mode. It specifies the encoding in which the configuration file
|
2003-04-21 07:23:02 -04:00
|
|
|
is written.}
|
|
|
|
|
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\wxheading{Remarks}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-09-17 16:57:08 -04:00
|
|
|
By default, environment variable expansion is on and recording defaults is
|
|
|
|
off.
|
1998-08-18 10:54:21 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::\destruct{wxConfigBase}}\label{wxconfigbasedtor}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\func{}{\destruct{wxConfigBase}}{\void}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
Empty but ensures that dtor of all derived classes is virtual.
|
1998-08-18 10:54:21 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-18 10:54:21 -04:00
|
|
|
\membersection{wxConfigBase::Create}\label{wxconfigbasecreate}
|
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\func{static wxConfigBase *}{Create}{\void}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
|
|
|
Create a new config object: this function will create the "best"
|
1998-09-17 16:57:08 -04:00
|
|
|
implementation of wxConfig available for the current platform, see comments
|
|
|
|
near the definition of wxCONFIG\_WIN32\_NATIVE for details. It returns the
|
|
|
|
created object and also sets it as the current one.
|
1998-08-18 10:54:21 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-18 10:54:21 -04:00
|
|
|
\membersection{wxConfigBase::DontCreateOnDemand}\label{wxconfigbasedontcreateondemand}
|
|
|
|
|
|
|
|
\func{void}{DontCreateOnDemand}{\void}
|
|
|
|
|
|
|
|
Calling this function will prevent {\it Get()} from automatically creating a
|
|
|
|
new config object if the current one is NULL. It might be useful to call it
|
2005-04-08 10:34:30 -04:00
|
|
|
near the program end to prevent "accidental" creation of a new config object.
|
1998-08-18 10:54:21 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::DeleteAll}\label{wxconfigbasedeleteall}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\func{bool}{DeleteAll}{\void}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
Delete the whole underlying object (disk file, registry key, ...). Primarly
|
2005-04-08 10:34:30 -04:00
|
|
|
for use by uninstallation routine.
|
1998-08-18 10:54:21 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::DeleteEntry}\label{wxconfigbasedeleteentry}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
2003-01-17 19:16:34 -05:00
|
|
|
\func{bool}{DeleteEntry}{\param{const wxString\& }{ key}, \param{bool}{ bDeleteGroupIfEmpty = true}}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-09-17 16:57:08 -04:00
|
|
|
Deletes the specified entry and the group it belongs to if it was the last key
|
|
|
|
in it and the second parameter is true.
|
1998-08-18 10:54:21 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::DeleteGroup}\label{wxconfigbasedeletegroup}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\func{bool}{DeleteGroup}{\param{const wxString\& }{ key}}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
2006-07-14 18:08:43 -04:00
|
|
|
Delete the group (with all subgroups). If the current path is under the group
|
|
|
|
being deleted it is changed to its deepest still existing component. E.g. if
|
|
|
|
the current path is \texttt{/A/B/C/D} and the group \texttt{C} is deleted the
|
|
|
|
path becomes \texttt{/A/B}.
|
1998-08-27 17:10:49 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::Exists}\label{wxconfigbaseexists}
|
|
|
|
|
|
|
|
\constfunc{bool}{Exists}{\param{wxString\& }{strName}}
|
|
|
|
|
2005-04-08 10:34:30 -04:00
|
|
|
returns \true if either a group or an entry with a given name exists
|
1998-08-27 17:10:49 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::Flush}\label{wxconfigbaseflush}
|
|
|
|
|
2003-01-17 19:16:34 -05:00
|
|
|
\func{bool}{Flush}{\param{bool }{bCurrentOnly = false}}
|
1998-08-27 17:10:49 -04:00
|
|
|
|
|
|
|
permanently writes all changes (otherwise, they're only written from object's
|
|
|
|
destructor)
|
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::Get}\label{wxconfigbaseget}
|
|
|
|
|
2003-01-17 19:16:34 -05:00
|
|
|
\func{static wxConfigBase *}{Get}{\param{bool }{CreateOnDemand = true}}
|
1998-08-27 17:10:49 -04:00
|
|
|
|
2000-01-17 12:18:27 -05:00
|
|
|
Get the current config object. If there is no current object and
|
2003-01-17 19:16:34 -05:00
|
|
|
{\it CreateOnDemand} is true, creates one
|
1998-08-27 17:10:49 -04:00
|
|
|
(using {\it Create}) unless DontCreateOnDemand was called previously.
|
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::GetAppName}\label{wxconfigbasegetappname}
|
|
|
|
|
|
|
|
\constfunc{wxString}{GetAppName}{\void}
|
|
|
|
|
|
|
|
Returns the application name.
|
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1999-04-06 06:23:31 -04:00
|
|
|
\membersection{wxConfigBase::GetEntryType}\label{wxconfigbasegetentrytype}
|
|
|
|
|
|
|
|
\constfunc{enum wxConfigBase::EntryType}{GetEntryType}{\param{const wxString\& }{name}}
|
|
|
|
|
|
|
|
Returns the type of the given entry or {\it Unknown} if the entry doesn't
|
|
|
|
exist. This function should be used to decide which version of Read() should
|
|
|
|
be used because some of wxConfig implementations will complain about type
|
|
|
|
mismatch otherwise: e.g., an attempt to read a string value from an integer
|
1999-05-06 04:38:01 -04:00
|
|
|
key with wxRegConfig will fail.
|
1999-04-06 06:23:31 -04:00
|
|
|
|
|
|
|
The result is an element of enum EntryType:
|
|
|
|
|
|
|
|
\begin{verbatim}
|
|
|
|
enum EntryType
|
|
|
|
{
|
2005-04-08 10:34:30 -04:00
|
|
|
Type_Unknown,
|
|
|
|
Type_String,
|
|
|
|
Type_Boolean,
|
|
|
|
Type_Integer,
|
|
|
|
Type_Float
|
1999-04-06 06:23:31 -04:00
|
|
|
};
|
|
|
|
\end{verbatim}
|
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::GetFirstGroup}\label{wxconfigbasegetfirstgroup}
|
|
|
|
|
2000-07-15 15:51:35 -04:00
|
|
|
\constfunc{bool}{GetFirstGroup}{\param{wxString\& }{str}, \param{long\&}{ index}}
|
1998-08-27 17:10:49 -04:00
|
|
|
|
|
|
|
Gets the first group.
|
|
|
|
|
1999-02-24 03:17:50 -05:00
|
|
|
\pythonnote{The wxPython version of this method returns a 3-tuple
|
|
|
|
consisting of the continue flag, the value string, and the index for
|
|
|
|
the next call.}
|
|
|
|
|
2002-02-15 16:50:50 -05:00
|
|
|
\perlnote{In wxPerl this method takes no arguments and returns a 3-element
|
|
|
|
list {\tt ( continue, str, index )}.}
|
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::GetFirstEntry}\label{wxconfigbasegetfirstentry}
|
|
|
|
|
2000-07-15 15:51:35 -04:00
|
|
|
\constfunc{bool}{GetFirstEntry}{\param{wxString\& }{str}, \param{long\&}{ index}}
|
1998-08-27 17:10:49 -04:00
|
|
|
|
|
|
|
Gets the first entry.
|
|
|
|
|
1999-02-24 03:17:50 -05:00
|
|
|
\pythonnote{The wxPython version of this method returns a 3-tuple
|
|
|
|
consisting of the continue flag, the value string, and the index for
|
|
|
|
the next call.}
|
|
|
|
|
2002-02-15 16:50:50 -05:00
|
|
|
\perlnote{In wxPerl this method takes no arguments and returns a 3-element
|
|
|
|
list {\tt ( continue, str, index )}.}
|
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::GetNextGroup}\label{wxconfigbasegetnextgroup}
|
|
|
|
|
2000-07-15 15:51:35 -04:00
|
|
|
\constfunc{bool}{GetNextGroup}{\param{wxString\& }{str}, \param{long\&}{ index}}
|
1998-08-27 17:10:49 -04:00
|
|
|
|
|
|
|
Gets the next group.
|
|
|
|
|
1999-02-24 03:17:50 -05:00
|
|
|
\pythonnote{The wxPython version of this method returns a 3-tuple
|
|
|
|
consisting of the continue flag, the value string, and the index for
|
|
|
|
the next call.}
|
|
|
|
|
2002-02-15 16:50:50 -05:00
|
|
|
\perlnote{In wxPerl this method only takes the {\tt index} parameter
|
|
|
|
and returns a 3-element list {\tt ( continue, str, index )}.}
|
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::GetNextEntry}\label{wxconfigbasegetnextentry}
|
|
|
|
|
2000-07-15 15:51:35 -04:00
|
|
|
\constfunc{bool}{GetNextEntry}{\param{wxString\& }{str}, \param{long\&}{ index}}
|
1998-08-27 17:10:49 -04:00
|
|
|
|
|
|
|
Gets the next entry.
|
|
|
|
|
1999-02-24 03:17:50 -05:00
|
|
|
\pythonnote{The wxPython version of this method returns a 3-tuple
|
|
|
|
consisting of the continue flag, the value string, and the index for
|
|
|
|
the next call.}
|
|
|
|
|
2002-02-15 16:50:50 -05:00
|
|
|
\perlnote{In wxPerl this method only takes the {\tt index} parameter
|
|
|
|
and returns a 3-element list {\tt ( continue, str, index )}.}
|
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::GetNumberOfEntries}\label{wxconfigbasegetnumberofentries}
|
|
|
|
|
2003-01-17 19:16:34 -05:00
|
|
|
\constfunc{uint }{GetNumberOfEntries}{\param{bool }{bRecursive = false}}
|
1998-08-27 17:10:49 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::GetNumberOfGroups}\label{wxconfigbasegetnumberofgroups}
|
|
|
|
|
2003-01-17 19:16:34 -05:00
|
|
|
\constfunc{uint}{GetNumberOfGroups}{\param{bool }{bRecursive = false}}
|
1998-08-27 17:10:49 -04:00
|
|
|
|
1998-09-17 16:57:08 -04:00
|
|
|
Get number of entries/subgroups in the current group, with or without its
|
|
|
|
subgroups.
|
1998-08-18 10:54:21 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-18 10:54:21 -04:00
|
|
|
\membersection{wxConfigBase::GetPath}\label{wxconfigbasegetpath}
|
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\constfunc{const wxString\&}{GetPath}{\void}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
|
|
|
Retrieve the current path (always as absolute path).
|
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::GetVendorName}\label{wxconfigbasegetvendorname}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\constfunc{wxString}{GetVendorName}{\void}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
Returns the vendor name.
|
1998-08-18 10:54:21 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-18 10:54:21 -04:00
|
|
|
\membersection{wxConfigBase::HasEntry}\label{wxconfigbasehasentry}
|
|
|
|
|
|
|
|
\constfunc{bool}{HasEntry}{\param{wxString\& }{strName}}
|
|
|
|
|
2005-04-08 10:34:30 -04:00
|
|
|
returns \true if the entry by this name exists
|
1998-08-18 10:54:21 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::HasGroup}\label{wxconfigbasehasgroup}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\constfunc{bool}{HasGroup}{\param{const wxString\& }{strName}}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
2005-04-08 10:34:30 -04:00
|
|
|
returns \true if the group by this name exists
|
1998-08-27 17:10:49 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::IsExpandingEnvVars}\label{wxconfigbaseisexpandingenvvars}
|
|
|
|
|
|
|
|
\constfunc{bool}{IsExpandingEnvVars}{\void}
|
|
|
|
|
2005-04-08 10:34:30 -04:00
|
|
|
Returns \true if we are expanding environment variables in key values.
|
1998-08-27 17:10:49 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::IsRecordingDefaults}\label{wxconfigbaseisrecordingdefaults}
|
|
|
|
|
2000-07-15 15:51:35 -04:00
|
|
|
\constfunc{bool}{IsRecordingDefaults}{\void}
|
1998-08-27 17:10:49 -04:00
|
|
|
|
2005-04-08 10:34:30 -04:00
|
|
|
Returns \true if we are writing defaults back to the config file.
|
1998-08-18 10:54:21 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-18 10:54:21 -04:00
|
|
|
\membersection{wxConfigBase::Read}\label{wxconfigbaseread}
|
|
|
|
|
2000-07-15 15:51:35 -04:00
|
|
|
\constfunc{bool}{Read}{\param{const wxString\& }{key}, \param{wxString*}{ str}}
|
1998-08-27 17:10:49 -04:00
|
|
|
|
2005-04-08 10:34:30 -04:00
|
|
|
Read a string from the key, returning \true if the value was read. If the key
|
1998-09-17 16:57:08 -04:00
|
|
|
was not found, {\it str} is not changed.
|
1998-08-27 17:10:49 -04:00
|
|
|
|
2000-07-15 15:51:35 -04:00
|
|
|
\constfunc{bool}{Read}{\param{const wxString\& }{key}, \param{wxString*}{ str}, \param{const wxString\& }{defaultVal}}
|
1998-08-27 17:10:49 -04:00
|
|
|
|
1998-09-17 16:57:08 -04:00
|
|
|
Read a string from the key. The default value is returned if the key was not
|
|
|
|
found.
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2005-04-08 10:34:30 -04:00
|
|
|
Returns \true if value was really read, \false if the default was used.
|
1998-08-17 18:45:47 -04:00
|
|
|
|
1998-09-17 16:57:08 -04:00
|
|
|
\constfunc{wxString}{Read}{\param{const wxString\& }{key}, \param{const
|
|
|
|
wxString\& }{defaultVal}}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
Another version of {\it Read()}, returning the string value directly.
|
1998-08-17 18:45:47 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{long*}{ l}}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2005-04-08 10:34:30 -04:00
|
|
|
Reads a long value, returning \true if the value was found. If the value was
|
1998-09-17 16:57:08 -04:00
|
|
|
not found, {\it l} is not changed.
|
1998-08-17 18:45:47 -04:00
|
|
|
|
1998-09-17 16:57:08 -04:00
|
|
|
\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{long*}{ l},
|
|
|
|
\param{long}{ defaultVal}}
|
1998-08-27 17:10:49 -04:00
|
|
|
|
2005-04-08 10:34:30 -04:00
|
|
|
Reads a long value, returning \true if the value was found. If the value was
|
1998-09-17 16:57:08 -04:00
|
|
|
not found, {\it defaultVal} is used instead.
|
1998-08-27 17:10:49 -04:00
|
|
|
|
|
|
|
\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{double*}{ d}}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2005-04-08 10:34:30 -04:00
|
|
|
Reads a double value, returning \true if the value was found. If the value was
|
1998-09-17 16:57:08 -04:00
|
|
|
not found, {\it d} is not changed.
|
1998-08-17 18:45:47 -04:00
|
|
|
|
1998-09-17 16:57:08 -04:00
|
|
|
\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{double*}{ d},
|
1998-10-21 17:43:20 -04:00
|
|
|
\param{double}{ defaultVal}}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
2005-04-08 10:34:30 -04:00
|
|
|
Reads a double value, returning \true if the value was found. If the value was
|
1998-09-17 16:57:08 -04:00
|
|
|
not found, {\it defaultVal} is used instead.
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{bool*}{ b}}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2005-04-08 10:34:30 -04:00
|
|
|
Reads a bool value, returning \true if the value was found. If the value was
|
1998-09-17 16:57:08 -04:00
|
|
|
not found, {\it b} is not changed.
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-09-17 16:57:08 -04:00
|
|
|
\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{bool*}{ d},
|
|
|
|
\param{bool}{ defaultVal}}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2005-04-08 10:34:30 -04:00
|
|
|
Reads a bool value, returning \true if the value was found. If the value was
|
1998-09-17 16:57:08 -04:00
|
|
|
not found, {\it defaultVal} is used instead.
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2007-07-11 20:11:03 -04:00
|
|
|
\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{wxMemoryBuffer*}{ buf}}
|
|
|
|
|
|
|
|
Reads a binary block, returning \true if the value was found. If the value was
|
|
|
|
not found, {\it buf} is not changed.
|
|
|
|
|
2007-07-21 19:47:22 -04:00
|
|
|
\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{T*}{ value}}
|
|
|
|
|
|
|
|
Reads a value of type T, for which function
|
|
|
|
\helpref{wxFromString}{wxfromstring} is defined,
|
|
|
|
returning \true if the value was found.
|
|
|
|
If the value was not found, {\it value} is not changed.
|
|
|
|
|
|
|
|
\constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{T*}{ value},
|
|
|
|
\param{T const\& }{ defaultVal}}
|
|
|
|
|
|
|
|
Reads a value of type T, for which function
|
|
|
|
\helpref{wxFromString}{wxfromstring} is defined,
|
|
|
|
returning \true if the value was found.
|
|
|
|
If the value was not found, {\it defaultVal} is used instead.
|
|
|
|
|
|
|
|
bool Read(const wxString& key, T* value) const;
|
|
|
|
|
1999-02-24 03:17:50 -05:00
|
|
|
\pythonnote{In place of a single overloaded method name, wxPython
|
|
|
|
implements the following methods:\par
|
|
|
|
\indented{2cm}{\begin{twocollist}
|
1999-12-25 15:34:56 -05:00
|
|
|
\twocolitem{{\bf Read(key, default="")}}{Returns a string.}
|
|
|
|
\twocolitem{{\bf ReadInt(key, default=0)}}{Returns an int.}
|
|
|
|
\twocolitem{{\bf ReadFloat(key, default=0.0)}}{Returns a floating point number.}
|
1999-02-24 03:17:50 -05:00
|
|
|
\end{twocollist}}
|
|
|
|
}
|
|
|
|
|
2002-02-15 16:50:50 -05:00
|
|
|
\perlnote{In place of a single overloaded method, wxPerl uses:\par
|
|
|
|
\indented{2cm}{\begin{twocollist}
|
|
|
|
\twocolitem{{\bf Read(key, default="")}}{Returns a string}
|
|
|
|
\twocolitem{{\bf ReadInt(key, default=0)}}{Returns an integer}
|
|
|
|
\twocolitem{{\bf ReadFloat(key, default=0.0)}}{Returns a floating point number}
|
|
|
|
\twocolitem{{\bf ReadBool(key, default=0)}}{Returns a boolean}
|
|
|
|
\end{twocollist}
|
|
|
|
}}
|
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
2007-08-15 16:23:01 -04:00
|
|
|
\membersection{wxConfigBase::ReadBool}\label{wxconfigbasereadbool}
|
|
|
|
|
|
|
|
\constfunc{long }{ReadBool}{\param{const wxString\& }{key}, \param{bool}{ defaultVal}}
|
|
|
|
|
|
|
|
Reads a bool value from the key and returns it. {\it defaultVal} is returned
|
|
|
|
if the key is not found.
|
|
|
|
|
|
|
|
|
|
|
|
\membersection{wxConfigBase::ReadDouble}\label{wxconfigbasereaddouble}
|
|
|
|
|
|
|
|
\constfunc{long }{ReadDouble}{\param{const wxString\& }{key}, \param{double}{ defaultVal}}
|
|
|
|
|
|
|
|
Reads a double value from the key and returns it. {\it defaultVal} is returned
|
|
|
|
if the key is not found.
|
|
|
|
|
|
|
|
|
|
|
|
\membersection{wxConfigBase::ReadLong}\label{wxconfigbasereadlong}
|
|
|
|
|
|
|
|
\constfunc{long }{ReadLong}{\param{const wxString\& }{key}, \param{long}{ defaultVal}}
|
|
|
|
|
|
|
|
Reads a long value from the key and returns it. {\it defaultVal} is returned
|
|
|
|
if the key is not found.
|
|
|
|
|
|
|
|
|
|
|
|
\membersection{wxConfigBase::ReadObject}\label{wxconfigbasereadobject}
|
|
|
|
|
|
|
|
\constfunc{T }{ReadObject}{\param{const wxString\& }{key}, \param{T const&}{ defaultVal}}
|
|
|
|
|
|
|
|
Reads a value of type T, for which function
|
|
|
|
\helpref{wxFromString}{wxfromstring} is defined, from the key and returns it.
|
|
|
|
{\it defaultVal} is returned if the key is not found.
|
|
|
|
|
|
|
|
|
1999-01-20 14:54:17 -05:00
|
|
|
\membersection{wxConfigBase::RenameEntry}\label{wxconfigbaserenameentry}
|
|
|
|
|
|
|
|
\func{bool}{RenameEntry}{\param{const wxString\& }{ oldName}, \param{const wxString\& }{ newName}}
|
|
|
|
|
|
|
|
Renames an entry in the current group. The entries names (both the old and
|
|
|
|
the new one) shouldn't contain backslashes, i.e. only simple names and not
|
|
|
|
arbitrary paths are accepted by this function.
|
|
|
|
|
2005-04-08 10:34:30 -04:00
|
|
|
Returns \false if {\it oldName} doesn't exist or if {\it newName} already
|
1999-01-20 14:54:17 -05:00
|
|
|
exists.
|
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1999-01-20 14:54:17 -05:00
|
|
|
\membersection{wxConfigBase::RenameGroup}\label{wxconfigbaserenamegroup}
|
|
|
|
|
|
|
|
\func{bool}{RenameGroup}{\param{const wxString\& }{ oldName}, \param{const wxString\& }{ newName}}
|
|
|
|
|
|
|
|
Renames a subgroup of the current group. The subgroup names (both the old and
|
|
|
|
the new one) shouldn't contain backslashes, i.e. only simple names and not
|
|
|
|
arbitrary paths are accepted by this function.
|
|
|
|
|
2005-04-08 10:34:30 -04:00
|
|
|
Returns \false if {\it oldName} doesn't exist or if {\it newName} already
|
1999-01-20 14:54:17 -05:00
|
|
|
exists.
|
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::Set}\label{wxconfigbaseset}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2002-04-06 10:04:27 -05:00
|
|
|
\func{static wxConfigBase *}{Set}{\param{wxConfigBase *}{pConfig}}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
Sets the config object as the current one, returns the pointer to the previous
|
|
|
|
current object (both the parameter and returned value may be NULL)
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
2000-07-15 15:51:35 -04:00
|
|
|
\membersection{wxConfigBase::SetExpandEnvVars}\label{wxconfigbasesetexpandenvvars}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2003-01-17 19:16:34 -05:00
|
|
|
\func{void}{SetExpandEnvVars }{\param{bool }{bDoIt = true}}
|
1998-08-18 10:54:21 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
Determine whether we wish to expand environment variables in key values.
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::SetPath}\label{wxconfigbasesetpath}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\func{void}{SetPath}{\param{const wxString\& }{strPath}}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2000-07-15 15:51:35 -04:00
|
|
|
Set current path: if the first character is '/', it is the absolute path,
|
2005-04-08 10:34:30 -04:00
|
|
|
otherwise it is a relative path. '..' is supported. If strPath doesn't
|
1998-09-17 16:57:08 -04:00
|
|
|
exist it is created.
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2004-10-03 18:55:08 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::SetRecordDefaults}\label{wxconfigbasesetrecorddefaults}
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2003-01-17 19:16:34 -05:00
|
|
|
\func{void}{SetRecordDefaults}{\param{bool }{bDoIt = true}}
|
1998-08-27 17:10:49 -04:00
|
|
|
|
2001-12-12 08:38:28 -05:00
|
|
|
Sets whether defaults are recorded to the config file whenever an attempt to
|
2005-04-08 10:34:30 -04:00
|
|
|
read the value which is not present in it is done.
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2001-12-12 08:38:28 -05:00
|
|
|
If on (default is off) all default values for the settings used by the program
|
|
|
|
are written back to the config file. This allows the user to see what config
|
|
|
|
options may be changed and is probably useful only for wxFileConfig.
|
1998-08-17 18:45:47 -04:00
|
|
|
|
2000-07-15 15:51:35 -04:00
|
|
|
|
1998-08-27 17:10:49 -04:00
|
|
|
\membersection{wxConfigBase::Write}\label{wxconfigbasewrite}
|
|
|
|
|
1998-09-17 16:57:08 -04:00
|
|
|
\func{bool}{Write}{\param{const wxString\& }{ key}, \param{const wxString\& }{
|
|
|
|
value}}
|
1998-08-27 17:10:49 -04:00
|
|
|
|
|
|
|
\func{bool}{Write}{\param{const wxString\& }{ key}, \param{long}{ value}}
|
|
|
|
|
|
|
|
\func{bool}{Write}{\param{const wxString\& }{ key}, \param{double}{ value}}
|
|
|
|
|
|
|
|
\func{bool}{Write}{\param{const wxString\& }{ key}, \param{bool}{ value}}
|
|
|
|
|
2007-07-11 20:11:03 -04:00
|
|
|
\func{bool}{Write}{\param{const wxString\& }{ key}, \param{const wxMemoryBuffer\&}{ buf}}
|
|
|
|
|
2007-07-21 19:47:22 -04:00
|
|
|
\func{bool}{Write}{\param{const wxString\& }{ key}, \param{const T\&}{ buf}}
|
|
|
|
|
|
|
|
These functions write the specified value to the config file and return \true
|
|
|
|
on success. In the last one, function \helpref{wxToString}{wxtostring} must be
|
|
|
|
defined for type {\it T}.
|
1998-08-17 18:45:47 -04:00
|
|
|
|
1999-02-24 03:17:50 -05:00
|
|
|
\pythonnote{In place of a single overloaded method name, wxPython
|
|
|
|
implements the following methods:\par
|
|
|
|
\indented{2cm}{\begin{twocollist}
|
1999-12-25 15:34:56 -05:00
|
|
|
\twocolitem{{\bf Write(key, value)}}{Writes a string.}
|
|
|
|
\twocolitem{{\bf WriteInt(key, value)}}{Writes an int.}
|
|
|
|
\twocolitem{{\bf WriteFloat(key, value)}}{Writes a floating point number.}
|
1999-02-24 03:17:50 -05:00
|
|
|
\end{twocollist}}
|
|
|
|
}
|
|
|
|
|
2002-02-15 16:50:50 -05:00
|
|
|
\perlnote{In place of a single overloaded method, wxPerl uses:\par
|
|
|
|
\indented{2cm}{\begin{twocollist}
|
|
|
|
\twocolitem{{\bf Write(key, value)}}{Writes a string}
|
|
|
|
\twocolitem{{\bf WriteInt(key, value)}}{Writes an integer}
|
|
|
|
\twocolitem{{\bf WriteFloat(key, value)}}{Writes a floating point number}
|
|
|
|
\twocolitem{{\bf WriteBool(key, value)}}{Writes a boolean}
|
|
|
|
\end{twocollist}
|
|
|
|
}}
|
2005-02-11 15:08:51 -05:00
|
|
|
|