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


2cfdd601b57b6506b1b3757ea6ea5a7c4dff91e5
[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 #else // 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 // FIXME: this is broken because if we have part of multibyte
509 // character in the buffer (and another part hasn't been
510 // read yet) we're going to lose data because of conversion
511 // errors
512 buf[inStream.LastRead()] = '\0';
513 strTmp += conv.cMB2WX(buf);
514 }
515 while ( !inStream.Eof() );
516
517 strTrans = wxTextBuffer::Translate(strTmp);
518 }
519
520 wxMemoryText memText;
521
522 // Now we can add the text to the memory text. To do this we extract line
523 // by line from the translated string, until we've reached the end.
524 //
525 // VZ: all this is horribly inefficient, we should do the translation on
526 // the fly in one pass saving both memory and time (TODO)
527
528 const wxChar *pEOL = wxTextBuffer::GetEOL(wxTextBuffer::typeDefault);
529 const size_t EOLLen = wxStrlen(pEOL);
530
531 int posLineStart = strTrans.Find(pEOL);
532 while ( posLineStart != -1 )
533 {
534 wxString line(strTrans.Left(posLineStart));
535
536 memText.AddLine(line);
537
538 strTrans = strTrans.Mid(posLineStart + EOLLen);
539
540 posLineStart = strTrans.Find(pEOL);
541 }
542
543 // also add whatever we have left in the translated string.
544 if ( !strTrans.empty() )
545 memText.AddLine(strTrans);
546
547 // Finally we can parse it all.
548 Parse(memText, true /* local */);
549
550 SetRootPath();
551 ResetDirty();
552 }
553
554 #endif // wxUSE_STREAMS
555
556 void wxFileConfig::CleanUp()
557 {
558 delete m_pRootGroup;
559
560 wxFileConfigLineList *pCur = m_linesHead;
561 while ( pCur != NULL ) {
562 wxFileConfigLineList *pNext = pCur->Next();
563 delete pCur;
564 pCur = pNext;
565 }
566 }
567
568 wxFileConfig::~wxFileConfig()
569 {
570 Flush();
571
572 CleanUp();
573 }
574
575 // ----------------------------------------------------------------------------
576 // parse a config file
577 // ----------------------------------------------------------------------------
578
579 void wxFileConfig::Parse(wxTextBuffer& buffer, bool bLocal)
580 {
581 const wxChar *pStart;
582 const wxChar *pEnd;
583 wxString strLine;
584
585 size_t nLineCount = buffer.GetLineCount();
586
587 for ( size_t n = 0; n < nLineCount; n++ )
588 {
589 strLine = buffer[n];
590
591 // add the line to linked list
592 if ( bLocal )
593 {
594 LineListAppend(strLine);
595
596 // let the root group have its start line as well
597 if ( !n )
598 {
599 m_pCurrentGroup->SetLine(m_linesTail);
600 }
601 }
602
603
604 // skip leading spaces
605 for ( pStart = strLine; wxIsspace(*pStart); pStart++ )
606 ;
607
608 // skip blank/comment lines
609 if ( *pStart == wxT('\0')|| *pStart == wxT(';') || *pStart == wxT('#') )
610 continue;
611
612 if ( *pStart == wxT('[') ) { // a new group
613 pEnd = pStart;
614
615 while ( *++pEnd != wxT(']') ) {
616 if ( *pEnd == wxT('\\') ) {
617 // the next char is escaped, so skip it even if it is ']'
618 pEnd++;
619 }
620
621 if ( *pEnd == wxT('\n') || *pEnd == wxT('\0') ) {
622 // we reached the end of line, break out of the loop
623 break;
624 }
625 }
626
627 if ( *pEnd != wxT(']') ) {
628 wxLogError(_("file '%s': unexpected character %c at line %d."),
629 buffer.GetName(), *pEnd, n + 1);
630 continue; // skip this line
631 }
632
633 // group name here is always considered as abs path
634 wxString strGroup;
635 pStart++;
636 strGroup << wxCONFIG_PATH_SEPARATOR
637 << FilterInEntryName(wxString(pStart, pEnd - pStart));
638
639 // will create it if doesn't yet exist
640 SetPath(strGroup);
641
642 if ( bLocal )
643 {
644 if ( m_pCurrentGroup->Parent() )
645 m_pCurrentGroup->Parent()->SetLastGroup(m_pCurrentGroup);
646 m_pCurrentGroup->SetLine(m_linesTail);
647 }
648
649 // check that there is nothing except comments left on this line
650 bool bCont = true;
651 while ( *++pEnd != wxT('\0') && bCont ) {
652 switch ( *pEnd ) {
653 case wxT('#'):
654 case wxT(';'):
655 bCont = false;
656 break;
657
658 case wxT(' '):
659 case wxT('\t'):
660 // ignore whitespace ('\n' impossible here)
661 break;
662
663 default:
664 wxLogWarning(_("file '%s', line %d: '%s' ignored after group header."),
665 buffer.GetName(), n + 1, pEnd);
666 bCont = false;
667 }
668 }
669 }
670 else { // a key
671 const wxChar *pEnd = pStart;
672 while ( *pEnd && *pEnd != wxT('=') /* && !wxIsspace(*pEnd)*/ ) {
673 if ( *pEnd == wxT('\\') ) {
674 // next character may be space or not - still take it because it's
675 // quoted (unless there is nothing)
676 pEnd++;
677 if ( !*pEnd ) {
678 // the error message will be given below anyhow
679 break;
680 }
681 }
682
683 pEnd++;
684 }
685
686 wxString strKey(FilterInEntryName(wxString(pStart, pEnd).Trim()));
687
688 // skip whitespace
689 while ( wxIsspace(*pEnd) )
690 pEnd++;
691
692 if ( *pEnd++ != wxT('=') ) {
693 wxLogError(_("file '%s', line %d: '=' expected."),
694 buffer.GetName(), n + 1);
695 }
696 else {
697 wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strKey);
698
699 if ( pEntry == NULL ) {
700 // new entry
701 pEntry = m_pCurrentGroup->AddEntry(strKey, n);
702 }
703 else {
704 if ( bLocal && pEntry->IsImmutable() ) {
705 // immutable keys can't be changed by user
706 wxLogWarning(_("file '%s', line %d: value for immutable key '%s' ignored."),
707 buffer.GetName(), n + 1, strKey.c_str());
708 continue;
709 }
710 // the condition below catches the cases (a) and (b) but not (c):
711 // (a) global key found second time in global file
712 // (b) key found second (or more) time in local file
713 // (c) key from global file now found in local one
714 // which is exactly what we want.
715 else if ( !bLocal || pEntry->IsLocal() ) {
716 wxLogWarning(_("file '%s', line %d: key '%s' was first found at line %d."),
717 buffer.GetName(), n + 1, strKey.c_str(), pEntry->Line());
718
719 }
720 }
721
722 if ( bLocal )
723 pEntry->SetLine(m_linesTail);
724
725 // skip whitespace
726 while ( wxIsspace(*pEnd) )
727 pEnd++;
728
729 wxString value = pEnd;
730 if ( !(GetStyle() & wxCONFIG_USE_NO_ESCAPE_CHARACTERS) )
731 value = FilterInValue(value);
732
733 pEntry->SetValue(value, false);
734 }
735 }
736 }
737 }
738
739 // ----------------------------------------------------------------------------
740 // set/retrieve path
741 // ----------------------------------------------------------------------------
742
743 void wxFileConfig::SetRootPath()
744 {
745 m_strPath.Empty();
746 m_pCurrentGroup = m_pRootGroup;
747 }
748
749 void wxFileConfig::SetPath(const wxString& strPath)
750 {
751 wxArrayString aParts;
752
753 if ( strPath.empty() ) {
754 SetRootPath();
755 return;
756 }
757
758 if ( strPath[0] == wxCONFIG_PATH_SEPARATOR ) {
759 // absolute path
760 wxSplitPath(aParts, strPath);
761 }
762 else {
763 // relative path, combine with current one
764 wxString strFullPath = m_strPath;
765 strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
766 wxSplitPath(aParts, strFullPath);
767 }
768
769 // change current group
770 size_t n;
771 m_pCurrentGroup = m_pRootGroup;
772 for ( n = 0; n < aParts.Count(); n++ ) {
773 wxFileConfigGroup *pNextGroup = m_pCurrentGroup->FindSubgroup(aParts[n]);
774 if ( pNextGroup == NULL )
775 pNextGroup = m_pCurrentGroup->AddSubgroup(aParts[n]);
776 m_pCurrentGroup = pNextGroup;
777 }
778
779 // recombine path parts in one variable
780 m_strPath.Empty();
781 for ( n = 0; n < aParts.Count(); n++ ) {
782 m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n];
783 }
784 }
785
786 // ----------------------------------------------------------------------------
787 // enumeration
788 // ----------------------------------------------------------------------------
789
790 bool wxFileConfig::GetFirstGroup(wxString& str, long& lIndex) const
791 {
792 lIndex = 0;
793 return GetNextGroup(str, lIndex);
794 }
795
796 bool wxFileConfig::GetNextGroup (wxString& str, long& lIndex) const
797 {
798 if ( size_t(lIndex) < m_pCurrentGroup->Groups().Count() ) {
799 str = m_pCurrentGroup->Groups()[(size_t)lIndex++]->Name();
800 return true;
801 }
802 else
803 return false;
804 }
805
806 bool wxFileConfig::GetFirstEntry(wxString& str, long& lIndex) const
807 {
808 lIndex = 0;
809 return GetNextEntry(str, lIndex);
810 }
811
812 bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) const
813 {
814 if ( size_t(lIndex) < m_pCurrentGroup->Entries().Count() ) {
815 str = m_pCurrentGroup->Entries()[(size_t)lIndex++]->Name();
816 return true;
817 }
818 else
819 return false;
820 }
821
822 size_t wxFileConfig::GetNumberOfEntries(bool bRecursive) const
823 {
824 size_t n = m_pCurrentGroup->Entries().Count();
825 if ( bRecursive ) {
826 wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
827 size_t nSubgroups = m_pCurrentGroup->Groups().Count();
828 for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
829 CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
830 n += GetNumberOfEntries(true);
831 CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
832 }
833 }
834
835 return n;
836 }
837
838 size_t wxFileConfig::GetNumberOfGroups(bool bRecursive) const
839 {
840 size_t n = m_pCurrentGroup->Groups().Count();
841 if ( bRecursive ) {
842 wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
843 size_t nSubgroups = m_pCurrentGroup->Groups().Count();
844 for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
845 CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
846 n += GetNumberOfGroups(true);
847 CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
848 }
849 }
850
851 return n;
852 }
853
854 // ----------------------------------------------------------------------------
855 // tests for existence
856 // ----------------------------------------------------------------------------
857
858 bool wxFileConfig::HasGroup(const wxString& strName) const
859 {
860 wxConfigPathChanger path(this, strName);
861
862 wxFileConfigGroup *pGroup = m_pCurrentGroup->FindSubgroup(path.Name());
863 return pGroup != NULL;
864 }
865
866 bool wxFileConfig::HasEntry(const wxString& strName) const
867 {
868 wxConfigPathChanger path(this, strName);
869
870 wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
871 return pEntry != NULL;
872 }
873
874 // ----------------------------------------------------------------------------
875 // read/write values
876 // ----------------------------------------------------------------------------
877
878 bool wxFileConfig::DoReadString(const wxString& key, wxString* pStr) const
879 {
880 wxConfigPathChanger path(this, key);
881
882 wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
883 if (pEntry == NULL) {
884 return false;
885 }
886
887 *pStr = pEntry->Value();
888
889 return true;
890 }
891
892 bool wxFileConfig::DoReadLong(const wxString& key, long *pl) const
893 {
894 wxString str;
895 if ( !Read(key, &str) )
896 return false;
897
898 // extra spaces shouldn't prevent us from reading numeric values
899 str.Trim();
900
901 return str.ToLong(pl);
902 }
903
904 bool wxFileConfig::DoWriteString(const wxString& key, const wxString& szValue)
905 {
906 wxConfigPathChanger path(this, key);
907 wxString strName = path.Name();
908
909 wxLogTrace( FILECONF_TRACE_MASK,
910 _T(" Writing String '%s' = '%s' to Group '%s'"),
911 strName.c_str(),
912 szValue.c_str(),
913 GetPath().c_str() );
914
915 if ( strName.empty() )
916 {
917 // setting the value of a group is an error
918
919 wxASSERT_MSG( szValue.empty(), wxT("can't set value of a group!") );
920
921 // ... except if it's empty in which case it's a way to force it's creation
922
923 wxLogTrace( FILECONF_TRACE_MASK,
924 _T(" Creating group %s"),
925 m_pCurrentGroup->Name().c_str() );
926
927 SetDirty();
928
929 // this will add a line for this group if it didn't have it before
930
931 (void)m_pCurrentGroup->GetGroupLine();
932 }
933 else
934 {
935 // writing an entry check that the name is reasonable
936 if ( strName[0u] == wxCONFIG_IMMUTABLE_PREFIX )
937 {
938 wxLogError( _("Config entry name cannot start with '%c'."),
939 wxCONFIG_IMMUTABLE_PREFIX);
940 return false;
941 }
942
943 wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strName);
944
945 if ( pEntry == 0 )
946 {
947 wxLogTrace( FILECONF_TRACE_MASK,
948 _T(" Adding Entry %s"),
949 strName.c_str() );
950 pEntry = m_pCurrentGroup->AddEntry(strName);
951 }
952
953 wxLogTrace( FILECONF_TRACE_MASK,
954 _T(" Setting value %s"),
955 szValue.c_str() );
956 pEntry->SetValue(szValue);
957
958 SetDirty();
959 }
960
961 return true;
962 }
963
964 bool wxFileConfig::DoWriteLong(const wxString& key, long lValue)
965 {
966 return Write(key, wxString::Format(_T("%ld"), lValue));
967 }
968
969 bool wxFileConfig::Flush(bool /* bCurrentOnly */)
970 {
971 if ( !IsDirty() || !m_strLocalFile )
972 return true;
973
974 // set the umask if needed
975 wxCHANGE_UMASK(m_umask);
976
977 wxTempFile file(m_strLocalFile);
978
979 if ( !file.IsOpened() )
980 {
981 wxLogError(_("can't open user configuration file."));
982 return false;
983 }
984
985 // write all strings to file
986 for ( wxFileConfigLineList *p = m_linesHead; p != NULL; p = p->Next() )
987 {
988 wxString line = p->Text();
989 line += wxTextFile::GetEOL();
990 if ( !file.Write(line, m_conv) )
991 {
992 wxLogError(_("can't write user configuration file."));
993 return false;
994 }
995 }
996
997 if ( !file.Commit() )
998 {
999 wxLogError(_("Failed to update user configuration file."));
1000
1001 return false;
1002 }
1003
1004 ResetDirty();
1005
1006 #if defined(__WXMAC__)
1007 wxFileName(m_strLocalFile).MacSetTypeAndCreator('TEXT', 'ttxt');
1008 #endif // __WXMAC__
1009
1010 return true;
1011 }
1012
1013 #if wxUSE_STREAMS
1014
1015 bool wxFileConfig::Save(wxOutputStream& os, wxMBConv& conv)
1016 {
1017 // save unconditionally, even if not dirty
1018 for ( wxFileConfigLineList *p = m_linesHead; p != NULL; p = p->Next() )
1019 {
1020 wxString line = p->Text();
1021 line += wxTextFile::GetEOL();
1022
1023 wxCharBuffer buf(line.mb_str(conv));
1024 if ( !os.Write(buf, strlen(buf)) )
1025 {
1026 wxLogError(_("Error saving user configuration data."));
1027
1028 return false;
1029 }
1030 }
1031
1032 ResetDirty();
1033
1034 return true;
1035 }
1036
1037 #endif // wxUSE_STREAMS
1038
1039 // ----------------------------------------------------------------------------
1040 // renaming groups/entries
1041 // ----------------------------------------------------------------------------
1042
1043 bool wxFileConfig::RenameEntry(const wxString& oldName,
1044 const wxString& newName)
1045 {
1046 wxASSERT_MSG( !wxStrchr(oldName, wxCONFIG_PATH_SEPARATOR),
1047 _T("RenameEntry(): paths are not supported") );
1048
1049 // check that the entry exists
1050 wxFileConfigEntry *oldEntry = m_pCurrentGroup->FindEntry(oldName);
1051 if ( !oldEntry )
1052 return false;
1053
1054 // check that the new entry doesn't already exist
1055 if ( m_pCurrentGroup->FindEntry(newName) )
1056 return false;
1057
1058 // delete the old entry, create the new one
1059 wxString value = oldEntry->Value();
1060 if ( !m_pCurrentGroup->DeleteEntry(oldName) )
1061 return false;
1062
1063 SetDirty();
1064
1065 wxFileConfigEntry *newEntry = m_pCurrentGroup->AddEntry(newName);
1066 newEntry->SetValue(value);
1067
1068 return true;
1069 }
1070
1071 bool wxFileConfig::RenameGroup(const wxString& oldName,
1072 const wxString& newName)
1073 {
1074 // check that the group exists
1075 wxFileConfigGroup *group = m_pCurrentGroup->FindSubgroup(oldName);
1076 if ( !group )
1077 return false;
1078
1079 // check that the new group doesn't already exist
1080 if ( m_pCurrentGroup->FindSubgroup(newName) )
1081 return false;
1082
1083 group->Rename(newName);
1084
1085 SetDirty();
1086
1087 return true;
1088 }
1089
1090 // ----------------------------------------------------------------------------
1091 // delete groups/entries
1092 // ----------------------------------------------------------------------------
1093
1094 bool wxFileConfig::DeleteEntry(const wxString& key, bool bGroupIfEmptyAlso)
1095 {
1096 wxConfigPathChanger path(this, key);
1097
1098 if ( !m_pCurrentGroup->DeleteEntry(path.Name()) )
1099 return false;
1100
1101 if ( bGroupIfEmptyAlso && m_pCurrentGroup->IsEmpty() ) {
1102 if ( m_pCurrentGroup != m_pRootGroup ) {
1103 wxFileConfigGroup *pGroup = m_pCurrentGroup;
1104 SetPath(wxT("..")); // changes m_pCurrentGroup!
1105 if ( m_pCurrentGroup->DeleteSubgroupByName(pGroup->Name()) )
1106 SetDirty();
1107 }
1108 //else: never delete the root group
1109 }
1110
1111 return true;
1112 }
1113
1114 bool wxFileConfig::DeleteGroup(const wxString& key)
1115 {
1116 wxConfigPathChanger path(this, key);
1117
1118 if ( !m_pCurrentGroup->DeleteSubgroupByName(path.Name()) )
1119 return false;
1120
1121 SetDirty();
1122
1123 return true;
1124 }
1125
1126 bool wxFileConfig::DeleteAll()
1127 {
1128 CleanUp();
1129
1130 if ( !m_strLocalFile.empty() )
1131 {
1132 if ( wxFile::Exists(m_strLocalFile) && wxRemove(m_strLocalFile) == -1 )
1133 {
1134 wxLogSysError(_("can't delete user configuration file '%s'"),
1135 m_strLocalFile.c_str());
1136 return false;
1137 }
1138
1139 m_strLocalFile =
1140 m_strGlobalFile = wxEmptyString;
1141 }
1142
1143 Init();
1144
1145 return true;
1146 }
1147
1148 // ----------------------------------------------------------------------------
1149 // linked list functions
1150 // ----------------------------------------------------------------------------
1151
1152 // append a new line to the end of the list
1153
1154 wxFileConfigLineList *wxFileConfig::LineListAppend(const wxString& str)
1155 {
1156 wxLogTrace( FILECONF_TRACE_MASK,
1157 _T(" ** Adding Line '%s'"),
1158 str.c_str() );
1159 wxLogTrace( FILECONF_TRACE_MASK,
1160 _T(" head: %s"),
1161 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1162 wxLogTrace( FILECONF_TRACE_MASK,
1163 _T(" tail: %s"),
1164 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1165
1166 wxFileConfigLineList *pLine = new wxFileConfigLineList(str);
1167
1168 if ( m_linesTail == NULL )
1169 {
1170 // list is empty
1171 m_linesHead = pLine;
1172 }
1173 else
1174 {
1175 // adjust pointers
1176 m_linesTail->SetNext(pLine);
1177 pLine->SetPrev(m_linesTail);
1178 }
1179
1180 m_linesTail = pLine;
1181
1182 wxLogTrace( FILECONF_TRACE_MASK,
1183 _T(" head: %s"),
1184 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1185 wxLogTrace( FILECONF_TRACE_MASK,
1186 _T(" tail: %s"),
1187 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1188
1189 return m_linesTail;
1190 }
1191
1192 // insert a new line after the given one or in the very beginning if !pLine
1193 wxFileConfigLineList *wxFileConfig::LineListInsert(const wxString& str,
1194 wxFileConfigLineList *pLine)
1195 {
1196 wxLogTrace( FILECONF_TRACE_MASK,
1197 _T(" ** Inserting Line '%s' after '%s'"),
1198 str.c_str(),
1199 ((pLine) ? pLine->Text().c_str() : wxEmptyString) );
1200 wxLogTrace( FILECONF_TRACE_MASK,
1201 _T(" head: %s"),
1202 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1203 wxLogTrace( FILECONF_TRACE_MASK,
1204 _T(" tail: %s"),
1205 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1206
1207 if ( pLine == m_linesTail )
1208 return LineListAppend(str);
1209
1210 wxFileConfigLineList *pNewLine = new wxFileConfigLineList(str);
1211 if ( pLine == NULL )
1212 {
1213 // prepend to the list
1214 pNewLine->SetNext(m_linesHead);
1215 m_linesHead->SetPrev(pNewLine);
1216 m_linesHead = pNewLine;
1217 }
1218 else
1219 {
1220 // insert before pLine
1221 wxFileConfigLineList *pNext = pLine->Next();
1222 pNewLine->SetNext(pNext);
1223 pNewLine->SetPrev(pLine);
1224 pNext->SetPrev(pNewLine);
1225 pLine->SetNext(pNewLine);
1226 }
1227
1228 wxLogTrace( FILECONF_TRACE_MASK,
1229 _T(" head: %s"),
1230 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1231 wxLogTrace( FILECONF_TRACE_MASK,
1232 _T(" tail: %s"),
1233 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1234
1235 return pNewLine;
1236 }
1237
1238 void wxFileConfig::LineListRemove(wxFileConfigLineList *pLine)
1239 {
1240 wxLogTrace( FILECONF_TRACE_MASK,
1241 _T(" ** Removing Line '%s'"),
1242 pLine->Text().c_str() );
1243 wxLogTrace( FILECONF_TRACE_MASK,
1244 _T(" head: %s"),
1245 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1246 wxLogTrace( FILECONF_TRACE_MASK,
1247 _T(" tail: %s"),
1248 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1249
1250 wxFileConfigLineList *pPrev = pLine->Prev(),
1251 *pNext = pLine->Next();
1252
1253 // first entry?
1254
1255 if ( pPrev == NULL )
1256 m_linesHead = pNext;
1257 else
1258 pPrev->SetNext(pNext);
1259
1260 // last entry?
1261
1262 if ( pNext == NULL )
1263 m_linesTail = pPrev;
1264 else
1265 pNext->SetPrev(pPrev);
1266
1267 if ( m_pRootGroup->GetGroupLine() == pLine )
1268 m_pRootGroup->SetLine(m_linesHead);
1269
1270 wxLogTrace( FILECONF_TRACE_MASK,
1271 _T(" head: %s"),
1272 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1273 wxLogTrace( FILECONF_TRACE_MASK,
1274 _T(" tail: %s"),
1275 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1276
1277 delete pLine;
1278 }
1279
1280 bool wxFileConfig::LineListIsEmpty()
1281 {
1282 return m_linesHead == NULL;
1283 }
1284
1285 // ============================================================================
1286 // wxFileConfig::wxFileConfigGroup
1287 // ============================================================================
1288
1289 // ----------------------------------------------------------------------------
1290 // ctor/dtor
1291 // ----------------------------------------------------------------------------
1292
1293 // ctor
1294 wxFileConfigGroup::wxFileConfigGroup(wxFileConfigGroup *pParent,
1295 const wxString& strName,
1296 wxFileConfig *pConfig)
1297 : m_aEntries(CompareEntries),
1298 m_aSubgroups(CompareGroups),
1299 m_strName(strName)
1300 {
1301 m_pConfig = pConfig;
1302 m_pParent = pParent;
1303 m_pLine = NULL;
1304
1305 m_pLastEntry = NULL;
1306 m_pLastGroup = NULL;
1307 }
1308
1309 // dtor deletes all children
1310 wxFileConfigGroup::~wxFileConfigGroup()
1311 {
1312 // entries
1313 size_t n, nCount = m_aEntries.Count();
1314 for ( n = 0; n < nCount; n++ )
1315 delete m_aEntries[n];
1316
1317 // subgroups
1318 nCount = m_aSubgroups.Count();
1319 for ( n = 0; n < nCount; n++ )
1320 delete m_aSubgroups[n];
1321 }
1322
1323 // ----------------------------------------------------------------------------
1324 // line
1325 // ----------------------------------------------------------------------------
1326
1327 void wxFileConfigGroup::SetLine(wxFileConfigLineList *pLine)
1328 {
1329 // shouldn't be called twice unless we are resetting the line
1330 wxASSERT( m_pLine == 0 || pLine == 0 );
1331 m_pLine = pLine;
1332 }
1333
1334 /*
1335 This is a bit complicated, so let me explain it in details. All lines that
1336 were read from the local file (the only one we will ever modify) are stored
1337 in a (doubly) linked list. Our problem is to know at which position in this
1338 list should we insert the new entries/subgroups. To solve it we keep three
1339 variables for each group: m_pLine, m_pLastEntry and m_pLastGroup.
1340
1341 m_pLine points to the line containing "[group_name]"
1342 m_pLastEntry points to the last entry of this group in the local file.
1343 m_pLastGroup subgroup
1344
1345 Initially, they're NULL all three. When the group (an entry/subgroup) is read
1346 from the local file, the corresponding variable is set. However, if the group
1347 was read from the global file and then modified or created by the application
1348 these variables are still NULL and we need to create the corresponding lines.
1349 See the following functions (and comments preceding them) for the details of
1350 how we do it.
1351
1352 Also, when our last entry/group are deleted we need to find the new last
1353 element - the code in DeleteEntry/Subgroup does this by backtracking the list
1354 of lines until it either founds an entry/subgroup (and this is the new last
1355 element) or the m_pLine of the group, in which case there are no more entries
1356 (or subgroups) left and m_pLast<element> becomes NULL.
1357
1358 NB: This last problem could be avoided for entries if we added new entries
1359 immediately after m_pLine, but in this case the entries would appear
1360 backwards in the config file (OTOH, it's not that important) and as we
1361 would still need to do it for the subgroups the code wouldn't have been
1362 significantly less complicated.
1363 */
1364
1365 // Return the line which contains "[our name]". If we're still not in the list,
1366 // add our line to it immediately after the last line of our parent group if we
1367 // have it or in the very beginning if we're the root group.
1368 wxFileConfigLineList *wxFileConfigGroup::GetGroupLine()
1369 {
1370 wxLogTrace( FILECONF_TRACE_MASK,
1371 _T(" GetGroupLine() for Group '%s'"),
1372 Name().c_str() );
1373
1374 if ( !m_pLine )
1375 {
1376 wxLogTrace( FILECONF_TRACE_MASK,
1377 _T(" Getting Line item pointer") );
1378
1379 wxFileConfigGroup *pParent = Parent();
1380
1381 // this group wasn't present in local config file, add it now
1382 if ( pParent )
1383 {
1384 wxLogTrace( FILECONF_TRACE_MASK,
1385 _T(" checking parent '%s'"),
1386 pParent->Name().c_str() );
1387
1388 wxString strFullName;
1389
1390 // add 1 to the name because we don't want to start with '/'
1391 strFullName << wxT("[")
1392 << FilterOutEntryName(GetFullName().c_str() + 1)
1393 << wxT("]");
1394 m_pLine = m_pConfig->LineListInsert(strFullName,
1395 pParent->GetLastGroupLine());
1396 pParent->SetLastGroup(this); // we're surely after all the others
1397 }
1398 //else: this is the root group and so we return NULL because we don't
1399 // have any group line
1400 }
1401
1402 return m_pLine;
1403 }
1404
1405 // Return the last line belonging to the subgroups of this group (after which
1406 // we can add a new subgroup), if we don't have any subgroups or entries our
1407 // last line is the group line (m_pLine) itself.
1408 wxFileConfigLineList *wxFileConfigGroup::GetLastGroupLine()
1409 {
1410 // if we have any subgroups, our last line is the last line of the last
1411 // subgroup
1412 if ( m_pLastGroup )
1413 {
1414 wxFileConfigLineList *pLine = m_pLastGroup->GetLastGroupLine();
1415
1416 wxASSERT_MSG( pLine, _T("last group must have !NULL associated line") );
1417
1418 return pLine;
1419 }
1420
1421 // no subgroups, so the last line is the line of thelast entry (if any)
1422 return GetLastEntryLine();
1423 }
1424
1425 // return the last line belonging to the entries of this group (after which
1426 // we can add a new entry), if we don't have any entries we will add the new
1427 // one immediately after the group line itself.
1428 wxFileConfigLineList *wxFileConfigGroup::GetLastEntryLine()
1429 {
1430 wxLogTrace( FILECONF_TRACE_MASK,
1431 _T(" GetLastEntryLine() for Group '%s'"),
1432 Name().c_str() );
1433
1434 if ( m_pLastEntry )
1435 {
1436 wxFileConfigLineList *pLine = m_pLastEntry->GetLine();
1437
1438 wxASSERT_MSG( pLine, _T("last entry must have !NULL associated line") );
1439
1440 return pLine;
1441 }
1442
1443 // no entries: insert after the group header, if any
1444 return GetGroupLine();
1445 }
1446
1447 void wxFileConfigGroup::SetLastEntry(wxFileConfigEntry *pEntry)
1448 {
1449 m_pLastEntry = pEntry;
1450
1451 if ( !m_pLine )
1452 {
1453 // the only situation in which a group without its own line can have
1454 // an entry is when the first entry is added to the initially empty
1455 // root pseudo-group
1456 wxASSERT_MSG( !m_pParent, _T("unexpected for non root group") );
1457
1458 // let the group know that it does have a line in the file now
1459 m_pLine = pEntry->GetLine();
1460 }
1461 }
1462
1463 // ----------------------------------------------------------------------------
1464 // group name
1465 // ----------------------------------------------------------------------------
1466
1467 void wxFileConfigGroup::UpdateGroupAndSubgroupsLines()
1468 {
1469 // update the line of this group
1470 wxFileConfigLineList *line = GetGroupLine();
1471 wxCHECK_RET( line, _T("a non root group must have a corresponding line!") );
1472
1473 // +1: skip the leading '/'
1474 line->SetText(wxString::Format(_T("[%s]"), GetFullName().c_str() + 1));
1475
1476
1477 // also update all subgroups as they have this groups name in their lines
1478 const size_t nCount = m_aSubgroups.Count();
1479 for ( size_t n = 0; n < nCount; n++ )
1480 {
1481 m_aSubgroups[n]->UpdateGroupAndSubgroupsLines();
1482 }
1483 }
1484
1485 void wxFileConfigGroup::Rename(const wxString& newName)
1486 {
1487 wxCHECK_RET( m_pParent, _T("the root group can't be renamed") );
1488
1489 m_strName = newName;
1490
1491 // update the group lines recursively
1492 UpdateGroupAndSubgroupsLines();
1493 }
1494
1495 wxString wxFileConfigGroup::GetFullName() const
1496 {
1497 wxString fullname;
1498 if ( Parent() )
1499 fullname = Parent()->GetFullName() + wxCONFIG_PATH_SEPARATOR + Name();
1500
1501 return fullname;
1502 }
1503
1504 // ----------------------------------------------------------------------------
1505 // find an item
1506 // ----------------------------------------------------------------------------
1507
1508 // use binary search because the array is sorted
1509 wxFileConfigEntry *
1510 wxFileConfigGroup::FindEntry(const wxChar *szName) const
1511 {
1512 size_t i,
1513 lo = 0,
1514 hi = m_aEntries.Count();
1515 int res;
1516 wxFileConfigEntry *pEntry;
1517
1518 while ( lo < hi ) {
1519 i = (lo + hi)/2;
1520 pEntry = m_aEntries[i];
1521
1522 #if wxCONFIG_CASE_SENSITIVE
1523 res = wxStrcmp(pEntry->Name(), szName);
1524 #else
1525 res = wxStricmp(pEntry->Name(), szName);
1526 #endif
1527
1528 if ( res > 0 )
1529 hi = i;
1530 else if ( res < 0 )
1531 lo = i + 1;
1532 else
1533 return pEntry;
1534 }
1535
1536 return NULL;
1537 }
1538
1539 wxFileConfigGroup *
1540 wxFileConfigGroup::FindSubgroup(const wxChar *szName) const
1541 {
1542 size_t i,
1543 lo = 0,
1544 hi = m_aSubgroups.Count();
1545 int res;
1546 wxFileConfigGroup *pGroup;
1547
1548 while ( lo < hi ) {
1549 i = (lo + hi)/2;
1550 pGroup = m_aSubgroups[i];
1551
1552 #if wxCONFIG_CASE_SENSITIVE
1553 res = wxStrcmp(pGroup->Name(), szName);
1554 #else
1555 res = wxStricmp(pGroup->Name(), szName);
1556 #endif
1557
1558 if ( res > 0 )
1559 hi = i;
1560 else if ( res < 0 )
1561 lo = i + 1;
1562 else
1563 return pGroup;
1564 }
1565
1566 return NULL;
1567 }
1568
1569 // ----------------------------------------------------------------------------
1570 // create a new item
1571 // ----------------------------------------------------------------------------
1572
1573 // create a new entry and add it to the current group
1574 wxFileConfigEntry *wxFileConfigGroup::AddEntry(const wxString& strName, int nLine)
1575 {
1576 wxASSERT( FindEntry(strName) == 0 );
1577
1578 wxFileConfigEntry *pEntry = new wxFileConfigEntry(this, strName, nLine);
1579
1580 m_aEntries.Add(pEntry);
1581 return pEntry;
1582 }
1583
1584 // create a new group and add it to the current group
1585 wxFileConfigGroup *wxFileConfigGroup::AddSubgroup(const wxString& strName)
1586 {
1587 wxASSERT( FindSubgroup(strName) == 0 );
1588
1589 wxFileConfigGroup *pGroup = new wxFileConfigGroup(this, strName, m_pConfig);
1590
1591 m_aSubgroups.Add(pGroup);
1592 return pGroup;
1593 }
1594
1595 // ----------------------------------------------------------------------------
1596 // delete an item
1597 // ----------------------------------------------------------------------------
1598
1599 /*
1600 The delete operations are _very_ slow if we delete the last item of this
1601 group (see comments before GetXXXLineXXX functions for more details),
1602 so it's much better to start with the first entry/group if we want to
1603 delete several of them.
1604 */
1605
1606 bool wxFileConfigGroup::DeleteSubgroupByName(const wxChar *szName)
1607 {
1608 wxFileConfigGroup * const pGroup = FindSubgroup(szName);
1609
1610 return pGroup ? DeleteSubgroup(pGroup) : false;
1611 }
1612
1613 // Delete the subgroup and remove all references to it from
1614 // other data structures.
1615 bool wxFileConfigGroup::DeleteSubgroup(wxFileConfigGroup *pGroup)
1616 {
1617 wxCHECK_MSG( pGroup, false, _T("deleting non existing group?") );
1618
1619 wxLogTrace( FILECONF_TRACE_MASK,
1620 _T("Deleting group '%s' from '%s'"),
1621 pGroup->Name().c_str(),
1622 Name().c_str() );
1623
1624 wxLogTrace( FILECONF_TRACE_MASK,
1625 _T(" (m_pLine) = prev: %p, this %p, next %p"),
1626 ((m_pLine) ? m_pLine->Prev() : 0),
1627 m_pLine,
1628 ((m_pLine) ? m_pLine->Next() : 0) );
1629 wxLogTrace( FILECONF_TRACE_MASK,
1630 _T(" text: '%s'"),
1631 ((m_pLine) ? m_pLine->Text().c_str() : wxEmptyString) );
1632
1633 // delete all entries...
1634 size_t nCount = pGroup->m_aEntries.Count();
1635
1636 wxLogTrace(FILECONF_TRACE_MASK,
1637 _T("Removing %lu entries"), (unsigned long)nCount );
1638
1639 for ( size_t nEntry = 0; nEntry < nCount; nEntry++ )
1640 {
1641 wxFileConfigLineList *pLine = pGroup->m_aEntries[nEntry]->GetLine();
1642
1643 if ( pLine )
1644 {
1645 wxLogTrace( FILECONF_TRACE_MASK,
1646 _T(" '%s'"),
1647 pLine->Text().c_str() );
1648 m_pConfig->LineListRemove(pLine);
1649 }
1650 }
1651
1652 // ...and subgroups of this subgroup
1653 nCount = pGroup->m_aSubgroups.Count();
1654
1655 wxLogTrace( FILECONF_TRACE_MASK,
1656 _T("Removing %lu subgroups"), (unsigned long)nCount );
1657
1658 for ( size_t nGroup = 0; nGroup < nCount; nGroup++ )
1659 {
1660 pGroup->DeleteSubgroup(pGroup->m_aSubgroups[0]);
1661 }
1662
1663 // and then finally the group itself
1664 wxFileConfigLineList *pLine = pGroup->m_pLine;
1665 if ( pLine )
1666 {
1667 wxLogTrace( FILECONF_TRACE_MASK,
1668 _T(" Removing line for group '%s' : '%s'"),
1669 pGroup->Name().c_str(),
1670 pLine->Text().c_str() );
1671 wxLogTrace( FILECONF_TRACE_MASK,
1672 _T(" Removing from group '%s' : '%s'"),
1673 Name().c_str(),
1674 ((m_pLine) ? m_pLine->Text().c_str() : wxEmptyString) );
1675
1676 // notice that we may do this test inside the previous "if"
1677 // because the last entry's line is surely !NULL
1678 if ( pGroup == m_pLastGroup )
1679 {
1680 wxLogTrace( FILECONF_TRACE_MASK,
1681 _T(" Removing last group") );
1682
1683 // our last entry is being deleted, so find the last one which
1684 // stays by going back until we find a subgroup or reach the
1685 // group line
1686 const size_t nSubgroups = m_aSubgroups.Count();
1687
1688 m_pLastGroup = NULL;
1689 for ( wxFileConfigLineList *pl = pLine->Prev();
1690 pl && pl != m_pLine && !m_pLastGroup;
1691 pl = pl->Prev() )
1692 {
1693 // does this line belong to our subgroup?
1694 for ( size_t n = 0; n < nSubgroups; n++ )
1695 {
1696 // do _not_ call GetGroupLine! we don't want to add it to
1697 // the local file if it's not already there
1698 if ( m_aSubgroups[n]->m_pLine == pl )
1699 {
1700 m_pLastGroup = m_aSubgroups[n];
1701 break;
1702 }
1703 }
1704 }
1705 }
1706
1707 m_pConfig->LineListRemove(pLine);
1708 }
1709 else
1710 {
1711 wxLogTrace( FILECONF_TRACE_MASK,
1712 _T(" No line entry for Group '%s'?"),
1713 pGroup->Name().c_str() );
1714 }
1715
1716 m_aSubgroups.Remove(pGroup);
1717 delete pGroup;
1718
1719 return true;
1720 }
1721
1722 bool wxFileConfigGroup::DeleteEntry(const wxChar *szName)
1723 {
1724 wxFileConfigEntry *pEntry = FindEntry(szName);
1725 if ( !pEntry )
1726 {
1727 // entry doesn't exist, nothing to do
1728 return false;
1729 }
1730
1731 wxFileConfigLineList *pLine = pEntry->GetLine();
1732 if ( pLine != NULL ) {
1733 // notice that we may do this test inside the previous "if" because the
1734 // last entry's line is surely !NULL
1735 if ( pEntry == m_pLastEntry ) {
1736 // our last entry is being deleted - find the last one which stays
1737 wxASSERT( m_pLine != NULL ); // if we have an entry with !NULL pLine...
1738
1739 // go back until we find another entry or reach the group's line
1740 wxFileConfigEntry *pNewLast = NULL;
1741 size_t n, nEntries = m_aEntries.Count();
1742 wxFileConfigLineList *pl;
1743 for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) {
1744 // is it our subgroup?
1745 for ( n = 0; (pNewLast == NULL) && (n < nEntries); n++ ) {
1746 if ( m_aEntries[n]->GetLine() == m_pLine )
1747 pNewLast = m_aEntries[n];
1748 }
1749
1750 if ( pNewLast != NULL ) // found?
1751 break;
1752 }
1753
1754 if ( pl == m_pLine ) {
1755 wxASSERT( !pNewLast ); // how comes it has the same line as we?
1756
1757 // we've reached the group line without finding any subgroups
1758 m_pLastEntry = NULL;
1759 }
1760 else
1761 m_pLastEntry = pNewLast;
1762 }
1763
1764 m_pConfig->LineListRemove(pLine);
1765 }
1766
1767 m_aEntries.Remove(pEntry);
1768 delete pEntry;
1769
1770 return true;
1771 }
1772
1773 // ============================================================================
1774 // wxFileConfig::wxFileConfigEntry
1775 // ============================================================================
1776
1777 // ----------------------------------------------------------------------------
1778 // ctor
1779 // ----------------------------------------------------------------------------
1780 wxFileConfigEntry::wxFileConfigEntry(wxFileConfigGroup *pParent,
1781 const wxString& strName,
1782 int nLine)
1783 : m_strName(strName)
1784 {
1785 wxASSERT( !strName.empty() );
1786
1787 m_pParent = pParent;
1788 m_nLine = nLine;
1789 m_pLine = NULL;
1790
1791 m_bHasValue = false;
1792
1793 m_bImmutable = strName[0] == wxCONFIG_IMMUTABLE_PREFIX;
1794 if ( m_bImmutable )
1795 m_strName.erase(0, 1); // remove first character
1796 }
1797
1798 // ----------------------------------------------------------------------------
1799 // set value
1800 // ----------------------------------------------------------------------------
1801
1802 void wxFileConfigEntry::SetLine(wxFileConfigLineList *pLine)
1803 {
1804 if ( m_pLine != NULL ) {
1805 wxLogWarning(_("entry '%s' appears more than once in group '%s'"),
1806 Name().c_str(), m_pParent->GetFullName().c_str());
1807 }
1808
1809 m_pLine = pLine;
1810 Group()->SetLastEntry(this);
1811 }
1812
1813 // second parameter is false if we read the value from file and prevents the
1814 // entry from being marked as 'dirty'
1815 void wxFileConfigEntry::SetValue(const wxString& strValue, bool bUser)
1816 {
1817 if ( bUser && IsImmutable() )
1818 {
1819 wxLogWarning( _("attempt to change immutable key '%s' ignored."),
1820 Name().c_str());
1821 return;
1822 }
1823
1824 // do nothing if it's the same value: but don't test for it if m_bHasValue
1825 // hadn't been set yet or we'd never write empty values to the file
1826 if ( m_bHasValue && strValue == m_strValue )
1827 return;
1828
1829 m_bHasValue = true;
1830 m_strValue = strValue;
1831
1832 if ( bUser )
1833 {
1834 wxString strValFiltered;
1835
1836 if ( Group()->Config()->GetStyle() & wxCONFIG_USE_NO_ESCAPE_CHARACTERS )
1837 {
1838 strValFiltered = strValue;
1839 }
1840 else {
1841 strValFiltered = FilterOutValue(strValue);
1842 }
1843
1844 wxString strLine;
1845 strLine << FilterOutEntryName(m_strName) << wxT('=') << strValFiltered;
1846
1847 if ( m_pLine )
1848 {
1849 // entry was read from the local config file, just modify the line
1850 m_pLine->SetText(strLine);
1851 }
1852 else // this entry didn't exist in the local file
1853 {
1854 // add a new line to the file: note the hack for the root group
1855 // which is special in that it doesn't have its own group line
1856 // (something like "[/]") and so the line we get for it may be not
1857 // its line at all if it doesn't have any entries
1858 //
1859 // this is definitely not the right place to fix it but changing
1860 // the root group to have NULL m_pLine will probably break too
1861 // much stuff elsewhere so I don't dare to do it...
1862 wxFileConfigLineList *line = Group()->GetLastEntryLine();
1863 if ( !Group()->Parent() && line == Group()->GetGroupLine() )
1864 {
1865 // prepend the first root group entry to the head of the list
1866 line = NULL;
1867 }
1868 m_pLine = Group()->Config()->LineListInsert(strLine, line);
1869
1870 Group()->SetLastEntry(this);
1871 }
1872 }
1873 }
1874
1875 // ============================================================================
1876 // global functions
1877 // ============================================================================
1878
1879 // ----------------------------------------------------------------------------
1880 // compare functions for array sorting
1881 // ----------------------------------------------------------------------------
1882
1883 int CompareEntries(wxFileConfigEntry *p1, wxFileConfigEntry *p2)
1884 {
1885 #if wxCONFIG_CASE_SENSITIVE
1886 return wxStrcmp(p1->Name(), p2->Name());
1887 #else
1888 return wxStricmp(p1->Name(), p2->Name());
1889 #endif
1890 }
1891
1892 int CompareGroups(wxFileConfigGroup *p1, wxFileConfigGroup *p2)
1893 {
1894 #if wxCONFIG_CASE_SENSITIVE
1895 return wxStrcmp(p1->Name(), p2->Name());
1896 #else
1897 return wxStricmp(p1->Name(), p2->Name());
1898 #endif
1899 }
1900
1901 // ----------------------------------------------------------------------------
1902 // filter functions
1903 // ----------------------------------------------------------------------------
1904
1905 // undo FilterOutValue
1906 static wxString FilterInValue(const wxString& str)
1907 {
1908 wxString strResult;
1909 strResult.Alloc(str.Len());
1910
1911 bool bQuoted = !str.empty() && str[0] == '"';
1912
1913 for ( size_t n = bQuoted ? 1 : 0; n < str.Len(); n++ ) {
1914 if ( str[n] == wxT('\\') ) {
1915 switch ( str[++n] ) {
1916 case wxT('n'):
1917 strResult += wxT('\n');
1918 break;
1919
1920 case wxT('r'):
1921 strResult += wxT('\r');
1922 break;
1923
1924 case wxT('t'):
1925 strResult += wxT('\t');
1926 break;
1927
1928 case wxT('\\'):
1929 strResult += wxT('\\');
1930 break;
1931
1932 case wxT('"'):
1933 strResult += wxT('"');
1934 break;
1935 }
1936 }
1937 else {
1938 if ( str[n] != wxT('"') || !bQuoted )
1939 strResult += str[n];
1940 else if ( n != str.Len() - 1 ) {
1941 wxLogWarning(_("unexpected \" at position %d in '%s'."),
1942 n, str.c_str());
1943 }
1944 //else: it's the last quote of a quoted string, ok
1945 }
1946 }
1947
1948 return strResult;
1949 }
1950
1951 // quote the string before writing it to file
1952 static wxString FilterOutValue(const wxString& str)
1953 {
1954 if ( !str )
1955 return str;
1956
1957 wxString strResult;
1958 strResult.Alloc(str.Len());
1959
1960 // quoting is necessary to preserve spaces in the beginning of the string
1961 bool bQuote = wxIsspace(str[0]) || str[0] == wxT('"');
1962
1963 if ( bQuote )
1964 strResult += wxT('"');
1965
1966 wxChar c;
1967 for ( size_t n = 0; n < str.Len(); n++ ) {
1968 switch ( str[n] ) {
1969 case wxT('\n'):
1970 c = wxT('n');
1971 break;
1972
1973 case wxT('\r'):
1974 c = wxT('r');
1975 break;
1976
1977 case wxT('\t'):
1978 c = wxT('t');
1979 break;
1980
1981 case wxT('\\'):
1982 c = wxT('\\');
1983 break;
1984
1985 case wxT('"'):
1986 if ( bQuote ) {
1987 c = wxT('"');
1988 break;
1989 }
1990 //else: fall through
1991
1992 default:
1993 strResult += str[n];
1994 continue; // nothing special to do
1995 }
1996
1997 // we get here only for special characters
1998 strResult << wxT('\\') << c;
1999 }
2000
2001 if ( bQuote )
2002 strResult += wxT('"');
2003
2004 return strResult;
2005 }
2006
2007 // undo FilterOutEntryName
2008 static wxString FilterInEntryName(const wxString& str)
2009 {
2010 wxString strResult;
2011 strResult.Alloc(str.Len());
2012
2013 for ( const wxChar *pc = str.c_str(); *pc != '\0'; pc++ ) {
2014 if ( *pc == wxT('\\') )
2015 pc++;
2016
2017 strResult += *pc;
2018 }
2019
2020 return strResult;
2021 }
2022
2023 // sanitize entry or group name: insert '\\' before any special characters
2024 static wxString FilterOutEntryName(const wxString& str)
2025 {
2026 wxString strResult;
2027 strResult.Alloc(str.Len());
2028
2029 for ( const wxChar *pc = str.c_str(); *pc != wxT('\0'); pc++ ) {
2030 const wxChar c = *pc;
2031
2032 // we explicitly allow some of "safe" chars and 8bit ASCII characters
2033 // which will probably never have special meaning and with which we can't
2034 // use isalnum() anyhow (in ASCII built, in Unicode it's just fine)
2035 //
2036 // NB: note that wxCONFIG_IMMUTABLE_PREFIX and wxCONFIG_PATH_SEPARATOR
2037 // should *not* be quoted
2038 if (
2039 #if !wxUSE_UNICODE
2040 ((unsigned char)c < 127) &&
2041 #endif // ANSI
2042 !wxIsalnum(c) && !wxStrchr(wxT("@_/-!.*%"), c) )
2043 {
2044 strResult += wxT('\\');
2045 }
2046
2047 strResult += c;
2048 }
2049
2050 return strResult;
2051 }
2052
2053 // we can't put ?: in the ctor initializer list because it confuses some
2054 // broken compilers (Borland C++)
2055 static wxString GetAppName(const wxString& appName)
2056 {
2057 if ( !appName && wxTheApp )
2058 return wxTheApp->GetAppName();
2059 else
2060 return appName;
2061 }
2062
2063 #endif // wxUSE_CONFIG
2064
wxWidgets (Impactor)