]> git.saurik.com Git - wxWidgets.git/blob - docs/latex/wx/config.tex
Minor doc updates
[wxWidgets.git] / docs / latex / wx / config.tex
1 \section{\class{wxConfigBase}}\label{wxconfigbase}
2
3 wxConfigBase class defines the basic interface of all config classes. It can
4 not be used by itself (it is an abstract base class) and you will always use one
5 of its derivations: \helpref{wxFileConfig}{wxfileconfig},
6 wxRegConfig or any other.
7
8 However, usually you don't even need to know the precise nature of the class
9 you're working with but you would just use the wxConfigBase methods. This
10 allows you to write the same code regardless of whether you're working with
11 the registry under Win32 or text-based config files under Unix (or even
12 Windows 3.1 .INI files if you're really unlucky). To make writing the portable
13 code even easier, wxWidgets provides a typedef wxConfig
14 which is mapped onto the native wxConfigBase implementation on the given
15 platform: i.e. wxRegConfig under Win32 and
16 wxFileConfig otherwise.
17
18 See \helpref{config overview}{wxconfigoverview} for the descriptions of all
19 features of this class.
20
21 It is highly recommended to use static functions {\it Get()} and/or {\it Set()},
22 so please have a \helpref{look at them.}{wxconfigstaticfunctions}
23
24 \wxheading{Derived from}
25
26 \helpref{wxObject}{wxobject}
27
28 \wxheading{Include files}
29
30 <wx/config.h> (to let wxWidgets choose a wxConfig class for your platform)\\
31 <wx/confbase.h> (base config class)\\
32 <wx/fileconf.h> (wxFileConfig class)\\
33 <wx/msw/regconf.h> (wxRegConfig class)
34
35 \wxheading{Example}
36
37 Here is how you would typically use this class:
38
39 \begin{verbatim}
40 // using wxConfig instead of writing wxFileConfig or wxRegConfig enhances
41 // portability of the code
42 wxConfig *config = new wxConfig("MyAppName");
43
44 wxString str;
45 if ( config->Read("LastPrompt", &str) ) {
46 // last prompt was found in the config file/registry and its value is now
47 // in str
48 ...
49 }
50 else {
51 // no last prompt...
52 }
53
54 // another example: using default values and the full path instead of just
55 // key name: if the key is not found , the value 17 is returned
56 long value = config->ReadLong("/LastRun/CalculatedValues/MaxValue", 17);
57 ...
58 ...
59 ...
60 // at the end of the program we would save everything back
61 config->Write("LastPrompt", str);
62 config->Write("/LastRun/CalculatedValues/MaxValue", value);
63
64 // the changes will be written back automatically
65 delete config;
66 \end{verbatim}
67
68 This basic example, of course, doesn't show all wxConfig features, such as
69 enumerating, testing for existence and deleting the entries and groups of
70 entries in the config file, its abilities to automatically store the default
71 values or expand the environment variables on the fly. However, the main idea
72 is that using this class is easy and that it should normally do what you
73 expect it to.
74
75 NB: in the documentation of this class, the words "config file" also mean
76 "registry hive" for wxRegConfig and, generally speaking, might mean any
77 physical storage where a wxConfigBase-derived class stores its data.
78
79 \latexignore{\rtfignore{\wxheading{Function groups}}}
80
81
82 \membersection{Static functions}\label{wxconfigstaticfunctions}
83
84 These functions deal with the "default" config object. Although its usage is
85 not at all mandatory it may be convenient to use a global config object
86 instead of creating and deleting the local config objects each time you need
87 one (especially because creating a wxFileConfig object might be a time
88 consuming operation). In this case, you may create this global config object
89 in the very start of the program and {\it Set()} it as the default. Then, from
90 anywhere in your program, you may access it using the {\it Get()} function.
91 This global wxConfig object will be deleted by wxWidgets automatically if it
92 exists. Note that this implies that if you do delete this object yourself
93 (usually in \helpref{wxApp::OnExit}{wxapponexit}) you must use {\it Set(NULL)}
94 to prevent wxWidgets from deleting it the second time.
95
96 As it happens, you may even further simplify the procedure described above:
97 you may forget about calling {\it Set()}. When {\it Get()} is called and there
98 is no current object, it will create one using {\it Create()} function. To
99 disable this behaviour {\it DontCreateOnDemand()} is provided.
100
101 {\bf Note:} You should use either {\it Set()} or {\it Get()} because wxWidgets
102 library itself would take advantage of it and could save various information
103 in it. For example \helpref{wxFontMapper}{wxfontmapper} or Unix version
104 of \helpref{wxFileDialog}{wxfiledialog} have the ability to use wxConfig class.
105
106 \helpref{Set}{wxconfigbaseset}\\
107 \helpref{Get}{wxconfigbaseget}\\
108 \helpref{Create}{wxconfigbasecreate}\\
109 \helpref{DontCreateOnDemand}{wxconfigbasedontcreateondemand}
110
111
112 \membersection{Constructor and destructor}\label{congigconstructordestructor}
113
114 \helpref{wxConfigBase}{wxconfigbasector}\\
115 \helpref{\destruct{wxConfigBase}}{wxconfigbasedtor}
116
117
118 \membersection{Path management}\label{configpathmanagement}
119
120 As explained in \helpref{config overview}{wxconfigoverview}, the config classes
121 support a file system-like hierarchy of keys (files) and groups (directories).
122 As in the file system case, to specify a key in the config class you must use
123 a path to it. Config classes also support the notion of the current group,
124 which makes it possible to use the relative paths. To clarify all this, here
125 is an example (it is only for the sake of demonstration, it doesn't do anything
126 sensible!):
127
128 \begin{verbatim}
129 wxConfig *config = new wxConfig("FooBarApp");
130
131 // right now the current path is '/'
132 conf->Write("RootEntry", 1);
133
134 // go to some other place: if the group(s) don't exist, they will be created
135 conf->SetPath("/Group/Subgroup");
136
137 // create an entry in subgroup
138 conf->Write("SubgroupEntry", 3);
139
140 // '..' is understood
141 conf->Write("../GroupEntry", 2);
142 conf->SetPath("..");
143
144 wxASSERT( conf->ReadLong("Subgroup/SubgroupEntry", 0) == 3 );
145
146 // use absolute path: it is allowed, too
147 wxASSERT( conf->ReadLong("/RootEntry", 0) == 1 );
148 \end{verbatim}
149
150 {\it Warning}: it is probably a good idea to always restore the path to its
151 old value on function exit:
152
153 \begin{verbatim}
154 void foo(wxConfigBase *config)
155 {
156 wxString strOldPath = config->GetPath();
157
158 config->SetPath("/Foo/Data");
159 ...
160
161 config->SetPath(strOldPath);
162 }
163 \end{verbatim}
164
165 because otherwise the assert in the following example will surely fail
166 (we suppose here that {\it foo()} function is the same as above except that it
167 doesn't save and restore the path):
168
169 \begin{verbatim}
170 void bar(wxConfigBase *config)
171 {
172 config->Write("Test", 17);
173
174 foo(config);
175
176 // we're reading "/Foo/Data/Test" here! -1 will probably be returned...
177 wxASSERT( config->ReadLong("Test", -1) == 17 );
178 }
179 \end{verbatim}
180
181 Finally, the path separator in wxConfigBase and derived classes is always '/',
182 regardless of the platform (i.e. it is {\bf not} '$\backslash\backslash$' under Windows).
183
184 \helpref{SetPath}{wxconfigbasesetpath}\\
185 \helpref{GetPath}{wxconfigbasegetpath}
186
187
188 \membersection{Enumeration}\label{configenumeration}
189
190 The functions in this section allow to enumerate all entries and groups in the
191 config file. All functions here return \false when there are no more items.
192
193 You must pass the same index to GetNext and GetFirst (don't modify it).
194 Please note that it is {\bf not} the index of the current item (you will have
195 some great surprises with wxRegConfig if you assume this) and you shouldn't
196 even look at it: it is just a "cookie" which stores the state of the
197 enumeration. It can't be stored inside the class because it would prevent you
198 from running several enumerations simultaneously, that's why you must pass it
199 explicitly.
200
201 Having said all this, enumerating the config entries/groups is very simple:
202
203 \begin{verbatim}
204 wxConfigBase *config = ...;
205 wxArrayString aNames;
206
207 // enumeration variables
208 wxString str;
209 long dummy;
210
211 // first enum all entries
212 bool bCont = config->GetFirstEntry(str, dummy);
213 while ( bCont ) {
214 aNames.Add(str);
215
216 bCont = GetConfig()->GetNextEntry(str, dummy);
217 }
218
219 ... we have all entry names in aNames...
220
221 // now all groups...
222 bCont = GetConfig()->GetFirstGroup(str, dummy);
223 while ( bCont ) {
224 aNames.Add(str);
225
226 bCont = GetConfig()->GetNextGroup(str, dummy);
227 }
228
229 ... we have all group (and entry) names in aNames...
230
231 \end{verbatim}
232
233 There are also functions to get the number of entries/subgroups without
234 actually enumerating them, but you will probably never need them.
235
236 \helpref{GetFirstGroup}{wxconfigbasegetfirstgroup}\\
237 \helpref{GetNextGroup}{wxconfigbasegetnextgroup}\\
238 \helpref{GetFirstEntry}{wxconfigbasegetfirstentry}\\
239 \helpref{GetNextEntry}{wxconfigbasegetnextentry}\\
240 \helpref{GetNumberOfEntries}{wxconfigbasegetnumberofentries}\\
241 \helpref{GetNumberOfGroups}{wxconfigbasegetnumberofgroups}
242
243
244 \membersection{Tests of existence}\label{configtestsofexistence}
245
246 \helpref{HasGroup}{wxconfigbasehasgroup}\\
247 \helpref{HasEntry}{wxconfigbasehasentry}\\
248 \helpref{Exists}{wxconfigbaseexists}\\
249 \helpref{GetEntryType}{wxconfigbasegetentrytype}
250
251
252 \membersection{Miscellaneous functions}\label{configmiscellaneous}
253
254 \helpref{GetAppName}{wxconfigbasegetappname}\\
255 \helpref{GetVendorName}{wxconfigbasegetvendorname}\\
256 \helpref{SetUmask}{wxfileconfigsetumask}
257
258
259 \membersection{Key access}\label{configkeyaccess}
260
261 These function are the core of wxConfigBase class: they allow you to read and
262 write config file data. All {\it Read} function take a default value which
263 will be returned if the specified key is not found in the config file.
264
265 Currently, supported types of data are:
266 \helpref{wxString}{wxstring}, {\it long}, {\it double}, {\it bool},
267 \helpref{wxColour}{wxcolour} and any other types,
268 for which functions \helpref{wxToString}{wxtostring}
269 and \helpref{wxFromString}{wxfromstring} are defined.
270
271 Try not to read long values into string variables and vice versa: although it
272 just might work with wxFileConfig, you will get a system error with
273 wxRegConfig because in the Windows registry the different types of entries are
274 indeed used.
275
276 Final remark: the {\it szKey} parameter for all these functions can contain an
277 arbitrary path (either relative or absolute), not just the key name.
278
279 \helpref{Read}{wxconfigbaseread}\\
280 \helpref{Write}{wxconfigbasewrite}\\
281 \helpref{Flush}{wxconfigbaseflush}
282
283
284 \membersection{Rename entries/groups}\label{configrenaming}
285
286 The functions in this section allow to rename entries or subgroups of the
287 current group. They will return \false on error. typically because either the
288 entry/group with the original name doesn't exist, because the entry/group with
289 the new name already exists or because the function is not supported in this
290 wxConfig implementation.
291
292 \helpref{RenameEntry}{wxconfigbaserenameentry}\\
293 \helpref{RenameGroup}{wxconfigbaserenamegroup}
294
295
296 \membersection{Delete entries/groups}\label{configdeleting}
297
298 The functions in this section delete entries and/or groups of entries from the
299 config file. {\it DeleteAll()} is especially useful if you want to erase all
300 traces of your program presence: for example, when you uninstall it.
301
302 \helpref{DeleteEntry}{wxconfigbasedeleteentry}\\
303 \helpref{DeleteGroup}{wxconfigbasedeletegroup}\\
304 \helpref{DeleteAll}{wxconfigbasedeleteall}
305
306
307 \membersection{Options}\label{configoptions}
308
309 Some aspects of wxConfigBase behaviour can be changed during run-time. The
310 first of them is the expansion of environment variables in the string values
311 read from the config file: for example, if you have the following in your
312 config file:
313
314 \begin{verbatim}
315 # config file for my program
316 UserData = $HOME/data
317
318 # the following syntax is valud only under Windows
319 UserData = %windir%\\data.dat
320 \end{verbatim}
321 % $ % help EMACS syntax highlighting...
322 the call to {\tt config->Read("UserData")} will return something like
323 {\tt "/home/zeitlin/data"} if you're lucky enough to run a Linux system ;-)
324
325 Although this feature is very useful, it may be annoying if you read a value
326 which containts '\$' or '\%' symbols (\% is used for environment variables
327 expansion under Windows) which are not used for environment variable
328 expansion. In this situation you may call SetExpandEnvVars(false) just before
329 reading this value and SetExpandEnvVars(true) just after. Another solution
330 would be to prefix the offending symbols with a backslash.
331
332 The following functions control this option:
333
334 \helpref{IsExpandingEnvVars}{wxconfigbaseisexpandingenvvars}\\
335 \helpref{SetExpandEnvVars}{wxconfigbasesetexpandenvvars}\\
336 \helpref{SetRecordDefaults}{wxconfigbasesetrecorddefaults}\\
337 \helpref{IsRecordingDefaults}{wxconfigbaseisrecordingdefaults}
338
339 %%%%% MEMBERS HERE %%%%%
340 \helponly{\insertatlevel{2}{
341
342 \wxheading{Members}
343
344 }}
345
346
347 \membersection{wxConfigBase::wxConfigBase}\label{wxconfigbasector}
348
349 \func{}{wxConfigBase}{\param{const wxString\& }{appName = wxEmptyString},
350 \param{const wxString\& }{vendorName = wxEmptyString},
351 \param{const wxString\& }{localFilename = wxEmptyString},
352 \param{const wxString\& }{globalFilename = wxEmptyString},
353 \param{long}{ style = 0},
354 \param{const wxMBConv\&}{ conv = wxConvAuto()}}
355
356 This is the default and only constructor of the wxConfigBase class, and
357 derived classes.
358
359 \wxheading{Parameters}
360
361 \docparam{appName}{The application name. If this is empty, the class will
362 normally use \helpref{wxApp::GetAppName}{wxappgetappname} to set it. The
363 application name is used in the registry key on Windows, and can be used to
364 deduce the local filename parameter if that is missing.}
365
366 \docparam{vendorName}{The vendor name. If this is empty, it is assumed that
367 no vendor name is wanted, if this is optional for the current config class.
368 The vendor name is appended to the application name for wxRegConfig.}
369
370 \docparam{localFilename}{Some config classes require a local filename. If this
371 is not present, but required, the application name will be used instead.}
372
373 \docparam{globalFilename}{Some config classes require a global filename. If
374 this is not present, but required, the application name will be used instead.}
375
376 \docparam{style}{Can be one of wxCONFIG\_USE\_LOCAL\_FILE and
377 wxCONFIG\_USE\_GLOBAL\_FILE. The style interpretation depends on the config
378 class and is ignored by some implementations. For wxFileConfig, these styles
379 determine whether a local or global config file is created or used: if
380 wxCONFIG\_USE\_GLOBAL\_FILE is used, then settings are read from the global
381 config file and if wxCONFIG\_USE\_LOCAL\_FILE is used, settings are read from
382 and written to local config file (if they are both set, global file is read
383 first, then local file, overwriting global settings). If the
384 flag is present but the parameter is empty, the parameter will be set to a
385 default. If the parameter is present but the style flag not, the relevant flag
386 will be added to the style. For wxRegConfig, thie GLOBAL flag refers to HKLM
387 key while LOCAL one is for the usual HKCU one.
388
389 For wxFileConfig you can also add wxCONFIG\_USE\_RELATIVE\_PATH by logically
390 or'ing it to either of the \_FILE options to tell wxFileConfig to use relative
391 instead of absolute paths.
392
393 On non-VMS Unix systems, the default local configuration file is \tt{~/.appname}.
394 However, this path may be also used as user data directory
395 (see \helpref{wxStandardPaths::GetUserDataDir}{wxstandardpathsgetuserdatadir}) if
396 the application has several data files. In this case wxCONFIG\_USE\_SUBDIR
397 flag, which changes the default local configuration file to \tt{~/.appname/appname}
398 should be used. Notice that this flag is ignored if \textit{localFilename} is
399 provided. \newsince{2.8.2}
400
401 For wxFileConfig, you can also add wxCONFIG\_USE\_NO\_ESCAPE\_CHARACTERS which
402 will turn off character escaping for the values of entries stored in the config
403 file: for example a {\it foo} key with some backslash characters will be stored
404 as {\tt foo=C:$\backslash$mydir} instead of the usual storage of {\tt
405 foo=C:$\backslash\backslash$mydir}.
406
407 The wxCONFIG\_USE\_NO\_ESCAPE\_CHARACTERS style can be helpful if your config
408 file must be read or written to by a non-wxWidgets program (which might not
409 understand the escape characters). Note, however, that if
410 wxCONFIG\_USE\_NO\_ESCAPE\_CHARACTERS style is used, it is is now
411 your application's responsibility to ensure that there is no newline or
412 other illegal characters in a value, before writing that value to the file.}
413
414 \docparam{conv}{This parameter is only used by wxFileConfig when compiled
415 in Unicode mode. It specifies the encoding in which the configuration file
416 is written.}
417
418
419 \wxheading{Remarks}
420
421 By default, environment variable expansion is on and recording defaults is
422 off.
423
424
425 \membersection{wxConfigBase::\destruct{wxConfigBase}}\label{wxconfigbasedtor}
426
427 \func{}{\destruct{wxConfigBase}}{\void}
428
429 Empty but ensures that dtor of all derived classes is virtual.
430
431
432 \membersection{wxConfigBase::Create}\label{wxconfigbasecreate}
433
434 \func{static wxConfigBase *}{Create}{\void}
435
436 Create a new config object: this function will create the "best"
437 implementation of wxConfig available for the current platform, see comments
438 near the definition of wxCONFIG\_WIN32\_NATIVE for details. It returns the
439 created object and also sets it as the current one.
440
441
442 \membersection{wxConfigBase::DontCreateOnDemand}\label{wxconfigbasedontcreateondemand}
443
444 \func{void}{DontCreateOnDemand}{\void}
445
446 Calling this function will prevent {\it Get()} from automatically creating a
447 new config object if the current one is NULL. It might be useful to call it
448 near the program end to prevent "accidental" creation of a new config object.
449
450
451 \membersection{wxConfigBase::DeleteAll}\label{wxconfigbasedeleteall}
452
453 \func{bool}{DeleteAll}{\void}
454
455 Delete the whole underlying object (disk file, registry key, ...). Primarly
456 for use by uninstallation routine.
457
458
459 \membersection{wxConfigBase::DeleteEntry}\label{wxconfigbasedeleteentry}
460
461 \func{bool}{DeleteEntry}{\param{const wxString\& }{ key}, \param{bool}{ bDeleteGroupIfEmpty = true}}
462
463 Deletes the specified entry and the group it belongs to if it was the last key
464 in it and the second parameter is true.
465
466
467 \membersection{wxConfigBase::DeleteGroup}\label{wxconfigbasedeletegroup}
468
469 \func{bool}{DeleteGroup}{\param{const wxString\& }{ key}}
470
471 Delete the group (with all subgroups). If the current path is under the group
472 being deleted it is changed to its deepest still existing component. E.g. if
473 the current path is \texttt{/A/B/C/D} and the group \texttt{C} is deleted the
474 path becomes \texttt{/A/B}.
475
476
477 \membersection{wxConfigBase::Exists}\label{wxconfigbaseexists}
478
479 \constfunc{bool}{Exists}{\param{wxString\& }{strName}}
480
481 returns \true if either a group or an entry with a given name exists
482
483
484 \membersection{wxConfigBase::Flush}\label{wxconfigbaseflush}
485
486 \func{bool}{Flush}{\param{bool }{bCurrentOnly = false}}
487
488 permanently writes all changes (otherwise, they're only written from object's
489 destructor)
490
491
492 \membersection{wxConfigBase::Get}\label{wxconfigbaseget}
493
494 \func{static wxConfigBase *}{Get}{\param{bool }{CreateOnDemand = true}}
495
496 Get the current config object. If there is no current object and
497 {\it CreateOnDemand} is true, creates one
498 (using {\it Create}) unless DontCreateOnDemand was called previously.
499
500
501 \membersection{wxConfigBase::GetAppName}\label{wxconfigbasegetappname}
502
503 \constfunc{wxString}{GetAppName}{\void}
504
505 Returns the application name.
506
507
508 \membersection{wxConfigBase::GetEntryType}\label{wxconfigbasegetentrytype}
509
510 \constfunc{enum wxConfigBase::EntryType}{GetEntryType}{\param{const wxString\& }{name}}
511
512 Returns the type of the given entry or {\it Unknown} if the entry doesn't
513 exist. This function should be used to decide which version of Read() should
514 be used because some of wxConfig implementations will complain about type
515 mismatch otherwise: e.g., an attempt to read a string value from an integer
516 key with wxRegConfig will fail.
517
518 The result is an element of enum EntryType:
519
520 \begin{verbatim}
521 enum EntryType
522 {
523 Type_Unknown,
524 Type_String,
525 Type_Boolean,
526 Type_Integer,
527 Type_Float
528 };
529 \end{verbatim}
530
531
532 \membersection{wxConfigBase::GetFirstGroup}\label{wxconfigbasegetfirstgroup}
533
534 \constfunc{bool}{GetFirstGroup}{\param{wxString\& }{str}, \param{long\&}{ index}}
535
536 Gets the first group.
537
538 \pythonnote{The wxPython version of this method returns a 3-tuple
539 consisting of the continue flag, the value string, and the index for
540 the next call.}
541
542 \perlnote{In wxPerl this method takes no arguments and returns a 3-element
543 list {\tt ( continue, str, index )}.}
544
545
546 \membersection{wxConfigBase::GetFirstEntry}\label{wxconfigbasegetfirstentry}
547
548 \constfunc{bool}{GetFirstEntry}{\param{wxString\& }{str}, \param{long\&}{ index}}
549
550 Gets the first entry.
551
552 \pythonnote{The wxPython version of this method returns a 3-tuple
553 consisting of the continue flag, the value string, and the index for
554 the next call.}
555
556 \perlnote{In wxPerl this method takes no arguments and returns a 3-element
557 list {\tt ( continue, str, index )}.}
558
559
560 \membersection{wxConfigBase::GetNextGroup}\label{wxconfigbasegetnextgroup}
561
562 \constfunc{bool}{GetNextGroup}{\param{wxString\& }{str}, \param{long\&}{ index}}
563
564 Gets the next group.
565
566 \pythonnote{The wxPython version of this method returns a 3-tuple
567 consisting of the continue flag, the value string, and the index for
568 the next call.}
569
570 \perlnote{In wxPerl this method only takes the {\tt index} parameter
571 and returns a 3-element list {\tt ( continue, str, index )}.}
572
573
574 \membersection{wxConfigBase::GetNextEntry}\label{wxconfigbasegetnextentry}
575
576 \constfunc{bool}{GetNextEntry}{\param{wxString\& }{str}, \param{long\&}{ index}}
577
578 Gets the next entry.
579
580 \pythonnote{The wxPython version of this method returns a 3-tuple
581 consisting of the continue flag, the value string, and the index for
582 the next call.}
583
584 \perlnote{In wxPerl this method only takes the {\tt index} parameter
585 and returns a 3-element list {\tt ( continue, str, index )}.}
586
587
588 \membersection{wxConfigBase::GetNumberOfEntries}\label{wxconfigbasegetnumberofentries}
589
590 \constfunc{uint }{GetNumberOfEntries}{\param{bool }{bRecursive = false}}
591
592
593 \membersection{wxConfigBase::GetNumberOfGroups}\label{wxconfigbasegetnumberofgroups}
594
595 \constfunc{uint}{GetNumberOfGroups}{\param{bool }{bRecursive = false}}
596
597 Get number of entries/subgroups in the current group, with or without its
598 subgroups.
599
600
601 \membersection{wxConfigBase::GetPath}\label{wxconfigbasegetpath}
602
603 \constfunc{const wxString\&}{GetPath}{\void}
604
605 Retrieve the current path (always as absolute path).
606
607
608 \membersection{wxConfigBase::GetVendorName}\label{wxconfigbasegetvendorname}
609
610 \constfunc{wxString}{GetVendorName}{\void}
611
612 Returns the vendor name.
613
614
615 \membersection{wxConfigBase::HasEntry}\label{wxconfigbasehasentry}
616
617 \constfunc{bool}{HasEntry}{\param{wxString\& }{strName}}
618
619 returns \true if the entry by this name exists
620
621
622 \membersection{wxConfigBase::HasGroup}\label{wxconfigbasehasgroup}
623
624 \constfunc{bool}{HasGroup}{\param{const wxString\& }{strName}}
625
626 returns \true if the group by this name exists
627
628
629 \membersection{wxConfigBase::IsExpandingEnvVars}\label{wxconfigbaseisexpandingenvvars}
630
631 \constfunc{bool}{IsExpandingEnvVars}{\void}
632
633 Returns \true if we are expanding environment variables in key values.
634
635
636 \membersection{wxConfigBase::IsRecordingDefaults}\label{wxconfigbaseisrecordingdefaults}
637
638 \constfunc{bool}{IsRecordingDefaults}{\void}
639
640 Returns \true if we are writing defaults back to the config file.
641
642
643 \membersection{wxConfigBase::Read}\label{wxconfigbaseread}
644
645 \constfunc{bool}{Read}{\param{const wxString\& }{key}, \param{wxString*}{ str}}
646
647 Read a string from the key, returning \true if the value was read. If the key
648 was not found, {\it str} is not changed.
649
650 \constfunc{bool}{Read}{\param{const wxString\& }{key}, \param{wxString*}{ str}, \param{const wxString\& }{defaultVal}}
651
652 Read a string from the key. The default value is returned if the key was not
653 found.
654
655 Returns \true if value was really read, \false if the default was used.
656
657 \constfunc{wxString}{Read}{\param{const wxString\& }{key}, \param{const
658 wxString\& }{defaultVal}}
659
660 Another version of {\it Read()}, returning the string value directly.
661
662 \constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{long*}{ l}}
663
664 Reads a long value, returning \true if the value was found. If the value was
665 not found, {\it l} is not changed.
666
667 \constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{long*}{ l},
668 \param{long}{ defaultVal}}
669
670 Reads a long value, returning \true if the value was found. If the value was
671 not found, {\it defaultVal} is used instead.
672
673 \constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{double*}{ d}}
674
675 Reads a double value, returning \true if the value was found. If the value was
676 not found, {\it d} is not changed.
677
678 \constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{double*}{ d},
679 \param{double}{ defaultVal}}
680
681 Reads a double value, returning \true if the value was found. If the value was
682 not found, {\it defaultVal} is used instead.
683
684 \constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{bool*}{ b}}
685
686 Reads a bool value, returning \true if the value was found. If the value was
687 not found, {\it b} is not changed.
688
689 \constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{bool*}{ d},
690 \param{bool}{ defaultVal}}
691
692 Reads a bool value, returning \true if the value was found. If the value was
693 not found, {\it defaultVal} is used instead.
694
695 \constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{wxMemoryBuffer*}{ buf}}
696
697 Reads a binary block, returning \true if the value was found. If the value was
698 not found, {\it buf} is not changed.
699
700 \constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{T*}{ value}}
701
702 Reads a value of type T, for which function
703 \helpref{wxFromString}{wxfromstring} is defined,
704 returning \true if the value was found.
705 If the value was not found, {\it value} is not changed.
706
707 \constfunc{bool}{Read}{\param{const wxString\& }{ key}, \param{T*}{ value},
708 \param{T const\& }{ defaultVal}}
709
710 Reads a value of type T, for which function
711 \helpref{wxFromString}{wxfromstring} is defined,
712 returning \true if the value was found.
713 If the value was not found, {\it defaultVal} is used instead.
714
715 bool Read(const wxString& key, T* value) const;
716
717 \pythonnote{In place of a single overloaded method name, wxPython
718 implements the following methods:\par
719 \indented{2cm}{\begin{twocollist}
720 \twocolitem{{\bf Read(key, default="")}}{Returns a string.}
721 \twocolitem{{\bf ReadInt(key, default=0)}}{Returns an int.}
722 \twocolitem{{\bf ReadFloat(key, default=0.0)}}{Returns a floating point number.}
723 \end{twocollist}}
724 }
725
726 \perlnote{In place of a single overloaded method, wxPerl uses:\par
727 \indented{2cm}{\begin{twocollist}
728 \twocolitem{{\bf Read(key, default="")}}{Returns a string}
729 \twocolitem{{\bf ReadInt(key, default=0)}}{Returns an integer}
730 \twocolitem{{\bf ReadFloat(key, default=0.0)}}{Returns a floating point number}
731 \twocolitem{{\bf ReadBool(key, default=0)}}{Returns a boolean}
732 \end{twocollist}
733 }}
734
735
736 \membersection{wxConfigBase::ReadBool}\label{wxconfigbasereadbool}
737
738 \constfunc{long }{ReadBool}{\param{const wxString\& }{key}, \param{bool}{ defaultVal}}
739
740 Reads a bool value from the key and returns it. {\it defaultVal} is returned
741 if the key is not found.
742
743
744 \membersection{wxConfigBase::ReadDouble}\label{wxconfigbasereaddouble}
745
746 \constfunc{long }{ReadDouble}{\param{const wxString\& }{key}, \param{double}{ defaultVal}}
747
748 Reads a double value from the key and returns it. {\it defaultVal} is returned
749 if the key is not found.
750
751
752 \membersection{wxConfigBase::ReadLong}\label{wxconfigbasereadlong}
753
754 \constfunc{long }{ReadLong}{\param{const wxString\& }{key}, \param{long}{ defaultVal}}
755
756 Reads a long value from the key and returns it. {\it defaultVal} is returned
757 if the key is not found.
758
759
760 \membersection{wxConfigBase::ReadObject}\label{wxconfigbasereadobject}
761
762 \constfunc{T }{ReadObject}{\param{const wxString\& }{key}, \param{T const&}{ defaultVal}}
763
764 Reads a value of type T, for which function
765 \helpref{wxFromString}{wxfromstring} is defined, from the key and returns it.
766 {\it defaultVal} is returned if the key is not found.
767
768
769 \membersection{wxConfigBase::RenameEntry}\label{wxconfigbaserenameentry}
770
771 \func{bool}{RenameEntry}{\param{const wxString\& }{ oldName}, \param{const wxString\& }{ newName}}
772
773 Renames an entry in the current group. The entries names (both the old and
774 the new one) shouldn't contain backslashes, i.e. only simple names and not
775 arbitrary paths are accepted by this function.
776
777 Returns \false if {\it oldName} doesn't exist or if {\it newName} already
778 exists.
779
780
781 \membersection{wxConfigBase::RenameGroup}\label{wxconfigbaserenamegroup}
782
783 \func{bool}{RenameGroup}{\param{const wxString\& }{ oldName}, \param{const wxString\& }{ newName}}
784
785 Renames a subgroup of the current group. The subgroup names (both the old and
786 the new one) shouldn't contain backslashes, i.e. only simple names and not
787 arbitrary paths are accepted by this function.
788
789 Returns \false if {\it oldName} doesn't exist or if {\it newName} already
790 exists.
791
792
793 \membersection{wxConfigBase::Set}\label{wxconfigbaseset}
794
795 \func{static wxConfigBase *}{Set}{\param{wxConfigBase *}{pConfig}}
796
797 Sets the config object as the current one, returns the pointer to the previous
798 current object (both the parameter and returned value may be NULL)
799
800
801 \membersection{wxConfigBase::SetExpandEnvVars}\label{wxconfigbasesetexpandenvvars}
802
803 \func{void}{SetExpandEnvVars }{\param{bool }{bDoIt = true}}
804
805 Determine whether we wish to expand environment variables in key values.
806
807
808 \membersection{wxConfigBase::SetPath}\label{wxconfigbasesetpath}
809
810 \func{void}{SetPath}{\param{const wxString\& }{strPath}}
811
812 Set current path: if the first character is '/', it is the absolute path,
813 otherwise it is a relative path. '..' is supported. If strPath doesn't
814 exist it is created.
815
816
817 \membersection{wxConfigBase::SetRecordDefaults}\label{wxconfigbasesetrecorddefaults}
818
819 \func{void}{SetRecordDefaults}{\param{bool }{bDoIt = true}}
820
821 Sets whether defaults are recorded to the config file whenever an attempt to
822 read the value which is not present in it is done.
823
824 If on (default is off) all default values for the settings used by the program
825 are written back to the config file. This allows the user to see what config
826 options may be changed and is probably useful only for wxFileConfig.
827
828
829 \membersection{wxConfigBase::Write}\label{wxconfigbasewrite}
830
831 \func{bool}{Write}{\param{const wxString\& }{ key}, \param{const wxString\& }{
832 value}}
833
834 \func{bool}{Write}{\param{const wxString\& }{ key}, \param{long}{ value}}
835
836 \func{bool}{Write}{\param{const wxString\& }{ key}, \param{double}{ value}}
837
838 \func{bool}{Write}{\param{const wxString\& }{ key}, \param{bool}{ value}}
839
840 \func{bool}{Write}{\param{const wxString\& }{ key}, \param{const wxMemoryBuffer\&}{ buf}}
841
842 \func{bool}{Write}{\param{const wxString\& }{ key}, \param{const T\&}{ buf}}
843
844 These functions write the specified value to the config file and return \true
845 on success. In the last one, function \helpref{wxToString}{wxtostring} must be
846 defined for type {\it T}.
847
848 \pythonnote{In place of a single overloaded method name, wxPython
849 implements the following methods:\par
850 \indented{2cm}{\begin{twocollist}
851 \twocolitem{{\bf Write(key, value)}}{Writes a string.}
852 \twocolitem{{\bf WriteInt(key, value)}}{Writes an int.}
853 \twocolitem{{\bf WriteFloat(key, value)}}{Writes a floating point number.}
854 \end{twocollist}}
855 }
856
857 \perlnote{In place of a single overloaded method, wxPerl uses:\par
858 \indented{2cm}{\begin{twocollist}
859 \twocolitem{{\bf Write(key, value)}}{Writes a string}
860 \twocolitem{{\bf WriteInt(key, value)}}{Writes an integer}
861 \twocolitem{{\bf WriteFloat(key, value)}}{Writes a floating point number}
862 \twocolitem{{\bf WriteBool(key, value)}}{Writes a boolean}
863 \end{twocollist}
864 }}
865