]> git.saurik.com Git - wxWidgets.git/blob - src/common/fileconf.cpp
changed version number
[wxWidgets.git] / src / common / fileconf.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: fileconf.cpp
3 // Purpose: implementation of wxFileConfig derivation of wxConfig
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 07.04.98 (adapted from appconf.cpp)
7 // RCS-ID: $Id$
8 // Copyright: (c) 1997 Karsten Ballüder & Vadim Zeitlin
9 // Ballueder@usa.net <zeitlin@dptmaths.ens-cachan.fr>
10 // Licence: wxWindows license
11 ///////////////////////////////////////////////////////////////////////////////
12
13 #ifdef __GNUG__
14 #pragma implementation "fileconf.h"
15 #endif
16
17 // ----------------------------------------------------------------------------
18 // headers
19 // ----------------------------------------------------------------------------
20
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif //__BORLANDC__
26
27 #if wxUSE_CONFIG
28
29 #ifndef WX_PRECOMP
30 #include "wx/string.h"
31 #include "wx/intl.h"
32 #endif //WX_PRECOMP
33
34 #include "wx/app.h"
35 #include "wx/dynarray.h"
36 #include "wx/file.h"
37 #include "wx/log.h"
38 #include "wx/textfile.h"
39 #include "wx/config.h"
40 #include "wx/fileconf.h"
41
42 #include "wx/utils.h" // for wxGetHomeDir
43
44 // _WINDOWS_ is defined when windows.h is included,
45 // __WXMSW__ is defined for MS Windows compilation
46 #if defined(__WXMSW__) && !defined(_WINDOWS_)
47 #include <windows.h>
48 #endif //windows.h
49 #if defined(__WXPM__)
50 #define INCL_DOS
51 #include <os2.h>
52 #endif
53
54 #include <stdlib.h>
55 #include <ctype.h>
56
57 // headers needed for umask()
58 #ifdef __UNIX__
59 #include <sys/types.h>
60 #include <sys/stat.h>
61 #endif // __UNIX__
62
63 // ----------------------------------------------------------------------------
64 // macros
65 // ----------------------------------------------------------------------------
66 #define CONST_CAST ((wxFileConfig *)this)->
67
68 // ----------------------------------------------------------------------------
69 // constants
70 // ----------------------------------------------------------------------------
71 #ifndef MAX_PATH
72 #define MAX_PATH 512
73 #endif
74
75 // ----------------------------------------------------------------------------
76 // global functions declarations
77 // ----------------------------------------------------------------------------
78
79 // compare functions for sorting the arrays
80 static int LINKAGEMODE CompareEntries(ConfigEntry *p1, ConfigEntry *p2);
81 static int LINKAGEMODE CompareGroups(ConfigGroup *p1, ConfigGroup *p2);
82
83 // filter strings
84 static wxString FilterInValue(const wxString& str);
85 static wxString FilterOutValue(const wxString& str);
86
87 static wxString FilterInEntryName(const wxString& str);
88 static wxString FilterOutEntryName(const wxString& str);
89
90 // get the name to use in wxFileConfig ctor
91 static wxString GetAppName(const wxString& appname);
92
93 // ============================================================================
94 // implementation
95 // ============================================================================
96
97 // ----------------------------------------------------------------------------
98 // static functions
99 // ----------------------------------------------------------------------------
100 wxString wxFileConfig::GetGlobalDir()
101 {
102 wxString strDir;
103
104 #ifdef __VMS__ // Note if __VMS is defined __UNIX is also defined
105 strDir = wxT("sys$manager:");
106 #elif defined( __UNIX__ )
107 strDir = wxT("/etc/");
108 #elif defined(__WXPM__)
109 ULONG aulSysInfo[QSV_MAX] = {0};
110 UINT drive;
111 APIRET rc;
112
113 rc = DosQuerySysInfo( 1L, QSV_MAX, (PVOID)aulSysInfo, sizeof(ULONG)*QSV_MAX);
114 if (rc == 0)
115 {
116 drive = aulSysInfo[QSV_BOOT_DRIVE - 1];
117 switch(drive)
118 {
119 case 1:
120 strDir = "A:\\OS2\\";
121 break;
122 case 2:
123 strDir = "B:\\OS2\\";
124 break;
125 case 3:
126 strDir = "C:\\OS2\\";
127 break;
128 case 4:
129 strDir = "D:\\OS2\\";
130 break;
131 case 5:
132 strDir = "E:\\OS2\\";
133 break;
134 case 6:
135 strDir = "F:\\OS2\\";
136 break;
137 case 7:
138 strDir = "G:\\OS2\\";
139 break;
140 case 8:
141 strDir = "H:\\OS2\\";
142 break;
143 case 9:
144 strDir = "I:\\OS2\\";
145 break;
146 case 10:
147 strDir = "J:\\OS2\\";
148 break;
149 case 11:
150 strDir = "K:\\OS2\\";
151 break;
152 case 12:
153 strDir = "L:\\OS2\\";
154 break;
155 case 13:
156 strDir = "M:\\OS2\\";
157 break;
158 case 14:
159 strDir = "N:\\OS2\\";
160 break;
161 case 15:
162 strDir = "O:\\OS2\\";
163 break;
164 case 16:
165 strDir = "P:\\OS2\\";
166 break;
167 case 17:
168 strDir = "Q:\\OS2\\";
169 break;
170 case 18:
171 strDir = "R:\\OS2\\";
172 break;
173 case 19:
174 strDir = "S:\\OS2\\";
175 break;
176 case 20:
177 strDir = "T:\\OS2\\";
178 break;
179 case 21:
180 strDir = "U:\\OS2\\";
181 break;
182 case 22:
183 strDir = "V:\\OS2\\";
184 break;
185 case 23:
186 strDir = "W:\\OS2\\";
187 break;
188 case 24:
189 strDir = "X:\\OS2\\";
190 break;
191 case 25:
192 strDir = "Y:\\OS2\\";
193 break;
194 case 26:
195 strDir = "Z:\\OS2\\";
196 break;
197 }
198 }
199 #elif defined(__WXSTUBS__)
200 wxASSERT_MSG( FALSE, wxT("TODO") ) ;
201 #elif defined(__WXMAC__)
202 strDir = wxMacFindFolder( (short) kOnSystemDisk, kPreferencesFolderType, kDontCreateFolder ) ;
203 #else // Windows
204 wxChar szWinDir[MAX_PATH];
205 ::GetWindowsDirectory(szWinDir, MAX_PATH);
206
207 strDir = szWinDir;
208 strDir << wxT('\\');
209 #endif // Unix/Windows
210
211 return strDir;
212 }
213
214 wxString wxFileConfig::GetLocalDir()
215 {
216 wxString strDir;
217
218 #ifndef __WXMAC__
219 wxGetHomeDir(&strDir);
220
221 #ifdef __UNIX__
222 #ifdef __VMS
223 if (strDir.Last() != wxT(']'))
224 #endif
225 if (strDir.Last() != wxT('/')) strDir << wxT('/');
226 #else
227 if (strDir.Last() != wxT('\\')) strDir << wxT('\\');
228 #endif
229 #else
230 // no local dir concept on mac
231 return GetGlobalDir() ;
232 #endif
233
234 return strDir;
235 }
236
237 wxString wxFileConfig::GetGlobalFileName(const wxChar *szFile)
238 {
239 wxString str = GetGlobalDir();
240 str << szFile;
241
242 if ( wxStrchr(szFile, wxT('.')) == NULL )
243 #ifdef __UNIX__
244 str << wxT(".conf");
245 #elif defined( __WXMAC__ )
246 str << " Preferences";
247 #else // Windows
248 str << wxT(".ini");
249 #endif // UNIX/Win
250
251 return str;
252 }
253
254 wxString wxFileConfig::GetLocalFileName(const wxChar *szFile)
255 {
256 #ifdef __VMS__ // On VMS I saw the problem that the home directory was appended
257 // twice for the configuration file. Does that also happen for other
258 // platforms?
259 wxString str = wxT( '.' );
260 #else
261 wxString str = GetLocalDir();
262 #endif
263
264 #if defined( __UNIX__ ) && !defined( __VMS )
265 str << wxT('.');
266 #endif
267
268 str << szFile;
269
270 #ifdef __WXMSW__
271 if ( wxStrchr(szFile, wxT('.')) == NULL )
272 str << wxT(".ini");
273 #endif
274
275
276 #ifdef __WXMAC__
277 str << " Preferences";
278 #endif
279 return str;
280 }
281
282 // ----------------------------------------------------------------------------
283 // ctor
284 // ----------------------------------------------------------------------------
285
286 void wxFileConfig::Init()
287 {
288 m_pCurrentGroup =
289 m_pRootGroup = new ConfigGroup(NULL, "", this);
290
291 m_linesHead =
292 m_linesTail = NULL;
293
294 // it's not an error if (one of the) file(s) doesn't exist
295
296 // parse the global file
297 if ( !m_strGlobalFile.IsEmpty() && wxFile::Exists(m_strGlobalFile) ) {
298 wxTextFile fileGlobal(m_strGlobalFile);
299
300 if ( fileGlobal.Open() ) {
301 Parse(fileGlobal, FALSE /* global */);
302 SetRootPath();
303 }
304 else
305 wxLogWarning(_("can't open global configuration file '%s'."),
306 m_strGlobalFile.c_str());
307 }
308
309 // parse the local file
310 if ( !m_strLocalFile.IsEmpty() && wxFile::Exists(m_strLocalFile) ) {
311 wxTextFile fileLocal(m_strLocalFile);
312 if ( fileLocal.Open() ) {
313 Parse(fileLocal, TRUE /* local */);
314 SetRootPath();
315 }
316 else
317 wxLogWarning(_("can't open user configuration file '%s'."),
318 m_strLocalFile.c_str());
319 }
320 }
321
322 // constructor supports creation of wxFileConfig objects of any type
323 wxFileConfig::wxFileConfig(const wxString& appName, const wxString& vendorName,
324 const wxString& strLocal, const wxString& strGlobal,
325 long style)
326 : wxConfigBase(::GetAppName(appName), vendorName,
327 strLocal, strGlobal,
328 style),
329 m_strLocalFile(strLocal), m_strGlobalFile(strGlobal)
330 {
331 // Make up names for files if empty
332 if ( m_strLocalFile.IsEmpty() && (style & wxCONFIG_USE_LOCAL_FILE) )
333 {
334 m_strLocalFile = GetLocalFileName(GetAppName());
335 }
336
337 if ( m_strGlobalFile.IsEmpty() && (style & wxCONFIG_USE_GLOBAL_FILE) )
338 {
339 m_strGlobalFile = GetGlobalFileName(GetAppName());
340 }
341
342 // Check if styles are not supplied, but filenames are, in which case
343 // add the correct styles.
344 if ( !m_strLocalFile.IsEmpty() )
345 SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE);
346
347 if ( !m_strGlobalFile.IsEmpty() )
348 SetStyle(GetStyle() | wxCONFIG_USE_GLOBAL_FILE);
349
350 // if the path is not absolute, prepend the standard directory to it
351 // UNLESS wxCONFIG_USE_RELATIVE_PATH style is set
352 if ( !(style & wxCONFIG_USE_RELATIVE_PATH) )
353 {
354 if ( !m_strLocalFile.IsEmpty() && !wxIsAbsolutePath(m_strLocalFile) )
355 {
356 wxString strLocal = m_strLocalFile;
357 m_strLocalFile = GetLocalDir();
358 m_strLocalFile << strLocal;
359 }
360
361 if ( !m_strGlobalFile.IsEmpty() && !wxIsAbsolutePath(m_strGlobalFile) )
362 {
363 wxString strGlobal = m_strGlobalFile;
364 m_strGlobalFile = GetGlobalDir();
365 m_strGlobalFile << strGlobal;
366 }
367 }
368
369 SetUmask(-1);
370
371 Init();
372 }
373
374 void wxFileConfig::CleanUp()
375 {
376 delete m_pRootGroup;
377
378 LineList *pCur = m_linesHead;
379 while ( pCur != NULL ) {
380 LineList *pNext = pCur->Next();
381 delete pCur;
382 pCur = pNext;
383 }
384 }
385
386 wxFileConfig::~wxFileConfig()
387 {
388 Flush();
389
390 CleanUp();
391 }
392
393 // ----------------------------------------------------------------------------
394 // parse a config file
395 // ----------------------------------------------------------------------------
396
397 void wxFileConfig::Parse(wxTextFile& file, bool bLocal)
398 {
399 const wxChar *pStart;
400 const wxChar *pEnd;
401 wxString strLine;
402
403 size_t nLineCount = file.GetLineCount();
404 for ( size_t n = 0; n < nLineCount; n++ ) {
405 strLine = file[n];
406
407 // add the line to linked list
408 if ( bLocal )
409 LineListAppend(strLine);
410
411 // skip leading spaces
412 for ( pStart = strLine; wxIsspace(*pStart); pStart++ )
413 ;
414
415 // skip blank/comment lines
416 if ( *pStart == wxT('\0')|| *pStart == wxT(';') || *pStart == wxT('#') )
417 continue;
418
419 if ( *pStart == wxT('[') ) { // a new group
420 pEnd = pStart;
421
422 while ( *++pEnd != wxT(']') ) {
423 if ( *pEnd == wxT('\\') ) {
424 // the next char is escaped, so skip it even if it is ']'
425 pEnd++;
426 }
427
428 if ( *pEnd == wxT('\n') || *pEnd == wxT('\0') ) {
429 // we reached the end of line, break out of the loop
430 break;
431 }
432 }
433
434 if ( *pEnd != wxT(']') ) {
435 wxLogError(_("file '%s': unexpected character %c at line %d."),
436 file.GetName(), *pEnd, n + 1);
437 continue; // skip this line
438 }
439
440 // group name here is always considered as abs path
441 wxString strGroup;
442 pStart++;
443 strGroup << wxCONFIG_PATH_SEPARATOR
444 << FilterInEntryName(wxString(pStart, pEnd - pStart));
445
446 // will create it if doesn't yet exist
447 SetPath(strGroup);
448
449 if ( bLocal )
450 m_pCurrentGroup->SetLine(m_linesTail);
451
452 // check that there is nothing except comments left on this line
453 bool bCont = TRUE;
454 while ( *++pEnd != wxT('\0') && bCont ) {
455 switch ( *pEnd ) {
456 case wxT('#'):
457 case wxT(';'):
458 bCont = FALSE;
459 break;
460
461 case wxT(' '):
462 case wxT('\t'):
463 // ignore whitespace ('\n' impossible here)
464 break;
465
466 default:
467 wxLogWarning(_("file '%s', line %d: '%s' ignored after group header."),
468 file.GetName(), n + 1, pEnd);
469 bCont = FALSE;
470 }
471 }
472 }
473 else { // a key
474 const wxChar *pEnd = pStart;
475 while ( *pEnd && *pEnd != wxT('=') && !wxIsspace(*pEnd) ) {
476 if ( *pEnd == wxT('\\') ) {
477 // next character may be space or not - still take it because it's
478 // quoted (unless there is nothing)
479 pEnd++;
480 if ( !*pEnd ) {
481 // the error message will be given below anyhow
482 break;
483 }
484 }
485
486 pEnd++;
487 }
488
489 wxString strKey(FilterInEntryName(wxString(pStart, pEnd)));
490
491 // skip whitespace
492 while ( wxIsspace(*pEnd) )
493 pEnd++;
494
495 if ( *pEnd++ != wxT('=') ) {
496 wxLogError(_("file '%s', line %d: '=' expected."),
497 file.GetName(), n + 1);
498 }
499 else {
500 ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strKey);
501
502 if ( pEntry == NULL ) {
503 // new entry
504 pEntry = m_pCurrentGroup->AddEntry(strKey, n);
505
506 if ( bLocal )
507 pEntry->SetLine(m_linesTail);
508 }
509 else {
510 if ( bLocal && pEntry->IsImmutable() ) {
511 // immutable keys can't be changed by user
512 wxLogWarning(_("file '%s', line %d: value for immutable key '%s' ignored."),
513 file.GetName(), n + 1, strKey.c_str());
514 continue;
515 }
516 // the condition below catches the cases (a) and (b) but not (c):
517 // (a) global key found second time in global file
518 // (b) key found second (or more) time in local file
519 // (c) key from global file now found in local one
520 // which is exactly what we want.
521 else if ( !bLocal || pEntry->IsLocal() ) {
522 wxLogWarning(_("file '%s', line %d: key '%s' was first found at line %d."),
523 file.GetName(), n + 1, strKey.c_str(), pEntry->Line());
524
525 if ( bLocal )
526 pEntry->SetLine(m_linesTail);
527 }
528 }
529
530 // skip whitespace
531 while ( wxIsspace(*pEnd) )
532 pEnd++;
533
534 pEntry->SetValue(FilterInValue(pEnd), FALSE /* read from file */);
535 }
536 }
537 }
538 }
539
540 // ----------------------------------------------------------------------------
541 // set/retrieve path
542 // ----------------------------------------------------------------------------
543
544 void wxFileConfig::SetRootPath()
545 {
546 m_strPath.Empty();
547 m_pCurrentGroup = m_pRootGroup;
548 }
549
550 void wxFileConfig::SetPath(const wxString& strPath)
551 {
552 wxArrayString aParts;
553
554 if ( strPath.IsEmpty() ) {
555 SetRootPath();
556 return;
557 }
558
559 if ( strPath[0] == wxCONFIG_PATH_SEPARATOR ) {
560 // absolute path
561 wxSplitPath(aParts, strPath);
562 }
563 else {
564 // relative path, combine with current one
565 wxString strFullPath = m_strPath;
566 strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
567 wxSplitPath(aParts, strFullPath);
568 }
569
570 // change current group
571 size_t n;
572 m_pCurrentGroup = m_pRootGroup;
573 for ( n = 0; n < aParts.Count(); n++ ) {
574 ConfigGroup *pNextGroup = m_pCurrentGroup->FindSubgroup(aParts[n]);
575 if ( pNextGroup == NULL )
576 pNextGroup = m_pCurrentGroup->AddSubgroup(aParts[n]);
577 m_pCurrentGroup = pNextGroup;
578 }
579
580 // recombine path parts in one variable
581 m_strPath.Empty();
582 for ( n = 0; n < aParts.Count(); n++ ) {
583 m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n];
584 }
585 }
586
587 // ----------------------------------------------------------------------------
588 // enumeration
589 // ----------------------------------------------------------------------------
590
591 bool wxFileConfig::GetFirstGroup(wxString& str, long& lIndex) const
592 {
593 lIndex = 0;
594 return GetNextGroup(str, lIndex);
595 }
596
597 bool wxFileConfig::GetNextGroup (wxString& str, long& lIndex) const
598 {
599 if ( size_t(lIndex) < m_pCurrentGroup->Groups().Count() ) {
600 str = m_pCurrentGroup->Groups()[(size_t)lIndex++]->Name();
601 return TRUE;
602 }
603 else
604 return FALSE;
605 }
606
607 bool wxFileConfig::GetFirstEntry(wxString& str, long& lIndex) const
608 {
609 lIndex = 0;
610 return GetNextEntry(str, lIndex);
611 }
612
613 bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) const
614 {
615 if ( size_t(lIndex) < m_pCurrentGroup->Entries().Count() ) {
616 str = m_pCurrentGroup->Entries()[(size_t)lIndex++]->Name();
617 return TRUE;
618 }
619 else
620 return FALSE;
621 }
622
623 size_t wxFileConfig::GetNumberOfEntries(bool bRecursive) const
624 {
625 size_t n = m_pCurrentGroup->Entries().Count();
626 if ( bRecursive ) {
627 ConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
628 size_t nSubgroups = m_pCurrentGroup->Groups().Count();
629 for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
630 CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
631 n += GetNumberOfEntries(TRUE);
632 CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
633 }
634 }
635
636 return n;
637 }
638
639 size_t wxFileConfig::GetNumberOfGroups(bool bRecursive) const
640 {
641 size_t n = m_pCurrentGroup->Groups().Count();
642 if ( bRecursive ) {
643 ConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
644 size_t nSubgroups = m_pCurrentGroup->Groups().Count();
645 for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
646 CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
647 n += GetNumberOfGroups(TRUE);
648 CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
649 }
650 }
651
652 return n;
653 }
654
655 // ----------------------------------------------------------------------------
656 // tests for existence
657 // ----------------------------------------------------------------------------
658
659 bool wxFileConfig::HasGroup(const wxString& strName) const
660 {
661 wxConfigPathChanger path(this, strName);
662
663 ConfigGroup *pGroup = m_pCurrentGroup->FindSubgroup(path.Name());
664 return pGroup != NULL;
665 }
666
667 bool wxFileConfig::HasEntry(const wxString& strName) const
668 {
669 wxConfigPathChanger path(this, strName);
670
671 ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
672 return pEntry != NULL;
673 }
674
675 // ----------------------------------------------------------------------------
676 // read/write values
677 // ----------------------------------------------------------------------------
678
679 bool wxFileConfig::Read(const wxString& key,
680 wxString* pStr) const
681 {
682 wxConfigPathChanger path(this, key);
683
684 ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
685 if (pEntry == NULL) {
686 return FALSE;
687 }
688
689 *pStr = ExpandEnvVars(pEntry->Value());
690 return TRUE;
691 }
692
693 bool wxFileConfig::Read(const wxString& key,
694 wxString* pStr, const wxString& defVal) const
695 {
696 wxConfigPathChanger path(this, key);
697
698 ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
699 bool ok;
700 if (pEntry == NULL) {
701 if( IsRecordingDefaults() )
702 ((wxFileConfig *)this)->Write(key,defVal);
703 *pStr = ExpandEnvVars(defVal);
704 ok = FALSE;
705 }
706 else {
707 *pStr = ExpandEnvVars(pEntry->Value());
708 ok = TRUE;
709 }
710
711 return ok;
712 }
713
714 bool wxFileConfig::Read(const wxString& key, long *pl) const
715 {
716 wxString str;
717 if ( !Read(key, & str) )
718 {
719 return FALSE;
720 }
721
722 *pl = wxAtol(str);
723 return TRUE;
724 }
725
726 bool wxFileConfig::Write(const wxString& key, const wxString& szValue)
727 {
728 wxConfigPathChanger path(this, key);
729
730 wxString strName = path.Name();
731 if ( strName.IsEmpty() ) {
732 // setting the value of a group is an error
733 wxASSERT_MSG( wxIsEmpty(szValue), wxT("can't set value of a group!") );
734
735 // ... except if it's empty in which case it's a way to force it's creation
736 m_pCurrentGroup->SetDirty();
737
738 // this will add a line for this group if it didn't have it before
739 (void)m_pCurrentGroup->GetGroupLine();
740 }
741 else {
742 // writing an entry
743
744 // check that the name is reasonable
745 if ( strName[0u] == wxCONFIG_IMMUTABLE_PREFIX ) {
746 wxLogError(_("Config entry name cannot start with '%c'."),
747 wxCONFIG_IMMUTABLE_PREFIX);
748 return FALSE;
749 }
750
751 ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strName);
752 if ( pEntry == NULL )
753 pEntry = m_pCurrentGroup->AddEntry(strName);
754
755 pEntry->SetValue(szValue);
756 }
757
758 return TRUE;
759 }
760
761 bool wxFileConfig::Write(const wxString& key, long lValue)
762 {
763 // ltoa() is not ANSI :-(
764 wxString buf;
765 buf.Printf(wxT("%ld"), lValue);
766 return Write(key, buf);
767 }
768
769 bool wxFileConfig::Flush(bool /* bCurrentOnly */)
770 {
771 if ( LineListIsEmpty() || !m_pRootGroup->IsDirty() || !m_strLocalFile )
772 return TRUE;
773
774 #ifdef __UNIX__
775 // set the umask if needed
776 mode_t umaskOld = 0;
777 if ( m_umask != -1 )
778 {
779 umaskOld = umask((mode_t)m_umask);
780 }
781 #endif // __UNIX__
782
783 wxTempFile file(m_strLocalFile);
784
785 if ( !file.IsOpened() ) {
786 wxLogError(_("can't open user configuration file."));
787 return FALSE;
788 }
789
790 // write all strings to file
791 for ( LineList *p = m_linesHead; p != NULL; p = p->Next() ) {
792 if ( !file.Write(p->Text() + wxTextFile::GetEOL()) ) {
793 wxLogError(_("can't write user configuration file."));
794 return FALSE;
795 }
796 }
797
798 bool ret = file.Commit();
799
800 #if defined(__WXMAC__) && !defined(__UNIX__)
801 if ( ret )
802 {
803 FSSpec spec ;
804
805 wxUnixFilename2FSSpec( m_strLocalFile , &spec ) ;
806 FInfo finfo ;
807 if ( FSpGetFInfo( &spec , &finfo ) == noErr )
808 {
809 finfo.fdType = 'TEXT' ;
810 finfo.fdCreator = 'ttxt' ;
811 FSpSetFInfo( &spec , &finfo ) ;
812 }
813 }
814 #endif // __WXMAC__ && !__UNIX__
815
816 #ifdef __UNIX__
817 // restore the old umask if we changed it
818 if ( m_umask != -1 )
819 {
820 (void)umask(umaskOld);
821 }
822 #endif // __UNIX__
823
824 return ret;
825 }
826
827 // ----------------------------------------------------------------------------
828 // renaming groups/entries
829 // ----------------------------------------------------------------------------
830
831 bool wxFileConfig::RenameEntry(const wxString& oldName,
832 const wxString& newName)
833 {
834 // check that the entry exists
835 ConfigEntry *oldEntry = m_pCurrentGroup->FindEntry(oldName);
836 if ( !oldEntry )
837 return FALSE;
838
839 // check that the new entry doesn't already exist
840 if ( m_pCurrentGroup->FindEntry(newName) )
841 return FALSE;
842
843 // delete the old entry, create the new one
844 wxString value = oldEntry->Value();
845 if ( !m_pCurrentGroup->DeleteEntry(oldName) )
846 return FALSE;
847
848 ConfigEntry *newEntry = m_pCurrentGroup->AddEntry(newName);
849 newEntry->SetValue(value);
850
851 return TRUE;
852 }
853
854 bool wxFileConfig::RenameGroup(const wxString& oldName,
855 const wxString& newName)
856 {
857 // check that the group exists
858 ConfigGroup *group = m_pCurrentGroup->FindSubgroup(oldName);
859 if ( !group )
860 return FALSE;
861
862 // check that the new group doesn't already exist
863 if ( m_pCurrentGroup->FindSubgroup(newName) )
864 return FALSE;
865
866 group->Rename(newName);
867
868 return TRUE;
869 }
870
871 // ----------------------------------------------------------------------------
872 // delete groups/entries
873 // ----------------------------------------------------------------------------
874
875 bool wxFileConfig::DeleteEntry(const wxString& key, bool bGroupIfEmptyAlso)
876 {
877 wxConfigPathChanger path(this, key);
878
879 if ( !m_pCurrentGroup->DeleteEntry(path.Name()) )
880 return FALSE;
881
882 if ( bGroupIfEmptyAlso && m_pCurrentGroup->IsEmpty() ) {
883 if ( m_pCurrentGroup != m_pRootGroup ) {
884 ConfigGroup *pGroup = m_pCurrentGroup;
885 SetPath(wxT("..")); // changes m_pCurrentGroup!
886 m_pCurrentGroup->DeleteSubgroupByName(pGroup->Name());
887 }
888 //else: never delete the root group
889 }
890
891 return TRUE;
892 }
893
894 bool wxFileConfig::DeleteGroup(const wxString& key)
895 {
896 wxConfigPathChanger path(this, key);
897
898 return m_pCurrentGroup->DeleteSubgroupByName(path.Name());
899 }
900
901 bool wxFileConfig::DeleteAll()
902 {
903 CleanUp();
904
905 if ( wxRemove(m_strLocalFile) == -1 )
906 wxLogSysError(_("can't delete user configuration file '%s'"), m_strLocalFile.c_str());
907
908 m_strLocalFile = m_strGlobalFile = wxT("");
909 Init();
910
911 return TRUE;
912 }
913
914 // ----------------------------------------------------------------------------
915 // linked list functions
916 // ----------------------------------------------------------------------------
917
918 // append a new line to the end of the list
919 LineList *wxFileConfig::LineListAppend(const wxString& str)
920 {
921 LineList *pLine = new LineList(str);
922
923 if ( m_linesTail == NULL ) {
924 // list is empty
925 m_linesHead = pLine;
926 }
927 else {
928 // adjust pointers
929 m_linesTail->SetNext(pLine);
930 pLine->SetPrev(m_linesTail);
931 }
932
933 m_linesTail = pLine;
934 return m_linesTail;
935 }
936
937 // insert a new line after the given one or in the very beginning if !pLine
938 LineList *wxFileConfig::LineListInsert(const wxString& str,
939 LineList *pLine)
940 {
941 if ( pLine == m_linesTail )
942 return LineListAppend(str);
943
944 LineList *pNewLine = new LineList(str);
945 if ( pLine == NULL ) {
946 // prepend to the list
947 pNewLine->SetNext(m_linesHead);
948 m_linesHead->SetPrev(pNewLine);
949 m_linesHead = pNewLine;
950 }
951 else {
952 // insert before pLine
953 LineList *pNext = pLine->Next();
954 pNewLine->SetNext(pNext);
955 pNewLine->SetPrev(pLine);
956 pNext->SetPrev(pNewLine);
957 pLine->SetNext(pNewLine);
958 }
959
960 return pNewLine;
961 }
962
963 void wxFileConfig::LineListRemove(LineList *pLine)
964 {
965 LineList *pPrev = pLine->Prev(),
966 *pNext = pLine->Next();
967
968 // first entry?
969 if ( pPrev == NULL )
970 m_linesHead = pNext;
971 else
972 pPrev->SetNext(pNext);
973
974 // last entry?
975 if ( pNext == NULL )
976 m_linesTail = pPrev;
977 else
978 pNext->SetPrev(pPrev);
979
980 delete pLine;
981 }
982
983 bool wxFileConfig::LineListIsEmpty()
984 {
985 return m_linesHead == NULL;
986 }
987
988 // ============================================================================
989 // wxFileConfig::ConfigGroup
990 // ============================================================================
991
992 // ----------------------------------------------------------------------------
993 // ctor/dtor
994 // ----------------------------------------------------------------------------
995
996 // ctor
997 ConfigGroup::ConfigGroup(ConfigGroup *pParent,
998 const wxString& strName,
999 wxFileConfig *pConfig)
1000 : m_aEntries(CompareEntries),
1001 m_aSubgroups(CompareGroups),
1002 m_strName(strName)
1003 {
1004 m_pConfig = pConfig;
1005 m_pParent = pParent;
1006 m_bDirty = FALSE;
1007 m_pLine = NULL;
1008
1009 m_pLastEntry = NULL;
1010 m_pLastGroup = NULL;
1011 }
1012
1013 // dtor deletes all children
1014 ConfigGroup::~ConfigGroup()
1015 {
1016 // entries
1017 size_t n, nCount = m_aEntries.Count();
1018 for ( n = 0; n < nCount; n++ )
1019 delete m_aEntries[n];
1020
1021 // subgroups
1022 nCount = m_aSubgroups.Count();
1023 for ( n = 0; n < nCount; n++ )
1024 delete m_aSubgroups[n];
1025 }
1026
1027 // ----------------------------------------------------------------------------
1028 // line
1029 // ----------------------------------------------------------------------------
1030
1031 void ConfigGroup::SetLine(LineList *pLine)
1032 {
1033 wxASSERT( m_pLine == NULL ); // shouldn't be called twice
1034
1035 m_pLine = pLine;
1036 }
1037
1038 /*
1039 This is a bit complicated, so let me explain it in details. All lines that
1040 were read from the local file (the only one we will ever modify) are stored
1041 in a (doubly) linked list. Our problem is to know at which position in this
1042 list should we insert the new entries/subgroups. To solve it we keep three
1043 variables for each group: m_pLine, m_pLastEntry and m_pLastGroup.
1044
1045 m_pLine points to the line containing "[group_name]"
1046 m_pLastEntry points to the last entry of this group in the local file.
1047 m_pLastGroup subgroup
1048
1049 Initially, they're NULL all three. When the group (an entry/subgroup) is read
1050 from the local file, the corresponding variable is set. However, if the group
1051 was read from the global file and then modified or created by the application
1052 these variables are still NULL and we need to create the corresponding lines.
1053 See the following functions (and comments preceding them) for the details of
1054 how we do it.
1055
1056 Also, when our last entry/group are deleted we need to find the new last
1057 element - the code in DeleteEntry/Subgroup does this by backtracking the list
1058 of lines until it either founds an entry/subgroup (and this is the new last
1059 element) or the m_pLine of the group, in which case there are no more entries
1060 (or subgroups) left and m_pLast<element> becomes NULL.
1061
1062 NB: This last problem could be avoided for entries if we added new entries
1063 immediately after m_pLine, but in this case the entries would appear
1064 backwards in the config file (OTOH, it's not that important) and as we
1065 would still need to do it for the subgroups the code wouldn't have been
1066 significantly less complicated.
1067 */
1068
1069 // Return the line which contains "[our name]". If we're still not in the list,
1070 // add our line to it immediately after the last line of our parent group if we
1071 // have it or in the very beginning if we're the root group.
1072 LineList *ConfigGroup::GetGroupLine()
1073 {
1074 if ( m_pLine == NULL ) {
1075 ConfigGroup *pParent = Parent();
1076
1077 // this group wasn't present in local config file, add it now
1078 if ( pParent != NULL ) {
1079 wxString strFullName;
1080 strFullName << wxT("[")
1081 // +1: no '/'
1082 << FilterOutEntryName(GetFullName().c_str() + 1)
1083 << wxT("]");
1084 m_pLine = m_pConfig->LineListInsert(strFullName,
1085 pParent->GetLastGroupLine());
1086 pParent->SetLastGroup(this); // we're surely after all the others
1087 }
1088 else {
1089 // we return NULL, so that LineListInsert() will insert us in the
1090 // very beginning
1091 }
1092 }
1093
1094 return m_pLine;
1095 }
1096
1097 // Return the last line belonging to the subgroups of this group (after which
1098 // we can add a new subgroup), if we don't have any subgroups or entries our
1099 // last line is the group line (m_pLine) itself.
1100 LineList *ConfigGroup::GetLastGroupLine()
1101 {
1102 // if we have any subgroups, our last line is the last line of the last
1103 // subgroup
1104 if ( m_pLastGroup != NULL ) {
1105 LineList *pLine = m_pLastGroup->GetLastGroupLine();
1106
1107 wxASSERT( pLine != NULL ); // last group must have !NULL associated line
1108 return pLine;
1109 }
1110
1111 // no subgroups, so the last line is the line of thelast entry (if any)
1112 return GetLastEntryLine();
1113 }
1114
1115 // return the last line belonging to the entries of this group (after which
1116 // we can add a new entry), if we don't have any entries we will add the new
1117 // one immediately after the group line itself.
1118 LineList *ConfigGroup::GetLastEntryLine()
1119 {
1120 if ( m_pLastEntry != NULL ) {
1121 LineList *pLine = m_pLastEntry->GetLine();
1122
1123 wxASSERT( pLine != NULL ); // last entry must have !NULL associated line
1124 return pLine;
1125 }
1126
1127 // no entries: insert after the group header
1128 return GetGroupLine();
1129 }
1130
1131 // ----------------------------------------------------------------------------
1132 // group name
1133 // ----------------------------------------------------------------------------
1134
1135 void ConfigGroup::Rename(const wxString& newName)
1136 {
1137 m_strName = newName;
1138
1139 LineList *line = GetGroupLine();
1140 wxString strFullName;
1141 strFullName << wxT("[") << (GetFullName().c_str() + 1) << wxT("]"); // +1: no '/'
1142 line->SetText(strFullName);
1143
1144 SetDirty();
1145 }
1146
1147 wxString ConfigGroup::GetFullName() const
1148 {
1149 if ( Parent() )
1150 return Parent()->GetFullName() + wxCONFIG_PATH_SEPARATOR + Name();
1151 else
1152 return wxT("");
1153 }
1154
1155 // ----------------------------------------------------------------------------
1156 // find an item
1157 // ----------------------------------------------------------------------------
1158
1159 // use binary search because the array is sorted
1160 ConfigEntry *
1161 ConfigGroup::FindEntry(const wxChar *szName) const
1162 {
1163 size_t i,
1164 lo = 0,
1165 hi = m_aEntries.Count();
1166 int res;
1167 ConfigEntry *pEntry;
1168
1169 while ( lo < hi ) {
1170 i = (lo + hi)/2;
1171 pEntry = m_aEntries[i];
1172
1173 #if wxCONFIG_CASE_SENSITIVE
1174 res = wxStrcmp(pEntry->Name(), szName);
1175 #else
1176 res = wxStricmp(pEntry->Name(), szName);
1177 #endif
1178
1179 if ( res > 0 )
1180 hi = i;
1181 else if ( res < 0 )
1182 lo = i + 1;
1183 else
1184 return pEntry;
1185 }
1186
1187 return NULL;
1188 }
1189
1190 ConfigGroup *
1191 ConfigGroup::FindSubgroup(const wxChar *szName) const
1192 {
1193 size_t i,
1194 lo = 0,
1195 hi = m_aSubgroups.Count();
1196 int res;
1197 ConfigGroup *pGroup;
1198
1199 while ( lo < hi ) {
1200 i = (lo + hi)/2;
1201 pGroup = m_aSubgroups[i];
1202
1203 #if wxCONFIG_CASE_SENSITIVE
1204 res = wxStrcmp(pGroup->Name(), szName);
1205 #else
1206 res = wxStricmp(pGroup->Name(), szName);
1207 #endif
1208
1209 if ( res > 0 )
1210 hi = i;
1211 else if ( res < 0 )
1212 lo = i + 1;
1213 else
1214 return pGroup;
1215 }
1216
1217 return NULL;
1218 }
1219
1220 // ----------------------------------------------------------------------------
1221 // create a new item
1222 // ----------------------------------------------------------------------------
1223
1224 // create a new entry and add it to the current group
1225 ConfigEntry *
1226 ConfigGroup::AddEntry(const wxString& strName, int nLine)
1227 {
1228 wxASSERT( FindEntry(strName) == NULL );
1229
1230 ConfigEntry *pEntry = new ConfigEntry(this, strName, nLine);
1231 m_aEntries.Add(pEntry);
1232
1233 return pEntry;
1234 }
1235
1236 // create a new group and add it to the current group
1237 ConfigGroup *
1238 ConfigGroup::AddSubgroup(const wxString& strName)
1239 {
1240 wxASSERT( FindSubgroup(strName) == NULL );
1241
1242 ConfigGroup *pGroup = new ConfigGroup(this, strName, m_pConfig);
1243 m_aSubgroups.Add(pGroup);
1244
1245 return pGroup;
1246 }
1247
1248 // ----------------------------------------------------------------------------
1249 // delete an item
1250 // ----------------------------------------------------------------------------
1251
1252 /*
1253 The delete operations are _very_ slow if we delete the last item of this
1254 group (see comments before GetXXXLineXXX functions for more details),
1255 so it's much better to start with the first entry/group if we want to
1256 delete several of them.
1257 */
1258
1259 bool ConfigGroup::DeleteSubgroupByName(const wxChar *szName)
1260 {
1261 return DeleteSubgroup(FindSubgroup(szName));
1262 }
1263
1264 // doesn't delete the subgroup itself, but does remove references to it from
1265 // all other data structures (and normally the returned pointer should be
1266 // deleted a.s.a.p. because there is nothing much to be done with it anyhow)
1267 bool ConfigGroup::DeleteSubgroup(ConfigGroup *pGroup)
1268 {
1269 wxCHECK( pGroup != NULL, FALSE ); // deleting non existing group?
1270
1271 // delete all entries
1272 size_t nCount = pGroup->m_aEntries.Count();
1273 for ( size_t nEntry = 0; nEntry < nCount; nEntry++ ) {
1274 LineList *pLine = pGroup->m_aEntries[nEntry]->GetLine();
1275 if ( pLine != NULL )
1276 m_pConfig->LineListRemove(pLine);
1277 }
1278
1279 // and subgroups of this sungroup
1280 nCount = pGroup->m_aSubgroups.Count();
1281 for ( size_t nGroup = 0; nGroup < nCount; nGroup++ ) {
1282 pGroup->DeleteSubgroup(pGroup->m_aSubgroups[0]);
1283 }
1284
1285 LineList *pLine = pGroup->m_pLine;
1286 if ( pLine != NULL ) {
1287 // notice that we may do this test inside the previous "if" because the
1288 // last entry's line is surely !NULL
1289 if ( pGroup == m_pLastGroup ) {
1290 // our last entry is being deleted - find the last one which stays
1291 wxASSERT( m_pLine != NULL ); // we have a subgroup with !NULL pLine...
1292
1293 // go back until we find a subgroup or reach the group's line
1294 ConfigGroup *pNewLast = NULL;
1295 size_t n, nSubgroups = m_aSubgroups.Count();
1296 LineList *pl;
1297 for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) {
1298 // is it our subgroup?
1299 for ( n = 0; (pNewLast == NULL) && (n < nSubgroups); n++ ) {
1300 // do _not_ call GetGroupLine! we don't want to add it to the local
1301 // file if it's not already there
1302 if ( m_aSubgroups[n]->m_pLine == m_pLine )
1303 pNewLast = m_aSubgroups[n];
1304 }
1305
1306 if ( pNewLast != NULL ) // found?
1307 break;
1308 }
1309
1310 if ( pl == m_pLine ) {
1311 wxASSERT( !pNewLast ); // how comes it has the same line as we?
1312
1313 // we've reached the group line without finding any subgroups
1314 m_pLastGroup = NULL;
1315 }
1316 else
1317 m_pLastGroup = pNewLast;
1318 }
1319
1320 m_pConfig->LineListRemove(pLine);
1321 }
1322
1323 SetDirty();
1324
1325 m_aSubgroups.Remove(pGroup);
1326 delete pGroup;
1327
1328 return TRUE;
1329 }
1330
1331 bool ConfigGroup::DeleteEntry(const wxChar *szName)
1332 {
1333 ConfigEntry *pEntry = FindEntry(szName);
1334 wxCHECK( pEntry != NULL, FALSE ); // deleting non existing item?
1335
1336 LineList *pLine = pEntry->GetLine();
1337 if ( pLine != NULL ) {
1338 // notice that we may do this test inside the previous "if" because the
1339 // last entry's line is surely !NULL
1340 if ( pEntry == m_pLastEntry ) {
1341 // our last entry is being deleted - find the last one which stays
1342 wxASSERT( m_pLine != NULL ); // if we have an entry with !NULL pLine...
1343
1344 // go back until we find another entry or reach the group's line
1345 ConfigEntry *pNewLast = NULL;
1346 size_t n, nEntries = m_aEntries.Count();
1347 LineList *pl;
1348 for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) {
1349 // is it our subgroup?
1350 for ( n = 0; (pNewLast == NULL) && (n < nEntries); n++ ) {
1351 if ( m_aEntries[n]->GetLine() == m_pLine )
1352 pNewLast = m_aEntries[n];
1353 }
1354
1355 if ( pNewLast != NULL ) // found?
1356 break;
1357 }
1358
1359 if ( pl == m_pLine ) {
1360 wxASSERT( !pNewLast ); // how comes it has the same line as we?
1361
1362 // we've reached the group line without finding any subgroups
1363 m_pLastEntry = NULL;
1364 }
1365 else
1366 m_pLastEntry = pNewLast;
1367 }
1368
1369 m_pConfig->LineListRemove(pLine);
1370 }
1371
1372 // we must be written back for the changes to be saved
1373 SetDirty();
1374
1375 m_aEntries.Remove(pEntry);
1376 delete pEntry;
1377
1378 return TRUE;
1379 }
1380
1381 // ----------------------------------------------------------------------------
1382 //
1383 // ----------------------------------------------------------------------------
1384 void ConfigGroup::SetDirty()
1385 {
1386 m_bDirty = TRUE;
1387 if ( Parent() != NULL ) // propagate upwards
1388 Parent()->SetDirty();
1389 }
1390
1391 // ============================================================================
1392 // wxFileConfig::ConfigEntry
1393 // ============================================================================
1394
1395 // ----------------------------------------------------------------------------
1396 // ctor
1397 // ----------------------------------------------------------------------------
1398 ConfigEntry::ConfigEntry(ConfigGroup *pParent,
1399 const wxString& strName,
1400 int nLine)
1401 : m_strName(strName)
1402 {
1403 wxASSERT( !strName.IsEmpty() );
1404
1405 m_pParent = pParent;
1406 m_nLine = nLine;
1407 m_pLine = NULL;
1408
1409 m_bDirty = FALSE;
1410
1411 m_bImmutable = strName[0] == wxCONFIG_IMMUTABLE_PREFIX;
1412 if ( m_bImmutable )
1413 m_strName.erase(0, 1); // remove first character
1414 }
1415
1416 // ----------------------------------------------------------------------------
1417 // set value
1418 // ----------------------------------------------------------------------------
1419
1420 void ConfigEntry::SetLine(LineList *pLine)
1421 {
1422 if ( m_pLine != NULL ) {
1423 wxLogWarning(_("entry '%s' appears more than once in group '%s'"),
1424 Name().c_str(), m_pParent->GetFullName().c_str());
1425 }
1426
1427 m_pLine = pLine;
1428 Group()->SetLastEntry(this);
1429 }
1430
1431 // second parameter is FALSE if we read the value from file and prevents the
1432 // entry from being marked as 'dirty'
1433 void ConfigEntry::SetValue(const wxString& strValue, bool bUser)
1434 {
1435 if ( bUser && IsImmutable() ) {
1436 wxLogWarning(_("attempt to change immutable key '%s' ignored."),
1437 Name().c_str());
1438 return;
1439 }
1440
1441 // do nothing if it's the same value
1442 if ( strValue == m_strValue )
1443 return;
1444
1445 m_strValue = strValue;
1446
1447 if ( bUser ) {
1448 wxString strVal = FilterOutValue(strValue);
1449 wxString strLine;
1450 strLine << FilterOutEntryName(m_strName) << wxT('=') << strVal;
1451
1452 if ( m_pLine != NULL ) {
1453 // entry was read from the local config file, just modify the line
1454 m_pLine->SetText(strLine);
1455 }
1456 else {
1457 // add a new line to the file
1458 wxASSERT( m_nLine == wxNOT_FOUND ); // consistency check
1459
1460 m_pLine = Group()->Config()->LineListInsert(strLine,
1461 Group()->GetLastEntryLine());
1462 Group()->SetLastEntry(this);
1463 }
1464
1465 SetDirty();
1466 }
1467 }
1468
1469 void ConfigEntry::SetDirty()
1470 {
1471 m_bDirty = TRUE;
1472 Group()->SetDirty();
1473 }
1474
1475 // ============================================================================
1476 // global functions
1477 // ============================================================================
1478
1479 // ----------------------------------------------------------------------------
1480 // compare functions for array sorting
1481 // ----------------------------------------------------------------------------
1482
1483 int CompareEntries(ConfigEntry *p1,
1484 ConfigEntry *p2)
1485 {
1486 #if wxCONFIG_CASE_SENSITIVE
1487 return wxStrcmp(p1->Name(), p2->Name());
1488 #else
1489 return wxStricmp(p1->Name(), p2->Name());
1490 #endif
1491 }
1492
1493 int CompareGroups(ConfigGroup *p1,
1494 ConfigGroup *p2)
1495 {
1496 #if wxCONFIG_CASE_SENSITIVE
1497 return wxStrcmp(p1->Name(), p2->Name());
1498 #else
1499 return wxStricmp(p1->Name(), p2->Name());
1500 #endif
1501 }
1502
1503 // ----------------------------------------------------------------------------
1504 // filter functions
1505 // ----------------------------------------------------------------------------
1506
1507 // undo FilterOutValue
1508 static wxString FilterInValue(const wxString& str)
1509 {
1510 wxString strResult;
1511 strResult.Alloc(str.Len());
1512
1513 bool bQuoted = !str.IsEmpty() && str[0] == '"';
1514
1515 for ( size_t n = bQuoted ? 1 : 0; n < str.Len(); n++ ) {
1516 if ( str[n] == wxT('\\') ) {
1517 switch ( str[++n] ) {
1518 case wxT('n'):
1519 strResult += wxT('\n');
1520 break;
1521
1522 case wxT('r'):
1523 strResult += wxT('\r');
1524 break;
1525
1526 case wxT('t'):
1527 strResult += wxT('\t');
1528 break;
1529
1530 case wxT('\\'):
1531 strResult += wxT('\\');
1532 break;
1533
1534 case wxT('"'):
1535 strResult += wxT('"');
1536 break;
1537 }
1538 }
1539 else {
1540 if ( str[n] != wxT('"') || !bQuoted )
1541 strResult += str[n];
1542 else if ( n != str.Len() - 1 ) {
1543 wxLogWarning(_("unexpected \" at position %d in '%s'."),
1544 n, str.c_str());
1545 }
1546 //else: it's the last quote of a quoted string, ok
1547 }
1548 }
1549
1550 return strResult;
1551 }
1552
1553 // quote the string before writing it to file
1554 static wxString FilterOutValue(const wxString& str)
1555 {
1556 if ( !str )
1557 return str;
1558
1559 wxString strResult;
1560 strResult.Alloc(str.Len());
1561
1562 // quoting is necessary to preserve spaces in the beginning of the string
1563 bool bQuote = wxIsspace(str[0]) || str[0] == wxT('"');
1564
1565 if ( bQuote )
1566 strResult += wxT('"');
1567
1568 wxChar c;
1569 for ( size_t n = 0; n < str.Len(); n++ ) {
1570 switch ( str[n] ) {
1571 case wxT('\n'):
1572 c = wxT('n');
1573 break;
1574
1575 case wxT('\r'):
1576 c = wxT('r');
1577 break;
1578
1579 case wxT('\t'):
1580 c = wxT('t');
1581 break;
1582
1583 case wxT('\\'):
1584 c = wxT('\\');
1585 break;
1586
1587 case wxT('"'):
1588 if ( bQuote ) {
1589 c = wxT('"');
1590 break;
1591 }
1592 //else: fall through
1593
1594 default:
1595 strResult += str[n];
1596 continue; // nothing special to do
1597 }
1598
1599 // we get here only for special characters
1600 strResult << wxT('\\') << c;
1601 }
1602
1603 if ( bQuote )
1604 strResult += wxT('"');
1605
1606 return strResult;
1607 }
1608
1609 // undo FilterOutEntryName
1610 static wxString FilterInEntryName(const wxString& str)
1611 {
1612 wxString strResult;
1613 strResult.Alloc(str.Len());
1614
1615 for ( const wxChar *pc = str.c_str(); *pc != '\0'; pc++ ) {
1616 if ( *pc == wxT('\\') )
1617 pc++;
1618
1619 strResult += *pc;
1620 }
1621
1622 return strResult;
1623 }
1624
1625 // sanitize entry or group name: insert '\\' before any special characters
1626 static wxString FilterOutEntryName(const wxString& str)
1627 {
1628 wxString strResult;
1629 strResult.Alloc(str.Len());
1630
1631 for ( const wxChar *pc = str.c_str(); *pc != wxT('\0'); pc++ ) {
1632 wxChar c = *pc;
1633
1634 // we explicitly allow some of "safe" chars and 8bit ASCII characters
1635 // which will probably never have special meaning
1636 // NB: note that wxCONFIG_IMMUTABLE_PREFIX and wxCONFIG_PATH_SEPARATOR
1637 // should *not* be quoted
1638 if ( !wxIsalnum(c) && !wxStrchr(wxT("@_/-!.*%"), c) && ((c & 0x80) == 0) )
1639 strResult += wxT('\\');
1640
1641 strResult += c;
1642 }
1643
1644 return strResult;
1645 }
1646
1647 // we can't put ?: in the ctor initializer list because it confuses some
1648 // broken compilers (Borland C++)
1649 static wxString GetAppName(const wxString& appName)
1650 {
1651 if ( !appName && wxTheApp )
1652 return wxTheApp->GetAppName();
1653 else
1654 return appName;
1655 }
1656
1657 #endif // wxUSE_CONFIG
1658