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


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