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