]> 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
corrected WXDLLIMPEXP_ declaration for wxEventBlocker: it's part of core, not base
[wxWidgets.git] / src / common / fileconf.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/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 licence
11 ///////////////////////////////////////////////////////////////////////////////
12
13 // ----------------------------------------------------------------------------
14 // headers
15 // ----------------------------------------------------------------------------
16
17 // For compilers that support precompilation, includes "wx.h".
18 #include "wx/wxprec.h"
19
20 #ifdef __BORLANDC__
21 #pragma hdrstop
22 #endif //__BORLANDC__
23
24 #if wxUSE_CONFIG && wxUSE_FILECONFIG
25
26 #ifndef WX_PRECOMP
27 #include "wx/dynarray.h"
28 #include "wx/string.h"
29 #include "wx/intl.h"
30 #include "wx/log.h"
31 #include "wx/app.h"
32 #include "wx/utils.h" // for wxGetHomeDir
33 #if wxUSE_STREAMS
34 #include "wx/stream.h"
35 #endif // wxUSE_STREAMS
36 #endif //WX_PRECOMP
37
38 #include "wx/file.h"
39 #include "wx/textfile.h"
40 #include "wx/memtext.h"
41 #include "wx/config.h"
42 #include "wx/fileconf.h"
43 #include "wx/filefn.h"
44
45 #if defined(__WXMAC__)
46 #include "wx/mac/private.h" // includes mac headers
47 #include "wx/filename.h" // for MacSetTypeAndCreator
48 #endif
49
50 #if defined(__WXMSW__)
51 #include "wx/msw/private.h"
52 #endif //windows.h
53 #if defined(__WXPM__)
54 #define INCL_DOS
55 #include <os2.h>
56 #endif
57
58 #include <stdlib.h>
59 #include <ctype.h>
60
61 // ----------------------------------------------------------------------------
62 // macros
63 // ----------------------------------------------------------------------------
64 #define CONST_CAST ((wxFileConfig *)this)->
65
66 // ----------------------------------------------------------------------------
67 // constants
68 // ----------------------------------------------------------------------------
69
70 #ifndef MAX_PATH
71 #define MAX_PATH 512
72 #endif
73
74 #define FILECONF_TRACE_MASK _T("fileconf")
75
76 // ----------------------------------------------------------------------------
77 // global functions declarations
78 // ----------------------------------------------------------------------------
79
80 // compare functions for sorting the arrays
81 static int LINKAGEMODE CompareEntries(wxFileConfigEntry *p1, wxFileConfigEntry *p2);
82 static int LINKAGEMODE CompareGroups(wxFileConfigGroup *p1, wxFileConfigGroup *p2);
83
84 // filter strings
85 static wxString FilterInValue(const wxString& str);
86 static wxString FilterOutValue(const wxString& str);
87
88 static wxString FilterInEntryName(const wxString& str);
89 static wxString FilterOutEntryName(const wxString& str);
90
91 // get the name to use in wxFileConfig ctor
92 static wxString GetAppName(const wxString& appname);
93
94 // ============================================================================
95 // private classes
96 // ============================================================================
97
98 // ----------------------------------------------------------------------------
99 // "template" array types
100 // ----------------------------------------------------------------------------
101
102 #ifdef WXMAKINGDLL_BASE
103 WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(wxFileConfigEntry *, ArrayEntries,
104 WXDLLIMPEXP_BASE);
105 WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(wxFileConfigGroup *, ArrayGroups,
106 WXDLLIMPEXP_BASE);
107 #else
108 WX_DEFINE_SORTED_ARRAY(wxFileConfigEntry *, ArrayEntries);
109 WX_DEFINE_SORTED_ARRAY(wxFileConfigGroup *, ArrayGroups);
110 #endif
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 DECLARE_NO_COPY_CLASS(wxFileConfigLineList)
142 };
143
144 // ----------------------------------------------------------------------------
145 // wxFileConfigEntry: a name/value pair
146 // ----------------------------------------------------------------------------
147
148 class wxFileConfigEntry
149 {
150 private:
151 wxFileConfigGroup *m_pParent; // group that contains us
152
153 wxString m_strName, // entry name
154 m_strValue; // value
155 bool m_bImmutable:1, // can be overriden locally?
156 m_bHasValue:1; // set after first call to SetValue()
157
158 int m_nLine; // used if m_pLine == NULL only
159
160 // pointer to our line in the linked list or NULL if it was found in global
161 // file (which we don't modify)
162 wxFileConfigLineList *m_pLine;
163
164 public:
165 wxFileConfigEntry(wxFileConfigGroup *pParent,
166 const wxString& strName, int nLine);
167
168 // simple accessors
169 const wxString& Name() const { return m_strName; }
170 const wxString& Value() const { return m_strValue; }
171 wxFileConfigGroup *Group() const { return m_pParent; }
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 SetLine(wxFileConfigLineList *pLine);
181
182 DECLARE_NO_COPY_CLASS(wxFileConfigEntry)
183 };
184
185 // ----------------------------------------------------------------------------
186 // wxFileConfigGroup: container of entries and other groups
187 // ----------------------------------------------------------------------------
188
189 class wxFileConfigGroup
190 {
191 private:
192 wxFileConfig *m_pConfig; // config object we belong to
193 wxFileConfigGroup *m_pParent; // parent group (NULL for root group)
194 ArrayEntries m_aEntries; // entries in this group
195 ArrayGroups m_aSubgroups; // subgroups
196 wxString m_strName; // group's name
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 // used by Rename()
205 void UpdateGroupAndSubgroupsLines();
206
207 public:
208 // ctor
209 wxFileConfigGroup(wxFileConfigGroup *pParent, const wxString& strName, wxFileConfig *);
210
211 // dtor deletes all entries and subgroups also
212 ~wxFileConfigGroup();
213
214 // simple accessors
215 const wxString& Name() const { return m_strName; }
216 wxFileConfigGroup *Parent() const { return m_pParent; }
217 wxFileConfig *Config() const { return m_pConfig; }
218
219 const ArrayEntries& Entries() const { return m_aEntries; }
220 const ArrayGroups& Groups() const { return m_aSubgroups; }
221 bool IsEmpty() const { return Entries().IsEmpty() && Groups().IsEmpty(); }
222
223 // find entry/subgroup (NULL if not found)
224 wxFileConfigGroup *FindSubgroup(const wxChar *szName) const;
225 wxFileConfigEntry *FindEntry (const wxChar *szName) const;
226
227 // delete entry/subgroup, return false if doesn't exist
228 bool DeleteSubgroupByName(const wxChar *szName);
229 bool DeleteEntry(const wxChar *szName);
230
231 // create new entry/subgroup returning pointer to newly created element
232 wxFileConfigGroup *AddSubgroup(const wxString& strName);
233 wxFileConfigEntry *AddEntry (const wxString& strName, int nLine = wxNOT_FOUND);
234
235 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);
250 void SetLastGroup(wxFileConfigGroup *pGroup)
251 { m_pLastGroup = pGroup; }
252
253 DECLARE_NO_COPY_CLASS(wxFileConfigGroup)
254 };
255
256 // ============================================================================
257 // implementation
258 // ============================================================================
259
260 // ----------------------------------------------------------------------------
261 // static functions
262 // ----------------------------------------------------------------------------
263 wxString wxFileConfig::GetGlobalDir()
264 {
265 wxString strDir;
266
267 #ifdef __VMS__ // Note if __VMS is defined __UNIX is also defined
268 strDir = wxT("sys$manager:");
269 #elif defined(__WXMAC__)
270 strDir = wxMacFindFolder( (short) kOnSystemDisk, kPreferencesFolderType, kDontCreateFolder ) ;
271 #elif defined( __UNIX__ )
272 strDir = wxT("/etc/");
273 #elif defined(__OS2__)
274 ULONG aulSysInfo[QSV_MAX] = {0};
275 UINT drive;
276 APIRET rc;
277
278 rc = DosQuerySysInfo( 1L, QSV_MAX, (PVOID)aulSysInfo, sizeof(ULONG)*QSV_MAX);
279 if (rc == 0)
280 {
281 drive = aulSysInfo[QSV_BOOT_DRIVE - 1];
282 strDir.Printf(wxT("%c:\\OS2\\"), 'A'+drive-1);
283 }
284 #elif defined(__WXSTUBS__)
285 wxFAIL_MSG( wxT("TODO") );
286 #elif defined(__DOS__)
287 // There's no such thing as global cfg dir in MS-DOS, let's return
288 // current directory (FIXME_MGL?)
289 strDir = wxT(".\\");
290 #elif defined(__WXWINCE__)
291 strDir = wxT("\\Windows\\");
292 #else // Windows
293
294 wxChar szWinDir[MAX_PATH];
295 ::GetWindowsDirectory(szWinDir, MAX_PATH);
296
297 strDir = szWinDir;
298 strDir << wxT('\\');
299 #endif // Unix/Windows
300
301 return strDir;
302 }
303
304 wxString wxFileConfig::GetLocalDir()
305 {
306 wxString strDir;
307
308 #if defined(__WXMAC__) || defined(__DOS__)
309 // no local dir concept on Mac OS 9 or MS-DOS
310 strDir << GetGlobalDir() ;
311 #else
312 wxGetHomeDir(&strDir);
313
314 #ifdef __UNIX__
315 if (
316 (strDir.Last() != wxT('/'))
317 #ifdef __VMS
318 && (strDir.Last() != wxT(']'))
319 #endif
320 )
321 strDir << wxT('/');
322 #else
323 if (strDir.Last() != wxT('\\'))
324 strDir << wxT('\\');
325 #endif
326 #endif
327
328 return strDir;
329 }
330
331 wxString wxFileConfig::GetGlobalFileName(const wxChar *szFile)
332 {
333 wxString str = GetGlobalDir();
334 str << szFile;
335
336 if ( wxStrchr(szFile, wxT('.')) == NULL )
337 #if defined( __WXMAC__ )
338 str << wxT(" Preferences") ;
339 #elif defined( __UNIX__ )
340 str << wxT(".conf");
341 #else // Windows
342 str << wxT(".ini");
343 #endif // UNIX/Win
344
345 return str;
346 }
347
348 wxString wxFileConfig::GetLocalFileName(const wxChar *szFile)
349 {
350 #ifdef __VMS__
351 // On VMS I saw the problem that the home directory was appended
352 // twice for the configuration file. Does that also happen for
353 // other platforms?
354 wxString str = wxT( '.' );
355 #else
356 wxString str = GetLocalDir();
357 #endif
358
359 #if defined( __UNIX__ ) && !defined( __VMS ) && !defined( __WXMAC__ )
360 str << wxT('.');
361 #endif
362
363 str << szFile;
364
365 #if defined(__WINDOWS__) || defined(__DOS__)
366 if ( wxStrchr(szFile, wxT('.')) == NULL )
367 str << wxT(".ini");
368 #endif
369
370 #ifdef __WXMAC__
371 str << wxT(" Preferences") ;
372 #endif
373
374 return str;
375 }
376
377 // ----------------------------------------------------------------------------
378 // ctor
379 // ----------------------------------------------------------------------------
380
381 void wxFileConfig::Init()
382 {
383 m_pCurrentGroup =
384 m_pRootGroup = new wxFileConfigGroup(NULL, wxEmptyString, this);
385
386 m_linesHead =
387 m_linesTail = NULL;
388
389 // It's not an error if (one of the) file(s) doesn't exist.
390
391 // parse the global file
392 if ( !m_strGlobalFile.empty() && wxFile::Exists(m_strGlobalFile) )
393 {
394 wxTextFile fileGlobal(m_strGlobalFile);
395
396 if ( fileGlobal.Open(*m_conv/*ignored in ANSI build*/) )
397 {
398 Parse(fileGlobal, false /* global */);
399 SetRootPath();
400 }
401 else
402 {
403 wxLogWarning(_("can't open global configuration file '%s'."), m_strGlobalFile.c_str());
404 }
405 }
406
407 // parse the local file
408 if ( !m_strLocalFile.empty() && wxFile::Exists(m_strLocalFile) )
409 {
410 wxTextFile fileLocal(m_strLocalFile);
411 if ( fileLocal.Open(*m_conv/*ignored in ANSI build*/) )
412 {
413 Parse(fileLocal, true /* local */);
414 SetRootPath();
415 }
416 else
417 {
418 wxLogWarning(_("can't open user configuration file '%s'."), m_strLocalFile.c_str() );
419 }
420 }
421
422 m_isDirty = false;
423 }
424
425 // constructor supports creation of wxFileConfig objects of any type
426 wxFileConfig::wxFileConfig(const wxString& appName, const wxString& vendorName,
427 const wxString& strLocal, const wxString& strGlobal,
428 long style,
429 const wxMBConv& conv)
430 : wxConfigBase(::GetAppName(appName), vendorName,
431 strLocal, strGlobal,
432 style),
433 m_strLocalFile(strLocal), m_strGlobalFile(strGlobal),
434 m_conv(conv.Clone())
435 {
436 // Make up names for files if empty
437 if ( m_strLocalFile.empty() && (style & wxCONFIG_USE_LOCAL_FILE) )
438 {
439 m_strLocalFile = GetLocalFileName(GetAppName());
440 #if defined(__UNIX__) && !defined(__VMS)
441 if ( style & wxCONFIG_USE_SUBDIR )
442 m_strLocalFile << wxFILE_SEP_PATH << GetAppName() << _T(".conf");
443 #endif
444 }
445
446 if ( m_strGlobalFile.empty() && (style & wxCONFIG_USE_GLOBAL_FILE) )
447 m_strGlobalFile = GetGlobalFileName(GetAppName());
448
449 // Check if styles are not supplied, but filenames are, in which case
450 // add the correct styles.
451 if ( !m_strLocalFile.empty() )
452 SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE);
453
454 if ( !m_strGlobalFile.empty() )
455 SetStyle(GetStyle() | wxCONFIG_USE_GLOBAL_FILE);
456
457 // if the path is not absolute, prepend the standard directory to it
458 // UNLESS wxCONFIG_USE_RELATIVE_PATH style is set
459 if ( !(style & wxCONFIG_USE_RELATIVE_PATH) )
460 {
461 if ( !m_strLocalFile.empty() && !wxIsAbsolutePath(m_strLocalFile) )
462 {
463 const wxString strLocalOrig = m_strLocalFile;
464 m_strLocalFile = GetLocalDir();
465 m_strLocalFile << strLocalOrig;
466 }
467
468 if ( !m_strGlobalFile.empty() && !wxIsAbsolutePath(m_strGlobalFile) )
469 {
470 const wxString strGlobalOrig = m_strGlobalFile;
471 m_strGlobalFile = GetGlobalDir();
472 m_strGlobalFile << strGlobalOrig;
473 }
474 }
475
476 SetUmask(-1);
477
478 Init();
479 }
480
481 #if wxUSE_STREAMS
482
483 wxFileConfig::wxFileConfig(wxInputStream &inStream, const wxMBConv& conv)
484 : m_conv(conv.Clone())
485 {
486 // always local_file when this constructor is called (?)
487 SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE);
488
489 m_pCurrentGroup =
490 m_pRootGroup = new wxFileConfigGroup(NULL, wxEmptyString, this);
491
492 m_linesHead =
493 m_linesTail = NULL;
494
495 // translate everything to the current (platform-dependent) line
496 // termination character
497 wxString strTrans;
498 {
499 wxString strTmp;
500
501 char buf[1024];
502 do
503 {
504 inStream.Read(buf, WXSIZEOF(buf)-1); // leave room for the NULL
505
506 const wxStreamError err = inStream.GetLastError();
507
508 if ( err != wxSTREAM_NO_ERROR && err != wxSTREAM_EOF )
509 {
510 wxLogError(_("Error reading config options."));
511 break;
512 }
513
514 // FIXME: this is broken because if we have part of multibyte
515 // character in the buffer (and another part hasn't been
516 // read yet) we're going to lose data because of conversion
517 // errors
518 buf[inStream.LastRead()] = '\0';
519 strTmp += conv.cMB2WX(buf);
520 }
521 while ( !inStream.Eof() );
522
523 strTrans = wxTextBuffer::Translate(strTmp);
524 }
525
526 wxMemoryText memText;
527
528 // Now we can add the text to the memory text. To do this we extract line
529 // by line from the translated string, until we've reached the end.
530 //
531 // VZ: all this is horribly inefficient, we should do the translation on
532 // the fly in one pass saving both memory and time (TODO)
533
534 const wxChar *pEOL = wxTextBuffer::GetEOL(wxTextBuffer::typeDefault);
535 const size_t EOLLen = wxStrlen(pEOL);
536
537 int posLineStart = strTrans.Find(pEOL);
538 while ( posLineStart != -1 )
539 {
540 wxString line(strTrans.Left(posLineStart));
541
542 memText.AddLine(line);
543
544 strTrans = strTrans.Mid(posLineStart + EOLLen);
545
546 posLineStart = strTrans.Find(pEOL);
547 }
548
549 // also add whatever we have left in the translated string.
550 if ( !strTrans.empty() )
551 memText.AddLine(strTrans);
552
553 // Finally we can parse it all.
554 Parse(memText, true /* local */);
555
556 SetRootPath();
557 ResetDirty();
558 }
559
560 #endif // wxUSE_STREAMS
561
562 void wxFileConfig::CleanUp()
563 {
564 delete m_pRootGroup;
565
566 wxFileConfigLineList *pCur = m_linesHead;
567 while ( pCur != NULL ) {
568 wxFileConfigLineList *pNext = pCur->Next();
569 delete pCur;
570 pCur = pNext;
571 }
572 }
573
574 wxFileConfig::~wxFileConfig()
575 {
576 Flush();
577
578 CleanUp();
579
580 delete m_conv;
581 }
582
583 // ----------------------------------------------------------------------------
584 // parse a config file
585 // ----------------------------------------------------------------------------
586
587 void wxFileConfig::Parse(const wxTextBuffer& buffer, bool bLocal)
588 {
589 const wxChar *pStart;
590 const wxChar *pEnd;
591 wxString strLine;
592
593 size_t nLineCount = buffer.GetLineCount();
594
595 for ( size_t n = 0; n < nLineCount; n++ )
596 {
597 strLine = buffer[n];
598
599 // add the line to linked list
600 if ( bLocal )
601 {
602 LineListAppend(strLine);
603
604 // let the root group have its start line as well
605 if ( !n )
606 {
607 m_pCurrentGroup->SetLine(m_linesTail);
608 }
609 }
610
611
612 // skip leading spaces
613 for ( pStart = strLine; wxIsspace(*pStart); pStart++ )
614 ;
615
616 // skip blank/comment lines
617 if ( *pStart == wxT('\0')|| *pStart == wxT(';') || *pStart == wxT('#') )
618 continue;
619
620 if ( *pStart == wxT('[') ) { // a new group
621 pEnd = pStart;
622
623 while ( *++pEnd != wxT(']') ) {
624 if ( *pEnd == wxT('\\') ) {
625 // the next char is escaped, so skip it even if it is ']'
626 pEnd++;
627 }
628
629 if ( *pEnd == wxT('\n') || *pEnd == wxT('\0') ) {
630 // we reached the end of line, break out of the loop
631 break;
632 }
633 }
634
635 if ( *pEnd != wxT(']') ) {
636 wxLogError(_("file '%s': unexpected character %c at line %d."),
637 buffer.GetName(), *pEnd, n + 1);
638 continue; // skip this line
639 }
640
641 // group name here is always considered as abs path
642 wxString strGroup;
643 pStart++;
644 strGroup << wxCONFIG_PATH_SEPARATOR
645 << FilterInEntryName(wxString(pStart, pEnd - pStart));
646
647 // will create it if doesn't yet exist
648 SetPath(strGroup);
649
650 if ( bLocal )
651 {
652 if ( m_pCurrentGroup->Parent() )
653 m_pCurrentGroup->Parent()->SetLastGroup(m_pCurrentGroup);
654 m_pCurrentGroup->SetLine(m_linesTail);
655 }
656
657 // check that there is nothing except comments left on this line
658 bool bCont = true;
659 while ( *++pEnd != wxT('\0') && bCont ) {
660 switch ( *pEnd ) {
661 case wxT('#'):
662 case wxT(';'):
663 bCont = false;
664 break;
665
666 case wxT(' '):
667 case wxT('\t'):
668 // ignore whitespace ('\n' impossible here)
669 break;
670
671 default:
672 wxLogWarning(_("file '%s', line %d: '%s' ignored after group header."),
673 buffer.GetName(), n + 1, pEnd);
674 bCont = false;
675 }
676 }
677 }
678 else { // a key
679 pEnd = pStart;
680 while ( *pEnd && *pEnd != wxT('=') /* && !wxIsspace(*pEnd)*/ ) {
681 if ( *pEnd == wxT('\\') ) {
682 // next character may be space or not - still take it because it's
683 // quoted (unless there is nothing)
684 pEnd++;
685 if ( !*pEnd ) {
686 // the error message will be given below anyhow
687 break;
688 }
689 }
690
691 pEnd++;
692 }
693
694 wxString strKey(FilterInEntryName(wxString(pStart, pEnd).Trim()));
695
696 // skip whitespace
697 while ( wxIsspace(*pEnd) )
698 pEnd++;
699
700 if ( *pEnd++ != wxT('=') ) {
701 wxLogError(_("file '%s', line %d: '=' expected."),
702 buffer.GetName(), n + 1);
703 }
704 else {
705 wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strKey);
706
707 if ( pEntry == NULL ) {
708 // new entry
709 pEntry = m_pCurrentGroup->AddEntry(strKey, n);
710 }
711 else {
712 if ( bLocal && pEntry->IsImmutable() ) {
713 // immutable keys can't be changed by user
714 wxLogWarning(_("file '%s', line %d: value for immutable key '%s' ignored."),
715 buffer.GetName(), n + 1, strKey.c_str());
716 continue;
717 }
718 // the condition below catches the cases (a) and (b) but not (c):
719 // (a) global key found second time in global file
720 // (b) key found second (or more) time in local file
721 // (c) key from global file now found in local one
722 // which is exactly what we want.
723 else if ( !bLocal || pEntry->IsLocal() ) {
724 wxLogWarning(_("file '%s', line %d: key '%s' was first found at line %d."),
725 buffer.GetName(), n + 1, strKey.c_str(), pEntry->Line());
726
727 }
728 }
729
730 if ( bLocal )
731 pEntry->SetLine(m_linesTail);
732
733 // skip whitespace
734 while ( wxIsspace(*pEnd) )
735 pEnd++;
736
737 wxString value = pEnd;
738 if ( !(GetStyle() & wxCONFIG_USE_NO_ESCAPE_CHARACTERS) )
739 value = FilterInValue(value);
740
741 pEntry->SetValue(value, false);
742 }
743 }
744 }
745 }
746
747 // ----------------------------------------------------------------------------
748 // set/retrieve path
749 // ----------------------------------------------------------------------------
750
751 void wxFileConfig::SetRootPath()
752 {
753 m_strPath.Empty();
754 m_pCurrentGroup = m_pRootGroup;
755 }
756
757 bool
758 wxFileConfig::DoSetPath(const wxString& strPath, bool createMissingComponents)
759 {
760 wxArrayString aParts;
761
762 if ( strPath.empty() ) {
763 SetRootPath();
764 return true;
765 }
766
767 if ( strPath[0] == wxCONFIG_PATH_SEPARATOR ) {
768 // absolute path
769 wxSplitPath(aParts, strPath);
770 }
771 else {
772 // relative path, combine with current one
773 wxString strFullPath = m_strPath;
774 strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
775 wxSplitPath(aParts, strFullPath);
776 }
777
778 // change current group
779 size_t n;
780 m_pCurrentGroup = m_pRootGroup;
781 for ( n = 0; n < aParts.Count(); n++ ) {
782 wxFileConfigGroup *pNextGroup = m_pCurrentGroup->FindSubgroup(aParts[n]);
783 if ( pNextGroup == NULL )
784 {
785 if ( !createMissingComponents )
786 return false;
787
788 pNextGroup = m_pCurrentGroup->AddSubgroup(aParts[n]);
789 }
790
791 m_pCurrentGroup = pNextGroup;
792 }
793
794 // recombine path parts in one variable
795 m_strPath.Empty();
796 for ( n = 0; n < aParts.Count(); n++ ) {
797 m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n];
798 }
799
800 return true;
801 }
802
803 void wxFileConfig::SetPath(const wxString& strPath)
804 {
805 DoSetPath(strPath, true /* create missing path components */);
806 }
807
808 // ----------------------------------------------------------------------------
809 // enumeration
810 // ----------------------------------------------------------------------------
811
812 bool wxFileConfig::GetFirstGroup(wxString& str, long& lIndex) const
813 {
814 lIndex = 0;
815 return GetNextGroup(str, lIndex);
816 }
817
818 bool wxFileConfig::GetNextGroup (wxString& str, long& lIndex) const
819 {
820 if ( size_t(lIndex) < m_pCurrentGroup->Groups().Count() ) {
821 str = m_pCurrentGroup->Groups()[(size_t)lIndex++]->Name();
822 return true;
823 }
824 else
825 return false;
826 }
827
828 bool wxFileConfig::GetFirstEntry(wxString& str, long& lIndex) const
829 {
830 lIndex = 0;
831 return GetNextEntry(str, lIndex);
832 }
833
834 bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) const
835 {
836 if ( size_t(lIndex) < m_pCurrentGroup->Entries().Count() ) {
837 str = m_pCurrentGroup->Entries()[(size_t)lIndex++]->Name();
838 return true;
839 }
840 else
841 return false;
842 }
843
844 size_t wxFileConfig::GetNumberOfEntries(bool bRecursive) const
845 {
846 size_t n = m_pCurrentGroup->Entries().Count();
847 if ( bRecursive ) {
848 wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
849 size_t nSubgroups = m_pCurrentGroup->Groups().Count();
850 for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
851 CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
852 n += GetNumberOfEntries(true);
853 CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
854 }
855 }
856
857 return n;
858 }
859
860 size_t wxFileConfig::GetNumberOfGroups(bool bRecursive) const
861 {
862 size_t n = m_pCurrentGroup->Groups().Count();
863 if ( bRecursive ) {
864 wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
865 size_t nSubgroups = m_pCurrentGroup->Groups().Count();
866 for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
867 CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
868 n += GetNumberOfGroups(true);
869 CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
870 }
871 }
872
873 return n;
874 }
875
876 // ----------------------------------------------------------------------------
877 // tests for existence
878 // ----------------------------------------------------------------------------
879
880 bool wxFileConfig::HasGroup(const wxString& strName) const
881 {
882 // special case: DoSetPath("") does work as it's equivalent to DoSetPath("/")
883 // but there is no group with empty name so treat this separately
884 if ( strName.empty() )
885 return false;
886
887 const wxString pathOld = GetPath();
888
889 wxFileConfig *self = wx_const_cast(wxFileConfig *, this);
890 const bool
891 rc = self->DoSetPath(strName, false /* don't create missing components */);
892
893 self->SetPath(pathOld);
894
895 return rc;
896 }
897
898 bool wxFileConfig::HasEntry(const wxString& entry) const
899 {
900 // path is the part before the last "/"
901 wxString path = entry.BeforeLast(wxCONFIG_PATH_SEPARATOR);
902
903 // except in the special case of "/keyname" when there is nothing before "/"
904 if ( path.empty() && *entry.c_str() == wxCONFIG_PATH_SEPARATOR )
905 {
906 path = wxCONFIG_PATH_SEPARATOR;
907 }
908
909 // change to the path of the entry if necessary and remember the old path
910 // to restore it later
911 wxString pathOld;
912 wxFileConfig * const self = wx_const_cast(wxFileConfig *, this);
913 if ( !path.empty() )
914 {
915 pathOld = GetPath();
916 if ( pathOld.empty() )
917 pathOld = wxCONFIG_PATH_SEPARATOR;
918
919 if ( !self->DoSetPath(path, false /* don't create if doesn't exist */) )
920 {
921 return false;
922 }
923 }
924
925 // check if the entry exists in this group
926 const bool exists = m_pCurrentGroup->FindEntry(
927 entry.AfterLast(wxCONFIG_PATH_SEPARATOR)) != NULL;
928
929 // restore the old path if we changed it above
930 if ( !pathOld.empty() )
931 {
932 self->SetPath(pathOld);
933 }
934
935 return exists;
936 }
937
938 // ----------------------------------------------------------------------------
939 // read/write values
940 // ----------------------------------------------------------------------------
941
942 bool wxFileConfig::DoReadString(const wxString& key, wxString* pStr) const
943 {
944 wxConfigPathChanger path(this, key);
945
946 wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
947 if (pEntry == NULL) {
948 return false;
949 }
950
951 *pStr = pEntry->Value();
952
953 return true;
954 }
955
956 bool wxFileConfig::DoReadLong(const wxString& key, long *pl) const
957 {
958 wxString str;
959 if ( !Read(key, &str) )
960 return false;
961
962 // extra spaces shouldn't prevent us from reading numeric values
963 str.Trim();
964
965 return str.ToLong(pl);
966 }
967
968 bool wxFileConfig::DoWriteString(const wxString& key, const wxString& szValue)
969 {
970 wxConfigPathChanger path(this, key);
971 wxString strName = path.Name();
972
973 wxLogTrace( FILECONF_TRACE_MASK,
974 _T(" Writing String '%s' = '%s' to Group '%s'"),
975 strName.c_str(),
976 szValue.c_str(),
977 GetPath().c_str() );
978
979 if ( strName.empty() )
980 {
981 // setting the value of a group is an error
982
983 wxASSERT_MSG( szValue.empty(), wxT("can't set value of a group!") );
984
985 // ... except if it's empty in which case it's a way to force it's creation
986
987 wxLogTrace( FILECONF_TRACE_MASK,
988 _T(" Creating group %s"),
989 m_pCurrentGroup->Name().c_str() );
990
991 SetDirty();
992
993 // this will add a line for this group if it didn't have it before
994
995 (void)m_pCurrentGroup->GetGroupLine();
996 }
997 else
998 {
999 // writing an entry check that the name is reasonable
1000 if ( strName[0u] == wxCONFIG_IMMUTABLE_PREFIX )
1001 {
1002 wxLogError( _("Config entry name cannot start with '%c'."),
1003 wxCONFIG_IMMUTABLE_PREFIX);
1004 return false;
1005 }
1006
1007 wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strName);
1008
1009 if ( pEntry == 0 )
1010 {
1011 wxLogTrace( FILECONF_TRACE_MASK,
1012 _T(" Adding Entry %s"),
1013 strName.c_str() );
1014 pEntry = m_pCurrentGroup->AddEntry(strName);
1015 }
1016
1017 wxLogTrace( FILECONF_TRACE_MASK,
1018 _T(" Setting value %s"),
1019 szValue.c_str() );
1020 pEntry->SetValue(szValue);
1021
1022 SetDirty();
1023 }
1024
1025 return true;
1026 }
1027
1028 bool wxFileConfig::DoWriteLong(const wxString& key, long lValue)
1029 {
1030 return Write(key, wxString::Format(_T("%ld"), lValue));
1031 }
1032
1033 bool wxFileConfig::Flush(bool /* bCurrentOnly */)
1034 {
1035 if ( !IsDirty() || !m_strLocalFile )
1036 return true;
1037
1038 // set the umask if needed
1039 wxCHANGE_UMASK(m_umask);
1040
1041 wxTempFile file(m_strLocalFile);
1042
1043 if ( !file.IsOpened() )
1044 {
1045 wxLogError(_("can't open user configuration file."));
1046 return false;
1047 }
1048
1049 // write all strings to file
1050 for ( wxFileConfigLineList *p = m_linesHead; p != NULL; p = p->Next() )
1051 {
1052 wxString line = p->Text();
1053 line += wxTextFile::GetEOL();
1054 if ( !file.Write(line, *m_conv) )
1055 {
1056 wxLogError(_("can't write user configuration file."));
1057 return false;
1058 }
1059 }
1060
1061 if ( !file.Commit() )
1062 {
1063 wxLogError(_("Failed to update user configuration file."));
1064
1065 return false;
1066 }
1067
1068 ResetDirty();
1069
1070 #if defined(__WXMAC__)
1071 wxFileName(m_strLocalFile).MacSetTypeAndCreator('TEXT', 'ttxt');
1072 #endif // __WXMAC__
1073
1074 return true;
1075 }
1076
1077 #if wxUSE_STREAMS
1078
1079 bool wxFileConfig::Save(wxOutputStream& os, const wxMBConv& conv)
1080 {
1081 // save unconditionally, even if not dirty
1082 for ( wxFileConfigLineList *p = m_linesHead; p != NULL; p = p->Next() )
1083 {
1084 wxString line = p->Text();
1085 line += wxTextFile::GetEOL();
1086
1087 wxCharBuffer buf(line.mb_str(conv));
1088 if ( !os.Write(buf, strlen(buf)) )
1089 {
1090 wxLogError(_("Error saving user configuration data."));
1091
1092 return false;
1093 }
1094 }
1095
1096 ResetDirty();
1097
1098 return true;
1099 }
1100
1101 #endif // wxUSE_STREAMS
1102
1103 // ----------------------------------------------------------------------------
1104 // renaming groups/entries
1105 // ----------------------------------------------------------------------------
1106
1107 bool wxFileConfig::RenameEntry(const wxString& oldName,
1108 const wxString& newName)
1109 {
1110 wxASSERT_MSG( !wxStrchr(oldName, wxCONFIG_PATH_SEPARATOR),
1111 _T("RenameEntry(): paths are not supported") );
1112
1113 // check that the entry exists
1114 wxFileConfigEntry *oldEntry = m_pCurrentGroup->FindEntry(oldName);
1115 if ( !oldEntry )
1116 return false;
1117
1118 // check that the new entry doesn't already exist
1119 if ( m_pCurrentGroup->FindEntry(newName) )
1120 return false;
1121
1122 // delete the old entry, create the new one
1123 wxString value = oldEntry->Value();
1124 if ( !m_pCurrentGroup->DeleteEntry(oldName) )
1125 return false;
1126
1127 SetDirty();
1128
1129 wxFileConfigEntry *newEntry = m_pCurrentGroup->AddEntry(newName);
1130 newEntry->SetValue(value);
1131
1132 return true;
1133 }
1134
1135 bool wxFileConfig::RenameGroup(const wxString& oldName,
1136 const wxString& newName)
1137 {
1138 // check that the group exists
1139 wxFileConfigGroup *group = m_pCurrentGroup->FindSubgroup(oldName);
1140 if ( !group )
1141 return false;
1142
1143 // check that the new group doesn't already exist
1144 if ( m_pCurrentGroup->FindSubgroup(newName) )
1145 return false;
1146
1147 group->Rename(newName);
1148
1149 SetDirty();
1150
1151 return true;
1152 }
1153
1154 // ----------------------------------------------------------------------------
1155 // delete groups/entries
1156 // ----------------------------------------------------------------------------
1157
1158 bool wxFileConfig::DeleteEntry(const wxString& key, bool bGroupIfEmptyAlso)
1159 {
1160 wxConfigPathChanger path(this, key);
1161
1162 if ( !m_pCurrentGroup->DeleteEntry(path.Name()) )
1163 return false;
1164
1165 SetDirty();
1166
1167 if ( bGroupIfEmptyAlso && m_pCurrentGroup->IsEmpty() ) {
1168 if ( m_pCurrentGroup != m_pRootGroup ) {
1169 wxFileConfigGroup *pGroup = m_pCurrentGroup;
1170 SetPath(wxT("..")); // changes m_pCurrentGroup!
1171 m_pCurrentGroup->DeleteSubgroupByName(pGroup->Name());
1172 }
1173 //else: never delete the root group
1174 }
1175
1176 return true;
1177 }
1178
1179 bool wxFileConfig::DeleteGroup(const wxString& key)
1180 {
1181 wxConfigPathChanger path(this, RemoveTrailingSeparator(key));
1182
1183 if ( !m_pCurrentGroup->DeleteSubgroupByName(path.Name()) )
1184 return false;
1185
1186 path.UpdateIfDeleted();
1187
1188 SetDirty();
1189
1190 return true;
1191 }
1192
1193 bool wxFileConfig::DeleteAll()
1194 {
1195 CleanUp();
1196
1197 if ( !m_strLocalFile.empty() )
1198 {
1199 if ( wxFile::Exists(m_strLocalFile) && wxRemove(m_strLocalFile) == -1 )
1200 {
1201 wxLogSysError(_("can't delete user configuration file '%s'"),
1202 m_strLocalFile.c_str());
1203 return false;
1204 }
1205 }
1206
1207 Init();
1208
1209 return true;
1210 }
1211
1212 // ----------------------------------------------------------------------------
1213 // linked list functions
1214 // ----------------------------------------------------------------------------
1215
1216 // append a new line to the end of the list
1217
1218 wxFileConfigLineList *wxFileConfig::LineListAppend(const wxString& str)
1219 {
1220 wxLogTrace( FILECONF_TRACE_MASK,
1221 _T(" ** Adding Line '%s'"),
1222 str.c_str() );
1223 wxLogTrace( FILECONF_TRACE_MASK,
1224 _T(" head: %s"),
1225 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1226 wxLogTrace( FILECONF_TRACE_MASK,
1227 _T(" tail: %s"),
1228 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1229
1230 wxFileConfigLineList *pLine = new wxFileConfigLineList(str);
1231
1232 if ( m_linesTail == NULL )
1233 {
1234 // list is empty
1235 m_linesHead = pLine;
1236 }
1237 else
1238 {
1239 // adjust pointers
1240 m_linesTail->SetNext(pLine);
1241 pLine->SetPrev(m_linesTail);
1242 }
1243
1244 m_linesTail = pLine;
1245
1246 wxLogTrace( FILECONF_TRACE_MASK,
1247 _T(" head: %s"),
1248 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1249 wxLogTrace( FILECONF_TRACE_MASK,
1250 _T(" tail: %s"),
1251 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1252
1253 return m_linesTail;
1254 }
1255
1256 // insert a new line after the given one or in the very beginning if !pLine
1257 wxFileConfigLineList *wxFileConfig::LineListInsert(const wxString& str,
1258 wxFileConfigLineList *pLine)
1259 {
1260 wxLogTrace( FILECONF_TRACE_MASK,
1261 _T(" ** Inserting Line '%s' after '%s'"),
1262 str.c_str(),
1263 ((pLine) ? pLine->Text().c_str() : wxEmptyString) );
1264 wxLogTrace( FILECONF_TRACE_MASK,
1265 _T(" head: %s"),
1266 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1267 wxLogTrace( FILECONF_TRACE_MASK,
1268 _T(" tail: %s"),
1269 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1270
1271 if ( pLine == m_linesTail )
1272 return LineListAppend(str);
1273
1274 wxFileConfigLineList *pNewLine = new wxFileConfigLineList(str);
1275 if ( pLine == NULL )
1276 {
1277 // prepend to the list
1278 pNewLine->SetNext(m_linesHead);
1279 m_linesHead->SetPrev(pNewLine);
1280 m_linesHead = pNewLine;
1281 }
1282 else
1283 {
1284 // insert before pLine
1285 wxFileConfigLineList *pNext = pLine->Next();
1286 pNewLine->SetNext(pNext);
1287 pNewLine->SetPrev(pLine);
1288 pNext->SetPrev(pNewLine);
1289 pLine->SetNext(pNewLine);
1290 }
1291
1292 wxLogTrace( FILECONF_TRACE_MASK,
1293 _T(" head: %s"),
1294 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1295 wxLogTrace( FILECONF_TRACE_MASK,
1296 _T(" tail: %s"),
1297 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1298
1299 return pNewLine;
1300 }
1301
1302 void wxFileConfig::LineListRemove(wxFileConfigLineList *pLine)
1303 {
1304 wxLogTrace( FILECONF_TRACE_MASK,
1305 _T(" ** Removing Line '%s'"),
1306 pLine->Text().c_str() );
1307 wxLogTrace( FILECONF_TRACE_MASK,
1308 _T(" head: %s"),
1309 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1310 wxLogTrace( FILECONF_TRACE_MASK,
1311 _T(" tail: %s"),
1312 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1313
1314 wxFileConfigLineList *pPrev = pLine->Prev(),
1315 *pNext = pLine->Next();
1316
1317 // first entry?
1318
1319 if ( pPrev == NULL )
1320 m_linesHead = pNext;
1321 else
1322 pPrev->SetNext(pNext);
1323
1324 // last entry?
1325
1326 if ( pNext == NULL )
1327 m_linesTail = pPrev;
1328 else
1329 pNext->SetPrev(pPrev);
1330
1331 if ( m_pRootGroup->GetGroupLine() == pLine )
1332 m_pRootGroup->SetLine(m_linesHead);
1333
1334 wxLogTrace( FILECONF_TRACE_MASK,
1335 _T(" head: %s"),
1336 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1337 wxLogTrace( FILECONF_TRACE_MASK,
1338 _T(" tail: %s"),
1339 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1340
1341 delete pLine;
1342 }
1343
1344 bool wxFileConfig::LineListIsEmpty()
1345 {
1346 return m_linesHead == NULL;
1347 }
1348
1349 // ============================================================================
1350 // wxFileConfig::wxFileConfigGroup
1351 // ============================================================================
1352
1353 // ----------------------------------------------------------------------------
1354 // ctor/dtor
1355 // ----------------------------------------------------------------------------
1356
1357 // ctor
1358 wxFileConfigGroup::wxFileConfigGroup(wxFileConfigGroup *pParent,
1359 const wxString& strName,
1360 wxFileConfig *pConfig)
1361 : m_aEntries(CompareEntries),
1362 m_aSubgroups(CompareGroups),
1363 m_strName(strName)
1364 {
1365 m_pConfig = pConfig;
1366 m_pParent = pParent;
1367 m_pLine = NULL;
1368
1369 m_pLastEntry = NULL;
1370 m_pLastGroup = NULL;
1371 }
1372
1373 // dtor deletes all children
1374 wxFileConfigGroup::~wxFileConfigGroup()
1375 {
1376 // entries
1377 size_t n, nCount = m_aEntries.Count();
1378 for ( n = 0; n < nCount; n++ )
1379 delete m_aEntries[n];
1380
1381 // subgroups
1382 nCount = m_aSubgroups.Count();
1383 for ( n = 0; n < nCount; n++ )
1384 delete m_aSubgroups[n];
1385 }
1386
1387 // ----------------------------------------------------------------------------
1388 // line
1389 // ----------------------------------------------------------------------------
1390
1391 void wxFileConfigGroup::SetLine(wxFileConfigLineList *pLine)
1392 {
1393 // for a normal (i.e. not root) group this method shouldn't be called twice
1394 // unless we are resetting the line
1395 wxASSERT_MSG( !m_pParent || !m_pLine || !pLine,
1396 _T("changing line for a non-root group?") );
1397
1398 m_pLine = pLine;
1399 }
1400
1401 /*
1402 This is a bit complicated, so let me explain it in details. All lines that
1403 were read from the local file (the only one we will ever modify) are stored
1404 in a (doubly) linked list. Our problem is to know at which position in this
1405 list should we insert the new entries/subgroups. To solve it we keep three
1406 variables for each group: m_pLine, m_pLastEntry and m_pLastGroup.
1407
1408 m_pLine points to the line containing "[group_name]"
1409 m_pLastEntry points to the last entry of this group in the local file.
1410 m_pLastGroup subgroup
1411
1412 Initially, they're NULL all three. When the group (an entry/subgroup) is read
1413 from the local file, the corresponding variable is set. However, if the group
1414 was read from the global file and then modified or created by the application
1415 these variables are still NULL and we need to create the corresponding lines.
1416 See the following functions (and comments preceding them) for the details of
1417 how we do it.
1418
1419 Also, when our last entry/group are deleted we need to find the new last
1420 element - the code in DeleteEntry/Subgroup does this by backtracking the list
1421 of lines until it either founds an entry/subgroup (and this is the new last
1422 element) or the m_pLine of the group, in which case there are no more entries
1423 (or subgroups) left and m_pLast<element> becomes NULL.
1424
1425 NB: This last problem could be avoided for entries if we added new entries
1426 immediately after m_pLine, but in this case the entries would appear
1427 backwards in the config file (OTOH, it's not that important) and as we
1428 would still need to do it for the subgroups the code wouldn't have been
1429 significantly less complicated.
1430 */
1431
1432 // Return the line which contains "[our name]". If we're still not in the list,
1433 // add our line to it immediately after the last line of our parent group if we
1434 // have it or in the very beginning if we're the root group.
1435 wxFileConfigLineList *wxFileConfigGroup::GetGroupLine()
1436 {
1437 wxLogTrace( FILECONF_TRACE_MASK,
1438 _T(" GetGroupLine() for Group '%s'"),
1439 Name().c_str() );
1440
1441 if ( !m_pLine )
1442 {
1443 wxLogTrace( FILECONF_TRACE_MASK,
1444 _T(" Getting Line item pointer") );
1445
1446 wxFileConfigGroup *pParent = Parent();
1447
1448 // this group wasn't present in local config file, add it now
1449 if ( pParent )
1450 {
1451 wxLogTrace( FILECONF_TRACE_MASK,
1452 _T(" checking parent '%s'"),
1453 pParent->Name().c_str() );
1454
1455 wxString strFullName;
1456
1457 // add 1 to the name because we don't want to start with '/'
1458 strFullName << wxT("[")
1459 << FilterOutEntryName(GetFullName().c_str() + 1)
1460 << wxT("]");
1461 m_pLine = m_pConfig->LineListInsert(strFullName,
1462 pParent->GetLastGroupLine());
1463 pParent->SetLastGroup(this); // we're surely after all the others
1464 }
1465 //else: this is the root group and so we return NULL because we don't
1466 // have any group line
1467 }
1468
1469 return m_pLine;
1470 }
1471
1472 // Return the last line belonging to the subgroups of this group (after which
1473 // we can add a new subgroup), if we don't have any subgroups or entries our
1474 // last line is the group line (m_pLine) itself.
1475 wxFileConfigLineList *wxFileConfigGroup::GetLastGroupLine()
1476 {
1477 // if we have any subgroups, our last line is the last line of the last
1478 // subgroup
1479 if ( m_pLastGroup )
1480 {
1481 wxFileConfigLineList *pLine = m_pLastGroup->GetLastGroupLine();
1482
1483 wxASSERT_MSG( pLine, _T("last group must have !NULL associated line") );
1484
1485 return pLine;
1486 }
1487
1488 // no subgroups, so the last line is the line of thelast entry (if any)
1489 return GetLastEntryLine();
1490 }
1491
1492 // return the last line belonging to the entries of this group (after which
1493 // we can add a new entry), if we don't have any entries we will add the new
1494 // one immediately after the group line itself.
1495 wxFileConfigLineList *wxFileConfigGroup::GetLastEntryLine()
1496 {
1497 wxLogTrace( FILECONF_TRACE_MASK,
1498 _T(" GetLastEntryLine() for Group '%s'"),
1499 Name().c_str() );
1500
1501 if ( m_pLastEntry )
1502 {
1503 wxFileConfigLineList *pLine = m_pLastEntry->GetLine();
1504
1505 wxASSERT_MSG( pLine, _T("last entry must have !NULL associated line") );
1506
1507 return pLine;
1508 }
1509
1510 // no entries: insert after the group header, if any
1511 return GetGroupLine();
1512 }
1513
1514 void wxFileConfigGroup::SetLastEntry(wxFileConfigEntry *pEntry)
1515 {
1516 m_pLastEntry = pEntry;
1517
1518 if ( !m_pLine )
1519 {
1520 // the only situation in which a group without its own line can have
1521 // an entry is when the first entry is added to the initially empty
1522 // root pseudo-group
1523 wxASSERT_MSG( !m_pParent, _T("unexpected for non root group") );
1524
1525 // let the group know that it does have a line in the file now
1526 m_pLine = pEntry->GetLine();
1527 }
1528 }
1529
1530 // ----------------------------------------------------------------------------
1531 // group name
1532 // ----------------------------------------------------------------------------
1533
1534 void wxFileConfigGroup::UpdateGroupAndSubgroupsLines()
1535 {
1536 // update the line of this group
1537 wxFileConfigLineList *line = GetGroupLine();
1538 wxCHECK_RET( line, _T("a non root group must have a corresponding line!") );
1539
1540 // +1: skip the leading '/'
1541 line->SetText(wxString::Format(_T("[%s]"), GetFullName().c_str() + 1));
1542
1543
1544 // also update all subgroups as they have this groups name in their lines
1545 const size_t nCount = m_aSubgroups.Count();
1546 for ( size_t n = 0; n < nCount; n++ )
1547 {
1548 m_aSubgroups[n]->UpdateGroupAndSubgroupsLines();
1549 }
1550 }
1551
1552 void wxFileConfigGroup::Rename(const wxString& newName)
1553 {
1554 wxCHECK_RET( m_pParent, _T("the root group can't be renamed") );
1555
1556 if ( newName == m_strName )
1557 return;
1558
1559 // we need to remove the group from the parent and it back under the new
1560 // name to keep the parents array of subgroups alphabetically sorted
1561 m_pParent->m_aSubgroups.Remove(this);
1562
1563 m_strName = newName;
1564
1565 m_pParent->m_aSubgroups.Add(this);
1566
1567 // update the group lines recursively
1568 UpdateGroupAndSubgroupsLines();
1569 }
1570
1571 wxString wxFileConfigGroup::GetFullName() const
1572 {
1573 wxString fullname;
1574 if ( Parent() )
1575 fullname = Parent()->GetFullName() + wxCONFIG_PATH_SEPARATOR + Name();
1576
1577 return fullname;
1578 }
1579
1580 // ----------------------------------------------------------------------------
1581 // find an item
1582 // ----------------------------------------------------------------------------
1583
1584 // use binary search because the array is sorted
1585 wxFileConfigEntry *
1586 wxFileConfigGroup::FindEntry(const wxChar *szName) const
1587 {
1588 size_t i,
1589 lo = 0,
1590 hi = m_aEntries.Count();
1591 int res;
1592 wxFileConfigEntry *pEntry;
1593
1594 while ( lo < hi ) {
1595 i = (lo + hi)/2;
1596 pEntry = m_aEntries[i];
1597
1598 #if wxCONFIG_CASE_SENSITIVE
1599 res = wxStrcmp(pEntry->Name(), szName);
1600 #else
1601 res = wxStricmp(pEntry->Name(), szName);
1602 #endif
1603
1604 if ( res > 0 )
1605 hi = i;
1606 else if ( res < 0 )
1607 lo = i + 1;
1608 else
1609 return pEntry;
1610 }
1611
1612 return NULL;
1613 }
1614
1615 wxFileConfigGroup *
1616 wxFileConfigGroup::FindSubgroup(const wxChar *szName) const
1617 {
1618 size_t i,
1619 lo = 0,
1620 hi = m_aSubgroups.Count();
1621 int res;
1622 wxFileConfigGroup *pGroup;
1623
1624 while ( lo < hi ) {
1625 i = (lo + hi)/2;
1626 pGroup = m_aSubgroups[i];
1627
1628 #if wxCONFIG_CASE_SENSITIVE
1629 res = wxStrcmp(pGroup->Name(), szName);
1630 #else
1631 res = wxStricmp(pGroup->Name(), szName);
1632 #endif
1633
1634 if ( res > 0 )
1635 hi = i;
1636 else if ( res < 0 )
1637 lo = i + 1;
1638 else
1639 return pGroup;
1640 }
1641
1642 return NULL;
1643 }
1644
1645 // ----------------------------------------------------------------------------
1646 // create a new item
1647 // ----------------------------------------------------------------------------
1648
1649 // create a new entry and add it to the current group
1650 wxFileConfigEntry *wxFileConfigGroup::AddEntry(const wxString& strName, int nLine)
1651 {
1652 wxASSERT( FindEntry(strName) == 0 );
1653
1654 wxFileConfigEntry *pEntry = new wxFileConfigEntry(this, strName, nLine);
1655
1656 m_aEntries.Add(pEntry);
1657 return pEntry;
1658 }
1659
1660 // create a new group and add it to the current group
1661 wxFileConfigGroup *wxFileConfigGroup::AddSubgroup(const wxString& strName)
1662 {
1663 wxASSERT( FindSubgroup(strName) == 0 );
1664
1665 wxFileConfigGroup *pGroup = new wxFileConfigGroup(this, strName, m_pConfig);
1666
1667 m_aSubgroups.Add(pGroup);
1668 return pGroup;
1669 }
1670
1671 // ----------------------------------------------------------------------------
1672 // delete an item
1673 // ----------------------------------------------------------------------------
1674
1675 /*
1676 The delete operations are _very_ slow if we delete the last item of this
1677 group (see comments before GetXXXLineXXX functions for more details),
1678 so it's much better to start with the first entry/group if we want to
1679 delete several of them.
1680 */
1681
1682 bool wxFileConfigGroup::DeleteSubgroupByName(const wxChar *szName)
1683 {
1684 wxFileConfigGroup * const pGroup = FindSubgroup(szName);
1685
1686 return pGroup ? DeleteSubgroup(pGroup) : false;
1687 }
1688
1689 // Delete the subgroup and remove all references to it from
1690 // other data structures.
1691 bool wxFileConfigGroup::DeleteSubgroup(wxFileConfigGroup *pGroup)
1692 {
1693 wxCHECK_MSG( pGroup, false, _T("deleting non existing group?") );
1694
1695 wxLogTrace( FILECONF_TRACE_MASK,
1696 _T("Deleting group '%s' from '%s'"),
1697 pGroup->Name().c_str(),
1698 Name().c_str() );
1699
1700 wxLogTrace( FILECONF_TRACE_MASK,
1701 _T(" (m_pLine) = prev: %p, this %p, next %p"),
1702 m_pLine ? wx_static_cast(void*, m_pLine->Prev()) : 0,
1703 wx_static_cast(void*, m_pLine),
1704 m_pLine ? wx_static_cast(void*, m_pLine->Next()) : 0 );
1705 wxLogTrace( FILECONF_TRACE_MASK,
1706 _T(" text: '%s'"),
1707 m_pLine ? m_pLine->Text().c_str() : wxEmptyString );
1708
1709 // delete all entries...
1710 size_t nCount = pGroup->m_aEntries.Count();
1711
1712 wxLogTrace(FILECONF_TRACE_MASK,
1713 _T("Removing %lu entries"), (unsigned long)nCount );
1714
1715 for ( size_t nEntry = 0; nEntry < nCount; nEntry++ )
1716 {
1717 wxFileConfigLineList *pLine = pGroup->m_aEntries[nEntry]->GetLine();
1718
1719 if ( pLine )
1720 {
1721 wxLogTrace( FILECONF_TRACE_MASK,
1722 _T(" '%s'"),
1723 pLine->Text().c_str() );
1724 m_pConfig->LineListRemove(pLine);
1725 }
1726 }
1727
1728 // ...and subgroups of this subgroup
1729 nCount = pGroup->m_aSubgroups.Count();
1730
1731 wxLogTrace( FILECONF_TRACE_MASK,
1732 _T("Removing %lu subgroups"), (unsigned long)nCount );
1733
1734 for ( size_t nGroup = 0; nGroup < nCount; nGroup++ )
1735 {
1736 pGroup->DeleteSubgroup(pGroup->m_aSubgroups[0]);
1737 }
1738
1739 // and then finally the group itself
1740 wxFileConfigLineList *pLine = pGroup->m_pLine;
1741 if ( pLine )
1742 {
1743 wxLogTrace( FILECONF_TRACE_MASK,
1744 _T(" Removing line for group '%s' : '%s'"),
1745 pGroup->Name().c_str(),
1746 pLine->Text().c_str() );
1747 wxLogTrace( FILECONF_TRACE_MASK,
1748 _T(" Removing from group '%s' : '%s'"),
1749 Name().c_str(),
1750 ((m_pLine) ? m_pLine->Text().c_str() : wxEmptyString) );
1751
1752 // notice that we may do this test inside the previous "if"
1753 // because the last entry's line is surely !NULL
1754 if ( pGroup == m_pLastGroup )
1755 {
1756 wxLogTrace( FILECONF_TRACE_MASK,
1757 _T(" Removing last group") );
1758
1759 // our last entry is being deleted, so find the last one which
1760 // stays by going back until we find a subgroup or reach the
1761 // group line
1762 const size_t nSubgroups = m_aSubgroups.Count();
1763
1764 m_pLastGroup = NULL;
1765 for ( wxFileConfigLineList *pl = pLine->Prev();
1766 pl && pl != m_pLine && !m_pLastGroup;
1767 pl = pl->Prev() )
1768 {
1769 // does this line belong to our subgroup?
1770 for ( size_t n = 0; n < nSubgroups; n++ )
1771 {
1772 // do _not_ call GetGroupLine! we don't want to add it to
1773 // the local file if it's not already there
1774 if ( m_aSubgroups[n]->m_pLine == pl )
1775 {
1776 m_pLastGroup = m_aSubgroups[n];
1777 break;
1778 }
1779 }
1780 }
1781 }
1782
1783 m_pConfig->LineListRemove(pLine);
1784 }
1785 else
1786 {
1787 wxLogTrace( FILECONF_TRACE_MASK,
1788 _T(" No line entry for Group '%s'?"),
1789 pGroup->Name().c_str() );
1790 }
1791
1792 m_aSubgroups.Remove(pGroup);
1793 delete pGroup;
1794
1795 return true;
1796 }
1797
1798 bool wxFileConfigGroup::DeleteEntry(const wxChar *szName)
1799 {
1800 wxFileConfigEntry *pEntry = FindEntry(szName);
1801 if ( !pEntry )
1802 {
1803 // entry doesn't exist, nothing to do
1804 return false;
1805 }
1806
1807 wxFileConfigLineList *pLine = pEntry->GetLine();
1808 if ( pLine != NULL ) {
1809 // notice that we may do this test inside the previous "if" because the
1810 // last entry's line is surely !NULL
1811 if ( pEntry == m_pLastEntry ) {
1812 // our last entry is being deleted - find the last one which stays
1813 wxASSERT( m_pLine != NULL ); // if we have an entry with !NULL pLine...
1814
1815 // go back until we find another entry or reach the group's line
1816 wxFileConfigEntry *pNewLast = NULL;
1817 size_t n, nEntries = m_aEntries.Count();
1818 wxFileConfigLineList *pl;
1819 for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) {
1820 // is it our subgroup?
1821 for ( n = 0; (pNewLast == NULL) && (n < nEntries); n++ ) {
1822 if ( m_aEntries[n]->GetLine() == m_pLine )
1823 pNewLast = m_aEntries[n];
1824 }
1825
1826 if ( pNewLast != NULL ) // found?
1827 break;
1828 }
1829
1830 if ( pl == m_pLine ) {
1831 wxASSERT( !pNewLast ); // how comes it has the same line as we?
1832
1833 // we've reached the group line without finding any subgroups
1834 m_pLastEntry = NULL;
1835 }
1836 else
1837 m_pLastEntry = pNewLast;
1838 }
1839
1840 m_pConfig->LineListRemove(pLine);
1841 }
1842
1843 m_aEntries.Remove(pEntry);
1844 delete pEntry;
1845
1846 return true;
1847 }
1848
1849 // ============================================================================
1850 // wxFileConfig::wxFileConfigEntry
1851 // ============================================================================
1852
1853 // ----------------------------------------------------------------------------
1854 // ctor
1855 // ----------------------------------------------------------------------------
1856 wxFileConfigEntry::wxFileConfigEntry(wxFileConfigGroup *pParent,
1857 const wxString& strName,
1858 int nLine)
1859 : m_strName(strName)
1860 {
1861 wxASSERT( !strName.empty() );
1862
1863 m_pParent = pParent;
1864 m_nLine = nLine;
1865 m_pLine = NULL;
1866
1867 m_bHasValue = false;
1868
1869 m_bImmutable = strName[0] == wxCONFIG_IMMUTABLE_PREFIX;
1870 if ( m_bImmutable )
1871 m_strName.erase(0, 1); // remove first character
1872 }
1873
1874 // ----------------------------------------------------------------------------
1875 // set value
1876 // ----------------------------------------------------------------------------
1877
1878 void wxFileConfigEntry::SetLine(wxFileConfigLineList *pLine)
1879 {
1880 if ( m_pLine != NULL ) {
1881 wxLogWarning(_("entry '%s' appears more than once in group '%s'"),
1882 Name().c_str(), m_pParent->GetFullName().c_str());
1883 }
1884
1885 m_pLine = pLine;
1886 Group()->SetLastEntry(this);
1887 }
1888
1889 // second parameter is false if we read the value from file and prevents the
1890 // entry from being marked as 'dirty'
1891 void wxFileConfigEntry::SetValue(const wxString& strValue, bool bUser)
1892 {
1893 if ( bUser && IsImmutable() )
1894 {
1895 wxLogWarning( _("attempt to change immutable key '%s' ignored."),
1896 Name().c_str());
1897 return;
1898 }
1899
1900 // do nothing if it's the same value: but don't test for it if m_bHasValue
1901 // hadn't been set yet or we'd never write empty values to the file
1902 if ( m_bHasValue && strValue == m_strValue )
1903 return;
1904
1905 m_bHasValue = true;
1906 m_strValue = strValue;
1907
1908 if ( bUser )
1909 {
1910 wxString strValFiltered;
1911
1912 if ( Group()->Config()->GetStyle() & wxCONFIG_USE_NO_ESCAPE_CHARACTERS )
1913 {
1914 strValFiltered = strValue;
1915 }
1916 else {
1917 strValFiltered = FilterOutValue(strValue);
1918 }
1919
1920 wxString strLine;
1921 strLine << FilterOutEntryName(m_strName) << wxT('=') << strValFiltered;
1922
1923 if ( m_pLine )
1924 {
1925 // entry was read from the local config file, just modify the line
1926 m_pLine->SetText(strLine);
1927 }
1928 else // this entry didn't exist in the local file
1929 {
1930 // add a new line to the file: note that line returned by
1931 // GetLastEntryLine() may be NULL if we're in the root group and it
1932 // doesn't have any entries yet, but this is ok as passing NULL
1933 // line to LineListInsert() means to prepend new line to the list
1934 wxFileConfigLineList *line = Group()->GetLastEntryLine();
1935 m_pLine = Group()->Config()->LineListInsert(strLine, line);
1936
1937 Group()->SetLastEntry(this);
1938 }
1939 }
1940 }
1941
1942 // ============================================================================
1943 // global functions
1944 // ============================================================================
1945
1946 // ----------------------------------------------------------------------------
1947 // compare functions for array sorting
1948 // ----------------------------------------------------------------------------
1949
1950 int CompareEntries(wxFileConfigEntry *p1, wxFileConfigEntry *p2)
1951 {
1952 #if wxCONFIG_CASE_SENSITIVE
1953 return wxStrcmp(p1->Name(), p2->Name());
1954 #else
1955 return wxStricmp(p1->Name(), p2->Name());
1956 #endif
1957 }
1958
1959 int CompareGroups(wxFileConfigGroup *p1, wxFileConfigGroup *p2)
1960 {
1961 #if wxCONFIG_CASE_SENSITIVE
1962 return wxStrcmp(p1->Name(), p2->Name());
1963 #else
1964 return wxStricmp(p1->Name(), p2->Name());
1965 #endif
1966 }
1967
1968 // ----------------------------------------------------------------------------
1969 // filter functions
1970 // ----------------------------------------------------------------------------
1971
1972 // undo FilterOutValue
1973 static wxString FilterInValue(const wxString& str)
1974 {
1975 wxString strResult;
1976 strResult.Alloc(str.Len());
1977
1978 bool bQuoted = !str.empty() && str[0] == '"';
1979
1980 for ( size_t n = bQuoted ? 1 : 0; n < str.Len(); n++ ) {
1981 if ( str[n] == wxT('\\') ) {
1982 switch ( str[++n] ) {
1983 case wxT('n'):
1984 strResult += wxT('\n');
1985 break;
1986
1987 case wxT('r'):
1988 strResult += wxT('\r');
1989 break;
1990
1991 case wxT('t'):
1992 strResult += wxT('\t');
1993 break;
1994
1995 case wxT('\\'):
1996 strResult += wxT('\\');
1997 break;
1998
1999 case wxT('"'):
2000 strResult += wxT('"');
2001 break;
2002 }
2003 }
2004 else {
2005 if ( str[n] != wxT('"') || !bQuoted )
2006 strResult += str[n];
2007 else if ( n != str.Len() - 1 ) {
2008 wxLogWarning(_("unexpected \" at position %d in '%s'."),
2009 n, str.c_str());
2010 }
2011 //else: it's the last quote of a quoted string, ok
2012 }
2013 }
2014
2015 return strResult;
2016 }
2017
2018 // quote the string before writing it to file
2019 static wxString FilterOutValue(const wxString& str)
2020 {
2021 if ( !str )
2022 return str;
2023
2024 wxString strResult;
2025 strResult.Alloc(str.Len());
2026
2027 // quoting is necessary to preserve spaces in the beginning of the string
2028 bool bQuote = wxIsspace(str[0]) || str[0] == wxT('"');
2029
2030 if ( bQuote )
2031 strResult += wxT('"');
2032
2033 wxChar c;
2034 for ( size_t n = 0; n < str.Len(); n++ ) {
2035 switch ( str[n] ) {
2036 case wxT('\n'):
2037 c = wxT('n');
2038 break;
2039
2040 case wxT('\r'):
2041 c = wxT('r');
2042 break;
2043
2044 case wxT('\t'):
2045 c = wxT('t');
2046 break;
2047
2048 case wxT('\\'):
2049 c = wxT('\\');
2050 break;
2051
2052 case wxT('"'):
2053 if ( bQuote ) {
2054 c = wxT('"');
2055 break;
2056 }
2057 //else: fall through
2058
2059 default:
2060 strResult += str[n];
2061 continue; // nothing special to do
2062 }
2063
2064 // we get here only for special characters
2065 strResult << wxT('\\') << c;
2066 }
2067
2068 if ( bQuote )
2069 strResult += wxT('"');
2070
2071 return strResult;
2072 }
2073
2074 // undo FilterOutEntryName
2075 static wxString FilterInEntryName(const wxString& str)
2076 {
2077 wxString strResult;
2078 strResult.Alloc(str.Len());
2079
2080 for ( const wxChar *pc = str.c_str(); *pc != '\0'; pc++ ) {
2081 if ( *pc == wxT('\\') ) {
2082 // we need to test it here or we'd skip past the NUL in the loop line
2083 if ( *++pc == _T('\0') )
2084 break;
2085 }
2086
2087 strResult += *pc;
2088 }
2089
2090 return strResult;
2091 }
2092
2093 // sanitize entry or group name: insert '\\' before any special characters
2094 static wxString FilterOutEntryName(const wxString& str)
2095 {
2096 wxString strResult;
2097 strResult.Alloc(str.Len());
2098
2099 for ( const wxChar *pc = str.c_str(); *pc != wxT('\0'); pc++ ) {
2100 const wxChar c = *pc;
2101
2102 // we explicitly allow some of "safe" chars and 8bit ASCII characters
2103 // which will probably never have special meaning and with which we can't
2104 // use isalnum() anyhow (in ASCII built, in Unicode it's just fine)
2105 //
2106 // NB: note that wxCONFIG_IMMUTABLE_PREFIX and wxCONFIG_PATH_SEPARATOR
2107 // should *not* be quoted
2108 if (
2109 #if !wxUSE_UNICODE
2110 ((unsigned char)c < 127) &&
2111 #endif // ANSI
2112 !wxIsalnum(c) && !wxStrchr(wxT("@_/-!.*%"), c) )
2113 {
2114 strResult += wxT('\\');
2115 }
2116
2117 strResult += c;
2118 }
2119
2120 return strResult;
2121 }
2122
2123 // we can't put ?: in the ctor initializer list because it confuses some
2124 // broken compilers (Borland C++)
2125 static wxString GetAppName(const wxString& appName)
2126 {
2127 if ( !appName && wxTheApp )
2128 return wxTheApp->GetAppName();
2129 else
2130 return appName;
2131 }
2132
2133 #endif // wxUSE_CONFIG
wxWidgets (Impactor)