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