Initial revision

[wxWidgets.git] / src / msw / regconf.cpp

diff --git a/src/msw/regconf.cpp b/src/msw/regconf.cpp
index 635bdf355dd712614fb1b405b7f87fcf472cc575..e62511ca68015e8ed19a3e509b696af4a3a0290a 100644 (file)
--- a/src/msw/regconf.cpp
+++ b/src/msw/regconf.cpp
@@ -13,32 +13,26 @@
 #pragma implementation "regconf.h"
 #endif
 
 #pragma implementation "regconf.h"
 #endif
 

-// ============================================================================
-// declarations
-// ============================================================================
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"

 
 

-// ----------------------------------------------------------------------------
-// headers
-// ----------------------------------------------------------------------------
-
-#ifdef __GNUG__
-  #pragma implementation "regconf.h"
+#ifdef __BORLANDC__
+#pragma hdrstop

 #endif
 
 #endif
 

-#include  "wx/wxprec.h"
-
-#ifdef    __BORLANDC__
-  #pragma hdrstop
-#endif  //__BORLANDC__
-

 #ifndef WX_PRECOMP
 #ifndef WX_PRECOMP

-  #include  <wx/string.h>
+  #include  "wx/string.h"

 #endif //WX_PRECOMP
 
 #endif //WX_PRECOMP
 

-#include <wx/log.h>
-#include <wx/config.h>
-#include <wx/msw/registry.h>
-#include <wx/msw/regconf.h>
+#include "wx/event.h"
+#include "wx/app.h"
+#include "wx/log.h"
+#include "wx/config.h"
+
+#ifndef __WIN16__
+
+#include "wx/msw/registry.h"
+#include "wx/msw/regconf.h"

 
 // ----------------------------------------------------------------------------
 // constants
 
 // ----------------------------------------------------------------------------
 // constants


@@ -69,17 +63,75 @@ bool TryGetValue(const wxRegKey& key, const wxString& str, long *plVal)
 // ----------------------------------------------------------------------------
 // ctor/dtor
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // ctor/dtor
 // ----------------------------------------------------------------------------

-wxRegConfig::wxRegConfig(const wxString& strRoot)
-           : m_keyLocalRoot(wxRegKey::HKCU, SOFTWARE_KEY + strRoot),
-             m_keyLocal(m_keyLocalRoot, ""),
-             m_keyGlobalRoot(wxRegKey::HKLM, SOFTWARE_KEY + strRoot),
-             m_keyGlobal(m_keyGlobalRoot, "")
+
+// create the config object which stores its data under HKCU\vendor\app and, if
+// style & wxCONFIG_USE_GLOBAL_FILE, under HKLM\vendor\app
+wxRegConfig::wxRegConfig(const wxString& appName, const wxString& vendorName,
+                         const wxString& strLocal, const wxString& strGlobal,
+                         long style)
+           : wxConfigBase(appName, vendorName, strLocal, strGlobal, style)

 {
 {

+  wxString strRoot;
+
+  bool bDoUseGlobal = (style & wxCONFIG_USE_GLOBAL_FILE) != 0;
+
+  // the convention is to put the programs keys under <vendor>\<appname>
+  // (but it can be overriden by specifying the pathes explicitly in strLocal
+  // and/or strGlobal)
+  if ( strLocal.IsEmpty() || (strGlobal.IsEmpty() && bDoUseGlobal) )
+  {
+    if ( vendorName.IsEmpty() )
+    {
+      if ( wxTheApp )
+        strRoot = wxTheApp->GetVendorName();
+    }
+    else
+    {
+      strRoot = vendorName;
+    }
+
+    // no '\\' needed if no vendor name
+    if ( !strRoot.IsEmpty() )
+    {
+      strRoot += '\\';
+    }
+
+    if ( appName.IsEmpty() )
+    {
+      wxCHECK_RET( wxTheApp, wxT("No application name in wxRegConfig ctor!") );
+      strRoot << wxTheApp->GetAppName();
+    }
+    else
+    {
+      strRoot << appName;
+    }
+  }
+  //else: we don't need to do all the complicated stuff above
+
+  wxString str = strLocal.IsEmpty() ? strRoot : strLocal;
+  m_keyLocalRoot.SetName(wxRegKey::HKCU, SOFTWARE_KEY + str);
+  m_keyLocal.SetName(m_keyLocalRoot, "");
+
+  if ( bDoUseGlobal )
+  {
+    str = strGlobal.IsEmpty() ? strRoot : strGlobal;
+    m_keyGlobalRoot.SetName(wxRegKey::HKLM, SOFTWARE_KEY + str);
+    m_keyGlobal.SetName(m_keyGlobalRoot, "");
+  }
+

   // Create() will Open() if key already exists
   m_keyLocalRoot.Create();
 
   // Create() will Open() if key already exists
   m_keyLocalRoot.Create();
 

-  wxLogNull nolog;
-  m_keyGlobalRoot.Open();
+  // as it's the same key, Open() shouldn't fail (i.e. no need for Create())
+  m_keyLocal.Open();
+
+  // OTOH, this key may perfectly not exist, so suppress error messages the call
+  // to Open() might generate
+  if ( bDoUseGlobal )
+  {
+    wxLogNull nolog;
+    m_keyGlobalRoot.Open();
+  }

 }
 
 wxRegConfig::~wxRegConfig()
 }
 
 wxRegConfig::~wxRegConfig()


@@ -94,10 +146,9 @@ void wxRegConfig::SetPath(const wxString& strPath)
 {
   wxArrayString aParts;
 
 {
   wxArrayString aParts;
 

-  if ( strPath.IsEmpty() )
-    return;
-
-  if ( strPath[0] == wxCONFIG_PATH_SEPARATOR ) {
+  // 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);
   }
     // absolute path
     wxSplitPath(aParts, strPath);
   }


@@ -109,13 +160,25 @@ void wxRegConfig::SetPath(const wxString& strPath)
   }
 
   // recombine path parts in one variable
   }
 
   // recombine path parts in one variable

-  wxString strRegPath;
+  wxString strOldPath = m_strPath, strRegPath;

   m_strPath.Empty();
   m_strPath.Empty();

-  for ( uint n = 0; n < aParts.Count(); n++ ) {
+  for ( size_t n = 0; n < aParts.Count(); n++ ) {

     strRegPath << '\\' << aParts[n];
     m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n];
   }
 
     strRegPath << '\\' << aParts[n];
     m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n];
   }
 

+  if ( m_strPath == strOldPath )
+      return;
+
+  // 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.IsEmpty() )
+  {
+      m_keyLocal.DeleteSelf();
+  }
+

   // change current key(s)
   m_keyLocal.SetName(m_keyLocalRoot, strRegPath);
   m_keyGlobal.SetName(m_keyGlobalRoot, strRegPath);
   // change current key(s)
   m_keyLocal.SetName(m_keyLocalRoot, strRegPath);
   m_keyGlobal.SetName(m_keyGlobalRoot, strRegPath);


@@ -198,9 +261,9 @@ bool wxRegConfig::GetNextEntry(wxString& str, long& lIndex) const
   return bOk;
 }
 
   return bOk;
 }
 

-uint wxRegConfig::GetNumberOfEntries(bool bRecursive) const
+size_t wxRegConfig::GetNumberOfEntries(bool bRecursive) const

 {
 {

-  uint nEntries = 0;
+  size_t nEntries = 0;

 
   // dummy vars
   wxString str;
 
   // dummy vars
   wxString str;


@@ -215,9 +278,9 @@ uint wxRegConfig::GetNumberOfEntries(bool bRecursive) const
   return nEntries;
 }
 
   return nEntries;
 }
 

-uint wxRegConfig::GetNumberOfGroups(bool bRecursive) const
+size_t wxRegConfig::GetNumberOfGroups(bool bRecursive) const

 {
 {

-  uint nGroups = 0;
+  size_t nGroups = 0;

 
   // dummy vars
   wxString str;
 
   // dummy vars
   wxString str;


@@ -236,25 +299,48 @@ uint wxRegConfig::GetNumberOfGroups(bool bRecursive) const
 // tests for existence
 // ----------------------------------------------------------------------------
 
 // tests for existence
 // ----------------------------------------------------------------------------
 

-bool wxRegConfig::HasGroup(const wxString& strName) const
+bool wxRegConfig::HasGroup(const wxString& key) const

 {
 {

-  return m_keyLocal.HasSubKey(strName) || m_keyGlobal.HasSubKey(strName);
+    wxConfigPathChanger path(this, key);
+
+    wxString strName(path.Name());
+
+    return m_keyLocal.HasSubKey(strName) || m_keyGlobal.HasSubKey(strName);

 }
 
 }
 

-bool wxRegConfig::HasEntry(const wxString& strName) const
+bool wxRegConfig::HasEntry(const wxString& key) const

 {
 {

-  return m_keyLocal.HasValue(strName) || m_keyGlobal.HasValue(strName);
+    wxConfigPathChanger path(this, key);
+
+    wxString strName(path.Name());
+
+    return m_keyLocal.HasValue(strName) || m_keyGlobal.HasValue(strName);
+}
+
+wxConfigBase::EntryType wxRegConfig::GetEntryType(const wxString& key) const
+{
+    wxConfigPathChanger path(this, key);
+
+    wxString strName(path.Name());
+
+    bool isNumeric;
+    if ( m_keyLocal.HasValue(strName) )
+        isNumeric = m_keyLocal.IsNumericValue(strName);
+    else if ( m_keyGlobal.HasValue(strName) )
+        isNumeric = m_keyGlobal.IsNumericValue(strName);
+    else
+        return wxConfigBase::Type_Unknown;
+
+    return isNumeric ? wxConfigBase::Type_Integer : wxConfigBase::Type_String;

 }
 
 // ----------------------------------------------------------------------------
 // reading/writing
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // reading/writing
 // ----------------------------------------------------------------------------
 

-bool wxRegConfig::Read(wxString *pStr,
-                       const char *szKey,
-                       const char *szDefault) const
+bool wxRegConfig::Read(const wxString& key, wxString *pStr) const

 {
 {

-  PathChanger path(this, szKey);
+  wxConfigPathChanger path(this, key);

 
   bool bQueryGlobal = TRUE;
 
 
   bool bQueryGlobal = TRUE;
 


@@ -263,7 +349,43 @@ bool wxRegConfig::Read(wxString *pStr,
   if ( IsImmutable(path.Name()) ) {
     if ( TryGetValue(m_keyGlobal, path.Name(), *pStr) ) {
       if ( m_keyLocal.HasValue(path.Name()) ) {
   if ( IsImmutable(path.Name()) ) {
     if ( TryGetValue(m_keyGlobal, path.Name(), *pStr) ) {
       if ( m_keyLocal.HasValue(path.Name()) ) {

-        wxLogWarning("User value for immutable key '%s' ignored.",
+        wxLogWarning(wxT("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;
+
+  // 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(wxT("User value for immutable key '%s' ignored."),

                    path.Name().c_str());
       }
 
                    path.Name().c_str());
       }
 


@@ -278,20 +400,26 @@ bool wxRegConfig::Read(wxString *pStr,
   // first try local key
   if ( TryGetValue(m_keyLocal, path.Name(), *pStr) ||
        (bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), *pStr)) ) {
   // first try local key
   if ( TryGetValue(m_keyLocal, path.Name(), *pStr) ||
        (bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), *pStr)) ) {

+    *pStr = wxConfigBase::ExpandEnvVars(*pStr);

     return TRUE;
   }
     return TRUE;
   }

+  else {
+    if ( IsRecordingDefaults() ) {
+      ((wxRegConfig*)this)->Write(key, szDefault);
+    }
+
+    // default value
+    *pStr = szDefault;
+  }

 
 

-  if(IsRecordingDefaults())
-     Write(szKey,szDefault);
+  *pStr = wxConfigBase::ExpandEnvVars(*pStr);

 
 

-  // default value
-  *pStr = szDefault;

   return FALSE;
 }
 
   return FALSE;
 }
 

-bool wxRegConfig::Read(long *plResult, const char *szKey, long lDefault) const
+bool wxRegConfig::Read(const wxString& key, long *plResult) const

 {
 {

-  PathChanger path(this, szKey);
+  wxConfigPathChanger path(this, key);

 
   bool bQueryGlobal = TRUE;
 
 
   bool bQueryGlobal = TRUE;
 


@@ -300,7 +428,7 @@ bool wxRegConfig::Read(long *plResult, const char *szKey, long lDefault) const
   if ( IsImmutable(path.Name()) ) {
     if ( TryGetValue(m_keyGlobal, path.Name(), plResult) ) {
       if ( m_keyLocal.HasValue(path.Name()) ) {
   if ( IsImmutable(path.Name()) ) {
     if ( TryGetValue(m_keyGlobal, path.Name(), plResult) ) {
       if ( m_keyLocal.HasValue(path.Name()) ) {

-        wxLogWarning("User value for immutable key '%s' ignored.",
+        wxLogWarning(wxT("User value for immutable key '%s' ignored."),

                      path.Name().c_str());
       }
 
                      path.Name().c_str());
       }
 


@@ -317,48 +445,106 @@ bool wxRegConfig::Read(long *plResult, const char *szKey, long lDefault) const
        (bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), plResult)) ) {
     return TRUE;
   }
        (bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), plResult)) ) {
     return TRUE;
   }

-
-  // default
-  *plResult = lDefault;

   return FALSE;
 }
 
   return FALSE;
 }
 

-bool wxRegConfig::Write(const char *szKey, const char *szValue)
+bool wxRegConfig::Write(const wxString& key, const wxString& szValue)

 {
 {

-  PathChanger path(this, szKey);
+  wxConfigPathChanger path(this, key);

 
   if ( IsImmutable(path.Name()) ) {
 
   if ( IsImmutable(path.Name()) ) {

-    wxLogError("Can't change immutable entry '%s'.", path.Name().c_str());
+    wxLogError(wxT("Can't change immutable entry '%s'."), path.Name().c_str());

     return FALSE;
   }
 
   return m_keyLocal.SetValue(path.Name(), szValue);
 }
 
     return FALSE;
   }
 
   return m_keyLocal.SetValue(path.Name(), szValue);
 }
 

-bool wxRegConfig::Write(const char *szKey, long lValue)
+bool wxRegConfig::Write(const wxString& key, long lValue)

 {
 {

-  PathChanger path(this, szKey);
+  wxConfigPathChanger path(this, key);

 
   if ( IsImmutable(path.Name()) ) {
 
   if ( IsImmutable(path.Name()) ) {

-    wxLogError("Can't change immutable entry '%s'.", path.Name().c_str());
+    wxLogError(wxT("Can't change immutable entry '%s'."), path.Name().c_str());

     return FALSE;
   }
 
   return m_keyLocal.SetValue(path.Name(), lValue);
 }
 
     return FALSE;
   }
 
   return m_keyLocal.SetValue(path.Name(), lValue);
 }
 

+// ----------------------------------------------------------------------------
+// renaming
+// ----------------------------------------------------------------------------
+
+bool wxRegConfig::RenameEntry(const wxString& oldName, const wxString& newName)
+{
+    // check that the old entry exists...
+    if ( !HasEntry(oldName) )
+        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
+
+    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;
+}
+
+bool wxRegConfig::RenameGroup(const wxString& oldName, const wxString& newName)
+{
+    // check that the old group exists...
+    if ( !HasGroup(oldName) )
+        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(wxT("Registry key renaming not implemented"));
+
+    return FALSE;
+}
+

 // ----------------------------------------------------------------------------
 // deleting
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // deleting
 // ----------------------------------------------------------------------------

-bool wxRegConfig::DeleteEntry(const char *szValue, bool bGroupIfEmptyAlso)
+bool wxRegConfig::DeleteEntry(const wxString& value, bool bGroupIfEmptyAlso)

 {
 {

-  PathChanger path(this, szValue);
+  wxConfigPathChanger path(this, value);

 
   if ( !m_keyLocal.DeleteValue(path.Name()) )
     return FALSE;
 
 
   if ( !m_keyLocal.DeleteValue(path.Name()) )
     return FALSE;
 

-  if ( !m_keyLocal.HasSubkeys() ) {
-    wxString strKey = GetPath().Right(wxCONFIG_PATH_SEPARATOR);
+  if ( m_keyLocal.IsEmpty() ) {
+    wxString strKey = GetPath().AfterLast(wxCONFIG_PATH_SEPARATOR);

     SetPath("..");  // changes m_keyLocal
     return m_keyLocal.DeleteKey(strKey);
   }
     SetPath("..");  // changes m_keyLocal
     return m_keyLocal.DeleteKey(strKey);
   }


@@ -366,9 +552,9 @@ bool wxRegConfig::DeleteEntry(const char *szValue, bool bGroupIfEmptyAlso)
   return TRUE;
 }
 
   return TRUE;
 }
 

-bool wxRegConfig::DeleteGroup(const char *szKey)
+bool wxRegConfig::DeleteGroup(const wxString& key)

 {
 {

-  PathChanger path(this, szKey);
+  wxConfigPathChanger path(this, key);

 
   return m_keyLocal.DeleteKey(path.Name());
 }
 
   return m_keyLocal.DeleteKey(path.Name());
 }


@@ -379,8 +565,15 @@ bool wxRegConfig::DeleteAll()
   m_keyGlobal.Close();
 
   bool bOk = m_keyLocalRoot.DeleteSelf();
   m_keyGlobal.Close();
 
   bool bOk = m_keyLocalRoot.DeleteSelf();

-  if ( bOk )
+
+  // make sure that we opened m_keyGlobalRoot and so it has a reasonable name:
+  // otherwise we will delete HKEY_CLASSES_ROOT recursively
+  if ( bOk && m_keyGlobalRoot.IsOpened() )

     bOk = m_keyGlobalRoot.DeleteSelf();
 
   return bOk;
 }
     bOk = m_keyGlobalRoot.DeleteSelf();
 
   return bOk;
 }

+
+#endif
+  // __WIN16__
+