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


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