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