X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/92049cd473c81fbce934e71796b2d841d5e605fa..795c9ab863b2cd2c8839f042162c6e8b921f1734:/src/msw/regconf.cpp?ds=sidebyside

diff --git a/src/msw/regconf.cpp b/src/msw/regconf.cpp
index 6ec17a61ff..13f59406cd 100644
--- a/src/msw/regconf.cpp
+++ b/src/msw/regconf.cpp
@@ -6,10 +6,10 @@
 // Created:     27.04.98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
-// Licence:     wxWindows license
+// Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
 #pragma implementation "regconf.h"
 #endif
 
@@ -22,14 +22,16 @@
 
 #ifndef WX_PRECOMP
   #include  "wx/string.h"
+  #include  "wx/intl.h"
 #endif //WX_PRECOMP
 
 #include "wx/event.h"
 #include "wx/app.h"
 #include "wx/log.h"
-#include "wx/config.h"
 
-#ifndef __WIN16__
+#if wxUSE_CONFIG
+
+#include "wx/config.h"
 
 #include "wx/msw/registry.h"
 #include "wx/msw/regconf.h"
@@ -39,7 +41,7 @@
 // ----------------------------------------------------------------------------
 
 // we put our data in HKLM\SOFTWARE_KEY\appname
-#define SOFTWARE_KEY    wxString("Software\\")
+#define SOFTWARE_KEY    wxString(wxT("Software\\"))
 
 // ----------------------------------------------------------------------------
 // global functions
@@ -98,7 +100,7 @@ wxRegConfig::wxRegConfig(const wxString& appName, const wxString& vendorName,
 
     if ( appName.IsEmpty() )
     {
-      wxCHECK_RET( wxTheApp, _T("No application name in wxRegConfig ctor!") );
+      wxCHECK_RET( wxTheApp, wxT("No application name in wxRegConfig ctor!") );
       strRoot << wxTheApp->GetAppName();
     }
     else
@@ -109,14 +111,28 @@ wxRegConfig::wxRegConfig(const wxString& appName, const wxString& vendorName,
   //else: we don't need to do all the complicated stuff above
 
   wxString str = strLocal.IsEmpty() ? strRoot : strLocal;
+
+  // as we're going to change the name of these keys fairly often and as
+  // there are only few of wxRegConfig objects (usually 1), we can allow
+  // ourselves to be generous and spend some memory to significantly improve
+  // performance of SetPath()
+  static const size_t MEMORY_PREALLOC = 512;
+
+  m_keyLocalRoot.ReserveMemoryForName(MEMORY_PREALLOC);
+  m_keyLocal.ReserveMemoryForName(MEMORY_PREALLOC);
+
   m_keyLocalRoot.SetName(wxRegKey::HKCU, SOFTWARE_KEY + str);
-  m_keyLocal.SetName(m_keyLocalRoot, "");
+  m_keyLocal.SetName(m_keyLocalRoot, wxEmptyString);
 
   if ( bDoUseGlobal )
   {
     str = strGlobal.IsEmpty() ? strRoot : strGlobal;
+
+    m_keyGlobalRoot.ReserveMemoryForName(MEMORY_PREALLOC);
+    m_keyGlobal.ReserveMemoryForName(MEMORY_PREALLOC);
+
     m_keyGlobalRoot.SetName(wxRegKey::HKLM, SOFTWARE_KEY + str);
-    m_keyGlobal.SetName(m_keyGlobalRoot, "");
+    m_keyGlobal.SetName(m_keyGlobalRoot, wxEmptyString);
   }
 
   // Create() will Open() if key already exists
@@ -130,50 +146,247 @@ wxRegConfig::wxRegConfig(const wxString& appName, const wxString& vendorName,
   if ( bDoUseGlobal )
   {
     wxLogNull nolog;
-    m_keyGlobalRoot.Open();
+    m_keyGlobalRoot.Open(wxRegKey::Read);
+    m_keyGlobal.Open(wxRegKey::Read);
   }
 }
 
-wxRegConfig::~wxRegConfig()
-{
-  // nothing to do - key will be closed in their dtors
-}
-
 // ----------------------------------------------------------------------------
 // path management
 // ----------------------------------------------------------------------------
+
+// this function is called a *lot* of times (as I learned after seeing from
+// profiler output that it is called ~12000 times from Mahogany start up code!)
+// so it is important to optimize it - in particular, avoid using generic
+// string functions here and do everything manually because it is faster
+//
+// I still kept the old version to be able to check that the optimized code has
+// the same output as the non optimized version.
 void wxRegConfig::SetPath(const wxString& strPath)
 {
-  wxArrayString aParts;
+    // remember the old path
+    wxString strOldPath = m_strPath;
 
-  // because GetPath() returns "" when we're at root, we must understand
-  // empty string as "/"
-  if ( strPath.IsEmpty() || (strPath[0] == wxCONFIG_PATH_SEPARATOR) ) {
-    // absolute path
-    wxSplitPath(aParts, strPath);
-  }
-  else {
-    // relative path, combine with current one
-    wxString strFullPath = GetPath();
-    strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
-    wxSplitPath(aParts, strFullPath);
-  }
+#ifdef WX_DEBUG_SET_PATH // non optimized version kept here for testing
+    wxString m_strPathAlt;
 
-  // recombine path parts in one variable
-  wxString strRegPath;
-  m_strPath.Empty();
-  for ( size_t n = 0; n < aParts.Count(); n++ ) {
-    strRegPath << '\\' << aParts[n];
-    m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n];
-  }
+    {
+        wxArrayString aParts;
+
+        // because GetPath() returns "" when we're at root, we must understand
+        // empty string as "/"
+        if ( strPath.IsEmpty() || (strPath[0] == wxCONFIG_PATH_SEPARATOR) ) {
+            // absolute path
+            wxSplitPath(aParts, strPath);
+        }
+        else {
+            // relative path, combine with current one
+            wxString strFullPath = GetPath();
+            strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
+            wxSplitPath(aParts, strFullPath);
+        }
+
+        // recombine path parts in one variable
+        wxString strRegPath;
+        m_strPathAlt.Empty();
+        for ( size_t n = 0; n < aParts.Count(); n++ ) {
+            strRegPath << '\\' << aParts[n];
+            m_strPathAlt << wxCONFIG_PATH_SEPARATOR << aParts[n];
+        }
+    }
+#endif // 0
 
-  // change current key(s)
-  m_keyLocal.SetName(m_keyLocalRoot, strRegPath);
-  m_keyGlobal.SetName(m_keyGlobalRoot, strRegPath);
-  m_keyLocal.Create();
+    // check for the most common case first
+    if ( strPath.empty() )
+    {
+        m_strPath = wxCONFIG_PATH_SEPARATOR;
+    }
+    else // not root
+    {
+        // construct the full path
+        wxString strFullPath;
+        if ( strPath[0u] == wxCONFIG_PATH_SEPARATOR )
+        {
+            // absolute path
+            strFullPath = strPath;
+        }
+        else // relative path
+        {
+            strFullPath.reserve(2*m_strPath.length());
+
+            strFullPath << m_strPath;
+            if ( strFullPath.Len() == 0 ||
+                 strFullPath.Last() != wxCONFIG_PATH_SEPARATOR )
+                strFullPath << wxCONFIG_PATH_SEPARATOR;
+            strFullPath << strPath;
+        }
+
+        // simplify it: we need to handle ".." here
+
+        // count the total number of slashes we have to know if we can go upper
+        size_t totalSlashes = 0;
+
+        // position of the last slash to be able to backtrack to it quickly if
+        // needed, but we set it to -1 if we don't have a valid position
+        //
+        // we only remember the last position which means that we handle ".."
+        // quite efficiently but not "../.." - however the latter should be
+        // much more rare, so it is probably ok
+        int posLastSlash = -1;
+
+        const wxChar *src = strFullPath.c_str();
+        size_t len = strFullPath.length();
+        const wxChar *end = src + len;
+
+        wxStringBufferLength buf(m_strPath, len);
+        wxChar *dst = buf;
+        wxChar *start = dst;
+
+        for ( ; src < end; src++, dst++ )
+        {
+            if ( *src == wxCONFIG_PATH_SEPARATOR )
+            {
+                // check for "/.."
+
+                // note that we don't have to check for src < end here as
+                // *end == 0 so can't be '.'
+                if ( src[1] == _T('.') && src[2] == _T('.') &&
+                     (src + 3 == end || src[3] == wxCONFIG_PATH_SEPARATOR) )
+                {
+                    if ( !totalSlashes )
+                    {
+                        wxLogWarning(_("'%s' has extra '..', ignored."),
+                                     strFullPath.c_str());
+                    }
+                    else // return to the previous path component
+                    {
+                        // do we already have its position?
+                        if ( posLastSlash == -1 )
+                        {
+                            // no, find it: note that we are sure to have one
+                            // because totalSlashes > 0 so we don't have to
+                            // check the boundary condition below
+
+                            // this is more efficient than strrchr()
+                            dst--;
+                            while ( *dst != wxCONFIG_PATH_SEPARATOR )
+                            {
+                                dst--;
+                            }
+                        }
+                        else // the position of last slash was stored
+                        {
+                            // go directly there
+                            dst = start + posLastSlash;
+
+                            // invalidate posLastSlash
+                            posLastSlash = -1;
+                        }
+
+                        // we must have found a slash one way or another!
+                        wxASSERT_MSG( *dst == wxCONFIG_PATH_SEPARATOR,
+                                      _T("error in wxRegConfig::SetPath") );
+
+                        // stay at the same position
+                        dst--;
+
+                        // we killed one
+                        totalSlashes--;
+                    }
+
+                    // skip both dots
+                    src += 2;
+                }
+                else // not "/.."
+                {
+                    if ( (dst == start) || (dst[-1] != wxCONFIG_PATH_SEPARATOR) )
+                    {
+                        *dst = wxCONFIG_PATH_SEPARATOR;
+
+                        posLastSlash = dst - start;
+
+                        totalSlashes++;
+                    }
+                    else // previous char was a slash too
+                    {
+                        // squeeze several subsequent slashes into one: i.e.
+                        // just ignore this one
+                        dst--;
+                    }
+                }
+            }
+            else // normal character
+            {
+                // just copy
+                *dst = *src;
+            }
+        }
+
+        // NUL terminate the string
+        if ( dst[-1] == wxCONFIG_PATH_SEPARATOR && (dst != start + 1) )
+        {
+            // if it has a trailing slash we remove it unless it is the only
+            // string character
+            dst--;
+        }
+
+        *dst = _T('\0');
+        buf.SetLength(dst - start);
+    }
 
-  wxLogNull nolog;
-  m_keyGlobal.Open();
+#ifdef WX_DEBUG_SET_PATH
+    wxASSERT( m_strPath == m_strPathAlt );
+#endif
+
+    if ( m_strPath == strOldPath )
+        return;
+
+    // registry APIs want backslashes instead of slashes
+    wxString strRegPath;
+    if ( !m_strPath.empty() )
+    {
+        size_t len = m_strPath.length();
+
+        const wxChar *src = m_strPath.c_str();
+        wxStringBufferLength buf(strRegPath, len);
+        wxChar *dst = buf;
+
+        const wxChar *end = src + len;
+        for ( ; src < end; src++, dst++ )
+        {
+            if ( *src == wxCONFIG_PATH_SEPARATOR )
+                *dst = _T('\\');
+            else
+                *dst = *src;
+        }
+
+        buf.SetLength(len);
+    }
+
+    // this is not needed any longer as we don't create keys unnecessarily any
+    // more (now it is done on demand, i.e. only when they're going to contain
+    // something)
+#if 0
+    // as we create the registry key when SetPath(key) is done, we can be left
+    // with plenty of empty keys if this was only done to try to read some
+    // value which, in fact, doesn't exist - to prevent this from happening we
+    // automatically delete the old key if it was empty
+    if ( m_keyLocal.Exists() && LocalKey().IsEmpty() )
+    {
+        m_keyLocal.DeleteSelf();
+    }
+#endif // 0
+
+    // change current key(s)
+    m_keyLocal.SetName(m_keyLocalRoot, strRegPath);
+
+    if ( GetStyle() & wxCONFIG_USE_GLOBAL_FILE )
+    {
+      m_keyGlobal.SetName(m_keyGlobalRoot, strRegPath);
+
+      wxLogNull nolog;
+      m_keyGlobal.Open(wxRegKey::Read);
+    }
 }
 
 // ----------------------------------------------------------------------------
@@ -202,19 +415,25 @@ bool wxRegConfig::GetNextGroup(wxString& str, long& lIndex) const
   // are we already enumerating local entries?
   if ( m_keyGlobal.IsOpened() && !IS_LOCAL_INDEX(lIndex) ) {
     // try to find a global entry which doesn't appear locally
-    do {
-      if ( !m_keyGlobal.GetNextKey(str, lIndex) ) {
-        // no more global entries
-        lIndex |= LOCAL_MASK;
-        break;
+    while ( m_keyGlobal.GetNextKey(str, lIndex) ) {
+      if ( !m_keyLocal.Exists() || !LocalKey().HasSubKey(str) ) {
+        // ok, found one - return it
+        return true;
       }
-    } while( m_keyLocal.HasSubKey(str) );
+    }
+
+    // no more global entries
+    lIndex |= LOCAL_MASK;
   }
 
+  // if we don't have the key at all, don't try to enumerate anything under it
+  if ( !m_keyLocal.Exists() )
+      return false;
+
   // much easier with local entries: get the next one we find
   // (don't forget to clear our flag bit and set it again later)
   lIndex &= ~LOCAL_MASK;
-  bool bOk = m_keyLocal.GetNextKey(str, lIndex);
+  bool bOk = LocalKey().GetNextKey(str, lIndex);
   lIndex |= LOCAL_MASK;
 
   return bOk;
@@ -231,25 +450,31 @@ bool wxRegConfig::GetNextEntry(wxString& str, long& lIndex) const
   // are we already enumerating local entries?
   if ( m_keyGlobal.IsOpened() && !IS_LOCAL_INDEX(lIndex) ) {
     // try to find a global entry which doesn't appear locally
-    do {
-      if ( !m_keyGlobal.GetNextValue(str, lIndex) ) {
-        // no more global entries
-        lIndex |= LOCAL_MASK;
-        break;
+    while ( m_keyGlobal.GetNextValue(str, lIndex) ) {
+      if ( !m_keyLocal.Exists() || !LocalKey().HasValue(str) ) {
+        // ok, found one - return it
+        return true;
       }
-    } while( m_keyLocal.HasValue(str) );
+    }
+
+    // no more global entries
+    lIndex |= LOCAL_MASK;
   }
 
+  // if we don't have the key at all, don't try to enumerate anything under it
+  if ( !m_keyLocal.Exists() )
+      return false;
+
   // much easier with local entries: get the next one we find
   // (don't forget to clear our flag bit and set it again later)
   lIndex &= ~LOCAL_MASK;
-  bool bOk = m_keyLocal.GetNextValue(str, lIndex);
+  bool bOk = LocalKey().GetNextValue(str, lIndex);
   lIndex |= LOCAL_MASK;
 
   return bOk;
 }
 
-size_t wxRegConfig::GetNumberOfEntries(bool bRecursive) const
+size_t wxRegConfig::GetNumberOfEntries(bool WXUNUSED(bRecursive)) const
 {
   size_t nEntries = 0;
 
@@ -266,7 +491,7 @@ size_t wxRegConfig::GetNumberOfEntries(bool bRecursive) const
   return nEntries;
 }
 
-size_t wxRegConfig::GetNumberOfGroups(bool bRecursive) const
+size_t wxRegConfig::GetNumberOfGroups(bool WXUNUSED(bRecursive)) const
 {
   size_t nGroups = 0;
 
@@ -293,7 +518,8 @@ bool wxRegConfig::HasGroup(const wxString& key) const
 
     wxString strName(path.Name());
 
-    return m_keyLocal.HasSubKey(strName) || m_keyGlobal.HasSubKey(strName);
+    return (m_keyLocal.Exists() && LocalKey().HasSubKey(strName)) ||
+           m_keyGlobal.HasSubKey(strName);
 }
 
 bool wxRegConfig::HasEntry(const wxString& key) const
@@ -302,7 +528,8 @@ bool wxRegConfig::HasEntry(const wxString& key) const
 
     wxString strName(path.Name());
 
-    return m_keyLocal.HasValue(strName) || m_keyGlobal.HasValue(strName);
+    return (m_keyLocal.Exists() && LocalKey().HasValue(strName)) ||
+           m_keyGlobal.HasValue(strName);
 }
 
 wxConfigBase::EntryType wxRegConfig::GetEntryType(const wxString& key) const
@@ -312,7 +539,7 @@ wxConfigBase::EntryType wxRegConfig::GetEntryType(const wxString& key) const
     wxString strName(path.Name());
 
     bool isNumeric;
-    if ( m_keyLocal.HasValue(strName) )
+    if ( m_keyLocal.Exists() && LocalKey().HasValue(strName) )
         isNumeric = m_keyLocal.IsNumericValue(strName);
     else if ( m_keyGlobal.HasValue(strName) )
         isNumeric = m_keyGlobal.IsNumericValue(strName);
@@ -326,138 +553,99 @@ wxConfigBase::EntryType wxRegConfig::GetEntryType(const wxString& key) const
 // reading/writing
 // ----------------------------------------------------------------------------
 
-bool wxRegConfig::Read(const wxString& key, wxString *pStr) const
+bool wxRegConfig::DoReadString(const wxString& key, wxString *pStr) const
 {
-  wxConfigPathChanger path(this, key);
+    wxCHECK_MSG( pStr, false, _T("wxRegConfig::Read(): NULL param") );
 
-  bool bQueryGlobal = TRUE;
-
-  // if immutable key exists in global key we must check that it's not
-  // overriden by the local key with the same name
-  if ( IsImmutable(path.Name()) ) {
-    if ( TryGetValue(m_keyGlobal, path.Name(), *pStr) ) {
-      if ( m_keyLocal.HasValue(path.Name()) ) {
-        wxLogWarning(_T("User value for immutable key '%s' ignored."),
-                   path.Name().c_str());
-      }
-     *pStr = wxConfigBase::ExpandEnvVars(*pStr);
-      return TRUE;
-    }
-    else {
-      // don't waste time - it's not there anyhow
-      bQueryGlobal = FALSE;
-    }
-  }
-
-  // first try local key
-  if ( TryGetValue(m_keyLocal, path.Name(), *pStr) ||
-       (bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), *pStr)) ) {
-    // nothing to do
-
-    *pStr = wxConfigBase::ExpandEnvVars(*pStr);
-    return TRUE;
-  }
-
-  return FALSE;
-}
-
-bool wxRegConfig::Read(const wxString& key, wxString *pStr,
-                       const wxString& szDefault) const
-{
   wxConfigPathChanger path(this, key);
 
-  bool bQueryGlobal = TRUE;
+  bool bQueryGlobal = true;
 
   // if immutable key exists in global key we must check that it's not
   // overriden by the local key with the same name
   if ( IsImmutable(path.Name()) ) {
     if ( TryGetValue(m_keyGlobal, path.Name(), *pStr) ) {
-      if ( m_keyLocal.HasValue(path.Name()) ) {
-        wxLogWarning(_T("User value for immutable key '%s' ignored."),
+      if ( m_keyLocal.Exists() && LocalKey().HasValue(path.Name()) ) {
+        wxLogWarning(wxT("User value for immutable key '%s' ignored."),
                    path.Name().c_str());
       }
 
-      return TRUE;
+      return true;
     }
     else {
       // don't waste time - it's not there anyhow
-      bQueryGlobal = FALSE;
+      bQueryGlobal = false;
     }
   }
 
   // first try local key
-  if ( TryGetValue(m_keyLocal, path.Name(), *pStr) ||
+  if ( (m_keyLocal.Exists() && TryGetValue(LocalKey(), path.Name(), *pStr)) ||
        (bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), *pStr)) ) {
-    *pStr = wxConfigBase::ExpandEnvVars(*pStr);
-    return TRUE;
-  }
-  else {
-    if ( IsRecordingDefaults() ) {
-      ((wxRegConfig*)this)->Write(key, szDefault);
-    }
-
-    // default value
-    *pStr = szDefault;
+    return true;
   }
 
-  *pStr = wxConfigBase::ExpandEnvVars(*pStr);
-
-  return FALSE;
+  return false;
 }
 
-bool wxRegConfig::Read(const wxString& key, long *plResult) const
+// this exactly reproduces the string version above except for ExpandEnvVars(),
+// we really should avoid this code duplication somehow...
+
+bool wxRegConfig::DoReadLong(const wxString& key, long *plResult) const
 {
+    wxCHECK_MSG( plResult, false, _T("wxRegConfig::Read(): NULL param") );
+
   wxConfigPathChanger path(this, key);
 
-  bool bQueryGlobal = TRUE;
+  bool bQueryGlobal = true;
 
   // if immutable key exists in global key we must check that it's not
   // overriden by the local key with the same name
   if ( IsImmutable(path.Name()) ) {
     if ( TryGetValue(m_keyGlobal, path.Name(), plResult) ) {
-      if ( m_keyLocal.HasValue(path.Name()) ) {
-        wxLogWarning(_T("User value for immutable key '%s' ignored."),
+      if ( m_keyLocal.Exists() && LocalKey().HasValue(path.Name()) ) {
+        wxLogWarning(wxT("User value for immutable key '%s' ignored."),
                      path.Name().c_str());
       }
 
-      return TRUE;
+      return true;
     }
     else {
       // don't waste time - it's not there anyhow
-      bQueryGlobal = FALSE;
+      bQueryGlobal = false;
     }
   }
 
   // first try local key
-  if ( TryGetValue(m_keyLocal, path.Name(), plResult) ||
+  if ( (m_keyLocal.Exists() && TryGetValue(LocalKey(), path.Name(), plResult)) ||
        (bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), plResult)) ) {
-    return TRUE;
+    return true;
   }
-  return FALSE;
+
+  return false;
 }
 
-bool wxRegConfig::Write(const wxString& key, const wxString& szValue)
+bool wxRegConfig::DoWriteString(const wxString& key, const wxString& szValue)
 {
   wxConfigPathChanger path(this, key);
 
   if ( IsImmutable(path.Name()) ) {
-    wxLogError(_T("Can't change immutable entry '%s'."), path.Name().c_str());
-    return FALSE;
+    wxLogError(wxT("Can't change immutable entry '%s'."), path.Name().c_str());
+    return false;
   }
 
-  return m_keyLocal.SetValue(path.Name(), szValue);
+  return LocalKey().SetValue(path.Name(), szValue);
 }
 
-bool wxRegConfig::Write(const wxString& key, long lValue)
+bool wxRegConfig::DoWriteLong(const wxString& key, long lValue)
 {
   wxConfigPathChanger path(this, key);
 
   if ( IsImmutable(path.Name()) ) {
-    wxLogError(_T("Can't change immutable entry '%s'."), path.Name().c_str());
-    return FALSE;
+    wxLogError(wxT("Can't change immutable entry '%s'."), path.Name().c_str());
+    return false;
   }
 
-  return m_keyLocal.SetValue(path.Name(), lValue);
+  return LocalKey().SetValue(path.Name(), lValue);
 }
 
 // ----------------------------------------------------------------------------
@@ -468,83 +656,55 @@ bool wxRegConfig::RenameEntry(const wxString& oldName, const wxString& newName)
 {
     // check that the old entry exists...
     if ( !HasEntry(oldName) )
-        return FALSE;
+        return false;
 
     // and that the new one doesn't
     if ( HasEntry(newName) )
-        return FALSE;
-
-    // delete the old entry and create the new one - but do in the reverse
-    // order to not lose the data if Create() fails
+        return false;
 
-    bool ok;
-    if ( m_keyLocal.IsNumericValue(oldName) )
-    {
-        long val;
-        ok = m_keyLocal.QueryValue(oldName, &val) &&
-             m_keyLocal.SetValue(newName, val);
-    }
-    else
-    {
-        wxString val;
-        ok = m_keyLocal.QueryValue(oldName, val) &&
-             m_keyLocal.SetValue(newName, val);
-    }
-
-    if ( !ok )
-        return FALSE;
-
-    if ( !m_keyLocal.DeleteValue(oldName) )
-    {
-        m_keyLocal.DeleteValue(newName);
-
-        return FALSE;
-    }
-
-    return TRUE;
+    return m_keyLocal.RenameValue(oldName, newName);
 }
 
 bool wxRegConfig::RenameGroup(const wxString& oldName, const wxString& newName)
 {
     // check that the old group exists...
     if ( !HasGroup(oldName) )
-        return FALSE;
+        return false;
 
     // and that the new one doesn't
     if ( HasGroup(newName) )
-        return FALSE;
-
-    // TODO there is no way to rename a registry key - we must do a deep copy
-    //      ourselves
-    wxFAIL_MSG(_T("Registry key renaming not implemented"));
+        return false;
 
-    return FALSE;
+    return wxRegKey(m_keyLocal, oldName).Rename(newName);
 }
 
 // ----------------------------------------------------------------------------
 // deleting
 // ----------------------------------------------------------------------------
+
 bool wxRegConfig::DeleteEntry(const wxString& value, bool bGroupIfEmptyAlso)
 {
   wxConfigPathChanger path(this, value);
 
-  if ( !m_keyLocal.DeleteValue(path.Name()) )
-    return FALSE;
+  if ( m_keyLocal.Exists() ) {
+    if ( !m_keyLocal.DeleteValue(path.Name()) )
+      return false;
 
-  if ( m_keyLocal.IsEmpty() ) {
-    wxString strKey = GetPath().AfterLast(wxCONFIG_PATH_SEPARATOR);
-    SetPath("..");  // changes m_keyLocal
-    return m_keyLocal.DeleteKey(strKey);
+    if ( bGroupIfEmptyAlso && m_keyLocal.IsEmpty() ) {
+      wxString strKey = GetPath().AfterLast(wxCONFIG_PATH_SEPARATOR);
+      SetPath(_T(".."));  // changes m_keyLocal
+      return LocalKey().DeleteKey(strKey);
+    }
   }
 
-  return TRUE;
+  return true;
 }
 
 bool wxRegConfig::DeleteGroup(const wxString& key)
 {
   wxConfigPathChanger path(this, key);
 
-  return m_keyLocal.DeleteKey(path.Name());
+  return m_keyLocal.Exists() ? LocalKey().DeleteKey(path.Name()) : true;
 }
 
 bool wxRegConfig::DeleteAll()
@@ -563,5 +723,4 @@ bool wxRegConfig::DeleteAll()
 }
 
 #endif
-  // __WIN16__
-
+  // wxUSE_CONFIG