1 ///////////////////////////////////////////////////////////////////////////////
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 license
11 ///////////////////////////////////////////////////////////////////////////////
14 #pragma implementation "fileconf.h"
17 // ----------------------------------------------------------------------------
19 // ----------------------------------------------------------------------------
21 #include "wx/wxprec.h"
30 #include "wx/string.h"
35 #include "wx/dynarray.h"
38 #include "wx/textfile.h"
39 #include "wx/memtext.h"
40 #include "wx/config.h"
41 #include "wx/fileconf.h"
44 #include "wx/stream.h"
45 #endif // wxUSE_STREAMS
47 #include "wx/utils.h" // for wxGetHomeDir
49 #if defined(__WXMAC__)
50 #include "wx/mac/private.h" // includes mac headers
53 #if defined(__WXMSW__)
54 #include "wx/msw/private.h"
64 // headers needed for umask()
66 #include <sys/types.h>
70 // ----------------------------------------------------------------------------
72 // ----------------------------------------------------------------------------
73 #define CONST_CAST ((wxFileConfig *)this)->
75 // ----------------------------------------------------------------------------
77 // ----------------------------------------------------------------------------
83 // ----------------------------------------------------------------------------
84 // global functions declarations
85 // ----------------------------------------------------------------------------
87 // compare functions for sorting the arrays
88 static int LINKAGEMODE
CompareEntries(wxFileConfigEntry
*p1
, wxFileConfigEntry
*p2
);
89 static int LINKAGEMODE
CompareGroups(wxFileConfigGroup
*p1
, wxFileConfigGroup
*p2
);
92 static wxString
FilterInValue(const wxString
& str
);
93 static wxString
FilterOutValue(const wxString
& str
);
95 static wxString
FilterInEntryName(const wxString
& str
);
96 static wxString
FilterOutEntryName(const wxString
& str
);
98 // get the name to use in wxFileConfig ctor
99 static wxString
GetAppName(const wxString
& appname
);
101 // ============================================================================
103 // ============================================================================
105 // ----------------------------------------------------------------------------
106 // "template" array types
107 // ----------------------------------------------------------------------------
109 WX_DEFINE_SORTED_EXPORTED_ARRAY(wxFileConfigEntry
*, ArrayEntries
);
110 WX_DEFINE_SORTED_EXPORTED_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
142 // ----------------------------------------------------------------------------
143 // wxFileConfigEntry: a name/value pair
144 // ----------------------------------------------------------------------------
146 class wxFileConfigEntry
149 wxFileConfigGroup
*m_pParent
; // group that contains us
151 wxString m_strName
, // entry name
153 bool m_bDirty
:1, // changed since last read?
154 m_bImmutable
:1, // can be overriden locally?
155 m_bHasValue
:1; // set after first call to SetValue()
157 int m_nLine
; // used if m_pLine == NULL only
159 // pointer to our line in the linked list or NULL if it was found in global
160 // file (which we don't modify)
161 wxFileConfigLineList
*m_pLine
;
164 wxFileConfigEntry(wxFileConfigGroup
*pParent
,
165 const wxString
& strName
, int nLine
);
168 const wxString
& Name() const { return m_strName
; }
169 const wxString
& Value() const { return m_strValue
; }
170 wxFileConfigGroup
*Group() const { return m_pParent
; }
171 bool IsDirty() const { return m_bDirty
; }
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
);
181 void SetLine(wxFileConfigLineList
*pLine
);
184 // ----------------------------------------------------------------------------
185 // wxFileConfigGroup: container of entries and other groups
186 // ----------------------------------------------------------------------------
188 class wxFileConfigGroup
191 wxFileConfig
*m_pConfig
; // config object we belong to
192 wxFileConfigGroup
*m_pParent
; // parent group (NULL for root group)
193 ArrayEntries m_aEntries
; // entries in this group
194 ArrayGroups m_aSubgroups
; // subgroups
195 wxString m_strName
; // group's name
196 bool m_bDirty
; // if FALSE => all subgroups are not dirty
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
);
206 wxFileConfigGroup(wxFileConfigGroup
*pParent
, const wxString
& strName
, wxFileConfig
*);
208 // dtor deletes all entries and subgroups also
209 ~wxFileConfigGroup();
212 const wxString
& Name() const { return m_strName
; }
213 wxFileConfigGroup
*Parent() const { return m_pParent
; }
214 wxFileConfig
*Config() const { return m_pConfig
; }
215 bool IsDirty() const { return m_bDirty
; }
217 const ArrayEntries
& Entries() const { return m_aEntries
; }
218 const ArrayGroups
& Groups() const { return m_aSubgroups
; }
219 bool IsEmpty() const { return Entries().IsEmpty() && Groups().IsEmpty(); }
221 // find entry/subgroup (NULL if not found)
222 wxFileConfigGroup
*FindSubgroup(const wxChar
*szName
) const;
223 wxFileConfigEntry
*FindEntry (const wxChar
*szName
) const;
225 // delete entry/subgroup, return FALSE if doesn't exist
226 bool DeleteSubgroupByName(const wxChar
*szName
);
227 bool DeleteEntry(const wxChar
*szName
);
229 // create new entry/subgroup returning pointer to newly created element
230 wxFileConfigGroup
*AddSubgroup(const wxString
& strName
);
231 wxFileConfigEntry
*AddEntry (const wxString
& strName
, int nLine
= wxNOT_FOUND
);
233 // will also recursively set parent's dirty flag
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
) { m_pLastEntry
= pEntry
; }
250 void SetLastGroup(wxFileConfigGroup
*pGroup
) { m_pLastGroup
= pGroup
; }
253 // ============================================================================
255 // ============================================================================
257 // ----------------------------------------------------------------------------
259 // ----------------------------------------------------------------------------
260 wxString
wxFileConfig::GetGlobalDir()
264 #ifdef __VMS__ // Note if __VMS is defined __UNIX is also defined
265 strDir
= wxT("sys$manager:");
266 #elif defined(__WXMAC__)
267 strDir
= wxMacFindFolder( (short) kOnSystemDisk
, kPreferencesFolderType
, kDontCreateFolder
) ;
268 #elif defined( __UNIX__ )
269 strDir
= wxT("/etc/");
270 #elif defined(__WXPM__)
271 ULONG aulSysInfo
[QSV_MAX
] = {0};
275 rc
= DosQuerySysInfo( 1L, QSV_MAX
, (PVOID
)aulSysInfo
, sizeof(ULONG
)*QSV_MAX
);
278 drive
= aulSysInfo
[QSV_BOOT_DRIVE
- 1];
279 strDir
.Printf(wxT("%c:\\OS2\\"), 'A'+drive
-1);
281 #elif defined(__WXSTUBS__)
282 wxASSERT_MSG( FALSE
, wxT("TODO") ) ;
283 #elif defined(__DOS__)
284 // There's no such thing as global cfg dir in MS-DOS, let's return
285 // current directory (FIXME_MGL?)
288 wxChar szWinDir
[MAX_PATH
];
289 ::GetWindowsDirectory(szWinDir
, MAX_PATH
);
293 #endif // Unix/Windows
298 wxString
wxFileConfig::GetLocalDir()
302 #if defined(__WXMAC__) || defined(__DOS__)
303 // no local dir concept on Mac OS 9 or MS-DOS
304 return GetGlobalDir() ;
306 wxGetHomeDir(&strDir
);
310 if (strDir
.Last() != wxT(']'))
312 if (strDir
.Last() != wxT('/')) strDir
<< wxT('/');
314 if (strDir
.Last() != wxT('\\')) strDir
<< wxT('\\');
321 wxString
wxFileConfig::GetGlobalFileName(const wxChar
*szFile
)
323 wxString str
= GetGlobalDir();
326 if ( wxStrchr(szFile
, wxT('.')) == NULL
)
327 #if defined( __WXMAC__ )
328 str
<< " Preferences";
329 #elif defined( __UNIX__ )
338 wxString
wxFileConfig::GetLocalFileName(const wxChar
*szFile
)
341 // On VMS I saw the problem that the home directory was appended
342 // twice for the configuration file. Does that also happen for
344 wxString str
= wxT( '.' );
346 wxString str
= GetLocalDir();
349 #if defined( __UNIX__ ) && !defined( __VMS ) && !defined( __WXMAC__ )
355 #if defined(__WINDOWS__) || defined(__DOS__)
356 if ( wxStrchr(szFile
, wxT('.')) == NULL
)
361 str
<< " Preferences";
367 // ----------------------------------------------------------------------------
369 // ----------------------------------------------------------------------------
371 void wxFileConfig::Init()
374 m_pRootGroup
= new wxFileConfigGroup(NULL
, wxT(""), this);
379 // It's not an error if (one of the) file(s) doesn't exist.
381 // parse the global file
382 if ( !m_strGlobalFile
.IsEmpty() && wxFile::Exists(m_strGlobalFile
) )
384 wxTextFile
fileGlobal(m_strGlobalFile
);
386 #if defined(__WXGTK20__) && wxUSE_UNICODE
387 if ( fileGlobal
.Open( wxConvUTF8
) )
389 if ( fileGlobal
.Open() )
392 Parse(fileGlobal
, FALSE
/* global */);
397 wxLogWarning(_("can't open global configuration file '%s'."), m_strGlobalFile
.c_str());
401 // parse the local file
402 if ( !m_strLocalFile
.IsEmpty() && wxFile::Exists(m_strLocalFile
) )
404 wxTextFile
fileLocal(m_strLocalFile
);
405 #if defined(__WXGTK20__) && wxUSE_UNICODE
406 if ( fileLocal
.Open( wxConvUTF8
) )
408 if ( fileLocal
.Open() )
411 Parse(fileLocal
, TRUE
/* local */);
416 wxLogWarning(_("can't open user configuration file '%s'."), m_strLocalFile
.c_str() );
421 // constructor supports creation of wxFileConfig objects of any type
422 wxFileConfig::wxFileConfig(const wxString
& appName
, const wxString
& vendorName
,
423 const wxString
& strLocal
, const wxString
& strGlobal
,
425 : wxConfigBase(::GetAppName(appName
), vendorName
,
428 m_strLocalFile(strLocal
), m_strGlobalFile(strGlobal
)
430 // Make up names for files if empty
431 if ( m_strLocalFile
.IsEmpty() && (style
& wxCONFIG_USE_LOCAL_FILE
) )
432 m_strLocalFile
= GetLocalFileName(GetAppName());
434 if ( m_strGlobalFile
.IsEmpty() && (style
& wxCONFIG_USE_GLOBAL_FILE
) )
435 m_strGlobalFile
= GetGlobalFileName(GetAppName());
437 // Check if styles are not supplied, but filenames are, in which case
438 // add the correct styles.
439 if ( !m_strLocalFile
.IsEmpty() )
440 SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE
);
442 if ( !m_strGlobalFile
.IsEmpty() )
443 SetStyle(GetStyle() | wxCONFIG_USE_GLOBAL_FILE
);
445 // if the path is not absolute, prepend the standard directory to it
446 // UNLESS wxCONFIG_USE_RELATIVE_PATH style is set
447 if ( !(style
& wxCONFIG_USE_RELATIVE_PATH
) )
449 if ( !m_strLocalFile
.IsEmpty() && !wxIsAbsolutePath(m_strLocalFile
) )
451 wxString strLocal
= m_strLocalFile
;
452 m_strLocalFile
= GetLocalDir();
453 m_strLocalFile
<< strLocal
;
456 if ( !m_strGlobalFile
.IsEmpty() && !wxIsAbsolutePath(m_strGlobalFile
) )
458 wxString strGlobal
= m_strGlobalFile
;
459 m_strGlobalFile
= GetGlobalDir();
460 m_strGlobalFile
<< strGlobal
;
471 wxFileConfig::wxFileConfig(wxInputStream
&inStream
)
473 // always local_file when this constructor is called (?)
474 SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE
);
477 m_pRootGroup
= new wxFileConfigGroup(NULL
, wxT(""), this);
482 // translate everything to the current (platform-dependent) line
483 // termination character
489 while ( !inStream
.Read(buf
, WXSIZEOF(buf
)).Eof() )
490 strTmp
.append(wxConvertMB2WX(buf
), inStream
.LastRead());
492 strTmp
.append(wxConvertMB2WX(buf
), inStream
.LastRead());
494 strTrans
= wxTextBuffer::Translate(strTmp
);
497 wxMemoryText memText
;
499 // Now we can add the text to the memory text. To do this we extract line
500 // by line from the translated string, until we've reached the end.
502 // VZ: all this is horribly inefficient, we should do the translation on
503 // the fly in one pass saving both memory and time (TODO)
505 const wxChar
*pEOL
= wxTextBuffer::GetEOL(wxTextBuffer::typeDefault
);
506 const size_t EOLLen
= wxStrlen(pEOL
);
508 int posLineStart
= strTrans
.Find(pEOL
);
509 while ( posLineStart
!= -1 )
511 wxString
line(strTrans
.Left(posLineStart
));
513 memText
.AddLine(line
);
515 strTrans
= strTrans
.Mid(posLineStart
+ EOLLen
);
517 posLineStart
= strTrans
.Find(pEOL
);
520 // also add whatever we have left in the translated string.
521 memText
.AddLine(strTrans
);
523 // Finally we can parse it all.
524 Parse(memText
, TRUE
/* local */);
529 #endif // wxUSE_STREAMS
531 void wxFileConfig::CleanUp()
535 wxFileConfigLineList
*pCur
= m_linesHead
;
536 while ( pCur
!= NULL
) {
537 wxFileConfigLineList
*pNext
= pCur
->Next();
543 wxFileConfig::~wxFileConfig()
550 // ----------------------------------------------------------------------------
551 // parse a config file
552 // ----------------------------------------------------------------------------
554 void wxFileConfig::Parse(wxTextBuffer
& buffer
, bool bLocal
)
556 const wxChar
*pStart
;
560 size_t nLineCount
= buffer
.GetLineCount();
562 for ( size_t n
= 0; n
< nLineCount
; n
++ )
566 // add the line to linked list
568 LineListAppend(strLine
);
570 // skip leading spaces
571 for ( pStart
= strLine
; wxIsspace(*pStart
); pStart
++ )
574 // skip blank/comment lines
575 if ( *pStart
== wxT('\0')|| *pStart
== wxT(';') || *pStart
== wxT('#') )
578 if ( *pStart
== wxT('[') ) { // a new group
581 while ( *++pEnd
!= wxT(']') ) {
582 if ( *pEnd
== wxT('\\') ) {
583 // the next char is escaped, so skip it even if it is ']'
587 if ( *pEnd
== wxT('\n') || *pEnd
== wxT('\0') ) {
588 // we reached the end of line, break out of the loop
593 if ( *pEnd
!= wxT(']') ) {
594 wxLogError(_("file '%s': unexpected character %c at line %d."),
595 buffer
.GetName(), *pEnd
, n
+ 1);
596 continue; // skip this line
599 // group name here is always considered as abs path
602 strGroup
<< wxCONFIG_PATH_SEPARATOR
603 << FilterInEntryName(wxString(pStart
, pEnd
- pStart
));
605 // will create it if doesn't yet exist
609 m_pCurrentGroup
->SetLine(m_linesTail
);
611 // check that there is nothing except comments left on this line
613 while ( *++pEnd
!= wxT('\0') && bCont
) {
622 // ignore whitespace ('\n' impossible here)
626 wxLogWarning(_("file '%s', line %d: '%s' ignored after group header."),
627 buffer
.GetName(), n
+ 1, pEnd
);
633 const wxChar
*pEnd
= pStart
;
634 while ( *pEnd
&& *pEnd
!= wxT('=') && !wxIsspace(*pEnd
) ) {
635 if ( *pEnd
== wxT('\\') ) {
636 // next character may be space or not - still take it because it's
637 // quoted (unless there is nothing)
640 // the error message will be given below anyhow
648 wxString
strKey(FilterInEntryName(wxString(pStart
, pEnd
)));
651 while ( wxIsspace(*pEnd
) )
654 if ( *pEnd
++ != wxT('=') ) {
655 wxLogError(_("file '%s', line %d: '=' expected."),
656 buffer
.GetName(), n
+ 1);
659 wxFileConfigEntry
*pEntry
= m_pCurrentGroup
->FindEntry(strKey
);
661 if ( pEntry
== NULL
) {
663 pEntry
= m_pCurrentGroup
->AddEntry(strKey
, n
);
666 pEntry
->SetLine(m_linesTail
);
669 if ( bLocal
&& pEntry
->IsImmutable() ) {
670 // immutable keys can't be changed by user
671 wxLogWarning(_("file '%s', line %d: value for immutable key '%s' ignored."),
672 buffer
.GetName(), n
+ 1, strKey
.c_str());
675 // the condition below catches the cases (a) and (b) but not (c):
676 // (a) global key found second time in global file
677 // (b) key found second (or more) time in local file
678 // (c) key from global file now found in local one
679 // which is exactly what we want.
680 else if ( !bLocal
|| pEntry
->IsLocal() ) {
681 wxLogWarning(_("file '%s', line %d: key '%s' was first found at line %d."),
682 buffer
.GetName(), n
+ 1, strKey
.c_str(), pEntry
->Line());
685 pEntry
->SetLine(m_linesTail
);
690 while ( wxIsspace(*pEnd
) )
693 wxString value
= pEnd
;
694 if ( !(GetStyle() & wxCONFIG_USE_NO_ESCAPE_CHARACTERS
) )
695 value
= FilterInValue(value
);
697 pEntry
->SetValue(value
, FALSE
);
703 // ----------------------------------------------------------------------------
705 // ----------------------------------------------------------------------------
707 void wxFileConfig::SetRootPath()
710 m_pCurrentGroup
= m_pRootGroup
;
713 void wxFileConfig::SetPath(const wxString
& strPath
)
715 wxArrayString aParts
;
717 if ( strPath
.IsEmpty() ) {
722 if ( strPath
[0] == wxCONFIG_PATH_SEPARATOR
) {
724 wxSplitPath(aParts
, strPath
);
727 // relative path, combine with current one
728 wxString strFullPath
= m_strPath
;
729 strFullPath
<< wxCONFIG_PATH_SEPARATOR
<< strPath
;
730 wxSplitPath(aParts
, strFullPath
);
733 // change current group
735 m_pCurrentGroup
= m_pRootGroup
;
736 for ( n
= 0; n
< aParts
.Count(); n
++ ) {
737 wxFileConfigGroup
*pNextGroup
= m_pCurrentGroup
->FindSubgroup(aParts
[n
]);
738 if ( pNextGroup
== NULL
)
739 pNextGroup
= m_pCurrentGroup
->AddSubgroup(aParts
[n
]);
740 m_pCurrentGroup
= pNextGroup
;
743 // recombine path parts in one variable
745 for ( n
= 0; n
< aParts
.Count(); n
++ ) {
746 m_strPath
<< wxCONFIG_PATH_SEPARATOR
<< aParts
[n
];
750 // ----------------------------------------------------------------------------
752 // ----------------------------------------------------------------------------
754 bool wxFileConfig::GetFirstGroup(wxString
& str
, long& lIndex
) const
757 return GetNextGroup(str
, lIndex
);
760 bool wxFileConfig::GetNextGroup (wxString
& str
, long& lIndex
) const
762 if ( size_t(lIndex
) < m_pCurrentGroup
->Groups().Count() ) {
763 str
= m_pCurrentGroup
->Groups()[(size_t)lIndex
++]->Name();
770 bool wxFileConfig::GetFirstEntry(wxString
& str
, long& lIndex
) const
773 return GetNextEntry(str
, lIndex
);
776 bool wxFileConfig::GetNextEntry (wxString
& str
, long& lIndex
) const
778 if ( size_t(lIndex
) < m_pCurrentGroup
->Entries().Count() ) {
779 str
= m_pCurrentGroup
->Entries()[(size_t)lIndex
++]->Name();
786 size_t wxFileConfig::GetNumberOfEntries(bool bRecursive
) const
788 size_t n
= m_pCurrentGroup
->Entries().Count();
790 wxFileConfigGroup
*pOldCurrentGroup
= m_pCurrentGroup
;
791 size_t nSubgroups
= m_pCurrentGroup
->Groups().Count();
792 for ( size_t nGroup
= 0; nGroup
< nSubgroups
; nGroup
++ ) {
793 CONST_CAST m_pCurrentGroup
= m_pCurrentGroup
->Groups()[nGroup
];
794 n
+= GetNumberOfEntries(TRUE
);
795 CONST_CAST m_pCurrentGroup
= pOldCurrentGroup
;
802 size_t wxFileConfig::GetNumberOfGroups(bool bRecursive
) const
804 size_t n
= m_pCurrentGroup
->Groups().Count();
806 wxFileConfigGroup
*pOldCurrentGroup
= m_pCurrentGroup
;
807 size_t nSubgroups
= m_pCurrentGroup
->Groups().Count();
808 for ( size_t nGroup
= 0; nGroup
< nSubgroups
; nGroup
++ ) {
809 CONST_CAST m_pCurrentGroup
= m_pCurrentGroup
->Groups()[nGroup
];
810 n
+= GetNumberOfGroups(TRUE
);
811 CONST_CAST m_pCurrentGroup
= pOldCurrentGroup
;
818 // ----------------------------------------------------------------------------
819 // tests for existence
820 // ----------------------------------------------------------------------------
822 bool wxFileConfig::HasGroup(const wxString
& strName
) const
824 wxConfigPathChanger
path(this, strName
);
826 wxFileConfigGroup
*pGroup
= m_pCurrentGroup
->FindSubgroup(path
.Name());
827 return pGroup
!= NULL
;
830 bool wxFileConfig::HasEntry(const wxString
& strName
) const
832 wxConfigPathChanger
path(this, strName
);
834 wxFileConfigEntry
*pEntry
= m_pCurrentGroup
->FindEntry(path
.Name());
835 return pEntry
!= NULL
;
838 // ----------------------------------------------------------------------------
840 // ----------------------------------------------------------------------------
842 bool wxFileConfig::DoReadString(const wxString
& key
, wxString
* pStr
) const
844 wxConfigPathChanger
path(this, key
);
846 wxFileConfigEntry
*pEntry
= m_pCurrentGroup
->FindEntry(path
.Name());
847 if (pEntry
== NULL
) {
851 *pStr
= pEntry
->Value();
856 bool wxFileConfig::DoReadLong(const wxString
& key
, long *pl
) const
859 if ( !Read(key
, & str
) )
863 return str
.ToLong(pl
) ;
866 bool wxFileConfig::DoWriteString(const wxString
& key
, const wxString
& szValue
)
868 wxConfigPathChanger
path(this, key
);
869 wxString strName
= path
.Name();
871 wxLogTrace( _T("wxFileConfig"),
872 _T(" Writing String '%s' = '%s' to Group '%s'"),
877 if ( strName
.IsEmpty() )
879 // setting the value of a group is an error
881 wxASSERT_MSG( wxIsEmpty(szValue
), wxT("can't set value of a group!") );
883 // ... except if it's empty in which case it's a way to force it's creation
885 wxLogTrace( _T("wxFileConfig"),
886 _T(" Creating group %s"),
887 m_pCurrentGroup
->Name().c_str() );
889 m_pCurrentGroup
->SetDirty();
891 // this will add a line for this group if it didn't have it before
893 (void)m_pCurrentGroup
->GetGroupLine();
898 // check that the name is reasonable
900 if ( strName
[0u] == wxCONFIG_IMMUTABLE_PREFIX
)
902 wxLogError( _("Config entry name cannot start with '%c'."),
903 wxCONFIG_IMMUTABLE_PREFIX
);
907 wxFileConfigEntry
*pEntry
= m_pCurrentGroup
->FindEntry(strName
);
911 wxLogTrace( _T("wxFileConfig"),
912 _T(" Adding Entry %s"),
914 pEntry
= m_pCurrentGroup
->AddEntry(strName
);
917 wxLogTrace( _T("wxFileConfig"),
918 _T(" Setting value %s"),
920 pEntry
->SetValue(szValue
);
926 bool wxFileConfig::DoWriteLong(const wxString
& key
, long lValue
)
928 return Write(key
, wxString::Format(_T("%ld"), lValue
));
931 bool wxFileConfig::Flush(bool /* bCurrentOnly */)
933 if ( LineListIsEmpty() || !m_pRootGroup
->IsDirty() || !m_strLocalFile
)
937 // set the umask if needed
941 umaskOld
= umask((mode_t
)m_umask
);
945 wxTempFile
file(m_strLocalFile
);
947 if ( !file
.IsOpened() )
949 wxLogError(_("can't open user configuration file."));
953 // write all strings to file
954 for ( wxFileConfigLineList
*p
= m_linesHead
; p
!= NULL
; p
= p
->Next() )
956 wxString line
= p
->Text();
957 line
+= wxTextFile::GetEOL();
959 wxCharBuffer buf
= wxConvLocal
.cWX2MB( line
);
960 if ( !file
.Write( (const char*)buf
, strlen( (const char*) buf
) ) )
962 if ( !file
.Write( line
.c_str(), line
.Len() ) )
965 wxLogError(_("can't write user configuration file."));
970 bool ret
= file
.Commit();
972 #if defined(__WXMAC__)
977 wxMacFilename2FSSpec( m_strLocalFile
, &spec
) ;
979 if ( FSpGetFInfo( &spec
, &finfo
) == noErr
)
981 finfo
.fdType
= 'TEXT' ;
982 finfo
.fdCreator
= 'ttxt' ;
983 FSpSetFInfo( &spec
, &finfo
) ;
989 // restore the old umask if we changed it
992 (void)umask(umaskOld
);
999 // ----------------------------------------------------------------------------
1000 // renaming groups/entries
1001 // ----------------------------------------------------------------------------
1003 bool wxFileConfig::RenameEntry(const wxString
& oldName
,
1004 const wxString
& newName
)
1006 // check that the entry exists
1007 wxFileConfigEntry
*oldEntry
= m_pCurrentGroup
->FindEntry(oldName
);
1011 // check that the new entry doesn't already exist
1012 if ( m_pCurrentGroup
->FindEntry(newName
) )
1015 // delete the old entry, create the new one
1016 wxString value
= oldEntry
->Value();
1017 if ( !m_pCurrentGroup
->DeleteEntry(oldName
) )
1020 wxFileConfigEntry
*newEntry
= m_pCurrentGroup
->AddEntry(newName
);
1021 newEntry
->SetValue(value
);
1026 bool wxFileConfig::RenameGroup(const wxString
& oldName
,
1027 const wxString
& newName
)
1029 // check that the group exists
1030 wxFileConfigGroup
*group
= m_pCurrentGroup
->FindSubgroup(oldName
);
1034 // check that the new group doesn't already exist
1035 if ( m_pCurrentGroup
->FindSubgroup(newName
) )
1038 group
->Rename(newName
);
1043 // ----------------------------------------------------------------------------
1044 // delete groups/entries
1045 // ----------------------------------------------------------------------------
1047 bool wxFileConfig::DeleteEntry(const wxString
& key
, bool bGroupIfEmptyAlso
)
1049 wxConfigPathChanger
path(this, key
);
1051 if ( !m_pCurrentGroup
->DeleteEntry(path
.Name()) )
1054 if ( bGroupIfEmptyAlso
&& m_pCurrentGroup
->IsEmpty() ) {
1055 if ( m_pCurrentGroup
!= m_pRootGroup
) {
1056 wxFileConfigGroup
*pGroup
= m_pCurrentGroup
;
1057 SetPath(wxT("..")); // changes m_pCurrentGroup!
1058 m_pCurrentGroup
->DeleteSubgroupByName(pGroup
->Name());
1060 //else: never delete the root group
1066 bool wxFileConfig::DeleteGroup(const wxString
& key
)
1068 wxConfigPathChanger
path(this, key
);
1070 return m_pCurrentGroup
->DeleteSubgroupByName(path
.Name());
1073 bool wxFileConfig::DeleteAll()
1077 if ( wxRemove(m_strLocalFile
) == -1 )
1078 wxLogSysError(_("can't delete user configuration file '%s'"), m_strLocalFile
.c_str());
1080 m_strLocalFile
= m_strGlobalFile
= wxT("");
1086 // ----------------------------------------------------------------------------
1087 // linked list functions
1088 // ----------------------------------------------------------------------------
1090 // append a new line to the end of the list
1092 wxFileConfigLineList
*wxFileConfig::LineListAppend(const wxString
& str
)
1094 wxLogTrace( _T("wxFileConfig"),
1095 _T(" ** Adding Line '%s'"),
1097 wxLogTrace( _T("wxFileConfig"),
1099 ((m_linesHead
) ? m_linesHead
->Text().c_str() : wxEmptyString
) );
1100 wxLogTrace( _T("wxFileConfig"),
1102 ((m_linesTail
) ? m_linesTail
->Text().c_str() : wxEmptyString
) );
1104 wxFileConfigLineList
*pLine
= new wxFileConfigLineList(str
);
1106 if ( m_linesTail
== NULL
)
1109 m_linesHead
= pLine
;
1114 m_linesTail
->SetNext(pLine
);
1115 pLine
->SetPrev(m_linesTail
);
1118 m_linesTail
= pLine
;
1120 wxLogTrace( _T("wxFileConfig"),
1122 ((m_linesHead
) ? m_linesHead
->Text().c_str() : wxEmptyString
) );
1123 wxLogTrace( _T("wxFileConfig"),
1125 ((m_linesTail
) ? m_linesTail
->Text().c_str() : wxEmptyString
) );
1130 // insert a new line after the given one or in the very beginning if !pLine
1132 wxFileConfigLineList
*wxFileConfig::LineListInsert(const wxString
& str
,
1133 wxFileConfigLineList
*pLine
)
1135 wxLogTrace( _T("wxFileConfig"),
1136 _T(" ** Inserting Line '%s' after '%s'"),
1138 ((pLine
) ? pLine
->Text().c_str() : wxEmptyString
) );
1139 wxLogTrace( _T("wxFileConfig"),
1141 ((m_linesHead
) ? m_linesHead
->Text().c_str() : wxEmptyString
) );
1142 wxLogTrace( _T("wxFileConfig"),
1144 ((m_linesTail
) ? m_linesTail
->Text().c_str() : wxEmptyString
) );
1146 if ( pLine
== m_linesTail
)
1147 return LineListAppend(str
);
1149 wxFileConfigLineList
*pNewLine
= new wxFileConfigLineList(str
);
1150 if ( pLine
== NULL
)
1152 // prepend to the list
1153 pNewLine
->SetNext(m_linesHead
);
1154 m_linesHead
->SetPrev(pNewLine
);
1155 m_linesHead
= pNewLine
;
1159 // insert before pLine
1160 wxFileConfigLineList
*pNext
= pLine
->Next();
1161 pNewLine
->SetNext(pNext
);
1162 pNewLine
->SetPrev(pLine
);
1163 pNext
->SetPrev(pNewLine
);
1164 pLine
->SetNext(pNewLine
);
1167 wxLogTrace( _T("wxFileConfig"),
1169 ((m_linesHead
) ? m_linesHead
->Text().c_str() : wxEmptyString
) );
1170 wxLogTrace( _T("wxFileConfig"),
1172 ((m_linesTail
) ? m_linesTail
->Text().c_str() : wxEmptyString
) );
1177 void wxFileConfig::LineListRemove(wxFileConfigLineList
*pLine
)
1179 wxLogTrace( _T("wxFileConfig"),
1180 _T(" ** Removing Line '%s'"),
1181 pLine
->Text().c_str() );
1182 wxLogTrace( _T("wxFileConfig"),
1184 ((m_linesHead
) ? m_linesHead
->Text().c_str() : wxEmptyString
) );
1185 wxLogTrace( _T("wxFileConfig"),
1187 ((m_linesTail
) ? m_linesTail
->Text().c_str() : wxEmptyString
) );
1189 wxFileConfigLineList
*pPrev
= pLine
->Prev(),
1190 *pNext
= pLine
->Next();
1194 if ( pPrev
== NULL
)
1195 m_linesHead
= pNext
;
1197 pPrev
->SetNext(pNext
);
1201 if ( pNext
== NULL
)
1202 m_linesTail
= pPrev
;
1204 pNext
->SetPrev(pPrev
);
1206 wxLogTrace( _T("wxFileConfig"),
1208 ((m_linesHead
) ? m_linesHead
->Text().c_str() : wxEmptyString
) );
1209 wxLogTrace( _T("wxFileConfig"),
1211 ((m_linesTail
) ? m_linesTail
->Text().c_str() : wxEmptyString
) );
1216 bool wxFileConfig::LineListIsEmpty()
1218 return m_linesHead
== NULL
;
1221 // ============================================================================
1222 // wxFileConfig::wxFileConfigGroup
1223 // ============================================================================
1225 // ----------------------------------------------------------------------------
1227 // ----------------------------------------------------------------------------
1230 wxFileConfigGroup::wxFileConfigGroup(wxFileConfigGroup
*pParent
,
1231 const wxString
& strName
,
1232 wxFileConfig
*pConfig
)
1233 : m_aEntries(CompareEntries
),
1234 m_aSubgroups(CompareGroups
),
1237 m_pConfig
= pConfig
;
1238 m_pParent
= pParent
;
1242 m_pLastEntry
= NULL
;
1243 m_pLastGroup
= NULL
;
1246 // dtor deletes all children
1247 wxFileConfigGroup::~wxFileConfigGroup()
1250 size_t n
, nCount
= m_aEntries
.Count();
1251 for ( n
= 0; n
< nCount
; n
++ )
1252 delete m_aEntries
[n
];
1255 nCount
= m_aSubgroups
.Count();
1256 for ( n
= 0; n
< nCount
; n
++ )
1257 delete m_aSubgroups
[n
];
1260 // ----------------------------------------------------------------------------
1262 // ----------------------------------------------------------------------------
1264 void wxFileConfigGroup::SetLine(wxFileConfigLineList
*pLine
)
1266 wxASSERT( m_pLine
== 0 ); // shouldn't be called twice
1271 This is a bit complicated, so let me explain it in details. All lines that
1272 were read from the local file (the only one we will ever modify) are stored
1273 in a (doubly) linked list. Our problem is to know at which position in this
1274 list should we insert the new entries/subgroups. To solve it we keep three
1275 variables for each group: m_pLine, m_pLastEntry and m_pLastGroup.
1277 m_pLine points to the line containing "[group_name]"
1278 m_pLastEntry points to the last entry of this group in the local file.
1279 m_pLastGroup subgroup
1281 Initially, they're NULL all three. When the group (an entry/subgroup) is read
1282 from the local file, the corresponding variable is set. However, if the group
1283 was read from the global file and then modified or created by the application
1284 these variables are still NULL and we need to create the corresponding lines.
1285 See the following functions (and comments preceding them) for the details of
1288 Also, when our last entry/group are deleted we need to find the new last
1289 element - the code in DeleteEntry/Subgroup does this by backtracking the list
1290 of lines until it either founds an entry/subgroup (and this is the new last
1291 element) or the m_pLine of the group, in which case there are no more entries
1292 (or subgroups) left and m_pLast<element> becomes NULL.
1294 NB: This last problem could be avoided for entries if we added new entries
1295 immediately after m_pLine, but in this case the entries would appear
1296 backwards in the config file (OTOH, it's not that important) and as we
1297 would still need to do it for the subgroups the code wouldn't have been
1298 significantly less complicated.
1301 // Return the line which contains "[our name]". If we're still not in the list,
1302 // add our line to it immediately after the last line of our parent group if we
1303 // have it or in the very beginning if we're the root group.
1304 wxFileConfigLineList
*wxFileConfigGroup::GetGroupLine()
1306 wxLogTrace( _T("wxFileConfig"),
1307 _T(" GetGroupLine() for Group '%s'"),
1312 wxLogTrace( _T("wxFileConfig"),
1313 _T(" Getting Line item pointer") );
1315 wxFileConfigGroup
*pParent
= Parent();
1317 // this group wasn't present in local config file, add it now
1321 wxLogTrace( _T("wxFileConfig"),
1322 _T(" checking parent '%s'"),
1323 pParent
->Name().c_str() );
1325 wxString strFullName
;
1327 strFullName
<< wxT("[") // +1: no '/'
1328 << FilterOutEntryName(GetFullName().c_str() + 1)
1330 m_pLine
= m_pConfig
->LineListInsert(strFullName
,
1331 pParent
->GetLastGroupLine());
1332 pParent
->SetLastGroup(this); // we're surely after all the others
1336 // we return NULL, so that LineListInsert() will insert us in the
1344 // Return the last line belonging to the subgroups of this group (after which
1345 // we can add a new subgroup), if we don't have any subgroups or entries our
1346 // last line is the group line (m_pLine) itself.
1347 wxFileConfigLineList
*wxFileConfigGroup::GetLastGroupLine()
1349 // if we have any subgroups, our last line is
1350 // the last line of the last subgroup
1352 if ( m_pLastGroup
!= 0 )
1354 wxFileConfigLineList
*pLine
= m_pLastGroup
->GetLastGroupLine();
1356 wxASSERT( pLine
!= 0 ); // last group must have !NULL associated line
1360 // no subgroups, so the last line is the line of thelast entry (if any)
1362 return GetLastEntryLine();
1365 // return the last line belonging to the entries of this group (after which
1366 // we can add a new entry), if we don't have any entries we will add the new
1367 // one immediately after the group line itself.
1368 wxFileConfigLineList
*wxFileConfigGroup::GetLastEntryLine()
1370 wxLogTrace( _T("wxFileConfig"),
1371 _T(" GetLastEntryLine() for Group '%s'"),
1374 if ( m_pLastEntry
!= 0 )
1376 wxFileConfigLineList
*pLine
= m_pLastEntry
->GetLine();
1378 wxASSERT( pLine
!= 0 ); // last entry must have !NULL associated line
1382 // no entries: insert after the group header
1384 return GetGroupLine();
1387 // ----------------------------------------------------------------------------
1389 // ----------------------------------------------------------------------------
1391 void wxFileConfigGroup::Rename(const wxString
& newName
)
1393 m_strName
= newName
;
1395 wxFileConfigLineList
*line
= GetGroupLine();
1396 wxString strFullName
;
1397 strFullName
<< wxT("[") << (GetFullName().c_str() + 1) << wxT("]"); // +1: no '/'
1398 line
->SetText(strFullName
);
1403 wxString
wxFileConfigGroup::GetFullName() const
1406 return Parent()->GetFullName() + wxCONFIG_PATH_SEPARATOR
+ Name();
1411 // ----------------------------------------------------------------------------
1413 // ----------------------------------------------------------------------------
1415 // use binary search because the array is sorted
1417 wxFileConfigGroup::FindEntry(const wxChar
*szName
) const
1421 hi
= m_aEntries
.Count();
1423 wxFileConfigEntry
*pEntry
;
1427 pEntry
= m_aEntries
[i
];
1429 #if wxCONFIG_CASE_SENSITIVE
1430 res
= wxStrcmp(pEntry
->Name(), szName
);
1432 res
= wxStricmp(pEntry
->Name(), szName
);
1447 wxFileConfigGroup::FindSubgroup(const wxChar
*szName
) const
1451 hi
= m_aSubgroups
.Count();
1453 wxFileConfigGroup
*pGroup
;
1457 pGroup
= m_aSubgroups
[i
];
1459 #if wxCONFIG_CASE_SENSITIVE
1460 res
= wxStrcmp(pGroup
->Name(), szName
);
1462 res
= wxStricmp(pGroup
->Name(), szName
);
1476 // ----------------------------------------------------------------------------
1477 // create a new item
1478 // ----------------------------------------------------------------------------
1480 // create a new entry and add it to the current group
1481 wxFileConfigEntry
*wxFileConfigGroup::AddEntry(const wxString
& strName
, int nLine
)
1483 wxASSERT( FindEntry(strName
) == 0 );
1485 wxFileConfigEntry
*pEntry
= new wxFileConfigEntry(this, strName
, nLine
);
1487 m_aEntries
.Add(pEntry
);
1491 // create a new group and add it to the current group
1492 wxFileConfigGroup
*wxFileConfigGroup::AddSubgroup(const wxString
& strName
)
1494 wxASSERT( FindSubgroup(strName
) == 0 );
1496 wxFileConfigGroup
*pGroup
= new wxFileConfigGroup(this, strName
, m_pConfig
);
1498 m_aSubgroups
.Add(pGroup
);
1502 // ----------------------------------------------------------------------------
1504 // ----------------------------------------------------------------------------
1507 The delete operations are _very_ slow if we delete the last item of this
1508 group (see comments before GetXXXLineXXX functions for more details),
1509 so it's much better to start with the first entry/group if we want to
1510 delete several of them.
1513 bool wxFileConfigGroup::DeleteSubgroupByName(const wxChar
*szName
)
1515 return DeleteSubgroup(FindSubgroup(szName
));
1518 // Delete the subgroup and remove all references to it from
1519 // other data structures.
1520 bool wxFileConfigGroup::DeleteSubgroup(wxFileConfigGroup
*pGroup
)
1522 wxLogTrace( _T("wxFileConfig"),
1523 _T("Deleting group '%s' from '%s'"),
1524 pGroup
->Name().c_str(),
1527 wxLogTrace( _T("wxFileConfig"),
1528 _T(" (m_pLine) = prev: %p, this %p, next %p"),
1529 ((m_pLine
) ? m_pLine
->Prev() : 0),
1531 ((m_pLine
) ? m_pLine
->Next() : 0) );
1532 wxLogTrace( _T("wxFileConfig"),
1534 ((m_pLine
) ? m_pLine
->Text().c_str() : wxEmptyString
) );
1536 wxCHECK_MSG( pGroup
!= 0, FALSE
, _T("deleting non existing group?") );
1538 // delete all entries
1540 size_t nCount
= pGroup
->m_aEntries
.Count();
1542 wxLogTrace(_T("wxFileConfig"),
1543 _T("Removing %lu Entries"),
1544 (unsigned long)nCount
);
1546 for ( size_t nEntry
= 0; nEntry
< nCount
; nEntry
++ )
1548 wxFileConfigLineList
*pLine
= pGroup
->m_aEntries
[nEntry
]->GetLine();
1552 wxLogTrace( _T("wxFileConfig"),
1554 pLine
->Text().c_str() );
1555 m_pConfig
->LineListRemove(pLine
);
1559 // and subgroups of this subgroup
1561 nCount
= pGroup
->m_aSubgroups
.Count();
1563 wxLogTrace( _T("wxFileConfig"),
1564 _T("Removing %lu SubGroups"),
1565 (unsigned long)nCount
);
1567 for ( size_t nGroup
= 0; nGroup
< nCount
; nGroup
++ )
1569 pGroup
->DeleteSubgroup(pGroup
->m_aSubgroups
[0]);
1572 // finally the group itself
1574 wxFileConfigLineList
*pLine
= pGroup
->m_pLine
;
1578 wxLogTrace( _T("wxFileConfig"),
1579 _T(" Removing line entry for Group '%s' : '%s'"),
1580 pGroup
->Name().c_str(),
1581 pLine
->Text().c_str() );
1582 wxLogTrace( _T("wxFileConfig"),
1583 _T(" Removing from Group '%s' : '%s'"),
1585 ((m_pLine
) ? m_pLine
->Text().c_str() : wxEmptyString
) );
1587 // notice that we may do this test inside the previous "if"
1588 // because the last entry's line is surely !NULL
1590 if ( pGroup
== m_pLastGroup
)
1592 wxLogTrace( _T("wxFileConfig"),
1593 _T(" ------- Removing last group -------") );
1595 // our last entry is being deleted, so find the last one which stays.
1596 // go back until we find a subgroup or reach the group's line, unless
1597 // we are the root group, which we'll notice shortly.
1599 wxFileConfigGroup
*pNewLast
= 0;
1600 size_t nSubgroups
= m_aSubgroups
.Count();
1601 wxFileConfigLineList
*pl
;
1603 for ( pl
= pLine
->Prev(); pl
!= m_pLine
; pl
= pl
->Prev() )
1605 // is it our subgroup?
1607 for ( size_t n
= 0; (pNewLast
== 0) && (n
< nSubgroups
); n
++ )
1609 // do _not_ call GetGroupLine! we don't want to add it to the local
1610 // file if it's not already there
1612 if ( m_aSubgroups
[n
]->m_pLine
== m_pLine
)
1613 pNewLast
= m_aSubgroups
[n
];
1616 if ( pNewLast
!= 0 ) // found?
1620 if ( pl
== m_pLine
|| m_pParent
== 0 )
1622 wxLogTrace( _T("wxFileConfig"),
1623 _T(" ------- No previous group found -------") );
1625 wxASSERT_MSG( !pNewLast
|| m_pLine
== 0,
1626 _T("how comes it has the same line as we?") );
1628 // we've reached the group line without finding any subgroups,
1629 // or realised we removed the last group from the root.
1635 wxLogTrace( _T("wxFileConfig"),
1636 _T(" ------- Last Group set to '%s' -------"),
1637 pNewLast
->Name().c_str() );
1639 m_pLastGroup
= pNewLast
;
1643 m_pConfig
->LineListRemove(pLine
);
1647 wxLogTrace( _T("wxFileConfig"),
1648 _T(" No line entry for Group '%s'?"),
1649 pGroup
->Name().c_str() );
1654 m_aSubgroups
.Remove(pGroup
);
1660 bool wxFileConfigGroup::DeleteEntry(const wxChar
*szName
)
1662 wxFileConfigEntry
*pEntry
= FindEntry(szName
);
1663 wxCHECK( pEntry
!= NULL
, FALSE
); // deleting non existing item?
1665 wxFileConfigLineList
*pLine
= pEntry
->GetLine();
1666 if ( pLine
!= NULL
) {
1667 // notice that we may do this test inside the previous "if" because the
1668 // last entry's line is surely !NULL
1669 if ( pEntry
== m_pLastEntry
) {
1670 // our last entry is being deleted - find the last one which stays
1671 wxASSERT( m_pLine
!= NULL
); // if we have an entry with !NULL pLine...
1673 // go back until we find another entry or reach the group's line
1674 wxFileConfigEntry
*pNewLast
= NULL
;
1675 size_t n
, nEntries
= m_aEntries
.Count();
1676 wxFileConfigLineList
*pl
;
1677 for ( pl
= pLine
->Prev(); pl
!= m_pLine
; pl
= pl
->Prev() ) {
1678 // is it our subgroup?
1679 for ( n
= 0; (pNewLast
== NULL
) && (n
< nEntries
); n
++ ) {
1680 if ( m_aEntries
[n
]->GetLine() == m_pLine
)
1681 pNewLast
= m_aEntries
[n
];
1684 if ( pNewLast
!= NULL
) // found?
1688 if ( pl
== m_pLine
) {
1689 wxASSERT( !pNewLast
); // how comes it has the same line as we?
1691 // we've reached the group line without finding any subgroups
1692 m_pLastEntry
= NULL
;
1695 m_pLastEntry
= pNewLast
;
1698 m_pConfig
->LineListRemove(pLine
);
1701 // we must be written back for the changes to be saved
1704 m_aEntries
.Remove(pEntry
);
1710 // ----------------------------------------------------------------------------
1712 // ----------------------------------------------------------------------------
1713 void wxFileConfigGroup::SetDirty()
1716 if ( Parent() != NULL
) // propagate upwards
1717 Parent()->SetDirty();
1720 // ============================================================================
1721 // wxFileConfig::wxFileConfigEntry
1722 // ============================================================================
1724 // ----------------------------------------------------------------------------
1726 // ----------------------------------------------------------------------------
1727 wxFileConfigEntry::wxFileConfigEntry(wxFileConfigGroup
*pParent
,
1728 const wxString
& strName
,
1730 : m_strName(strName
)
1732 wxASSERT( !strName
.IsEmpty() );
1734 m_pParent
= pParent
;
1739 m_bHasValue
= FALSE
;
1741 m_bImmutable
= strName
[0] == wxCONFIG_IMMUTABLE_PREFIX
;
1743 m_strName
.erase(0, 1); // remove first character
1746 // ----------------------------------------------------------------------------
1748 // ----------------------------------------------------------------------------
1750 void wxFileConfigEntry::SetLine(wxFileConfigLineList
*pLine
)
1752 if ( m_pLine
!= NULL
) {
1753 wxLogWarning(_("entry '%s' appears more than once in group '%s'"),
1754 Name().c_str(), m_pParent
->GetFullName().c_str());
1758 Group()->SetLastEntry(this);
1761 // second parameter is FALSE if we read the value from file and prevents the
1762 // entry from being marked as 'dirty'
1763 void wxFileConfigEntry::SetValue(const wxString
& strValue
, bool bUser
)
1765 if ( bUser
&& IsImmutable() )
1767 wxLogWarning( _("attempt to change immutable key '%s' ignored."),
1772 // do nothing if it's the same value: but don't test for it
1773 // if m_bHasValue hadn't been set yet or we'd never write
1774 // empty values to the file
1776 if ( m_bHasValue
&& strValue
== m_strValue
)
1780 m_strValue
= strValue
;
1784 wxString strValFiltered
;
1786 if ( Group()->Config()->GetStyle() & wxCONFIG_USE_NO_ESCAPE_CHARACTERS
)
1788 strValFiltered
= strValue
;
1791 strValFiltered
= FilterOutValue(strValue
);
1795 strLine
<< FilterOutEntryName(m_strName
) << wxT('=') << strValFiltered
;
1799 // entry was read from the local config file, just modify the line
1800 m_pLine
->SetText(strLine
);
1803 // add a new line to the file
1804 wxASSERT( m_nLine
== wxNOT_FOUND
); // consistency check
1806 m_pLine
= Group()->Config()->LineListInsert(strLine
,
1807 Group()->GetLastEntryLine());
1808 Group()->SetLastEntry(this);
1815 void wxFileConfigEntry::SetDirty()
1818 Group()->SetDirty();
1821 // ============================================================================
1823 // ============================================================================
1825 // ----------------------------------------------------------------------------
1826 // compare functions for array sorting
1827 // ----------------------------------------------------------------------------
1829 int CompareEntries(wxFileConfigEntry
*p1
, wxFileConfigEntry
*p2
)
1831 #if wxCONFIG_CASE_SENSITIVE
1832 return wxStrcmp(p1
->Name(), p2
->Name());
1834 return wxStricmp(p1
->Name(), p2
->Name());
1838 int CompareGroups(wxFileConfigGroup
*p1
, wxFileConfigGroup
*p2
)
1840 #if wxCONFIG_CASE_SENSITIVE
1841 return wxStrcmp(p1
->Name(), p2
->Name());
1843 return wxStricmp(p1
->Name(), p2
->Name());
1847 // ----------------------------------------------------------------------------
1849 // ----------------------------------------------------------------------------
1851 // undo FilterOutValue
1852 static wxString
FilterInValue(const wxString
& str
)
1855 strResult
.Alloc(str
.Len());
1857 bool bQuoted
= !str
.IsEmpty() && str
[0] == '"';
1859 for ( size_t n
= bQuoted
? 1 : 0; n
< str
.Len(); n
++ ) {
1860 if ( str
[n
] == wxT('\\') ) {
1861 switch ( str
[++n
] ) {
1863 strResult
+= wxT('\n');
1867 strResult
+= wxT('\r');
1871 strResult
+= wxT('\t');
1875 strResult
+= wxT('\\');
1879 strResult
+= wxT('"');
1884 if ( str
[n
] != wxT('"') || !bQuoted
)
1885 strResult
+= str
[n
];
1886 else if ( n
!= str
.Len() - 1 ) {
1887 wxLogWarning(_("unexpected \" at position %d in '%s'."),
1890 //else: it's the last quote of a quoted string, ok
1897 // quote the string before writing it to file
1898 static wxString
FilterOutValue(const wxString
& str
)
1904 strResult
.Alloc(str
.Len());
1906 // quoting is necessary to preserve spaces in the beginning of the string
1907 bool bQuote
= wxIsspace(str
[0]) || str
[0] == wxT('"');
1910 strResult
+= wxT('"');
1913 for ( size_t n
= 0; n
< str
.Len(); n
++ ) {
1936 //else: fall through
1939 strResult
+= str
[n
];
1940 continue; // nothing special to do
1943 // we get here only for special characters
1944 strResult
<< wxT('\\') << c
;
1948 strResult
+= wxT('"');
1953 // undo FilterOutEntryName
1954 static wxString
FilterInEntryName(const wxString
& str
)
1957 strResult
.Alloc(str
.Len());
1959 for ( const wxChar
*pc
= str
.c_str(); *pc
!= '\0'; pc
++ ) {
1960 if ( *pc
== wxT('\\') )
1969 // sanitize entry or group name: insert '\\' before any special characters
1970 static wxString
FilterOutEntryName(const wxString
& str
)
1973 strResult
.Alloc(str
.Len());
1975 for ( const wxChar
*pc
= str
.c_str(); *pc
!= wxT('\0'); pc
++ ) {
1978 // we explicitly allow some of "safe" chars and 8bit ASCII characters
1979 // which will probably never have special meaning
1980 // NB: note that wxCONFIG_IMMUTABLE_PREFIX and wxCONFIG_PATH_SEPARATOR
1981 // should *not* be quoted
1982 if ( !wxIsalnum(c
) && !wxStrchr(wxT("@_/-!.*%"), c
) && ((c
& 0x80) == 0) )
1983 strResult
+= wxT('\\');
1991 // we can't put ?: in the ctor initializer list because it confuses some
1992 // broken compilers (Borland C++)
1993 static wxString
GetAppName(const wxString
& appName
)
1995 if ( !appName
&& wxTheApp
)
1996 return wxTheApp
->GetAppName();
2001 #endif // wxUSE_CONFIG