1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/fileconf.cpp
3 // Purpose: implementation of wxFileConfig derivation of wxConfig
4 // Author: Vadim Zeitlin
6 // Created: 07.04.98 (adapted from appconf.cpp)
8 // Copyright: (c) 1997 Karsten Ballüder & Vadim Zeitlin
9 // Ballueder@usa.net <zeitlin@dptmaths.ens-cachan.fr>
10 // Licence: wxWindows licence
11 ///////////////////////////////////////////////////////////////////////////////
13 // ----------------------------------------------------------------------------
15 // ----------------------------------------------------------------------------
17 // For compilers that support precompilation, includes "wx.h".
18 #include "wx/wxprec.h"
24 #if wxUSE_CONFIG && wxUSE_FILECONFIG
27 #include "wx/dynarray.h"
28 #include "wx/string.h"
32 #include "wx/utils.h" // for wxGetHomeDir
34 #include "wx/stream.h"
35 #endif // wxUSE_STREAMS
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"
45 #if defined(__WXMAC__)
46 #include "wx/mac/private.h" // includes mac headers
47 #include "wx/filename.h" // for MacSetTypeAndCreator
50 #if defined(__WXMSW__)
51 #include "wx/msw/private.h"
61 // ----------------------------------------------------------------------------
63 // ----------------------------------------------------------------------------
64 #define CONST_CAST ((wxFileConfig *)this)->
66 // ----------------------------------------------------------------------------
68 // ----------------------------------------------------------------------------
74 #define FILECONF_TRACE_MASK _T("fileconf")
76 // ----------------------------------------------------------------------------
77 // global functions declarations
78 // ----------------------------------------------------------------------------
80 // compare functions for sorting the arrays
81 static int LINKAGEMODE
CompareEntries(wxFileConfigEntry
*p1
, wxFileConfigEntry
*p2
);
82 static int LINKAGEMODE
CompareGroups(wxFileConfigGroup
*p1
, wxFileConfigGroup
*p2
);
85 static wxString
FilterInValue(const wxString
& str
);
86 static wxString
FilterOutValue(const wxString
& str
);
88 static wxString
FilterInEntryName(const wxString
& str
);
89 static wxString
FilterOutEntryName(const wxString
& str
);
91 // get the name to use in wxFileConfig ctor
92 static wxString
GetAppName(const wxString
& appname
);
94 // ============================================================================
96 // ============================================================================
98 // ----------------------------------------------------------------------------
99 // "template" array types
100 // ----------------------------------------------------------------------------
102 #ifdef WXMAKINGDLL_BASE
103 WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(wxFileConfigEntry
*, ArrayEntries
,
105 WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(wxFileConfigGroup
*, ArrayGroups
,
108 WX_DEFINE_SORTED_ARRAY(wxFileConfigEntry
*, ArrayEntries
);
109 WX_DEFINE_SORTED_ARRAY(wxFileConfigGroup
*, ArrayGroups
);
112 // ----------------------------------------------------------------------------
113 // wxFileConfigLineList
114 // ----------------------------------------------------------------------------
116 // we store all lines of the local config file as a linked list in memory
117 class wxFileConfigLineList
120 void SetNext(wxFileConfigLineList
*pNext
) { m_pNext
= pNext
; }
121 void SetPrev(wxFileConfigLineList
*pPrev
) { m_pPrev
= pPrev
; }
124 wxFileConfigLineList(const wxString
& str
,
125 wxFileConfigLineList
*pNext
= NULL
) : m_strLine(str
)
126 { SetNext(pNext
); SetPrev(NULL
); }
128 // next/prev nodes in the linked list
129 wxFileConfigLineList
*Next() const { return m_pNext
; }
130 wxFileConfigLineList
*Prev() const { return m_pPrev
; }
132 // get/change lines text
133 void SetText(const wxString
& str
) { m_strLine
= str
; }
134 const wxString
& Text() const { return m_strLine
; }
137 wxString m_strLine
; // line contents
138 wxFileConfigLineList
*m_pNext
, // next node
139 *m_pPrev
; // previous one
141 DECLARE_NO_COPY_CLASS(wxFileConfigLineList
)
144 // ----------------------------------------------------------------------------
145 // wxFileConfigEntry: a name/value pair
146 // ----------------------------------------------------------------------------
148 class wxFileConfigEntry
151 wxFileConfigGroup
*m_pParent
; // group that contains us
153 wxString m_strName
, // entry name
155 bool m_bImmutable
:1, // can be overriden locally?
156 m_bHasValue
:1; // set after first call to SetValue()
158 int m_nLine
; // used if m_pLine == NULL only
160 // pointer to our line in the linked list or NULL if it was found in global
161 // file (which we don't modify)
162 wxFileConfigLineList
*m_pLine
;
165 wxFileConfigEntry(wxFileConfigGroup
*pParent
,
166 const wxString
& strName
, int nLine
);
169 const wxString
& Name() const { return m_strName
; }
170 const wxString
& Value() const { return m_strValue
; }
171 wxFileConfigGroup
*Group() const { return m_pParent
; }
172 bool IsImmutable() const { return m_bImmutable
; }
173 bool IsLocal() const { return m_pLine
!= 0; }
174 int Line() const { return m_nLine
; }
175 wxFileConfigLineList
*
176 GetLine() const { return m_pLine
; }
178 // modify entry attributes
179 void SetValue(const wxString
& strValue
, bool bUser
= true);
180 void SetLine(wxFileConfigLineList
*pLine
);
182 DECLARE_NO_COPY_CLASS(wxFileConfigEntry
)
185 // ----------------------------------------------------------------------------
186 // wxFileConfigGroup: container of entries and other groups
187 // ----------------------------------------------------------------------------
189 class wxFileConfigGroup
192 wxFileConfig
*m_pConfig
; // config object we belong to
193 wxFileConfigGroup
*m_pParent
; // parent group (NULL for root group)
194 ArrayEntries m_aEntries
; // entries in this group
195 ArrayGroups m_aSubgroups
; // subgroups
196 wxString m_strName
; // group's name
197 wxFileConfigLineList
*m_pLine
; // pointer to our line in the linked list
198 wxFileConfigEntry
*m_pLastEntry
; // last entry/subgroup of this group in the
199 wxFileConfigGroup
*m_pLastGroup
; // local file (we insert new ones after it)
201 // DeleteSubgroupByName helper
202 bool DeleteSubgroup(wxFileConfigGroup
*pGroup
);
205 void UpdateGroupAndSubgroupsLines();
209 wxFileConfigGroup(wxFileConfigGroup
*pParent
, const wxString
& strName
, wxFileConfig
*);
211 // dtor deletes all entries and subgroups also
212 ~wxFileConfigGroup();
215 const wxString
& Name() const { return m_strName
; }
216 wxFileConfigGroup
*Parent() const { return m_pParent
; }
217 wxFileConfig
*Config() const { return m_pConfig
; }
219 const ArrayEntries
& Entries() const { return m_aEntries
; }
220 const ArrayGroups
& Groups() const { return m_aSubgroups
; }
221 bool IsEmpty() const { return Entries().IsEmpty() && Groups().IsEmpty(); }
223 // find entry/subgroup (NULL if not found)
224 wxFileConfigGroup
*FindSubgroup(const wxChar
*szName
) const;
225 wxFileConfigEntry
*FindEntry (const wxChar
*szName
) const;
227 // delete entry/subgroup, return false if doesn't exist
228 bool DeleteSubgroupByName(const wxChar
*szName
);
229 bool DeleteEntry(const wxChar
*szName
);
231 // create new entry/subgroup returning pointer to newly created element
232 wxFileConfigGroup
*AddSubgroup(const wxString
& strName
);
233 wxFileConfigEntry
*AddEntry (const wxString
& strName
, int nLine
= wxNOT_FOUND
);
235 void SetLine(wxFileConfigLineList
*pLine
);
237 // rename: no checks are done to ensure that the name is unique!
238 void Rename(const wxString
& newName
);
241 wxString
GetFullName() const;
243 // get the last line belonging to an entry/subgroup of this group
244 wxFileConfigLineList
*GetGroupLine(); // line which contains [group]
245 wxFileConfigLineList
*GetLastEntryLine(); // after which our subgroups start
246 wxFileConfigLineList
*GetLastGroupLine(); // after which the next group starts
248 // called by entries/subgroups when they're created/deleted
249 void SetLastEntry(wxFileConfigEntry
*pEntry
);
250 void SetLastGroup(wxFileConfigGroup
*pGroup
)
251 { m_pLastGroup
= pGroup
; }
253 DECLARE_NO_COPY_CLASS(wxFileConfigGroup
)
256 // ============================================================================
258 // ============================================================================
260 // ----------------------------------------------------------------------------
262 // ----------------------------------------------------------------------------
263 wxString
wxFileConfig::GetGlobalDir()
267 #ifdef __VMS__ // Note if __VMS is defined __UNIX is also defined
268 strDir
= wxT("sys$manager:");
269 #elif defined(__WXMAC__)
270 strDir
= wxMacFindFolder( (short) kOnSystemDisk
, kPreferencesFolderType
, kDontCreateFolder
) ;
271 #elif defined( __UNIX__ )
272 strDir
= wxT("/etc/");
273 #elif defined(__OS2__)
274 ULONG aulSysInfo
[QSV_MAX
] = {0};
278 rc
= DosQuerySysInfo( 1L, QSV_MAX
, (PVOID
)aulSysInfo
, sizeof(ULONG
)*QSV_MAX
);
281 drive
= aulSysInfo
[QSV_BOOT_DRIVE
- 1];
282 strDir
.Printf(wxT("%c:\\OS2\\"), 'A'+drive
-1);
284 #elif defined(__WXSTUBS__)
285 wxFAIL_MSG( wxT("TODO") );
286 #elif defined(__DOS__)
287 // There's no such thing as global cfg dir in MS-DOS, let's return
288 // current directory (FIXME_MGL?)
290 #elif defined(__WXWINCE__)
291 strDir
= wxT("\\Windows\\");
294 wxChar szWinDir
[MAX_PATH
];
295 ::GetWindowsDirectory(szWinDir
, MAX_PATH
);
299 #endif // Unix/Windows
304 wxString
wxFileConfig::GetLocalDir()
308 #if defined(__WXMAC__) || defined(__DOS__)
309 // no local dir concept on Mac OS 9 or MS-DOS
310 strDir
<< GetGlobalDir() ;
312 wxGetHomeDir(&strDir
);
316 (strDir
.Last() != wxT('/'))
318 && (strDir
.Last() != wxT(']'))
323 if (strDir
.Last() != wxT('\\'))
331 wxString
wxFileConfig::GetGlobalFileName(const wxChar
*szFile
)
333 wxString str
= GetGlobalDir();
336 if ( wxStrchr(szFile
, wxT('.')) == NULL
)
337 #if defined( __WXMAC__ )
338 str
<< wxT(" Preferences") ;
339 #elif defined( __UNIX__ )
348 wxString
wxFileConfig::GetLocalFileName(const wxChar
*szFile
)
351 // On VMS I saw the problem that the home directory was appended
352 // twice for the configuration file. Does that also happen for
354 wxString str
= wxT( '.' );
356 wxString str
= GetLocalDir();
359 #if defined( __UNIX__ ) && !defined( __VMS ) && !defined( __WXMAC__ )
365 #if defined(__WINDOWS__) || defined(__DOS__)
366 if ( wxStrchr(szFile
, wxT('.')) == NULL
)
371 str
<< wxT(" Preferences") ;
377 // ----------------------------------------------------------------------------
379 // ----------------------------------------------------------------------------
381 void wxFileConfig::Init()
384 m_pRootGroup
= new wxFileConfigGroup(NULL
, wxEmptyString
, this);
389 // It's not an error if (one of the) file(s) doesn't exist.
391 // parse the global file
392 if ( !m_strGlobalFile
.empty() && wxFile::Exists(m_strGlobalFile
) )
394 wxTextFile
fileGlobal(m_strGlobalFile
);
396 if ( fileGlobal
.Open(*m_conv
/*ignored in ANSI build*/) )
398 Parse(fileGlobal
, false /* global */);
403 wxLogWarning(_("can't open global configuration file '%s'."), m_strGlobalFile
.c_str());
407 // parse the local file
408 if ( !m_strLocalFile
.empty() && wxFile::Exists(m_strLocalFile
) )
410 wxTextFile
fileLocal(m_strLocalFile
);
411 if ( fileLocal
.Open(*m_conv
/*ignored in ANSI build*/) )
413 Parse(fileLocal
, true /* local */);
418 wxLogWarning(_("can't open user configuration file '%s'."), m_strLocalFile
.c_str() );
425 // constructor supports creation of wxFileConfig objects of any type
426 wxFileConfig::wxFileConfig(const wxString
& appName
, const wxString
& vendorName
,
427 const wxString
& strLocal
, const wxString
& strGlobal
,
429 const wxMBConv
& conv
)
430 : wxConfigBase(::GetAppName(appName
), vendorName
,
433 m_strLocalFile(strLocal
), m_strGlobalFile(strGlobal
),
436 // Make up names for files if empty
437 if ( m_strLocalFile
.empty() && (style
& wxCONFIG_USE_LOCAL_FILE
) )
438 m_strLocalFile
= GetLocalFileName(GetAppName());
440 if ( m_strGlobalFile
.empty() && (style
& wxCONFIG_USE_GLOBAL_FILE
) )
441 m_strGlobalFile
= GetGlobalFileName(GetAppName());
443 // Check if styles are not supplied, but filenames are, in which case
444 // add the correct styles.
445 if ( !m_strLocalFile
.empty() )
446 SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE
);
448 if ( !m_strGlobalFile
.empty() )
449 SetStyle(GetStyle() | wxCONFIG_USE_GLOBAL_FILE
);
451 // if the path is not absolute, prepend the standard directory to it
452 // UNLESS wxCONFIG_USE_RELATIVE_PATH style is set
453 if ( !(style
& wxCONFIG_USE_RELATIVE_PATH
) )
455 if ( !m_strLocalFile
.empty() && !wxIsAbsolutePath(m_strLocalFile
) )
457 const wxString strLocalOrig
= m_strLocalFile
;
458 m_strLocalFile
= GetLocalDir();
459 m_strLocalFile
<< strLocalOrig
;
462 if ( !m_strGlobalFile
.empty() && !wxIsAbsolutePath(m_strGlobalFile
) )
464 const wxString strGlobalOrig
= m_strGlobalFile
;
465 m_strGlobalFile
= GetGlobalDir();
466 m_strGlobalFile
<< strGlobalOrig
;
477 wxFileConfig::wxFileConfig(wxInputStream
&inStream
, const wxMBConv
& conv
)
478 : m_conv(conv
.Clone())
480 // always local_file when this constructor is called (?)
481 SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE
);
484 m_pRootGroup
= new wxFileConfigGroup(NULL
, wxEmptyString
, this);
489 // translate everything to the current (platform-dependent) line
490 // termination character
498 inStream
.Read(buf
, WXSIZEOF(buf
)-1); // leave room for the NULL
500 const wxStreamError err
= inStream
.GetLastError();
502 if ( err
!= wxSTREAM_NO_ERROR
&& err
!= wxSTREAM_EOF
)
504 wxLogError(_("Error reading config options."));
508 // FIXME: this is broken because if we have part of multibyte
509 // character in the buffer (and another part hasn't been
510 // read yet) we're going to lose data because of conversion
512 buf
[inStream
.LastRead()] = '\0';
513 strTmp
+= conv
.cMB2WX(buf
);
515 while ( !inStream
.Eof() );
517 strTrans
= wxTextBuffer::Translate(strTmp
);
520 wxMemoryText memText
;
522 // Now we can add the text to the memory text. To do this we extract line
523 // by line from the translated string, until we've reached the end.
525 // VZ: all this is horribly inefficient, we should do the translation on
526 // the fly in one pass saving both memory and time (TODO)
528 const wxChar
*pEOL
= wxTextBuffer::GetEOL(wxTextBuffer::typeDefault
);
529 const size_t EOLLen
= wxStrlen(pEOL
);
531 int posLineStart
= strTrans
.Find(pEOL
);
532 while ( posLineStart
!= -1 )
534 wxString
line(strTrans
.Left(posLineStart
));
536 memText
.AddLine(line
);
538 strTrans
= strTrans
.Mid(posLineStart
+ EOLLen
);
540 posLineStart
= strTrans
.Find(pEOL
);
543 // also add whatever we have left in the translated string.
544 if ( !strTrans
.empty() )
545 memText
.AddLine(strTrans
);
547 // Finally we can parse it all.
548 Parse(memText
, true /* local */);
554 #endif // wxUSE_STREAMS
556 void wxFileConfig::CleanUp()
560 wxFileConfigLineList
*pCur
= m_linesHead
;
561 while ( pCur
!= NULL
) {
562 wxFileConfigLineList
*pNext
= pCur
->Next();
568 wxFileConfig::~wxFileConfig()
577 // ----------------------------------------------------------------------------
578 // parse a config file
579 // ----------------------------------------------------------------------------
581 void wxFileConfig::Parse(const wxTextBuffer
& buffer
, bool bLocal
)
583 const wxChar
*pStart
;
587 size_t nLineCount
= buffer
.GetLineCount();
589 for ( size_t n
= 0; n
< nLineCount
; n
++ )
593 // add the line to linked list
596 LineListAppend(strLine
);
598 // let the root group have its start line as well
601 m_pCurrentGroup
->SetLine(m_linesTail
);
606 // skip leading spaces
607 for ( pStart
= strLine
; wxIsspace(*pStart
); pStart
++ )
610 // skip blank/comment lines
611 if ( *pStart
== wxT('\0')|| *pStart
== wxT(';') || *pStart
== wxT('#') )
614 if ( *pStart
== wxT('[') ) { // a new group
617 while ( *++pEnd
!= wxT(']') ) {
618 if ( *pEnd
== wxT('\\') ) {
619 // the next char is escaped, so skip it even if it is ']'
623 if ( *pEnd
== wxT('\n') || *pEnd
== wxT('\0') ) {
624 // we reached the end of line, break out of the loop
629 if ( *pEnd
!= wxT(']') ) {
630 wxLogError(_("file '%s': unexpected character %c at line %d."),
631 buffer
.GetName(), *pEnd
, n
+ 1);
632 continue; // skip this line
635 // group name here is always considered as abs path
638 strGroup
<< wxCONFIG_PATH_SEPARATOR
639 << FilterInEntryName(wxString(pStart
, pEnd
- pStart
));
641 // will create it if doesn't yet exist
646 if ( m_pCurrentGroup
->Parent() )
647 m_pCurrentGroup
->Parent()->SetLastGroup(m_pCurrentGroup
);
648 m_pCurrentGroup
->SetLine(m_linesTail
);
651 // check that there is nothing except comments left on this line
653 while ( *++pEnd
!= wxT('\0') && bCont
) {
662 // ignore whitespace ('\n' impossible here)
666 wxLogWarning(_("file '%s', line %d: '%s' ignored after group header."),
667 buffer
.GetName(), n
+ 1, pEnd
);
674 while ( *pEnd
&& *pEnd
!= wxT('=') /* && !wxIsspace(*pEnd)*/ ) {
675 if ( *pEnd
== wxT('\\') ) {
676 // next character may be space or not - still take it because it's
677 // quoted (unless there is nothing)
680 // the error message will be given below anyhow
688 wxString
strKey(FilterInEntryName(wxString(pStart
, pEnd
).Trim()));
691 while ( wxIsspace(*pEnd
) )
694 if ( *pEnd
++ != wxT('=') ) {
695 wxLogError(_("file '%s', line %d: '=' expected."),
696 buffer
.GetName(), n
+ 1);
699 wxFileConfigEntry
*pEntry
= m_pCurrentGroup
->FindEntry(strKey
);
701 if ( pEntry
== NULL
) {
703 pEntry
= m_pCurrentGroup
->AddEntry(strKey
, n
);
706 if ( bLocal
&& pEntry
->IsImmutable() ) {
707 // immutable keys can't be changed by user
708 wxLogWarning(_("file '%s', line %d: value for immutable key '%s' ignored."),
709 buffer
.GetName(), n
+ 1, strKey
.c_str());
712 // the condition below catches the cases (a) and (b) but not (c):
713 // (a) global key found second time in global file
714 // (b) key found second (or more) time in local file
715 // (c) key from global file now found in local one
716 // which is exactly what we want.
717 else if ( !bLocal
|| pEntry
->IsLocal() ) {
718 wxLogWarning(_("file '%s', line %d: key '%s' was first found at line %d."),
719 buffer
.GetName(), n
+ 1, strKey
.c_str(), pEntry
->Line());
725 pEntry
->SetLine(m_linesTail
);
728 while ( wxIsspace(*pEnd
) )
731 wxString value
= pEnd
;
732 if ( !(GetStyle() & wxCONFIG_USE_NO_ESCAPE_CHARACTERS
) )
733 value
= FilterInValue(value
);
735 pEntry
->SetValue(value
, false);
741 // ----------------------------------------------------------------------------
743 // ----------------------------------------------------------------------------
745 void wxFileConfig::SetRootPath()
748 m_pCurrentGroup
= m_pRootGroup
;
752 wxFileConfig::DoSetPath(const wxString
& strPath
, bool createMissingComponents
)
754 wxArrayString aParts
;
756 if ( strPath
.empty() ) {
761 if ( strPath
[0] == wxCONFIG_PATH_SEPARATOR
) {
763 wxSplitPath(aParts
, strPath
);
766 // relative path, combine with current one
767 wxString strFullPath
= m_strPath
;
768 strFullPath
<< wxCONFIG_PATH_SEPARATOR
<< strPath
;
769 wxSplitPath(aParts
, strFullPath
);
772 // change current group
774 m_pCurrentGroup
= m_pRootGroup
;
775 for ( n
= 0; n
< aParts
.Count(); n
++ ) {
776 wxFileConfigGroup
*pNextGroup
= m_pCurrentGroup
->FindSubgroup(aParts
[n
]);
777 if ( pNextGroup
== NULL
)
779 if ( !createMissingComponents
)
782 pNextGroup
= m_pCurrentGroup
->AddSubgroup(aParts
[n
]);
785 m_pCurrentGroup
= pNextGroup
;
788 // recombine path parts in one variable
790 for ( n
= 0; n
< aParts
.Count(); n
++ ) {
791 m_strPath
<< wxCONFIG_PATH_SEPARATOR
<< aParts
[n
];
797 void wxFileConfig::SetPath(const wxString
& strPath
)
799 DoSetPath(strPath
, true /* create missing path components */);
802 // ----------------------------------------------------------------------------
804 // ----------------------------------------------------------------------------
806 bool wxFileConfig::GetFirstGroup(wxString
& str
, long& lIndex
) const
809 return GetNextGroup(str
, lIndex
);
812 bool wxFileConfig::GetNextGroup (wxString
& str
, long& lIndex
) const
814 if ( size_t(lIndex
) < m_pCurrentGroup
->Groups().Count() ) {
815 str
= m_pCurrentGroup
->Groups()[(size_t)lIndex
++]->Name();
822 bool wxFileConfig::GetFirstEntry(wxString
& str
, long& lIndex
) const
825 return GetNextEntry(str
, lIndex
);
828 bool wxFileConfig::GetNextEntry (wxString
& str
, long& lIndex
) const
830 if ( size_t(lIndex
) < m_pCurrentGroup
->Entries().Count() ) {
831 str
= m_pCurrentGroup
->Entries()[(size_t)lIndex
++]->Name();
838 size_t wxFileConfig::GetNumberOfEntries(bool bRecursive
) const
840 size_t n
= m_pCurrentGroup
->Entries().Count();
842 wxFileConfigGroup
*pOldCurrentGroup
= m_pCurrentGroup
;
843 size_t nSubgroups
= m_pCurrentGroup
->Groups().Count();
844 for ( size_t nGroup
= 0; nGroup
< nSubgroups
; nGroup
++ ) {
845 CONST_CAST m_pCurrentGroup
= m_pCurrentGroup
->Groups()[nGroup
];
846 n
+= GetNumberOfEntries(true);
847 CONST_CAST m_pCurrentGroup
= pOldCurrentGroup
;
854 size_t wxFileConfig::GetNumberOfGroups(bool bRecursive
) const
856 size_t n
= m_pCurrentGroup
->Groups().Count();
858 wxFileConfigGroup
*pOldCurrentGroup
= m_pCurrentGroup
;
859 size_t nSubgroups
= m_pCurrentGroup
->Groups().Count();
860 for ( size_t nGroup
= 0; nGroup
< nSubgroups
; nGroup
++ ) {
861 CONST_CAST m_pCurrentGroup
= m_pCurrentGroup
->Groups()[nGroup
];
862 n
+= GetNumberOfGroups(true);
863 CONST_CAST m_pCurrentGroup
= pOldCurrentGroup
;
870 // ----------------------------------------------------------------------------
871 // tests for existence
872 // ----------------------------------------------------------------------------
874 bool wxFileConfig::HasGroup(const wxString
& strName
) const
876 // special case: DoSetPath("") does work as it's equivalent to DoSetPath("/")
877 // but there is no group with empty name so treat this separately
878 if ( strName
.empty() )
881 const wxString pathOld
= GetPath();
883 wxFileConfig
*self
= wx_const_cast(wxFileConfig
*, this);
885 rc
= self
->DoSetPath(strName
, false /* don't create missing components */);
887 self
->SetPath(pathOld
);
892 bool wxFileConfig::HasEntry(const wxString
& entry
) const
894 // path is the part before the last "/"
895 wxString path
= entry
.BeforeLast(wxCONFIG_PATH_SEPARATOR
);
897 // except in the special case of "/keyname" when there is nothing before "/"
898 if ( path
.empty() && *entry
.c_str() == wxCONFIG_PATH_SEPARATOR
)
900 path
= wxCONFIG_PATH_SEPARATOR
;
903 // change to the path of the entry if necessary and remember the old path
904 // to restore it later
906 wxFileConfig
* const self
= wx_const_cast(wxFileConfig
*, this);
910 if ( pathOld
.empty() )
911 pathOld
= wxCONFIG_PATH_SEPARATOR
;
913 if ( !self
->DoSetPath(path
, false /* don't create if doesn't exist */) )
919 // check if the entry exists in this group
920 const bool exists
= m_pCurrentGroup
->FindEntry(
921 entry
.AfterLast(wxCONFIG_PATH_SEPARATOR
)) != NULL
;
923 // restore the old path if we changed it above
924 if ( !pathOld
.empty() )
926 self
->SetPath(pathOld
);
932 // ----------------------------------------------------------------------------
934 // ----------------------------------------------------------------------------
936 bool wxFileConfig::DoReadString(const wxString
& key
, wxString
* pStr
) const
938 wxConfigPathChanger
path(this, key
);
940 wxFileConfigEntry
*pEntry
= m_pCurrentGroup
->FindEntry(path
.Name());
941 if (pEntry
== NULL
) {
945 *pStr
= pEntry
->Value();
950 bool wxFileConfig::DoReadLong(const wxString
& key
, long *pl
) const
953 if ( !Read(key
, &str
) )
956 // extra spaces shouldn't prevent us from reading numeric values
959 return str
.ToLong(pl
);
962 bool wxFileConfig::DoWriteString(const wxString
& key
, const wxString
& szValue
)
964 wxConfigPathChanger
path(this, key
);
965 wxString strName
= path
.Name();
967 wxLogTrace( FILECONF_TRACE_MASK
,
968 _T(" Writing String '%s' = '%s' to Group '%s'"),
973 if ( strName
.empty() )
975 // setting the value of a group is an error
977 wxASSERT_MSG( szValue
.empty(), wxT("can't set value of a group!") );
979 // ... except if it's empty in which case it's a way to force it's creation
981 wxLogTrace( FILECONF_TRACE_MASK
,
982 _T(" Creating group %s"),
983 m_pCurrentGroup
->Name().c_str() );
987 // this will add a line for this group if it didn't have it before
989 (void)m_pCurrentGroup
->GetGroupLine();
993 // writing an entry check that the name is reasonable
994 if ( strName
[0u] == wxCONFIG_IMMUTABLE_PREFIX
)
996 wxLogError( _("Config entry name cannot start with '%c'."),
997 wxCONFIG_IMMUTABLE_PREFIX
);
1001 wxFileConfigEntry
*pEntry
= m_pCurrentGroup
->FindEntry(strName
);
1005 wxLogTrace( FILECONF_TRACE_MASK
,
1006 _T(" Adding Entry %s"),
1008 pEntry
= m_pCurrentGroup
->AddEntry(strName
);
1011 wxLogTrace( FILECONF_TRACE_MASK
,
1012 _T(" Setting value %s"),
1014 pEntry
->SetValue(szValue
);
1022 bool wxFileConfig::DoWriteLong(const wxString
& key
, long lValue
)
1024 return Write(key
, wxString::Format(_T("%ld"), lValue
));
1027 bool wxFileConfig::Flush(bool /* bCurrentOnly */)
1029 if ( !IsDirty() || !m_strLocalFile
)
1032 // set the umask if needed
1033 wxCHANGE_UMASK(m_umask
);
1035 wxTempFile
file(m_strLocalFile
);
1037 if ( !file
.IsOpened() )
1039 wxLogError(_("can't open user configuration file."));
1043 // write all strings to file
1044 for ( wxFileConfigLineList
*p
= m_linesHead
; p
!= NULL
; p
= p
->Next() )
1046 wxString line
= p
->Text();
1047 line
+= wxTextFile::GetEOL();
1048 if ( !file
.Write(line
, *m_conv
) )
1050 wxLogError(_("can't write user configuration file."));
1055 if ( !file
.Commit() )
1057 wxLogError(_("Failed to update user configuration file."));
1064 #if defined(__WXMAC__)
1065 wxFileName(m_strLocalFile
).MacSetTypeAndCreator('TEXT', 'ttxt');
1073 bool wxFileConfig::Save(wxOutputStream
& os
, const wxMBConv
& conv
)
1075 // save unconditionally, even if not dirty
1076 for ( wxFileConfigLineList
*p
= m_linesHead
; p
!= NULL
; p
= p
->Next() )
1078 wxString line
= p
->Text();
1079 line
+= wxTextFile::GetEOL();
1081 wxCharBuffer
buf(line
.mb_str(conv
));
1082 if ( !os
.Write(buf
, strlen(buf
)) )
1084 wxLogError(_("Error saving user configuration data."));
1095 #endif // wxUSE_STREAMS
1097 // ----------------------------------------------------------------------------
1098 // renaming groups/entries
1099 // ----------------------------------------------------------------------------
1101 bool wxFileConfig::RenameEntry(const wxString
& oldName
,
1102 const wxString
& newName
)
1104 wxASSERT_MSG( !wxStrchr(oldName
, wxCONFIG_PATH_SEPARATOR
),
1105 _T("RenameEntry(): paths are not supported") );
1107 // check that the entry exists
1108 wxFileConfigEntry
*oldEntry
= m_pCurrentGroup
->FindEntry(oldName
);
1112 // check that the new entry doesn't already exist
1113 if ( m_pCurrentGroup
->FindEntry(newName
) )
1116 // delete the old entry, create the new one
1117 wxString value
= oldEntry
->Value();
1118 if ( !m_pCurrentGroup
->DeleteEntry(oldName
) )
1123 wxFileConfigEntry
*newEntry
= m_pCurrentGroup
->AddEntry(newName
);
1124 newEntry
->SetValue(value
);
1129 bool wxFileConfig::RenameGroup(const wxString
& oldName
,
1130 const wxString
& newName
)
1132 // check that the group exists
1133 wxFileConfigGroup
*group
= m_pCurrentGroup
->FindSubgroup(oldName
);
1137 // check that the new group doesn't already exist
1138 if ( m_pCurrentGroup
->FindSubgroup(newName
) )
1141 group
->Rename(newName
);
1148 // ----------------------------------------------------------------------------
1149 // delete groups/entries
1150 // ----------------------------------------------------------------------------
1152 bool wxFileConfig::DeleteEntry(const wxString
& key
, bool bGroupIfEmptyAlso
)
1154 wxConfigPathChanger
path(this, key
);
1156 if ( !m_pCurrentGroup
->DeleteEntry(path
.Name()) )
1161 if ( bGroupIfEmptyAlso
&& m_pCurrentGroup
->IsEmpty() ) {
1162 if ( m_pCurrentGroup
!= m_pRootGroup
) {
1163 wxFileConfigGroup
*pGroup
= m_pCurrentGroup
;
1164 SetPath(wxT("..")); // changes m_pCurrentGroup!
1165 m_pCurrentGroup
->DeleteSubgroupByName(pGroup
->Name());
1167 //else: never delete the root group
1173 bool wxFileConfig::DeleteGroup(const wxString
& key
)
1175 wxConfigPathChanger
path(this, key
);
1177 if ( !m_pCurrentGroup
->DeleteSubgroupByName(path
.Name()) )
1180 path
.UpdateIfDeleted();
1187 bool wxFileConfig::DeleteAll()
1191 if ( !m_strLocalFile
.empty() )
1193 if ( wxFile::Exists(m_strLocalFile
) && wxRemove(m_strLocalFile
) == -1 )
1195 wxLogSysError(_("can't delete user configuration file '%s'"),
1196 m_strLocalFile
.c_str());
1206 // ----------------------------------------------------------------------------
1207 // linked list functions
1208 // ----------------------------------------------------------------------------
1210 // append a new line to the end of the list
1212 wxFileConfigLineList
*wxFileConfig::LineListAppend(const wxString
& str
)
1214 wxLogTrace( FILECONF_TRACE_MASK
,
1215 _T(" ** Adding Line '%s'"),
1217 wxLogTrace( FILECONF_TRACE_MASK
,
1219 ((m_linesHead
) ? m_linesHead
->Text().c_str() : wxEmptyString
) );
1220 wxLogTrace( FILECONF_TRACE_MASK
,
1222 ((m_linesTail
) ? m_linesTail
->Text().c_str() : wxEmptyString
) );
1224 wxFileConfigLineList
*pLine
= new wxFileConfigLineList(str
);
1226 if ( m_linesTail
== NULL
)
1229 m_linesHead
= pLine
;
1234 m_linesTail
->SetNext(pLine
);
1235 pLine
->SetPrev(m_linesTail
);
1238 m_linesTail
= pLine
;
1240 wxLogTrace( FILECONF_TRACE_MASK
,
1242 ((m_linesHead
) ? m_linesHead
->Text().c_str() : wxEmptyString
) );
1243 wxLogTrace( FILECONF_TRACE_MASK
,
1245 ((m_linesTail
) ? m_linesTail
->Text().c_str() : wxEmptyString
) );
1250 // insert a new line after the given one or in the very beginning if !pLine
1251 wxFileConfigLineList
*wxFileConfig::LineListInsert(const wxString
& str
,
1252 wxFileConfigLineList
*pLine
)
1254 wxLogTrace( FILECONF_TRACE_MASK
,
1255 _T(" ** Inserting Line '%s' after '%s'"),
1257 ((pLine
) ? pLine
->Text().c_str() : wxEmptyString
) );
1258 wxLogTrace( FILECONF_TRACE_MASK
,
1260 ((m_linesHead
) ? m_linesHead
->Text().c_str() : wxEmptyString
) );
1261 wxLogTrace( FILECONF_TRACE_MASK
,
1263 ((m_linesTail
) ? m_linesTail
->Text().c_str() : wxEmptyString
) );
1265 if ( pLine
== m_linesTail
)
1266 return LineListAppend(str
);
1268 wxFileConfigLineList
*pNewLine
= new wxFileConfigLineList(str
);
1269 if ( pLine
== NULL
)
1271 // prepend to the list
1272 pNewLine
->SetNext(m_linesHead
);
1273 m_linesHead
->SetPrev(pNewLine
);
1274 m_linesHead
= pNewLine
;
1278 // insert before pLine
1279 wxFileConfigLineList
*pNext
= pLine
->Next();
1280 pNewLine
->SetNext(pNext
);
1281 pNewLine
->SetPrev(pLine
);
1282 pNext
->SetPrev(pNewLine
);
1283 pLine
->SetNext(pNewLine
);
1286 wxLogTrace( FILECONF_TRACE_MASK
,
1288 ((m_linesHead
) ? m_linesHead
->Text().c_str() : wxEmptyString
) );
1289 wxLogTrace( FILECONF_TRACE_MASK
,
1291 ((m_linesTail
) ? m_linesTail
->Text().c_str() : wxEmptyString
) );
1296 void wxFileConfig::LineListRemove(wxFileConfigLineList
*pLine
)
1298 wxLogTrace( FILECONF_TRACE_MASK
,
1299 _T(" ** Removing Line '%s'"),
1300 pLine
->Text().c_str() );
1301 wxLogTrace( FILECONF_TRACE_MASK
,
1303 ((m_linesHead
) ? m_linesHead
->Text().c_str() : wxEmptyString
) );
1304 wxLogTrace( FILECONF_TRACE_MASK
,
1306 ((m_linesTail
) ? m_linesTail
->Text().c_str() : wxEmptyString
) );
1308 wxFileConfigLineList
*pPrev
= pLine
->Prev(),
1309 *pNext
= pLine
->Next();
1313 if ( pPrev
== NULL
)
1314 m_linesHead
= pNext
;
1316 pPrev
->SetNext(pNext
);
1320 if ( pNext
== NULL
)
1321 m_linesTail
= pPrev
;
1323 pNext
->SetPrev(pPrev
);
1325 if ( m_pRootGroup
->GetGroupLine() == pLine
)
1326 m_pRootGroup
->SetLine(m_linesHead
);
1328 wxLogTrace( FILECONF_TRACE_MASK
,
1330 ((m_linesHead
) ? m_linesHead
->Text().c_str() : wxEmptyString
) );
1331 wxLogTrace( FILECONF_TRACE_MASK
,
1333 ((m_linesTail
) ? m_linesTail
->Text().c_str() : wxEmptyString
) );
1338 bool wxFileConfig::LineListIsEmpty()
1340 return m_linesHead
== NULL
;
1343 // ============================================================================
1344 // wxFileConfig::wxFileConfigGroup
1345 // ============================================================================
1347 // ----------------------------------------------------------------------------
1349 // ----------------------------------------------------------------------------
1352 wxFileConfigGroup::wxFileConfigGroup(wxFileConfigGroup
*pParent
,
1353 const wxString
& strName
,
1354 wxFileConfig
*pConfig
)
1355 : m_aEntries(CompareEntries
),
1356 m_aSubgroups(CompareGroups
),
1359 m_pConfig
= pConfig
;
1360 m_pParent
= pParent
;
1363 m_pLastEntry
= NULL
;
1364 m_pLastGroup
= NULL
;
1367 // dtor deletes all children
1368 wxFileConfigGroup::~wxFileConfigGroup()
1371 size_t n
, nCount
= m_aEntries
.Count();
1372 for ( n
= 0; n
< nCount
; n
++ )
1373 delete m_aEntries
[n
];
1376 nCount
= m_aSubgroups
.Count();
1377 for ( n
= 0; n
< nCount
; n
++ )
1378 delete m_aSubgroups
[n
];
1381 // ----------------------------------------------------------------------------
1383 // ----------------------------------------------------------------------------
1385 void wxFileConfigGroup::SetLine(wxFileConfigLineList
*pLine
)
1387 // for a normal (i.e. not root) group this method shouldn't be called twice
1388 // unless we are resetting the line
1389 wxASSERT_MSG( !m_pParent
|| !m_pLine
|| !pLine
,
1390 _T("changing line for a non-root group?") );
1396 This is a bit complicated, so let me explain it in details. All lines that
1397 were read from the local file (the only one we will ever modify) are stored
1398 in a (doubly) linked list. Our problem is to know at which position in this
1399 list should we insert the new entries/subgroups. To solve it we keep three
1400 variables for each group: m_pLine, m_pLastEntry and m_pLastGroup.
1402 m_pLine points to the line containing "[group_name]"
1403 m_pLastEntry points to the last entry of this group in the local file.
1404 m_pLastGroup subgroup
1406 Initially, they're NULL all three. When the group (an entry/subgroup) is read
1407 from the local file, the corresponding variable is set. However, if the group
1408 was read from the global file and then modified or created by the application
1409 these variables are still NULL and we need to create the corresponding lines.
1410 See the following functions (and comments preceding them) for the details of
1413 Also, when our last entry/group are deleted we need to find the new last
1414 element - the code in DeleteEntry/Subgroup does this by backtracking the list
1415 of lines until it either founds an entry/subgroup (and this is the new last
1416 element) or the m_pLine of the group, in which case there are no more entries
1417 (or subgroups) left and m_pLast<element> becomes NULL.
1419 NB: This last problem could be avoided for entries if we added new entries
1420 immediately after m_pLine, but in this case the entries would appear
1421 backwards in the config file (OTOH, it's not that important) and as we
1422 would still need to do it for the subgroups the code wouldn't have been
1423 significantly less complicated.
1426 // Return the line which contains "[our name]". If we're still not in the list,
1427 // add our line to it immediately after the last line of our parent group if we
1428 // have it or in the very beginning if we're the root group.
1429 wxFileConfigLineList
*wxFileConfigGroup::GetGroupLine()
1431 wxLogTrace( FILECONF_TRACE_MASK
,
1432 _T(" GetGroupLine() for Group '%s'"),
1437 wxLogTrace( FILECONF_TRACE_MASK
,
1438 _T(" Getting Line item pointer") );
1440 wxFileConfigGroup
*pParent
= Parent();
1442 // this group wasn't present in local config file, add it now
1445 wxLogTrace( FILECONF_TRACE_MASK
,
1446 _T(" checking parent '%s'"),
1447 pParent
->Name().c_str() );
1449 wxString strFullName
;
1451 // add 1 to the name because we don't want to start with '/'
1452 strFullName
<< wxT("[")
1453 << FilterOutEntryName(GetFullName().c_str() + 1)
1455 m_pLine
= m_pConfig
->LineListInsert(strFullName
,
1456 pParent
->GetLastGroupLine());
1457 pParent
->SetLastGroup(this); // we're surely after all the others
1459 //else: this is the root group and so we return NULL because we don't
1460 // have any group line
1466 // Return the last line belonging to the subgroups of this group (after which
1467 // we can add a new subgroup), if we don't have any subgroups or entries our
1468 // last line is the group line (m_pLine) itself.
1469 wxFileConfigLineList
*wxFileConfigGroup::GetLastGroupLine()
1471 // if we have any subgroups, our last line is the last line of the last
1475 wxFileConfigLineList
*pLine
= m_pLastGroup
->GetLastGroupLine();
1477 wxASSERT_MSG( pLine
, _T("last group must have !NULL associated line") );
1482 // no subgroups, so the last line is the line of thelast entry (if any)
1483 return GetLastEntryLine();
1486 // return the last line belonging to the entries of this group (after which
1487 // we can add a new entry), if we don't have any entries we will add the new
1488 // one immediately after the group line itself.
1489 wxFileConfigLineList
*wxFileConfigGroup::GetLastEntryLine()
1491 wxLogTrace( FILECONF_TRACE_MASK
,
1492 _T(" GetLastEntryLine() for Group '%s'"),
1497 wxFileConfigLineList
*pLine
= m_pLastEntry
->GetLine();
1499 wxASSERT_MSG( pLine
, _T("last entry must have !NULL associated line") );
1504 // no entries: insert after the group header, if any
1505 return GetGroupLine();
1508 void wxFileConfigGroup::SetLastEntry(wxFileConfigEntry
*pEntry
)
1510 m_pLastEntry
= pEntry
;
1514 // the only situation in which a group without its own line can have
1515 // an entry is when the first entry is added to the initially empty
1516 // root pseudo-group
1517 wxASSERT_MSG( !m_pParent
, _T("unexpected for non root group") );
1519 // let the group know that it does have a line in the file now
1520 m_pLine
= pEntry
->GetLine();
1524 // ----------------------------------------------------------------------------
1526 // ----------------------------------------------------------------------------
1528 void wxFileConfigGroup::UpdateGroupAndSubgroupsLines()
1530 // update the line of this group
1531 wxFileConfigLineList
*line
= GetGroupLine();
1532 wxCHECK_RET( line
, _T("a non root group must have a corresponding line!") );
1534 // +1: skip the leading '/'
1535 line
->SetText(wxString::Format(_T("[%s]"), GetFullName().c_str() + 1));
1538 // also update all subgroups as they have this groups name in their lines
1539 const size_t nCount
= m_aSubgroups
.Count();
1540 for ( size_t n
= 0; n
< nCount
; n
++ )
1542 m_aSubgroups
[n
]->UpdateGroupAndSubgroupsLines();
1546 void wxFileConfigGroup::Rename(const wxString
& newName
)
1548 wxCHECK_RET( m_pParent
, _T("the root group can't be renamed") );
1550 if ( newName
== m_strName
)
1553 // we need to remove the group from the parent and it back under the new
1554 // name to keep the parents array of subgroups alphabetically sorted
1555 m_pParent
->m_aSubgroups
.Remove(this);
1557 m_strName
= newName
;
1559 m_pParent
->m_aSubgroups
.Add(this);
1561 // update the group lines recursively
1562 UpdateGroupAndSubgroupsLines();
1565 wxString
wxFileConfigGroup::GetFullName() const
1569 fullname
= Parent()->GetFullName() + wxCONFIG_PATH_SEPARATOR
+ Name();
1574 // ----------------------------------------------------------------------------
1576 // ----------------------------------------------------------------------------
1578 // use binary search because the array is sorted
1580 wxFileConfigGroup::FindEntry(const wxChar
*szName
) const
1584 hi
= m_aEntries
.Count();
1586 wxFileConfigEntry
*pEntry
;
1590 pEntry
= m_aEntries
[i
];
1592 #if wxCONFIG_CASE_SENSITIVE
1593 res
= wxStrcmp(pEntry
->Name(), szName
);
1595 res
= wxStricmp(pEntry
->Name(), szName
);
1610 wxFileConfigGroup::FindSubgroup(const wxChar
*szName
) const
1614 hi
= m_aSubgroups
.Count();
1616 wxFileConfigGroup
*pGroup
;
1620 pGroup
= m_aSubgroups
[i
];
1622 #if wxCONFIG_CASE_SENSITIVE
1623 res
= wxStrcmp(pGroup
->Name(), szName
);
1625 res
= wxStricmp(pGroup
->Name(), szName
);
1639 // ----------------------------------------------------------------------------
1640 // create a new item
1641 // ----------------------------------------------------------------------------
1643 // create a new entry and add it to the current group
1644 wxFileConfigEntry
*wxFileConfigGroup::AddEntry(const wxString
& strName
, int nLine
)
1646 wxASSERT( FindEntry(strName
) == 0 );
1648 wxFileConfigEntry
*pEntry
= new wxFileConfigEntry(this, strName
, nLine
);
1650 m_aEntries
.Add(pEntry
);
1654 // create a new group and add it to the current group
1655 wxFileConfigGroup
*wxFileConfigGroup::AddSubgroup(const wxString
& strName
)
1657 wxASSERT( FindSubgroup(strName
) == 0 );
1659 wxFileConfigGroup
*pGroup
= new wxFileConfigGroup(this, strName
, m_pConfig
);
1661 m_aSubgroups
.Add(pGroup
);
1665 // ----------------------------------------------------------------------------
1667 // ----------------------------------------------------------------------------
1670 The delete operations are _very_ slow if we delete the last item of this
1671 group (see comments before GetXXXLineXXX functions for more details),
1672 so it's much better to start with the first entry/group if we want to
1673 delete several of them.
1676 bool wxFileConfigGroup::DeleteSubgroupByName(const wxChar
*szName
)
1678 wxFileConfigGroup
* const pGroup
= FindSubgroup(szName
);
1680 return pGroup
? DeleteSubgroup(pGroup
) : false;
1683 // Delete the subgroup and remove all references to it from
1684 // other data structures.
1685 bool wxFileConfigGroup::DeleteSubgroup(wxFileConfigGroup
*pGroup
)
1687 wxCHECK_MSG( pGroup
, false, _T("deleting non existing group?") );
1689 wxLogTrace( FILECONF_TRACE_MASK
,
1690 _T("Deleting group '%s' from '%s'"),
1691 pGroup
->Name().c_str(),
1694 wxLogTrace( FILECONF_TRACE_MASK
,
1695 _T(" (m_pLine) = prev: %p, this %p, next %p"),
1696 m_pLine
? wx_static_cast(void*, m_pLine
->Prev()) : 0,
1697 wx_static_cast(void*, m_pLine
),
1698 m_pLine
? wx_static_cast(void*, m_pLine
->Next()) : 0 );
1699 wxLogTrace( FILECONF_TRACE_MASK
,
1701 m_pLine
? m_pLine
->Text().c_str() : wxEmptyString
);
1703 // delete all entries...
1704 size_t nCount
= pGroup
->m_aEntries
.Count();
1706 wxLogTrace(FILECONF_TRACE_MASK
,
1707 _T("Removing %lu entries"), (unsigned long)nCount
);
1709 for ( size_t nEntry
= 0; nEntry
< nCount
; nEntry
++ )
1711 wxFileConfigLineList
*pLine
= pGroup
->m_aEntries
[nEntry
]->GetLine();
1715 wxLogTrace( FILECONF_TRACE_MASK
,
1717 pLine
->Text().c_str() );
1718 m_pConfig
->LineListRemove(pLine
);
1722 // ...and subgroups of this subgroup
1723 nCount
= pGroup
->m_aSubgroups
.Count();
1725 wxLogTrace( FILECONF_TRACE_MASK
,
1726 _T("Removing %lu subgroups"), (unsigned long)nCount
);
1728 for ( size_t nGroup
= 0; nGroup
< nCount
; nGroup
++ )
1730 pGroup
->DeleteSubgroup(pGroup
->m_aSubgroups
[0]);
1733 // and then finally the group itself
1734 wxFileConfigLineList
*pLine
= pGroup
->m_pLine
;
1737 wxLogTrace( FILECONF_TRACE_MASK
,
1738 _T(" Removing line for group '%s' : '%s'"),
1739 pGroup
->Name().c_str(),
1740 pLine
->Text().c_str() );
1741 wxLogTrace( FILECONF_TRACE_MASK
,
1742 _T(" Removing from group '%s' : '%s'"),
1744 ((m_pLine
) ? m_pLine
->Text().c_str() : wxEmptyString
) );
1746 // notice that we may do this test inside the previous "if"
1747 // because the last entry's line is surely !NULL
1748 if ( pGroup
== m_pLastGroup
)
1750 wxLogTrace( FILECONF_TRACE_MASK
,
1751 _T(" Removing last group") );
1753 // our last entry is being deleted, so find the last one which
1754 // stays by going back until we find a subgroup or reach the
1756 const size_t nSubgroups
= m_aSubgroups
.Count();
1758 m_pLastGroup
= NULL
;
1759 for ( wxFileConfigLineList
*pl
= pLine
->Prev();
1760 pl
&& pl
!= m_pLine
&& !m_pLastGroup
;
1763 // does this line belong to our subgroup?
1764 for ( size_t n
= 0; n
< nSubgroups
; n
++ )
1766 // do _not_ call GetGroupLine! we don't want to add it to
1767 // the local file if it's not already there
1768 if ( m_aSubgroups
[n
]->m_pLine
== pl
)
1770 m_pLastGroup
= m_aSubgroups
[n
];
1777 m_pConfig
->LineListRemove(pLine
);
1781 wxLogTrace( FILECONF_TRACE_MASK
,
1782 _T(" No line entry for Group '%s'?"),
1783 pGroup
->Name().c_str() );
1786 m_aSubgroups
.Remove(pGroup
);
1792 bool wxFileConfigGroup::DeleteEntry(const wxChar
*szName
)
1794 wxFileConfigEntry
*pEntry
= FindEntry(szName
);
1797 // entry doesn't exist, nothing to do
1801 wxFileConfigLineList
*pLine
= pEntry
->GetLine();
1802 if ( pLine
!= NULL
) {
1803 // notice that we may do this test inside the previous "if" because the
1804 // last entry's line is surely !NULL
1805 if ( pEntry
== m_pLastEntry
) {
1806 // our last entry is being deleted - find the last one which stays
1807 wxASSERT( m_pLine
!= NULL
); // if we have an entry with !NULL pLine...
1809 // go back until we find another entry or reach the group's line
1810 wxFileConfigEntry
*pNewLast
= NULL
;
1811 size_t n
, nEntries
= m_aEntries
.Count();
1812 wxFileConfigLineList
*pl
;
1813 for ( pl
= pLine
->Prev(); pl
!= m_pLine
; pl
= pl
->Prev() ) {
1814 // is it our subgroup?
1815 for ( n
= 0; (pNewLast
== NULL
) && (n
< nEntries
); n
++ ) {
1816 if ( m_aEntries
[n
]->GetLine() == m_pLine
)
1817 pNewLast
= m_aEntries
[n
];
1820 if ( pNewLast
!= NULL
) // found?
1824 if ( pl
== m_pLine
) {
1825 wxASSERT( !pNewLast
); // how comes it has the same line as we?
1827 // we've reached the group line without finding any subgroups
1828 m_pLastEntry
= NULL
;
1831 m_pLastEntry
= pNewLast
;
1834 m_pConfig
->LineListRemove(pLine
);
1837 m_aEntries
.Remove(pEntry
);
1843 // ============================================================================
1844 // wxFileConfig::wxFileConfigEntry
1845 // ============================================================================
1847 // ----------------------------------------------------------------------------
1849 // ----------------------------------------------------------------------------
1850 wxFileConfigEntry::wxFileConfigEntry(wxFileConfigGroup
*pParent
,
1851 const wxString
& strName
,
1853 : m_strName(strName
)
1855 wxASSERT( !strName
.empty() );
1857 m_pParent
= pParent
;
1861 m_bHasValue
= false;
1863 m_bImmutable
= strName
[0] == wxCONFIG_IMMUTABLE_PREFIX
;
1865 m_strName
.erase(0, 1); // remove first character
1868 // ----------------------------------------------------------------------------
1870 // ----------------------------------------------------------------------------
1872 void wxFileConfigEntry::SetLine(wxFileConfigLineList
*pLine
)
1874 if ( m_pLine
!= NULL
) {
1875 wxLogWarning(_("entry '%s' appears more than once in group '%s'"),
1876 Name().c_str(), m_pParent
->GetFullName().c_str());
1880 Group()->SetLastEntry(this);
1883 // second parameter is false if we read the value from file and prevents the
1884 // entry from being marked as 'dirty'
1885 void wxFileConfigEntry::SetValue(const wxString
& strValue
, bool bUser
)
1887 if ( bUser
&& IsImmutable() )
1889 wxLogWarning( _("attempt to change immutable key '%s' ignored."),
1894 // do nothing if it's the same value: but don't test for it if m_bHasValue
1895 // hadn't been set yet or we'd never write empty values to the file
1896 if ( m_bHasValue
&& strValue
== m_strValue
)
1900 m_strValue
= strValue
;
1904 wxString strValFiltered
;
1906 if ( Group()->Config()->GetStyle() & wxCONFIG_USE_NO_ESCAPE_CHARACTERS
)
1908 strValFiltered
= strValue
;
1911 strValFiltered
= FilterOutValue(strValue
);
1915 strLine
<< FilterOutEntryName(m_strName
) << wxT('=') << strValFiltered
;
1919 // entry was read from the local config file, just modify the line
1920 m_pLine
->SetText(strLine
);
1922 else // this entry didn't exist in the local file
1924 // add a new line to the file: note that line returned by
1925 // GetLastEntryLine() may be NULL if we're in the root group and it
1926 // doesn't have any entries yet, but this is ok as passing NULL
1927 // line to LineListInsert() means to prepend new line to the list
1928 wxFileConfigLineList
*line
= Group()->GetLastEntryLine();
1929 m_pLine
= Group()->Config()->LineListInsert(strLine
, line
);
1931 Group()->SetLastEntry(this);
1936 // ============================================================================
1938 // ============================================================================
1940 // ----------------------------------------------------------------------------
1941 // compare functions for array sorting
1942 // ----------------------------------------------------------------------------
1944 int CompareEntries(wxFileConfigEntry
*p1
, wxFileConfigEntry
*p2
)
1946 #if wxCONFIG_CASE_SENSITIVE
1947 return wxStrcmp(p1
->Name(), p2
->Name());
1949 return wxStricmp(p1
->Name(), p2
->Name());
1953 int CompareGroups(wxFileConfigGroup
*p1
, wxFileConfigGroup
*p2
)
1955 #if wxCONFIG_CASE_SENSITIVE
1956 return wxStrcmp(p1
->Name(), p2
->Name());
1958 return wxStricmp(p1
->Name(), p2
->Name());
1962 // ----------------------------------------------------------------------------
1964 // ----------------------------------------------------------------------------
1966 // undo FilterOutValue
1967 static wxString
FilterInValue(const wxString
& str
)
1970 strResult
.Alloc(str
.Len());
1972 bool bQuoted
= !str
.empty() && str
[0] == '"';
1974 for ( size_t n
= bQuoted
? 1 : 0; n
< str
.Len(); n
++ ) {
1975 if ( str
[n
] == wxT('\\') ) {
1976 switch ( str
[++n
] ) {
1978 strResult
+= wxT('\n');
1982 strResult
+= wxT('\r');
1986 strResult
+= wxT('\t');
1990 strResult
+= wxT('\\');
1994 strResult
+= wxT('"');
1999 if ( str
[n
] != wxT('"') || !bQuoted
)
2000 strResult
+= str
[n
];
2001 else if ( n
!= str
.Len() - 1 ) {
2002 wxLogWarning(_("unexpected \" at position %d in '%s'."),
2005 //else: it's the last quote of a quoted string, ok
2012 // quote the string before writing it to file
2013 static wxString
FilterOutValue(const wxString
& str
)
2019 strResult
.Alloc(str
.Len());
2021 // quoting is necessary to preserve spaces in the beginning of the string
2022 bool bQuote
= wxIsspace(str
[0]) || str
[0] == wxT('"');
2025 strResult
+= wxT('"');
2028 for ( size_t n
= 0; n
< str
.Len(); n
++ ) {
2051 //else: fall through
2054 strResult
+= str
[n
];
2055 continue; // nothing special to do
2058 // we get here only for special characters
2059 strResult
<< wxT('\\') << c
;
2063 strResult
+= wxT('"');
2068 // undo FilterOutEntryName
2069 static wxString
FilterInEntryName(const wxString
& str
)
2072 strResult
.Alloc(str
.Len());
2074 for ( const wxChar
*pc
= str
.c_str(); *pc
!= '\0'; pc
++ ) {
2075 if ( *pc
== wxT('\\') ) {
2076 // we need to test it here or we'd skip past the NUL in the loop line
2077 if ( *++pc
== _T('\0') )
2087 // sanitize entry or group name: insert '\\' before any special characters
2088 static wxString
FilterOutEntryName(const wxString
& str
)
2091 strResult
.Alloc(str
.Len());
2093 for ( const wxChar
*pc
= str
.c_str(); *pc
!= wxT('\0'); pc
++ ) {
2094 const wxChar c
= *pc
;
2096 // we explicitly allow some of "safe" chars and 8bit ASCII characters
2097 // which will probably never have special meaning and with which we can't
2098 // use isalnum() anyhow (in ASCII built, in Unicode it's just fine)
2100 // NB: note that wxCONFIG_IMMUTABLE_PREFIX and wxCONFIG_PATH_SEPARATOR
2101 // should *not* be quoted
2104 ((unsigned char)c
< 127) &&
2106 !wxIsalnum(c
) && !wxStrchr(wxT("@_/-!.*%"), c
) )
2108 strResult
+= wxT('\\');
2117 // we can't put ?: in the ctor initializer list because it confuses some
2118 // broken compilers (Borland C++)
2119 static wxString
GetAppName(const wxString
& appName
)
2121 if ( !appName
&& wxTheApp
)
2122 return wxTheApp
->GetAppName();
2127 #endif // wxUSE_CONFIG