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