]> 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
fixed typo in wxString::swap() which was completely broken
[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 pEntry->SetValue(FilterInValue(pEnd), FALSE /* read from file */);
680 }
681 }
682 }
683 }
684
685 // ----------------------------------------------------------------------------
686 // set/retrieve path
687 // ----------------------------------------------------------------------------
688
689 void wxFileConfig::SetRootPath()
690 {
691 m_strPath.Empty();
692 m_pCurrentGroup = m_pRootGroup;
693 }
694
695 void wxFileConfig::SetPath(const wxString& strPath)
696 {
697 wxArrayString aParts;
698
699 if ( strPath.IsEmpty() ) {
700 SetRootPath();
701 return;
702 }
703
704 if ( strPath[0] == wxCONFIG_PATH_SEPARATOR ) {
705 // absolute path
706 wxSplitPath(aParts, strPath);
707 }
708 else {
709 // relative path, combine with current one
710 wxString strFullPath = m_strPath;
711 strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
712 wxSplitPath(aParts, strFullPath);
713 }
714
715 // change current group
716 size_t n;
717 m_pCurrentGroup = m_pRootGroup;
718 for ( n = 0; n < aParts.Count(); n++ ) {
719 wxFileConfigGroup *pNextGroup = m_pCurrentGroup->FindSubgroup(aParts[n]);
720 if ( pNextGroup == NULL )
721 pNextGroup = m_pCurrentGroup->AddSubgroup(aParts[n]);
722 m_pCurrentGroup = pNextGroup;
723 }
724
725 // recombine path parts in one variable
726 m_strPath.Empty();
727 for ( n = 0; n < aParts.Count(); n++ ) {
728 m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n];
729 }
730 }
731
732 // ----------------------------------------------------------------------------
733 // enumeration
734 // ----------------------------------------------------------------------------
735
736 bool wxFileConfig::GetFirstGroup(wxString& str, long& lIndex) const
737 {
738 lIndex = 0;
739 return GetNextGroup(str, lIndex);
740 }
741
742 bool wxFileConfig::GetNextGroup (wxString& str, long& lIndex) const
743 {
744 if ( size_t(lIndex) < m_pCurrentGroup->Groups().Count() ) {
745 str = m_pCurrentGroup->Groups()[(size_t)lIndex++]->Name();
746 return TRUE;
747 }
748 else
749 return FALSE;
750 }
751
752 bool wxFileConfig::GetFirstEntry(wxString& str, long& lIndex) const
753 {
754 lIndex = 0;
755 return GetNextEntry(str, lIndex);
756 }
757
758 bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) const
759 {
760 if ( size_t(lIndex) < m_pCurrentGroup->Entries().Count() ) {
761 str = m_pCurrentGroup->Entries()[(size_t)lIndex++]->Name();
762 return TRUE;
763 }
764 else
765 return FALSE;
766 }
767
768 size_t wxFileConfig::GetNumberOfEntries(bool bRecursive) const
769 {
770 size_t n = m_pCurrentGroup->Entries().Count();
771 if ( bRecursive ) {
772 wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
773 size_t nSubgroups = m_pCurrentGroup->Groups().Count();
774 for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
775 CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
776 n += GetNumberOfEntries(TRUE);
777 CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
778 }
779 }
780
781 return n;
782 }
783
784 size_t wxFileConfig::GetNumberOfGroups(bool bRecursive) const
785 {
786 size_t n = m_pCurrentGroup->Groups().Count();
787 if ( bRecursive ) {
788 wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
789 size_t nSubgroups = m_pCurrentGroup->Groups().Count();
790 for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
791 CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
792 n += GetNumberOfGroups(TRUE);
793 CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
794 }
795 }
796
797 return n;
798 }
799
800 // ----------------------------------------------------------------------------
801 // tests for existence
802 // ----------------------------------------------------------------------------
803
804 bool wxFileConfig::HasGroup(const wxString& strName) const
805 {
806 wxConfigPathChanger path(this, strName);
807
808 wxFileConfigGroup *pGroup = m_pCurrentGroup->FindSubgroup(path.Name());
809 return pGroup != NULL;
810 }
811
812 bool wxFileConfig::HasEntry(const wxString& strName) const
813 {
814 wxConfigPathChanger path(this, strName);
815
816 wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
817 return pEntry != NULL;
818 }
819
820 // ----------------------------------------------------------------------------
821 // read/write values
822 // ----------------------------------------------------------------------------
823
824 bool wxFileConfig::DoReadString(const wxString& key, wxString* pStr) const
825 {
826 wxConfigPathChanger path(this, key);
827
828 wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
829 if (pEntry == NULL) {
830 return FALSE;
831 }
832
833 *pStr = pEntry->Value();
834
835 return TRUE;
836 }
837
838 bool wxFileConfig::DoReadLong(const wxString& key, long *pl) const
839 {
840 wxString str;
841 if ( !Read(key, & str) )
842 {
843 return FALSE;
844 }
845 return str.ToLong(pl) ;
846 }
847
848 bool wxFileConfig::DoWriteString(const wxString& key, const wxString& szValue)
849 {
850 wxConfigPathChanger path(this, key);
851
852 wxString strName = path.Name();
853 if ( strName.IsEmpty() ) {
854 // setting the value of a group is an error
855 wxASSERT_MSG( wxIsEmpty(szValue), wxT("can't set value of a group!") );
856
857 // ... except if it's empty in which case it's a way to force it's creation
858 m_pCurrentGroup->SetDirty();
859
860 // this will add a line for this group if it didn't have it before
861 (void)m_pCurrentGroup->GetGroupLine();
862 }
863 else {
864 // writing an entry
865
866 // check that the name is reasonable
867 if ( strName[0u] == wxCONFIG_IMMUTABLE_PREFIX ) {
868 wxLogError(_("Config entry name cannot start with '%c'."),
869 wxCONFIG_IMMUTABLE_PREFIX);
870 return FALSE;
871 }
872
873 wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strName);
874 if ( pEntry == NULL )
875 pEntry = m_pCurrentGroup->AddEntry(strName);
876
877 pEntry->SetValue(szValue);
878 }
879
880 return TRUE;
881 }
882
883 bool wxFileConfig::DoWriteLong(const wxString& key, long lValue)
884 {
885 return Write(key, wxString::Format(_T("%ld"), lValue));
886 }
887
888 bool wxFileConfig::Flush(bool /* bCurrentOnly */)
889 {
890 if ( LineListIsEmpty() || !m_pRootGroup->IsDirty() || !m_strLocalFile )
891 return TRUE;
892
893 #ifdef __UNIX__
894 // set the umask if needed
895 mode_t umaskOld = 0;
896 if ( m_umask != -1 )
897 {
898 umaskOld = umask((mode_t)m_umask);
899 }
900 #endif // __UNIX__
901
902 wxTempFile file(m_strLocalFile);
903
904 if ( !file.IsOpened() ) {
905 wxLogError(_("can't open user configuration file."));
906 return FALSE;
907 }
908
909 // write all strings to file
910 for ( wxFileConfigLineList *p = m_linesHead; p != NULL; p = p->Next() ) {
911 if ( !file.Write(p->Text() + wxTextFile::GetEOL()) ) {
912 wxLogError(_("can't write user configuration file."));
913 return FALSE;
914 }
915 }
916
917 bool ret = file.Commit();
918
919 #if defined(__WXMAC__)
920 if ( ret )
921 {
922 FSSpec spec ;
923
924 wxMacFilename2FSSpec( m_strLocalFile , &spec ) ;
925 FInfo finfo ;
926 if ( FSpGetFInfo( &spec , &finfo ) == noErr )
927 {
928 finfo.fdType = 'TEXT' ;
929 finfo.fdCreator = 'ttxt' ;
930 FSpSetFInfo( &spec , &finfo ) ;
931 }
932 }
933 #endif // __WXMAC__
934
935 #ifdef __UNIX__
936 // restore the old umask if we changed it
937 if ( m_umask != -1 )
938 {
939 (void)umask(umaskOld);
940 }
941 #endif // __UNIX__
942
943 return ret;
944 }
945
946 // ----------------------------------------------------------------------------
947 // renaming groups/entries
948 // ----------------------------------------------------------------------------
949
950 bool wxFileConfig::RenameEntry(const wxString& oldName,
951 const wxString& newName)
952 {
953 // check that the entry exists
954 wxFileConfigEntry *oldEntry = m_pCurrentGroup->FindEntry(oldName);
955 if ( !oldEntry )
956 return FALSE;
957
958 // check that the new entry doesn't already exist
959 if ( m_pCurrentGroup->FindEntry(newName) )
960 return FALSE;
961
962 // delete the old entry, create the new one
963 wxString value = oldEntry->Value();
964 if ( !m_pCurrentGroup->DeleteEntry(oldName) )
965 return FALSE;
966
967 wxFileConfigEntry *newEntry = m_pCurrentGroup->AddEntry(newName);
968 newEntry->SetValue(value);
969
970 return TRUE;
971 }
972
973 bool wxFileConfig::RenameGroup(const wxString& oldName,
974 const wxString& newName)
975 {
976 // check that the group exists
977 wxFileConfigGroup *group = m_pCurrentGroup->FindSubgroup(oldName);
978 if ( !group )
979 return FALSE;
980
981 // check that the new group doesn't already exist
982 if ( m_pCurrentGroup->FindSubgroup(newName) )
983 return FALSE;
984
985 group->Rename(newName);
986
987 return TRUE;
988 }
989
990 // ----------------------------------------------------------------------------
991 // delete groups/entries
992 // ----------------------------------------------------------------------------
993
994 bool wxFileConfig::DeleteEntry(const wxString& key, bool bGroupIfEmptyAlso)
995 {
996 wxConfigPathChanger path(this, key);
997
998 if ( !m_pCurrentGroup->DeleteEntry(path.Name()) )
999 return FALSE;
1000
1001 if ( bGroupIfEmptyAlso && m_pCurrentGroup->IsEmpty() ) {
1002 if ( m_pCurrentGroup != m_pRootGroup ) {
1003 wxFileConfigGroup *pGroup = m_pCurrentGroup;
1004 SetPath(wxT("..")); // changes m_pCurrentGroup!
1005 m_pCurrentGroup->DeleteSubgroupByName(pGroup->Name());
1006 }
1007 //else: never delete the root group
1008 }
1009
1010 return TRUE;
1011 }
1012
1013 bool wxFileConfig::DeleteGroup(const wxString& key)
1014 {
1015 wxConfigPathChanger path(this, key);
1016
1017 return m_pCurrentGroup->DeleteSubgroupByName(path.Name());
1018 }
1019
1020 bool wxFileConfig::DeleteAll()
1021 {
1022 CleanUp();
1023
1024 if ( wxRemove(m_strLocalFile) == -1 )
1025 wxLogSysError(_("can't delete user configuration file '%s'"), m_strLocalFile.c_str());
1026
1027 m_strLocalFile = m_strGlobalFile = wxT("");
1028 Init();
1029
1030 return TRUE;
1031 }
1032
1033 // ----------------------------------------------------------------------------
1034 // linked list functions
1035 // ----------------------------------------------------------------------------
1036
1037 // append a new line to the end of the list
1038 wxFileConfigLineList *wxFileConfig::LineListAppend(const wxString& str)
1039 {
1040 wxFileConfigLineList *pLine = new wxFileConfigLineList(str);
1041
1042 if ( m_linesTail == NULL ) {
1043 // list is empty
1044 m_linesHead = pLine;
1045 }
1046 else {
1047 // adjust pointers
1048 m_linesTail->SetNext(pLine);
1049 pLine->SetPrev(m_linesTail);
1050 }
1051
1052 m_linesTail = pLine;
1053 return m_linesTail;
1054 }
1055
1056 // insert a new line after the given one or in the very beginning if !pLine
1057 wxFileConfigLineList *wxFileConfig::LineListInsert(const wxString& str,
1058 wxFileConfigLineList *pLine)
1059 {
1060 if ( pLine == m_linesTail )
1061 return LineListAppend(str);
1062
1063 wxFileConfigLineList *pNewLine = new wxFileConfigLineList(str);
1064 if ( pLine == NULL ) {
1065 // prepend to the list
1066 pNewLine->SetNext(m_linesHead);
1067 m_linesHead->SetPrev(pNewLine);
1068 m_linesHead = pNewLine;
1069 }
1070 else {
1071 // insert before pLine
1072 wxFileConfigLineList *pNext = pLine->Next();
1073 pNewLine->SetNext(pNext);
1074 pNewLine->SetPrev(pLine);
1075 pNext->SetPrev(pNewLine);
1076 pLine->SetNext(pNewLine);
1077 }
1078
1079 return pNewLine;
1080 }
1081
1082 void wxFileConfig::LineListRemove(wxFileConfigLineList *pLine)
1083 {
1084 wxFileConfigLineList *pPrev = pLine->Prev(),
1085 *pNext = pLine->Next();
1086
1087 // first entry?
1088 if ( pPrev == NULL )
1089 m_linesHead = pNext;
1090 else
1091 pPrev->SetNext(pNext);
1092
1093 // last entry?
1094 if ( pNext == NULL )
1095 m_linesTail = pPrev;
1096 else
1097 pNext->SetPrev(pPrev);
1098
1099 delete pLine;
1100 }
1101
1102 bool wxFileConfig::LineListIsEmpty()
1103 {
1104 return m_linesHead == NULL;
1105 }
1106
1107 // ============================================================================
1108 // wxFileConfig::wxFileConfigGroup
1109 // ============================================================================
1110
1111 // ----------------------------------------------------------------------------
1112 // ctor/dtor
1113 // ----------------------------------------------------------------------------
1114
1115 // ctor
1116 wxFileConfigGroup::wxFileConfigGroup(wxFileConfigGroup *pParent,
1117 const wxString& strName,
1118 wxFileConfig *pConfig)
1119 : m_aEntries(CompareEntries),
1120 m_aSubgroups(CompareGroups),
1121 m_strName(strName)
1122 {
1123 m_pConfig = pConfig;
1124 m_pParent = pParent;
1125 m_bDirty = FALSE;
1126 m_pLine = NULL;
1127
1128 m_pLastEntry = NULL;
1129 m_pLastGroup = NULL;
1130 }
1131
1132 // dtor deletes all children
1133 wxFileConfigGroup::~wxFileConfigGroup()
1134 {
1135 // entries
1136 size_t n, nCount = m_aEntries.Count();
1137 for ( n = 0; n < nCount; n++ )
1138 delete m_aEntries[n];
1139
1140 // subgroups
1141 nCount = m_aSubgroups.Count();
1142 for ( n = 0; n < nCount; n++ )
1143 delete m_aSubgroups[n];
1144 }
1145
1146 // ----------------------------------------------------------------------------
1147 // line
1148 // ----------------------------------------------------------------------------
1149
1150 void wxFileConfigGroup::SetLine(wxFileConfigLineList *pLine)
1151 {
1152 wxASSERT( m_pLine == NULL ); // shouldn't be called twice
1153
1154 m_pLine = pLine;
1155 }
1156
1157 /*
1158 This is a bit complicated, so let me explain it in details. All lines that
1159 were read from the local file (the only one we will ever modify) are stored
1160 in a (doubly) linked list. Our problem is to know at which position in this
1161 list should we insert the new entries/subgroups. To solve it we keep three
1162 variables for each group: m_pLine, m_pLastEntry and m_pLastGroup.
1163
1164 m_pLine points to the line containing "[group_name]"
1165 m_pLastEntry points to the last entry of this group in the local file.
1166 m_pLastGroup subgroup
1167
1168 Initially, they're NULL all three. When the group (an entry/subgroup) is read
1169 from the local file, the corresponding variable is set. However, if the group
1170 was read from the global file and then modified or created by the application
1171 these variables are still NULL and we need to create the corresponding lines.
1172 See the following functions (and comments preceding them) for the details of
1173 how we do it.
1174
1175 Also, when our last entry/group are deleted we need to find the new last
1176 element - the code in DeleteEntry/Subgroup does this by backtracking the list
1177 of lines until it either founds an entry/subgroup (and this is the new last
1178 element) or the m_pLine of the group, in which case there are no more entries
1179 (or subgroups) left and m_pLast<element> becomes NULL.
1180
1181 NB: This last problem could be avoided for entries if we added new entries
1182 immediately after m_pLine, but in this case the entries would appear
1183 backwards in the config file (OTOH, it's not that important) and as we
1184 would still need to do it for the subgroups the code wouldn't have been
1185 significantly less complicated.
1186 */
1187
1188 // Return the line which contains "[our name]". If we're still not in the list,
1189 // add our line to it immediately after the last line of our parent group if we
1190 // have it or in the very beginning if we're the root group.
1191 wxFileConfigLineList *wxFileConfigGroup::GetGroupLine()
1192 {
1193 if ( m_pLine == NULL ) {
1194 wxFileConfigGroup *pParent = Parent();
1195
1196 // this group wasn't present in local config file, add it now
1197 if ( pParent != NULL ) {
1198 wxString strFullName;
1199 strFullName << wxT("[")
1200 // +1: no '/'
1201 << FilterOutEntryName(GetFullName().c_str() + 1)
1202 << wxT("]");
1203 m_pLine = m_pConfig->LineListInsert(strFullName,
1204 pParent->GetLastGroupLine());
1205 pParent->SetLastGroup(this); // we're surely after all the others
1206 }
1207 else {
1208 // we return NULL, so that LineListInsert() will insert us in the
1209 // very beginning
1210 }
1211 }
1212
1213 return m_pLine;
1214 }
1215
1216 // Return the last line belonging to the subgroups of this group (after which
1217 // we can add a new subgroup), if we don't have any subgroups or entries our
1218 // last line is the group line (m_pLine) itself.
1219 wxFileConfigLineList *wxFileConfigGroup::GetLastGroupLine()
1220 {
1221 // if we have any subgroups, our last line is the last line of the last
1222 // subgroup
1223 if ( m_pLastGroup != NULL ) {
1224 wxFileConfigLineList *pLine = m_pLastGroup->GetLastGroupLine();
1225
1226 wxASSERT( pLine != NULL ); // last group must have !NULL associated line
1227 return pLine;
1228 }
1229
1230 // no subgroups, so the last line is the line of thelast entry (if any)
1231 return GetLastEntryLine();
1232 }
1233
1234 // return the last line belonging to the entries of this group (after which
1235 // we can add a new entry), if we don't have any entries we will add the new
1236 // one immediately after the group line itself.
1237 wxFileConfigLineList *wxFileConfigGroup::GetLastEntryLine()
1238 {
1239 if ( m_pLastEntry != NULL ) {
1240 wxFileConfigLineList *pLine = m_pLastEntry->GetLine();
1241
1242 wxASSERT( pLine != NULL ); // last entry must have !NULL associated line
1243 return pLine;
1244 }
1245
1246 // no entries: insert after the group header
1247 return GetGroupLine();
1248 }
1249
1250 // ----------------------------------------------------------------------------
1251 // group name
1252 // ----------------------------------------------------------------------------
1253
1254 void wxFileConfigGroup::Rename(const wxString& newName)
1255 {
1256 m_strName = newName;
1257
1258 wxFileConfigLineList *line = GetGroupLine();
1259 wxString strFullName;
1260 strFullName << wxT("[") << (GetFullName().c_str() + 1) << wxT("]"); // +1: no '/'
1261 line->SetText(strFullName);
1262
1263 SetDirty();
1264 }
1265
1266 wxString wxFileConfigGroup::GetFullName() const
1267 {
1268 if ( Parent() )
1269 return Parent()->GetFullName() + wxCONFIG_PATH_SEPARATOR + Name();
1270 else
1271 return wxT("");
1272 }
1273
1274 // ----------------------------------------------------------------------------
1275 // find an item
1276 // ----------------------------------------------------------------------------
1277
1278 // use binary search because the array is sorted
1279 wxFileConfigEntry *
1280 wxFileConfigGroup::FindEntry(const wxChar *szName) const
1281 {
1282 size_t i,
1283 lo = 0,
1284 hi = m_aEntries.Count();
1285 int res;
1286 wxFileConfigEntry *pEntry;
1287
1288 while ( lo < hi ) {
1289 i = (lo + hi)/2;
1290 pEntry = m_aEntries[i];
1291
1292 #if wxCONFIG_CASE_SENSITIVE
1293 res = wxStrcmp(pEntry->Name(), szName);
1294 #else
1295 res = wxStricmp(pEntry->Name(), szName);
1296 #endif
1297
1298 if ( res > 0 )
1299 hi = i;
1300 else if ( res < 0 )
1301 lo = i + 1;
1302 else
1303 return pEntry;
1304 }
1305
1306 return NULL;
1307 }
1308
1309 wxFileConfigGroup *
1310 wxFileConfigGroup::FindSubgroup(const wxChar *szName) const
1311 {
1312 size_t i,
1313 lo = 0,
1314 hi = m_aSubgroups.Count();
1315 int res;
1316 wxFileConfigGroup *pGroup;
1317
1318 while ( lo < hi ) {
1319 i = (lo + hi)/2;
1320 pGroup = m_aSubgroups[i];
1321
1322 #if wxCONFIG_CASE_SENSITIVE
1323 res = wxStrcmp(pGroup->Name(), szName);
1324 #else
1325 res = wxStricmp(pGroup->Name(), szName);
1326 #endif
1327
1328 if ( res > 0 )
1329 hi = i;
1330 else if ( res < 0 )
1331 lo = i + 1;
1332 else
1333 return pGroup;
1334 }
1335
1336 return NULL;
1337 }
1338
1339 // ----------------------------------------------------------------------------
1340 // create a new item
1341 // ----------------------------------------------------------------------------
1342
1343 // create a new entry and add it to the current group
1344 wxFileConfigEntry *
1345 wxFileConfigGroup::AddEntry(const wxString& strName, int nLine)
1346 {
1347 wxASSERT( FindEntry(strName) == NULL );
1348
1349 wxFileConfigEntry *pEntry = new wxFileConfigEntry(this, strName, nLine);
1350 m_aEntries.Add(pEntry);
1351
1352 return pEntry;
1353 }
1354
1355 // create a new group and add it to the current group
1356 wxFileConfigGroup *
1357 wxFileConfigGroup::AddSubgroup(const wxString& strName)
1358 {
1359 wxASSERT( FindSubgroup(strName) == NULL );
1360
1361 wxFileConfigGroup *pGroup = new wxFileConfigGroup(this, strName, m_pConfig);
1362 m_aSubgroups.Add(pGroup);
1363
1364 return pGroup;
1365 }
1366
1367 // ----------------------------------------------------------------------------
1368 // delete an item
1369 // ----------------------------------------------------------------------------
1370
1371 /*
1372 The delete operations are _very_ slow if we delete the last item of this
1373 group (see comments before GetXXXLineXXX functions for more details),
1374 so it's much better to start with the first entry/group if we want to
1375 delete several of them.
1376 */
1377
1378 bool wxFileConfigGroup::DeleteSubgroupByName(const wxChar *szName)
1379 {
1380 return DeleteSubgroup(FindSubgroup(szName));
1381 }
1382
1383 // doesn't delete the subgroup itself, but does remove references to it from
1384 // all other data structures (and normally the returned pointer should be
1385 // deleted a.s.a.p. because there is nothing much to be done with it anyhow)
1386 bool wxFileConfigGroup::DeleteSubgroup(wxFileConfigGroup *pGroup)
1387 {
1388 wxCHECK( pGroup != NULL, FALSE ); // deleting non existing group?
1389
1390 // delete all entries
1391 size_t nCount = pGroup->m_aEntries.Count();
1392 for ( size_t nEntry = 0; nEntry < nCount; nEntry++ ) {
1393 wxFileConfigLineList *pLine = pGroup->m_aEntries[nEntry]->GetLine();
1394 if ( pLine != NULL )
1395 m_pConfig->LineListRemove(pLine);
1396 }
1397
1398 // and subgroups of this sungroup
1399 nCount = pGroup->m_aSubgroups.Count();
1400 for ( size_t nGroup = 0; nGroup < nCount; nGroup++ ) {
1401 pGroup->DeleteSubgroup(pGroup->m_aSubgroups[0]);
1402 }
1403
1404 wxFileConfigLineList *pLine = pGroup->m_pLine;
1405 if ( pLine != NULL ) {
1406 // notice that we may do this test inside the previous "if" because the
1407 // last entry's line is surely !NULL
1408 if ( pGroup == m_pLastGroup ) {
1409 // our last entry is being deleted - find the last one which stays
1410 wxASSERT( m_pLine != NULL ); // we have a subgroup with !NULL pLine...
1411
1412 // go back until we find a subgroup or reach the group's line
1413 wxFileConfigGroup *pNewLast = NULL;
1414 size_t n, nSubgroups = m_aSubgroups.Count();
1415 wxFileConfigLineList *pl;
1416 for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) {
1417 // is it our subgroup?
1418 for ( n = 0; (pNewLast == NULL) && (n < nSubgroups); n++ ) {
1419 // do _not_ call GetGroupLine! we don't want to add it to the local
1420 // file if it's not already there
1421 if ( m_aSubgroups[n]->m_pLine == m_pLine )
1422 pNewLast = m_aSubgroups[n];
1423 }
1424
1425 if ( pNewLast != NULL ) // found?
1426 break;
1427 }
1428
1429 if ( pl == m_pLine ) {
1430 wxASSERT( !pNewLast ); // how comes it has the same line as we?
1431
1432 // we've reached the group line without finding any subgroups
1433 m_pLastGroup = NULL;
1434 }
1435 else
1436 m_pLastGroup = pNewLast;
1437 }
1438
1439 m_pConfig->LineListRemove(pLine);
1440 }
1441
1442 SetDirty();
1443
1444 m_aSubgroups.Remove(pGroup);
1445 delete pGroup;
1446
1447 return TRUE;
1448 }
1449
1450 bool wxFileConfigGroup::DeleteEntry(const wxChar *szName)
1451 {
1452 wxFileConfigEntry *pEntry = FindEntry(szName);
1453 wxCHECK( pEntry != NULL, FALSE ); // deleting non existing item?
1454
1455 wxFileConfigLineList *pLine = pEntry->GetLine();
1456 if ( pLine != NULL ) {
1457 // notice that we may do this test inside the previous "if" because the
1458 // last entry's line is surely !NULL
1459 if ( pEntry == m_pLastEntry ) {
1460 // our last entry is being deleted - find the last one which stays
1461 wxASSERT( m_pLine != NULL ); // if we have an entry with !NULL pLine...
1462
1463 // go back until we find another entry or reach the group's line
1464 wxFileConfigEntry *pNewLast = NULL;
1465 size_t n, nEntries = m_aEntries.Count();
1466 wxFileConfigLineList *pl;
1467 for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) {
1468 // is it our subgroup?
1469 for ( n = 0; (pNewLast == NULL) && (n < nEntries); n++ ) {
1470 if ( m_aEntries[n]->GetLine() == m_pLine )
1471 pNewLast = m_aEntries[n];
1472 }
1473
1474 if ( pNewLast != NULL ) // found?
1475 break;
1476 }
1477
1478 if ( pl == m_pLine ) {
1479 wxASSERT( !pNewLast ); // how comes it has the same line as we?
1480
1481 // we've reached the group line without finding any subgroups
1482 m_pLastEntry = NULL;
1483 }
1484 else
1485 m_pLastEntry = pNewLast;
1486 }
1487
1488 m_pConfig->LineListRemove(pLine);
1489 }
1490
1491 // we must be written back for the changes to be saved
1492 SetDirty();
1493
1494 m_aEntries.Remove(pEntry);
1495 delete pEntry;
1496
1497 return TRUE;
1498 }
1499
1500 // ----------------------------------------------------------------------------
1501 //
1502 // ----------------------------------------------------------------------------
1503 void wxFileConfigGroup::SetDirty()
1504 {
1505 m_bDirty = TRUE;
1506 if ( Parent() != NULL ) // propagate upwards
1507 Parent()->SetDirty();
1508 }
1509
1510 // ============================================================================
1511 // wxFileConfig::wxFileConfigEntry
1512 // ============================================================================
1513
1514 // ----------------------------------------------------------------------------
1515 // ctor
1516 // ----------------------------------------------------------------------------
1517 wxFileConfigEntry::wxFileConfigEntry(wxFileConfigGroup *pParent,
1518 const wxString& strName,
1519 int nLine)
1520 : m_strName(strName)
1521 {
1522 wxASSERT( !strName.IsEmpty() );
1523
1524 m_pParent = pParent;
1525 m_nLine = nLine;
1526 m_pLine = NULL;
1527
1528 m_bDirty =
1529 m_bHasValue = FALSE;
1530
1531 m_bImmutable = strName[0] == wxCONFIG_IMMUTABLE_PREFIX;
1532 if ( m_bImmutable )
1533 m_strName.erase(0, 1); // remove first character
1534 }
1535
1536 // ----------------------------------------------------------------------------
1537 // set value
1538 // ----------------------------------------------------------------------------
1539
1540 void wxFileConfigEntry::SetLine(wxFileConfigLineList *pLine)
1541 {
1542 if ( m_pLine != NULL ) {
1543 wxLogWarning(_("entry '%s' appears more than once in group '%s'"),
1544 Name().c_str(), m_pParent->GetFullName().c_str());
1545 }
1546
1547 m_pLine = pLine;
1548 Group()->SetLastEntry(this);
1549 }
1550
1551 // second parameter is FALSE if we read the value from file and prevents the
1552 // entry from being marked as 'dirty'
1553 void wxFileConfigEntry::SetValue(const wxString& strValue, bool bUser)
1554 {
1555 if ( bUser && IsImmutable() ) {
1556 wxLogWarning(_("attempt to change immutable key '%s' ignored."),
1557 Name().c_str());
1558 return;
1559 }
1560
1561 // do nothing if it's the same value: but don't test for it if m_bHasValue
1562 // hadn't been set yet or we'd never write empty values to the file
1563 if ( m_bHasValue && strValue == m_strValue )
1564 return;
1565
1566 m_bHasValue = TRUE;
1567 m_strValue = strValue;
1568
1569 if ( bUser ) {
1570 wxString strVal = FilterOutValue(strValue);
1571 wxString strLine;
1572 strLine << FilterOutEntryName(m_strName) << wxT('=') << strVal;
1573
1574 if ( m_pLine != NULL ) {
1575 // entry was read from the local config file, just modify the line
1576 m_pLine->SetText(strLine);
1577 }
1578 else {
1579 // add a new line to the file
1580 wxASSERT( m_nLine == wxNOT_FOUND ); // consistency check
1581
1582 m_pLine = Group()->Config()->LineListInsert(strLine,
1583 Group()->GetLastEntryLine());
1584 Group()->SetLastEntry(this);
1585 }
1586
1587 SetDirty();
1588 }
1589 }
1590
1591 void wxFileConfigEntry::SetDirty()
1592 {
1593 m_bDirty = TRUE;
1594 Group()->SetDirty();
1595 }
1596
1597 // ============================================================================
1598 // global functions
1599 // ============================================================================
1600
1601 // ----------------------------------------------------------------------------
1602 // compare functions for array sorting
1603 // ----------------------------------------------------------------------------
1604
1605 int CompareEntries(wxFileConfigEntry *p1, wxFileConfigEntry *p2)
1606 {
1607 #if wxCONFIG_CASE_SENSITIVE
1608 return wxStrcmp(p1->Name(), p2->Name());
1609 #else
1610 return wxStricmp(p1->Name(), p2->Name());
1611 #endif
1612 }
1613
1614 int CompareGroups(wxFileConfigGroup *p1, wxFileConfigGroup *p2)
1615 {
1616 #if wxCONFIG_CASE_SENSITIVE
1617 return wxStrcmp(p1->Name(), p2->Name());
1618 #else
1619 return wxStricmp(p1->Name(), p2->Name());
1620 #endif
1621 }
1622
1623 // ----------------------------------------------------------------------------
1624 // filter functions
1625 // ----------------------------------------------------------------------------
1626
1627 // undo FilterOutValue
1628 static wxString FilterInValue(const wxString& str)
1629 {
1630 wxString strResult;
1631 strResult.Alloc(str.Len());
1632
1633 bool bQuoted = !str.IsEmpty() && str[0] == '"';
1634
1635 for ( size_t n = bQuoted ? 1 : 0; n < str.Len(); n++ ) {
1636 if ( str[n] == wxT('\\') ) {
1637 switch ( str[++n] ) {
1638 case wxT('n'):
1639 strResult += wxT('\n');
1640 break;
1641
1642 case wxT('r'):
1643 strResult += wxT('\r');
1644 break;
1645
1646 case wxT('t'):
1647 strResult += wxT('\t');
1648 break;
1649
1650 case wxT('\\'):
1651 strResult += wxT('\\');
1652 break;
1653
1654 case wxT('"'):
1655 strResult += wxT('"');
1656 break;
1657 }
1658 }
1659 else {
1660 if ( str[n] != wxT('"') || !bQuoted )
1661 strResult += str[n];
1662 else if ( n != str.Len() - 1 ) {
1663 wxLogWarning(_("unexpected \" at position %d in '%s'."),
1664 n, str.c_str());
1665 }
1666 //else: it's the last quote of a quoted string, ok
1667 }
1668 }
1669
1670 return strResult;
1671 }
1672
1673 // quote the string before writing it to file
1674 static wxString FilterOutValue(const wxString& str)
1675 {
1676 if ( !str )
1677 return str;
1678
1679 wxString strResult;
1680 strResult.Alloc(str.Len());
1681
1682 // quoting is necessary to preserve spaces in the beginning of the string
1683 bool bQuote = wxIsspace(str[0]) || str[0] == wxT('"');
1684
1685 if ( bQuote )
1686 strResult += wxT('"');
1687
1688 wxChar c;
1689 for ( size_t n = 0; n < str.Len(); n++ ) {
1690 switch ( str[n] ) {
1691 case wxT('\n'):
1692 c = wxT('n');
1693 break;
1694
1695 case wxT('\r'):
1696 c = wxT('r');
1697 break;
1698
1699 case wxT('\t'):
1700 c = wxT('t');
1701 break;
1702
1703 case wxT('\\'):
1704 c = wxT('\\');
1705 break;
1706
1707 case wxT('"'):
1708 if ( bQuote ) {
1709 c = wxT('"');
1710 break;
1711 }
1712 //else: fall through
1713
1714 default:
1715 strResult += str[n];
1716 continue; // nothing special to do
1717 }
1718
1719 // we get here only for special characters
1720 strResult << wxT('\\') << c;
1721 }
1722
1723 if ( bQuote )
1724 strResult += wxT('"');
1725
1726 return strResult;
1727 }
1728
1729 // undo FilterOutEntryName
1730 static wxString FilterInEntryName(const wxString& str)
1731 {
1732 wxString strResult;
1733 strResult.Alloc(str.Len());
1734
1735 for ( const wxChar *pc = str.c_str(); *pc != '\0'; pc++ ) {
1736 if ( *pc == wxT('\\') )
1737 pc++;
1738
1739 strResult += *pc;
1740 }
1741
1742 return strResult;
1743 }
1744
1745 // sanitize entry or group name: insert '\\' before any special characters
1746 static wxString FilterOutEntryName(const wxString& str)
1747 {
1748 wxString strResult;
1749 strResult.Alloc(str.Len());
1750
1751 for ( const wxChar *pc = str.c_str(); *pc != wxT('\0'); pc++ ) {
1752 wxChar c = *pc;
1753
1754 // we explicitly allow some of "safe" chars and 8bit ASCII characters
1755 // which will probably never have special meaning
1756 // NB: note that wxCONFIG_IMMUTABLE_PREFIX and wxCONFIG_PATH_SEPARATOR
1757 // should *not* be quoted
1758 if ( !wxIsalnum(c) && !wxStrchr(wxT("@_/-!.*%"), c) && ((c & 0x80) == 0) )
1759 strResult += wxT('\\');
1760
1761 strResult += c;
1762 }
1763
1764 return strResult;
1765 }
1766
1767 // we can't put ?: in the ctor initializer list because it confuses some
1768 // broken compilers (Borland C++)
1769 static wxString GetAppName(const wxString& appName)
1770 {
1771 if ( !appName && wxTheApp )
1772 return wxTheApp->GetAppName();
1773 else
1774 return appName;
1775 }
1776
1777 #endif // wxUSE_CONFIG
1778
wxWidgets (Impactor)