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


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