]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/fileconf.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Very bad wxPrintData destructor... fixed typo.
[wxWidgets.git] / src / common / fileconf.cpp
diff --git a/src/common/fileconf.cpp b/src/common/fileconf.cpp
index 0bf48eeb78eb9730b6b70a6fa91f9b04b3404e9a..cf8ad6879af2862b4cfc8079eacb2d6875254855 100644 (file)
--- a/src/common/fileconf.cpp
+++ b/src/common/fileconf.cpp
@@ -28,16 +28,19 @@
 #endif  //__BORLANDC__
 
 #ifndef   WX_PRECOMP
 #endif  //__BORLANDC__
 
 #ifndef   WX_PRECOMP
-  #include  <wx/string.h>
-  #include  <wx/intl.h>
+  #include  "wx/string.h"
+  #include  "wx/intl.h"
 #endif  //WX_PRECOMP
 
 #endif  //WX_PRECOMP
 
-#include  <wx/dynarray.h>
-#include  <wx/file.h>
-#include  <wx/log.h>
-#include  <wx/textfile.h>
-#include  <wx/config.h>
-#include  <wx/fileconf.h>
+#include  "wx/app.h"
+#include  "wx/dynarray.h"
+#include  "wx/file.h"
+#include  "wx/log.h"
+#include  "wx/textfile.h"
+#include  "wx/config.h"
+#include  "wx/fileconf.h"
+
+#include  "wx/utils.h"    // for wxGetHomeDir
 
 // _WINDOWS_ is defined when windows.h is included,
 // __WXMSW__ is defined for MS Windows compilation
 
 // _WINDOWS_ is defined when windows.h is included,
 // __WXMSW__ is defined for MS Windows compilation
@@ -54,23 +57,26 @@
 #define CONST_CAST ((wxFileConfig *)this)->
 
 // ----------------------------------------------------------------------------
 #define CONST_CAST ((wxFileConfig *)this)->
 
 // ----------------------------------------------------------------------------
-// global functions declarations
+// constants
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
+#ifndef MAX_PATH
+  #define MAX_PATH 512
+#endif
 
 
-// is 'c' a valid character in group name?
-// NB: wxCONFIG_IMMUTABLE_PREFIX and wxCONFIG_PATH_SEPARATOR must be valid chars,
-//     but _not_ ']' (group name delimiter)
-inline bool IsValid(char c) { return isalnum(c) || strchr("@_/-!.*%", c); }
+// ----------------------------------------------------------------------------
+// global functions declarations
+// ----------------------------------------------------------------------------
 
 // compare functions for sorting the arrays
 
 // compare functions for sorting the arrays
-static int CompareEntries(wxFileConfig::ConfigEntry *p1,
-                          wxFileConfig::ConfigEntry *p2);
-static int CompareGroups(wxFileConfig::ConfigGroup *p1,
-                         wxFileConfig::ConfigGroup *p2);
+static int CompareEntries(ConfigEntry *p1, ConfigEntry *p2);
+static int CompareGroups(ConfigGroup *p1, ConfigGroup *p2);
 
 // filter strings
 
 // filter strings
-static wxString FilterIn(const wxString& str);
-static wxString FilterOut(const wxString& str);
+static wxString FilterInValue(const wxString& str);
+static wxString FilterOutValue(const wxString& str);
+
+static wxString FilterInEntryName(const wxString& str);
+static wxString FilterOutEntryName(const wxString& str);
 
 // ============================================================================
 // implementation
 
 // ============================================================================
 // implementation
@@ -85,13 +91,13 @@ wxString wxFileConfig::GetGlobalDir()
 
   #ifdef __UNIX__
     strDir = "/etc/";
 
   #ifdef __UNIX__
     strDir = "/etc/";
+  #elif defined(__WXSTUBS__)
+    wxASSERT_MSG( FALSE, "TODO" ) ;
+  #elif defined(__WXMAC__)
+    wxASSERT_MSG( FALSE, "TODO" ) ;
   #else // Windows
   #else // Windows
-    #ifndef _MAX_PATH
-      #define _MAX_PATH 512
-    #endif
-
-    char szWinDir[_MAX_PATH];
-    ::GetWindowsDirectory(szWinDir, _MAX_PATH);
+    char szWinDir[MAX_PATH];
+    ::GetWindowsDirectory(szWinDir, MAX_PATH);
 
     strDir = szWinDir;
     strDir << '\\';
 
     strDir = szWinDir;
     strDir << '\\';
@@ -104,29 +110,13 @@ wxString wxFileConfig::GetLocalDir()
 {
   wxString strDir;
 
 {
   wxString strDir;
 
-  #ifdef __UNIX__
-    const char *szHome = getenv("HOME");
-    if ( szHome == NULL ) {
-      // we're homeless...
-      wxLogWarning(_("can't find user's HOME, using current directory."));
-      strDir = ".";
-    }
-    else
-       strDir = szHome;
-    strDir << '/'; // a double slash is no problem, a missin one yes
-  #else   // Windows
-    #ifdef  __WIN32__
-      const char *szHome = getenv("HOMEDRIVE");
-      if ( szHome != NULL )
-        strDir << szHome;
-      szHome = getenv("HOMEPATH");
-      if ( szHome != NULL )
-        strDir << szHome;
-    #else   // Win16
-      // Win16 has no idea about home, so use the current directory instead
-      strDir = ".\\";
-    #endif  // WIN16/32
-  #endif  // UNIX/Win
+  wxGetHomeDir(&strDir);
+
+#ifdef  __UNIX__
+  if (strDir.Last() != '/') strDir << '/';
+#else
+  if (strDir.Last() != '\\') strDir << '\\';
+#endif
 
   return strDir;
 }
 
   return strDir;
 }
@@ -204,34 +194,53 @@ void wxFileConfig::Init()
   }
 }
 
   }
 }
 
-wxFileConfig::wxFileConfig(const char *szAppName, bool bLocalOnly)
+// constructor supports creation of wxFileConfig objects of any type
+wxFileConfig::wxFileConfig(const wxString& appName, const wxString& vendorName,
+                           const wxString& strLocal, const wxString& strGlobal,
+                           long style)
+            : wxConfigBase(appName, vendorName, strLocal, strGlobal, style),
+              m_strLocalFile(strLocal), m_strGlobalFile(strGlobal)
 {
 {
-  wxASSERT( !IsEmpty(szAppName) ); // invent a name for your application!
+  // Make up an application name if not supplied
+  if (appName.IsEmpty() && wxTheApp)
+  {
+    SetAppName(wxTheApp->GetAppName());
+  }
 
 
-  m_strLocalFile = GetLocalFileName(szAppName);
-  if ( !bLocalOnly )
-    m_strGlobalFile = GetGlobalFileName(szAppName);
-  //else: it's going to be empty and we won't use the global file
+  // Make up names for files if empty
+  if ( m_strLocalFile.IsEmpty() && (style & wxCONFIG_USE_LOCAL_FILE) )
+  {
+    m_strLocalFile = GetLocalFileName(GetAppName());
+  }
 
 
-  Init();
-}
+  if ( m_strGlobalFile.IsEmpty() && (style & wxCONFIG_USE_GLOBAL_FILE) )
+  {
+    m_strGlobalFile = GetGlobalFileName(GetAppName());
+  }
 
 
-wxFileConfig::wxFileConfig(const wxString& strLocal, const wxString& strGlobal)
-            : m_strLocalFile(strLocal), m_strGlobalFile(strGlobal)
-{
-  // if the path is not absolute, prepend the standard directory to it
+  // Check if styles are not supplied, but filenames are, in which case
+  // add the correct styles.
+  if ( !m_strLocalFile.IsEmpty() )
+    SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE);
+
+  if ( !m_strGlobalFile.IsEmpty() )
+    SetStyle(GetStyle() | wxCONFIG_USE_GLOBAL_FILE);
 
 
-  if ( !strLocal.IsEmpty() && !wxIsPathSeparator(strLocal[0u]) )
+  // if the path is not absolute, prepend the standard directory to it
+  if ( !m_strLocalFile.IsEmpty() && !wxIsAbsolutePath(m_strLocalFile) )
   {
   {
-     m_strLocalFile = GetLocalDir();
-     m_strLocalFile << strLocal;
+    wxString strLocal = m_strLocalFile;
+    m_strLocalFile = GetLocalDir();
+    m_strLocalFile << strLocal;
   }
   }
-  
-  if ( !strGlobal.IsEmpty() && !wxIsPathSeparator(strGlobal[0u]) )
+
+  if ( !m_strGlobalFile.IsEmpty() && !wxIsAbsolutePath(m_strGlobalFile) )
   {
   {
-     m_strGlobalFile = GetGlobalDir();
-     m_strGlobalFile << strGlobal;
+    wxString strGlobal = m_strGlobalFile;
+    m_strGlobalFile = GetGlobalDir();
+    m_strGlobalFile << strGlobal;
   }
   }
+
   Init();
 }
 
   Init();
 }
 
@@ -264,8 +273,8 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal)
   const char *pEnd;
   wxString strLine;
 
   const char *pEnd;
   wxString strLine;
 
-  uint nLineCount = file.GetLineCount();
-  for ( uint n = 0; n < nLineCount; n++ ) {
+  size_t nLineCount = file.GetLineCount();
+  for ( size_t n = 0; n < nLineCount; n++ ) {
     strLine = file[n];
 
     // add the line to linked list
     strLine = file[n];
 
     // add the line to linked list
@@ -284,8 +293,8 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal)
       pEnd = pStart;
 
       while ( *++pEnd != ']' ) {
       pEnd = pStart;
 
       while ( *++pEnd != ']' ) {
-        if ( !IsValid(*pEnd) && *pEnd != ' ' )  // allow spaces in group names
-          break;
+        if ( *pEnd == '\n' || *pEnd == '\0' )
+            break;
       }
 
       if ( *pEnd != ']' ) {
       }
 
       if ( *pEnd != ']' ) {
@@ -297,7 +306,8 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal)
       // group name here is always considered as abs path
       wxString strGroup;
       pStart++;
       // group name here is always considered as abs path
       wxString strGroup;
       pStart++;
-      strGroup << wxCONFIG_PATH_SEPARATOR << wxString(pStart, pEnd - pStart);
+      strGroup << wxCONFIG_PATH_SEPARATOR
+               << FilterInEntryName(wxString(pStart, pEnd - pStart));
 
       // will create it if doesn't yet exist
       SetPath(strGroup);
 
       // will create it if doesn't yet exist
       SetPath(strGroup);
@@ -329,10 +339,17 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal)
     }
     else {                        // a key
       const char *pEnd = pStart;
     }
     else {                        // a key
       const char *pEnd = pStart;
-      while ( IsValid(*pEnd) )
+      while ( !isspace(*pEnd) ) {
+        if ( *pEnd == '\\' ) {
+          // next character may be space or not - still take it because it's
+          // quoted
+          pEnd++;
+        }
+
         pEnd++;
         pEnd++;
+      }
 
 
-      wxString strKey(pStart, pEnd);
+      wxString strKey(FilterInEntryName(wxString(pStart, pEnd)));
 
       // skip whitespace
       while ( isspace(*pEnd) )
 
       // skip whitespace
       while ( isspace(*pEnd) )
@@ -379,7 +396,7 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal)
         while ( isspace(*pEnd) )
           pEnd++;
 
         while ( isspace(*pEnd) )
           pEnd++;
 
-        pEntry->SetValue(FilterIn(pEnd), FALSE /* read from file */);
+        pEntry->SetValue(FilterInValue(pEnd), FALSE /* read from file */);
       }
     }
   }
       }
     }
   }
@@ -416,7 +433,7 @@ void wxFileConfig::SetPath(const wxString& strPath)
   }
 
   // change current group
   }
 
   // change current group
-  uint n;
+  size_t n;
   m_pCurrentGroup = m_pRootGroup;
   for ( n = 0; n < aParts.Count(); n++ ) {
     ConfigGroup *pNextGroup = m_pCurrentGroup->FindSubgroup(aParts[n]);
   m_pCurrentGroup = m_pRootGroup;
   for ( n = 0; n < aParts.Count(); n++ ) {
     ConfigGroup *pNextGroup = m_pCurrentGroup->FindSubgroup(aParts[n]);
@@ -444,7 +461,7 @@ bool wxFileConfig::GetFirstGroup(wxString& str, long& lIndex) const
 
 bool wxFileConfig::GetNextGroup (wxString& str, long& lIndex) const
 {
 
 bool wxFileConfig::GetNextGroup (wxString& str, long& lIndex) const
 {
-  if ( uint(lIndex) < m_pCurrentGroup->Groups().Count() ) {
+  if ( size_t(lIndex) < m_pCurrentGroup->Groups().Count() ) {
     str = m_pCurrentGroup->Groups()[lIndex++]->Name();
     return TRUE;
   }
     str = m_pCurrentGroup->Groups()[lIndex++]->Name();
     return TRUE;
   }
@@ -460,7 +477,7 @@ bool wxFileConfig::GetFirstEntry(wxString& str, long& lIndex) const
 
 bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) const
 {
 
 bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) const
 {
-  if ( uint(lIndex) < m_pCurrentGroup->Entries().Count() ) {
+  if ( size_t(lIndex) < m_pCurrentGroup->Entries().Count() ) {
     str = m_pCurrentGroup->Entries()[lIndex++]->Name();
     return TRUE;
   }
     str = m_pCurrentGroup->Entries()[lIndex++]->Name();
     return TRUE;
   }
@@ -468,13 +485,13 @@ bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) const
     return FALSE;
 }
 
     return FALSE;
 }
 
-uint wxFileConfig::GetNumberOfEntries(bool bRecursive) const
+size_t wxFileConfig::GetNumberOfEntries(bool bRecursive) const
 {
 {
-  uint n = m_pCurrentGroup->Entries().Count();
+  size_t n = m_pCurrentGroup->Entries().Count();
   if ( bRecursive ) {
     ConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
   if ( bRecursive ) {
     ConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
-    uint nSubgroups = m_pCurrentGroup->Groups().Count();
-    for ( uint nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
+    size_t nSubgroups = m_pCurrentGroup->Groups().Count();
+    for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
       CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
       n += GetNumberOfEntries(TRUE);
       CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
       CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
       n += GetNumberOfEntries(TRUE);
       CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
@@ -484,13 +501,13 @@ uint wxFileConfig::GetNumberOfEntries(bool bRecursive) const
   return n;
 }
 
   return n;
 }
 
-uint wxFileConfig::GetNumberOfGroups(bool bRecursive) const
+size_t wxFileConfig::GetNumberOfGroups(bool bRecursive) const
 {
 {
-  uint n = m_pCurrentGroup->Groups().Count();
+  size_t n = m_pCurrentGroup->Groups().Count();
   if ( bRecursive ) {
     ConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
   if ( bRecursive ) {
     ConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
-    uint nSubgroups = m_pCurrentGroup->Groups().Count();
-    for ( uint nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
+    size_t nSubgroups = m_pCurrentGroup->Groups().Count();
+    for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
       CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
       n += GetNumberOfGroups(TRUE);
       CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
       CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
       n += GetNumberOfGroups(TRUE);
       CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
@@ -506,7 +523,7 @@ uint wxFileConfig::GetNumberOfGroups(bool bRecursive) const
 
 bool wxFileConfig::HasGroup(const wxString& strName) const
 {
 
 bool wxFileConfig::HasGroup(const wxString& strName) const
 {
-  PathChanger path(this, strName);
+  wxConfigPathChanger path(this, strName);
 
   ConfigGroup *pGroup = m_pCurrentGroup->FindSubgroup(path.Name());
   return pGroup != NULL;
 
   ConfigGroup *pGroup = m_pCurrentGroup->FindSubgroup(path.Name());
   return pGroup != NULL;
@@ -514,7 +531,7 @@ bool wxFileConfig::HasGroup(const wxString& strName) const
 
 bool wxFileConfig::HasEntry(const wxString& strName) const
 {
 
 bool wxFileConfig::HasEntry(const wxString& strName) const
 {
-  PathChanger path(this, strName);
+  wxConfigPathChanger path(this, strName);
 
   ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
   return pEntry != NULL;
 
   ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
   return pEntry != NULL;
@@ -524,48 +541,54 @@ bool wxFileConfig::HasEntry(const wxString& strName) const
 // read/write values
 // ----------------------------------------------------------------------------
 
 // read/write values
 // ----------------------------------------------------------------------------
 
-bool wxFileConfig::Read(wxString   *pstr,
-                        const char *szKey,
-                        const char *szDefault) const
+bool wxFileConfig::Read(const wxString& key,
+                        wxString* pStr) const
 {
 {
-  PathChanger path(this, szKey);
+  wxConfigPathChanger path(this, key);
 
   ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
   if (pEntry == NULL) {
 
   ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
   if (pEntry == NULL) {
-    *pstr = ExpandEnvVars(szDefault);
     return FALSE;
   }
   else {
     return FALSE;
   }
   else {
-    *pstr = ExpandEnvVars(pEntry->Value());
+    *pStr = ExpandEnvVars(pEntry->Value());
     return TRUE;
   }
 }
 
     return TRUE;
   }
 }
 
-const char *wxFileConfig::Read(const char *szKey,
-                               const char *szDefault) const
+bool wxFileConfig::Read(const wxString& key,
+                        wxString* pStr, const wxString& defVal) const
 {
 {
-  static wxString s_str;
-  Read(&s_str, szKey, szDefault);
+  wxConfigPathChanger path(this, key);
 
 
-  return s_str.c_str();
+  ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
+  if (pEntry == NULL) {
+    if( IsRecordingDefaults() )
+      ((wxFileConfig *)this)->Write(key,defVal);
+    *pStr = ExpandEnvVars(defVal);
+    return FALSE;
+  }
+  else {
+    *pStr = ExpandEnvVars(pEntry->Value());
+    return TRUE;
+  }
 }
 
 }
 
-bool wxFileConfig::Read(long *pl, const char *szKey, long lDefault) const
+bool wxFileConfig::Read(const wxString& key, long *pl) const
 {
   wxString str;
 {
   wxString str;
-  if ( Read(&str, szKey) ) {
+  if ( Read(key, & str) ) {
     *pl = atol(str);
     return TRUE;
   }
   else {
     *pl = atol(str);
     return TRUE;
   }
   else {
-    *pl = lDefault;
     return FALSE;
   }
 }
 
     return FALSE;
   }
 }
 
-bool wxFileConfig::Write(const char *szKey, const char *szValue)
+bool wxFileConfig::Write(const wxString& key, const wxString& szValue)
 {
 {
-  PathChanger path(this, szKey);
+  wxConfigPathChanger path(this, key);
 
   wxString strName = path.Name();
   if ( strName.IsEmpty() ) {
 
   wxString strName = path.Name();
   if ( strName.IsEmpty() ) {
@@ -583,18 +606,12 @@ bool wxFileConfig::Write(const char *szKey, const char *szValue)
 
     // check that the name is reasonable
     if ( strName[0u] == wxCONFIG_IMMUTABLE_PREFIX ) {
 
     // check that the name is reasonable
     if ( strName[0u] == wxCONFIG_IMMUTABLE_PREFIX ) {
-      wxLogError(_("Entry name can't start with '%c'."),
+      wxLogError(_("Config entry name cannot start with '%c'."),
                  wxCONFIG_IMMUTABLE_PREFIX);
       return FALSE;
     }
 
                  wxCONFIG_IMMUTABLE_PREFIX);
       return FALSE;
     }
 
-    for ( const char *pc = strName; *pc != '\0'; pc++ ) {
-      if ( !IsValid(*pc) ) {
-        wxLogError(_("Character '%c' is invalid in a config entry name."),
-                   *pc);
-        return FALSE;
-      }
-    }
+    strName = FilterOutEntryName(strName);
 
     ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strName);
     if ( pEntry == NULL )
 
     ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strName);
     if ( pEntry == NULL )
@@ -606,12 +623,12 @@ bool wxFileConfig::Write(const char *szKey, const char *szValue)
   return TRUE;
 }
 
   return TRUE;
 }
 
-bool wxFileConfig::Write(const char *szKey, long lValue)
+bool wxFileConfig::Write(const wxString& key, long lValue)
 {
   // ltoa() is not ANSI :-(
 {
   // ltoa() is not ANSI :-(
-  char szBuf[40];   // should be good for sizeof(long) <= 16 (128 bits)
-  sprintf(szBuf, "%ld", lValue);
-  return Write(szKey, szBuf);
+  wxString buf;
+  buf.Printf("%ld", lValue);
+  return Write(key, buf);
 }
 
 bool wxFileConfig::Flush(bool /* bCurrentOnly */)
 }
 
 bool wxFileConfig::Flush(bool /* bCurrentOnly */)
@@ -637,13 +654,57 @@ bool wxFileConfig::Flush(bool /* bCurrentOnly */)
   return file.Commit();
 }
 
   return file.Commit();
 }
 
+// ----------------------------------------------------------------------------
+// renaming groups/entries
+// ----------------------------------------------------------------------------
+
+bool wxFileConfig::RenameEntry(const wxString& oldName,
+                               const wxString& newName)
+{
+    // check that the entry exists
+    ConfigEntry *oldEntry = m_pCurrentGroup->FindEntry(oldName);
+    if ( !oldEntry )
+        return FALSE;
+
+    // check that the new entry doesn't already exist
+    if ( m_pCurrentGroup->FindEntry(newName) )
+        return FALSE;
+
+    // delete the old entry, create the new one
+    wxString value = oldEntry->Value();
+    if ( !m_pCurrentGroup->DeleteEntry(oldName) )
+        return FALSE;
+
+    ConfigEntry *newEntry = m_pCurrentGroup->AddEntry(newName);
+    newEntry->SetValue(value);
+
+    return TRUE;
+}
+
+bool wxFileConfig::RenameGroup(const wxString& oldName,
+                               const wxString& newName)
+{
+    // check that the group exists
+    ConfigGroup *group = m_pCurrentGroup->FindSubgroup(oldName);
+    if ( !group )
+        return FALSE;
+
+    // check that the new group doesn't already exist
+    if ( m_pCurrentGroup->FindSubgroup(newName) )
+        return FALSE;
+
+    group->Rename(newName);
+
+    return TRUE;
+}
+
 // ----------------------------------------------------------------------------
 // delete groups/entries
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // delete groups/entries
 // ----------------------------------------------------------------------------
 
-bool wxFileConfig::DeleteEntry(const char *szKey, bool bGroupIfEmptyAlso)
+bool wxFileConfig::DeleteEntry(const wxString& key, bool bGroupIfEmptyAlso)
 {
 {
-  PathChanger path(this, szKey);
+  wxConfigPathChanger path(this, key);
 
   if ( !m_pCurrentGroup->DeleteEntry(path.Name()) )
     return FALSE;
 
   if ( !m_pCurrentGroup->DeleteEntry(path.Name()) )
     return FALSE;
@@ -660,9 +721,9 @@ bool wxFileConfig::DeleteEntry(const char *szKey, bool bGroupIfEmptyAlso)
   return TRUE;
 }
 
   return TRUE;
 }
 
-bool wxFileConfig::DeleteGroup(const char *szKey)
+bool wxFileConfig::DeleteGroup(const wxString& key)
 {
 {
-  PathChanger path(this, szKey);
+  wxConfigPathChanger path(this, key);
 
   return m_pCurrentGroup->DeleteSubgroupByName(path.Name());
 }
 
   return m_pCurrentGroup->DeleteSubgroupByName(path.Name());
 }
@@ -687,7 +748,7 @@ bool wxFileConfig::DeleteAll()
 // ----------------------------------------------------------------------------
 
 // append a new line to the end of the list
 // ----------------------------------------------------------------------------
 
 // append a new line to the end of the list
-wxFileConfig::LineList *wxFileConfig::LineListAppend(const wxString& str)
+LineList *wxFileConfig::LineListAppend(const wxString& str)
 {
   LineList *pLine = new LineList(str);
 
 {
   LineList *pLine = new LineList(str);
 
@@ -706,7 +767,7 @@ wxFileConfig::LineList *wxFileConfig::LineListAppend(const wxString& str)
 }
 
 // insert a new line after the given one or in the very beginning if !pLine
 }
 
 // insert a new line after the given one or in the very beginning if !pLine
-wxFileConfig::LineList *wxFileConfig::LineListInsert(const wxString& str,
+LineList *wxFileConfig::LineListInsert(const wxString& str,
                                                      LineList *pLine)
 {
   if ( pLine == m_linesTail )
                                                      LineList *pLine)
 {
   if ( pLine == m_linesTail )
@@ -745,7 +806,7 @@ void wxFileConfig::LineListRemove(LineList *pLine)
   // last entry?
   if ( pNext == NULL )
     m_linesTail = pPrev;
   // last entry?
   if ( pNext == NULL )
     m_linesTail = pPrev;
-  else    
+  else
     pNext->SetPrev(pPrev);
 
   delete pLine;
     pNext->SetPrev(pPrev);
 
   delete pLine;
@@ -765,7 +826,7 @@ bool wxFileConfig::LineListIsEmpty()
 // ----------------------------------------------------------------------------
 
 // ctor
 // ----------------------------------------------------------------------------
 
 // ctor
-wxFileConfig::ConfigGroup::ConfigGroup(wxFileConfig::ConfigGroup *pParent,
+ConfigGroup::ConfigGroup(ConfigGroup *pParent,
                                        const wxString& strName,
                                        wxFileConfig *pConfig)
                          : m_aEntries(CompareEntries),
                                        const wxString& strName,
                                        wxFileConfig *pConfig)
                          : m_aEntries(CompareEntries),
@@ -782,10 +843,10 @@ wxFileConfig::ConfigGroup::ConfigGroup(wxFileConfig::ConfigGroup *pParent,
 }
 
 // dtor deletes all children
 }
 
 // dtor deletes all children
-wxFileConfig::ConfigGroup::~ConfigGroup()
+ConfigGroup::~ConfigGroup()
 {
   // entries
 {
   // entries
-  uint n, nCount = m_aEntries.Count();
+  size_t n, nCount = m_aEntries.Count();
   for ( n = 0; n < nCount; n++ )
     delete m_aEntries[n];
 
   for ( n = 0; n < nCount; n++ )
     delete m_aEntries[n];
 
@@ -799,7 +860,7 @@ wxFileConfig::ConfigGroup::~ConfigGroup()
 // line
 // ----------------------------------------------------------------------------
 
 // line
 // ----------------------------------------------------------------------------
 
-void wxFileConfig::ConfigGroup::SetLine(LineList *pLine)
+void ConfigGroup::SetLine(LineList *pLine)
 {
   wxASSERT( m_pLine == NULL ); // shouldn't be called twice
 
 {
   wxASSERT( m_pLine == NULL ); // shouldn't be called twice
 
@@ -835,12 +896,12 @@ void wxFileConfig::ConfigGroup::SetLine(LineList *pLine)
       backwards in the config file (OTOH, it's not that important) and as we
       would still need to do it for the subgroups the code wouldn't have been
       significantly less complicated.
       backwards in the config file (OTOH, it's not that important) and as we
       would still need to do it for the subgroups the code wouldn't have been
       significantly less complicated.
- */
+*/
 
 // Return the line which contains "[our name]". If we're still not in the list,
 // add our line to it immediately after the last line of our parent group if we
 // have it or in the very beginning if we're the root group.
 
 // Return the line which contains "[our name]". If we're still not in the list,
 // add our line to it immediately after the last line of our parent group if we
 // have it or in the very beginning if we're the root group.
-wxFileConfig::LineList *wxFileConfig::ConfigGroup::GetGroupLine()
+LineList *ConfigGroup::GetGroupLine()
 {
   if ( m_pLine == NULL ) {
     ConfigGroup *pParent = Parent();
 {
   if ( m_pLine == NULL ) {
     ConfigGroup *pParent = Parent();
@@ -848,7 +909,7 @@ wxFileConfig::LineList *wxFileConfig::ConfigGroup::GetGroupLine()
     // this group wasn't present in local config file, add it now
     if ( pParent != NULL ) {
       wxString strFullName;
     // this group wasn't present in local config file, add it now
     if ( pParent != NULL ) {
       wxString strFullName;
-      strFullName << "[" << GetFullName().c_str() + 1 << "]"; // +1: no '/'
+      strFullName << "[" << (GetFullName().c_str() + 1) << "]"; // +1: no '/'
       m_pLine = m_pConfig->LineListInsert(strFullName,
                                           pParent->GetLastGroupLine());
       pParent->SetLastGroup(this);  // we're surely after all the others
       m_pLine = m_pConfig->LineListInsert(strFullName,
                                           pParent->GetLastGroupLine());
       pParent->SetLastGroup(this);  // we're surely after all the others
@@ -865,12 +926,12 @@ wxFileConfig::LineList *wxFileConfig::ConfigGroup::GetGroupLine()
 // Return the last line belonging to the subgroups of this group (after which
 // we can add a new subgroup), if we don't have any subgroups or entries our
 // last line is the group line (m_pLine) itself.
 // Return the last line belonging to the subgroups of this group (after which
 // we can add a new subgroup), if we don't have any subgroups or entries our
 // last line is the group line (m_pLine) itself.
-wxFileConfig::LineList *wxFileConfig::ConfigGroup::GetLastGroupLine()
+LineList *ConfigGroup::GetLastGroupLine()
 {
   // if we have any subgroups, our last line is the last line of the last
   // subgroup
   if ( m_pLastGroup != NULL ) {
 {
   // if we have any subgroups, our last line is the last line of the last
   // subgroup
   if ( m_pLastGroup != NULL ) {
-    wxFileConfig::LineList *pLine = m_pLastGroup->GetLastGroupLine();
+    LineList *pLine = m_pLastGroup->GetLastGroupLine();
 
     wxASSERT( pLine != NULL );  // last group must have !NULL associated line
     return pLine;
 
     wxASSERT( pLine != NULL );  // last group must have !NULL associated line
     return pLine;
@@ -883,10 +944,10 @@ wxFileConfig::LineList *wxFileConfig::ConfigGroup::GetLastGroupLine()
 // return the last line belonging to the entries of this group (after which
 // we can add a new entry), if we don't have any entries we will add the new
 // one immediately after the group line itself.
 // return the last line belonging to the entries of this group (after which
 // we can add a new entry), if we don't have any entries we will add the new
 // one immediately after the group line itself.
-wxFileConfig::LineList *wxFileConfig::ConfigGroup::GetLastEntryLine()
+LineList *ConfigGroup::GetLastEntryLine()
 {
   if ( m_pLastEntry != NULL ) {
 {
   if ( m_pLastEntry != NULL ) {
-    wxFileConfig::LineList *pLine = m_pLastEntry->GetLine();
+    LineList *pLine = m_pLastEntry->GetLine();
 
     wxASSERT( pLine != NULL );  // last entry must have !NULL associated line
     return pLine;
 
     wxASSERT( pLine != NULL );  // last entry must have !NULL associated line
     return pLine;
@@ -900,7 +961,19 @@ wxFileConfig::LineList *wxFileConfig::ConfigGroup::GetLastEntryLine()
 // group name
 // ----------------------------------------------------------------------------
 
 // group name
 // ----------------------------------------------------------------------------
 
-wxString wxFileConfig::ConfigGroup::GetFullName() const
+void ConfigGroup::Rename(const wxString& newName)
+{
+    m_strName = newName;
+
+    LineList *line = GetGroupLine();
+    wxString strFullName;
+    strFullName << "[" << (GetFullName().c_str() + 1) << "]"; // +1: no '/'
+    line->SetText(strFullName);
+
+    SetDirty();
+}
+
+wxString ConfigGroup::GetFullName() const
 {
   if ( Parent() )
     return Parent()->GetFullName() + wxCONFIG_PATH_SEPARATOR + Name();
 {
   if ( Parent() )
     return Parent()->GetFullName() + wxCONFIG_PATH_SEPARATOR + Name();
@@ -913,14 +986,14 @@ wxString wxFileConfig::ConfigGroup::GetFullName() const
 // ----------------------------------------------------------------------------
 
 // use binary search because the array is sorted
 // ----------------------------------------------------------------------------
 
 // use binary search because the array is sorted
-wxFileConfig::ConfigEntry *
-wxFileConfig::ConfigGroup::FindEntry(const char *szName) const
+ConfigEntry *
+ConfigGroup::FindEntry(const char *szName) const
 {
 {
-  uint i,
+  size_t i,
        lo = 0,
        hi = m_aEntries.Count();
   int res;
        lo = 0,
        hi = m_aEntries.Count();
   int res;
-  wxFileConfig::ConfigEntry *pEntry;
+  ConfigEntry *pEntry;
 
   while ( lo < hi ) {
     i = (lo + hi)/2;
 
   while ( lo < hi ) {
     i = (lo + hi)/2;
@@ -943,14 +1016,14 @@ wxFileConfig::ConfigGroup::FindEntry(const char *szName) const
   return NULL;
 }
 
   return NULL;
 }
 
-wxFileConfig::ConfigGroup *
-wxFileConfig::ConfigGroup::FindSubgroup(const char *szName) const
+ConfigGroup *
+ConfigGroup::FindSubgroup(const char *szName) const
 {
 {
-  uint i,
+  size_t i,
        lo = 0,
        hi = m_aSubgroups.Count();
   int res;
        lo = 0,
        hi = m_aSubgroups.Count();
   int res;
-  wxFileConfig::ConfigGroup *pGroup;
+  ConfigGroup *pGroup;
 
   while ( lo < hi ) {
     i = (lo + hi)/2;
 
   while ( lo < hi ) {
     i = (lo + hi)/2;
@@ -978,8 +1051,8 @@ wxFileConfig::ConfigGroup::FindSubgroup(const char *szName) const
 // ----------------------------------------------------------------------------
 
 // create a new entry and add it to the current group
 // ----------------------------------------------------------------------------
 
 // create a new entry and add it to the current group
-wxFileConfig::ConfigEntry *
-wxFileConfig::ConfigGroup::AddEntry(const wxString& strName, int nLine)
+ConfigEntry *
+ConfigGroup::AddEntry(const wxString& strName, int nLine)
 {
   wxASSERT( FindEntry(strName) == NULL );
 
 {
   wxASSERT( FindEntry(strName) == NULL );
 
@@ -990,8 +1063,8 @@ wxFileConfig::ConfigGroup::AddEntry(const wxString& strName, int nLine)
 }
 
 // create a new group and add it to the current group
 }
 
 // create a new group and add it to the current group
-wxFileConfig::ConfigGroup *
-wxFileConfig::ConfigGroup::AddSubgroup(const wxString& strName)
+ConfigGroup *
+ConfigGroup::AddSubgroup(const wxString& strName)
 {
   wxASSERT( FindSubgroup(strName) == NULL );
 
 {
   wxASSERT( FindSubgroup(strName) == NULL );
 
@@ -1012,7 +1085,7 @@ wxFileConfig::ConfigGroup::AddSubgroup(const wxString& strName)
   delete several of them.
  */
 
   delete several of them.
  */
 
-bool wxFileConfig::ConfigGroup::DeleteSubgroupByName(const char *szName)
+bool ConfigGroup::DeleteSubgroupByName(const char *szName)
 {
   return DeleteSubgroup(FindSubgroup(szName));
 }
 {
   return DeleteSubgroup(FindSubgroup(szName));
 }
@@ -1020,13 +1093,13 @@ bool wxFileConfig::ConfigGroup::DeleteSubgroupByName(const char *szName)
 // doesn't delete the subgroup itself, but does remove references to it from
 // all other data structures (and normally the returned pointer should be
 // deleted a.s.a.p. because there is nothing much to be done with it anyhow)
 // doesn't delete the subgroup itself, but does remove references to it from
 // all other data structures (and normally the returned pointer should be
 // deleted a.s.a.p. because there is nothing much to be done with it anyhow)
-bool wxFileConfig::ConfigGroup::DeleteSubgroup(ConfigGroup *pGroup)
+bool ConfigGroup::DeleteSubgroup(ConfigGroup *pGroup)
 {
   wxCHECK( pGroup != NULL, FALSE ); // deleting non existing group?
 
   // delete all entries
 {
   wxCHECK( pGroup != NULL, FALSE ); // deleting non existing group?
 
   // delete all entries
-  uint nCount = pGroup->m_aEntries.Count();
-  for ( uint nEntry = 0; nEntry < nCount; nEntry++ ) {
+  size_t nCount = pGroup->m_aEntries.Count();
+  for ( size_t nEntry = 0; nEntry < nCount; nEntry++ ) {
     LineList *pLine = pGroup->m_aEntries[nEntry]->GetLine();
     if ( pLine != NULL )
       m_pConfig->LineListRemove(pLine);
     LineList *pLine = pGroup->m_aEntries[nEntry]->GetLine();
     if ( pLine != NULL )
       m_pConfig->LineListRemove(pLine);
@@ -1034,7 +1107,7 @@ bool wxFileConfig::ConfigGroup::DeleteSubgroup(ConfigGroup *pGroup)
 
   // and subgroups of this sungroup
   nCount = pGroup->m_aSubgroups.Count();
 
   // and subgroups of this sungroup
   nCount = pGroup->m_aSubgroups.Count();
-  for ( uint nGroup = 0; nGroup < nCount; nGroup++ ) {
+  for ( size_t nGroup = 0; nGroup < nCount; nGroup++ ) {
     pGroup->DeleteSubgroup(pGroup->m_aSubgroups[nGroup]);
   }
 
     pGroup->DeleteSubgroup(pGroup->m_aSubgroups[nGroup]);
   }
 
@@ -1048,7 +1121,7 @@ bool wxFileConfig::ConfigGroup::DeleteSubgroup(ConfigGroup *pGroup)
 
       // go back until we find a subgroup or reach the group's line
       ConfigGroup *pNewLast = NULL;
 
       // go back until we find a subgroup or reach the group's line
       ConfigGroup *pNewLast = NULL;
-      uint n, nSubgroups = m_aSubgroups.Count();
+      size_t n, nSubgroups = m_aSubgroups.Count();
       LineList *pl;
       for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) {
         // is it our subgroup?
       LineList *pl;
       for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) {
         // is it our subgroup?
@@ -1084,7 +1157,7 @@ bool wxFileConfig::ConfigGroup::DeleteSubgroup(ConfigGroup *pGroup)
   return TRUE;
 }
 
   return TRUE;
 }
 
-bool wxFileConfig::ConfigGroup::DeleteEntry(const char *szName)
+bool ConfigGroup::DeleteEntry(const char *szName)
 {
   ConfigEntry *pEntry = FindEntry(szName);
   wxCHECK( pEntry != NULL, FALSE );  // deleting non existing item?
 {
   ConfigEntry *pEntry = FindEntry(szName);
   wxCHECK( pEntry != NULL, FALSE );  // deleting non existing item?
@@ -1099,7 +1172,7 @@ bool wxFileConfig::ConfigGroup::DeleteEntry(const char *szName)
 
       // go back until we find another entry or reach the group's line
       ConfigEntry *pNewLast = NULL;
 
       // go back until we find another entry or reach the group's line
       ConfigEntry *pNewLast = NULL;
-      uint n, nEntries = m_aEntries.Count();
+      size_t n, nEntries = m_aEntries.Count();
       LineList *pl;
       for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) {
         // is it our subgroup?
       LineList *pl;
       for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) {
         // is it our subgroup?
@@ -1137,7 +1210,7 @@ bool wxFileConfig::ConfigGroup::DeleteEntry(const char *szName)
 // ----------------------------------------------------------------------------
 //
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 //
 // ----------------------------------------------------------------------------
-void wxFileConfig::ConfigGroup::SetDirty()
+void ConfigGroup::SetDirty()
 {
   m_bDirty = TRUE;
   if ( Parent() != NULL )             // propagate upwards
 {
   m_bDirty = TRUE;
   if ( Parent() != NULL )             // propagate upwards
@@ -1151,7 +1224,7 @@ void wxFileConfig::ConfigGroup::SetDirty()
 // ----------------------------------------------------------------------------
 // ctor
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // ctor
 // ----------------------------------------------------------------------------
-wxFileConfig::ConfigEntry::ConfigEntry(wxFileConfig::ConfigGroup *pParent,
+ConfigEntry::ConfigEntry(ConfigGroup *pParent,
                                        const wxString& strName,
                                        int nLine)
                          : m_strName(strName)
                                        const wxString& strName,
                                        int nLine)
                          : m_strName(strName)
@@ -1173,7 +1246,7 @@ wxFileConfig::ConfigEntry::ConfigEntry(wxFileConfig::ConfigGroup *pParent,
 // set value
 // ----------------------------------------------------------------------------
 
 // set value
 // ----------------------------------------------------------------------------
 
-void wxFileConfig::ConfigEntry::SetLine(LineList *pLine)
+void ConfigEntry::SetLine(LineList *pLine)
 {
   if ( m_pLine != NULL ) {
     wxLogWarning(_("entry '%s' appears more than once in group '%s'"),
 {
   if ( m_pLine != NULL ) {
     wxLogWarning(_("entry '%s' appears more than once in group '%s'"),
@@ -1186,7 +1259,7 @@ void wxFileConfig::ConfigEntry::SetLine(LineList *pLine)
 
 // second parameter is FALSE if we read the value from file and prevents the
 // entry from being marked as 'dirty'
 
 // second parameter is FALSE if we read the value from file and prevents the
 // entry from being marked as 'dirty'
-void wxFileConfig::ConfigEntry::SetValue(const wxString& strValue, bool bUser)
+void ConfigEntry::SetValue(const wxString& strValue, bool bUser)
 {
   if ( bUser && IsImmutable() ) {
     wxLogWarning(_("attempt to change immutable key '%s' ignored."),
 {
   if ( bUser && IsImmutable() ) {
     wxLogWarning(_("attempt to change immutable key '%s' ignored."),
@@ -1201,7 +1274,7 @@ void wxFileConfig::ConfigEntry::SetValue(const wxString& strValue, bool bUser)
   m_strValue = strValue;
 
   if ( bUser ) {
   m_strValue = strValue;
 
   if ( bUser ) {
-    wxString strVal = FilterOut(strValue);
+    wxString strVal = FilterOutValue(strValue);
     wxString strLine;
     strLine << m_strName << " = " << strVal;
 
     wxString strLine;
     strLine << m_strName << " = " << strVal;
 
@@ -1211,7 +1284,7 @@ void wxFileConfig::ConfigEntry::SetValue(const wxString& strValue, bool bUser)
     }
     else {
       // add a new line to the file
     }
     else {
       // add a new line to the file
-      wxASSERT( m_nLine == NOT_FOUND );   // consistency check
+      wxASSERT( m_nLine == wxNOT_FOUND );   // consistency check
 
       m_pLine = Group()->Config()->LineListInsert(strLine,
                                                   Group()->GetLastEntryLine());
 
       m_pLine = Group()->Config()->LineListInsert(strLine,
                                                   Group()->GetLastEntryLine());
@@ -1222,7 +1295,7 @@ void wxFileConfig::ConfigEntry::SetValue(const wxString& strValue, bool bUser)
   }
 }
 
   }
 }
 
-void wxFileConfig::ConfigEntry::SetDirty()
+void ConfigEntry::SetDirty()
 {
   m_bDirty = TRUE;
   Group()->SetDirty();
 {
   m_bDirty = TRUE;
   Group()->SetDirty();
@@ -1236,8 +1309,8 @@ void wxFileConfig::ConfigEntry::SetDirty()
 // compare functions for array sorting
 // ----------------------------------------------------------------------------
 
 // compare functions for array sorting
 // ----------------------------------------------------------------------------
 
-int CompareEntries(wxFileConfig::ConfigEntry *p1,
-                   wxFileConfig::ConfigEntry *p2)
+int CompareEntries(ConfigEntry *p1,
+                   ConfigEntry *p2)
 {
   #if wxCONFIG_CASE_SENSITIVE
     return strcmp(p1->Name(), p2->Name());
 {
   #if wxCONFIG_CASE_SENSITIVE
     return strcmp(p1->Name(), p2->Name());
@@ -1246,8 +1319,8 @@ int CompareEntries(wxFileConfig::ConfigEntry *p1,
   #endif
 }
 
   #endif
 }
 
-int CompareGroups(wxFileConfig::ConfigGroup *p1,
-                  wxFileConfig::ConfigGroup *p2)
+int CompareGroups(ConfigGroup *p1,
+                  ConfigGroup *p2)
 {
   #if wxCONFIG_CASE_SENSITIVE
     return strcmp(p1->Name(), p2->Name());
 {
   #if wxCONFIG_CASE_SENSITIVE
     return strcmp(p1->Name(), p2->Name());
@@ -1260,15 +1333,15 @@ int CompareGroups(wxFileConfig::ConfigGroup *p1,
 // filter functions
 // ----------------------------------------------------------------------------
 
 // filter functions
 // ----------------------------------------------------------------------------
 
-// undo FilterOut
-wxString FilterIn(const wxString& str)
+// undo FilterOutValue
+static wxString FilterInValue(const wxString& str)
 {
   wxString strResult;
   strResult.Alloc(str.Len());
 
   bool bQuoted = !str.IsEmpty() && str[0] == '"';
 
 {
   wxString strResult;
   strResult.Alloc(str.Len());
 
   bool bQuoted = !str.IsEmpty() && str[0] == '"';
 
-  for ( uint n = bQuoted ? 1 : 0; n < str.Len(); n++ ) {
+  for ( size_t n = bQuoted ? 1 : 0; n < str.Len(); n++ ) {
     if ( str[n] == '\\' ) {
       switch ( str[++n] ) {
         case 'n':
     if ( str[n] == '\\' ) {
       switch ( str[++n] ) {
         case 'n':
@@ -1307,8 +1380,11 @@ wxString FilterIn(const wxString& str)
 }
 
 // quote the string before writing it to file
 }
 
 // quote the string before writing it to file
-wxString FilterOut(const wxString& str)
+static wxString FilterOutValue(const wxString& str)
 {
 {
+   if ( !str )
+      return str;
+
   wxString strResult;
   strResult.Alloc(str.Len());
 
   wxString strResult;
   strResult.Alloc(str.Len());
 
@@ -1319,7 +1395,7 @@ wxString FilterOut(const wxString& str)
     strResult += '"';
 
   char c;
     strResult += '"';
 
   char c;
-  for ( uint n = 0; n < str.Len(); n++ ) {
+  for ( size_t n = 0; n < str.Len(); n++ ) {
     switch ( str[n] ) {
       case '\n':
         c = 'n';
     switch ( str[n] ) {
       case '\n':
         c = 'n';
@@ -1358,3 +1434,42 @@ wxString FilterOut(const wxString& str)
 
   return strResult;
 }
 
   return strResult;
 }
+
+// undo FilterOutEntryName
+static wxString FilterInEntryName(const wxString& str)
+{
+  wxString strResult;
+  strResult.Alloc(str.Len());
+
+  for ( const char *pc = str.c_str(); *pc != '\0'; pc++ ) {
+    if ( *pc == '\\' )
+      pc++;
+
+    strResult += *pc;
+  }
+
+  return strResult;
+}
+
+// sanitize entry or group name: insert '\\' before any special characters
+static wxString FilterOutEntryName(const wxString& str)
+{
+  wxString strResult;
+  strResult.Alloc(str.Len());
+
+  for ( const char *pc = str.c_str(); *pc != '\0'; pc++ ) {
+    char c = *pc;
+
+    // we explicitly allow some of "safe" chars and 8bit ASCII characters
+    // which will probably never have special meaning
+    // NB: note that wxCONFIG_IMMUTABLE_PREFIX and wxCONFIG_PATH_SEPARATOR
+    //     should *not* be quoted
+    if ( !isalnum(c) && !strchr("@_/-!.*%", c) && ((c & 0x80) == 0) )
+      strResult += '\\';
+
+    strResult += c;
+  }
+
+  return strResult;
+}
+
wxWidgets (Impactor)