]> git.saurik.com Git - wxWidgets.git/blob - src/common/fileconf.cpp
projects / wxWidgets.git / blob
? search:


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