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


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