Changed the "delete win" to the more proper "win->Destroy()" in

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

diff --git a/src/msw/regconf.cpp b/src/msw/regconf.cpp
index 968053bea6ab1c4dd90cf571c66bf7cbd8a61327..5fec4bd4be88cf5bf84f92639be046f798e25e7e 100644 (file)
--- a/src/msw/regconf.cpp
+++ b/src/msw/regconf.cpp
@@ -1,25 +1,34 @@
 ///////////////////////////////////////////////////////////////////////////////
 // Name:        msw/regconf.cpp
 ///////////////////////////////////////////////////////////////////////////////
 // Name:        msw/regconf.cpp

-// Purpose:     
+// Purpose:

 // Author:      Vadim Zeitlin
 // Author:      Vadim Zeitlin

-// Modified by: 
+// Modified by:

 // Created:     27.04.98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Licence:     wxWindows license
 ///////////////////////////////////////////////////////////////////////////////
 
 // Created:     27.04.98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Licence:     wxWindows license
 ///////////////////////////////////////////////////////////////////////////////
 

-// ============================================================================
-// declarations
-// ============================================================================
+#ifdef __GNUG__
+#pragma implementation "regconf.h"
+#endif

 
 

-// ----------------------------------------------------------------------------
-// headers
-// ----------------------------------------------------------------------------
-#include <wx/wx.h>
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WX_PRECOMP
+  #include  <wx/string.h>
+#endif //WX_PRECOMP
+
+#include <wx/app.h>
+#include <wx/log.h>

 #include <wx/config.h>
 #include <wx/config.h>

-#include <wx/regconf.h>
-#include <wx/registry.h>
+#include <wx/msw/registry.h>
+#include <wx/msw/regconf.h>

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


@@ -50,17 +59,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, "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()


@@ -73,28 +140,27 @@ wxRegConfig::~wxRegConfig()
 // ----------------------------------------------------------------------------
 void wxRegConfig::SetPath(const wxString& strPath)
 {
 // ----------------------------------------------------------------------------
 void wxRegConfig::SetPath(const wxString& strPath)
 {

-  ArrayString aParts;
+  wxArrayString aParts;

 
 

-  if ( strPath.IsEmpty() )
-    return;
-
-  if ( strPath[0] == APPCONF_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
     // absolute path

-    SplitPath(aParts, strPath);
+    wxSplitPath(aParts, strPath);

   }
   else {
     // relative path, combine with current one
     wxString strFullPath = GetPath();
   }
   else {
     // relative path, combine with current one
     wxString strFullPath = GetPath();

-    strFullPath << APPCONF_PATH_SEPARATOR << strPath;
-    SplitPath(aParts, strFullPath);
+    strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
+    wxSplitPath(aParts, strFullPath);

   }
 
   // recombine path parts in one variable
   wxString strRegPath;
   m_strPath.Empty();
   }
 
   // recombine path parts in one variable
   wxString strRegPath;
   m_strPath.Empty();

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

     strRegPath << '\\' << aParts[n];
     strRegPath << '\\' << aParts[n];

-    m_strPath << APPCONF_PATH_SEPARATOR << aParts[n];
+    m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n];

   }
 
   // change current key(s)
   }
 
   // change current key(s)


@@ -111,7 +177,7 @@ void wxRegConfig::SetPath(const wxString& strPath)
 // ----------------------------------------------------------------------------
 
 /*
 // ----------------------------------------------------------------------------
 
 /*

-  We want to enumerate all local keys/values after the global ones, but, of 
+  We want to enumerate all local keys/values after the global ones, but, of

   course, we don't want to repeat a key which appears locally as well as
   globally twice.
 
   course, we don't want to repeat a key which appears locally as well as
   globally twice.
 


@@ -121,13 +187,13 @@ void wxRegConfig::SetPath(const wxString& strPath)
 #define LOCAL_MASK        0x8000
 #define IS_LOCAL_INDEX(l) (((l) & LOCAL_MASK) != 0)
 
 #define LOCAL_MASK        0x8000
 #define IS_LOCAL_INDEX(l) (((l) & LOCAL_MASK) != 0)
 

-bool wxRegConfig::GetFirstGroup(wxString& str, long& lIndex)
+bool wxRegConfig::GetFirstGroup(wxString& str, long& lIndex) const

 {
   lIndex = 0;
   return GetNextGroup(str, lIndex);
 }
 
 {
   lIndex = 0;
   return GetNextGroup(str, lIndex);
 }
 

-bool wxRegConfig::GetNextGroup (wxString& str, long& lIndex)
+bool wxRegConfig::GetNextGroup(wxString& str, long& lIndex) const

 {
   // are we already enumerating local entries?
   if ( m_keyGlobal.IsOpened() && !IS_LOCAL_INDEX(lIndex) ) {
 {
   // are we already enumerating local entries?
   if ( m_keyGlobal.IsOpened() && !IS_LOCAL_INDEX(lIndex) ) {


@@ -150,128 +216,218 @@ bool wxRegConfig::GetNextGroup (wxString& str, long& lIndex)
   return bOk;
 }
 
   return bOk;
 }
 

-bool wxRegConfig::GetFirstEntry(wxString& str, long& lIndex)
+bool wxRegConfig::GetFirstEntry(wxString& str, long& lIndex) const

 {
   lIndex = 0;
 {
   lIndex = 0;

-  return GetNextGroup(str, lIndex);
+  return GetNextEntry(str, lIndex);

 }
 
 }
 

-bool wxRegConfig::GetNextEntry (wxString& str, long& lIndex)
+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 {
 {
   // 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) ) {
+      if ( !m_keyGlobal.GetNextValue(str, lIndex) ) {

         // no more global entries
         lIndex |= LOCAL_MASK;
         break;
       }
         // no more global entries
         lIndex |= LOCAL_MASK;
         break;
       }

-    } while( m_keyLocal.HasSubKey(str) );
+    } while( m_keyLocal.HasValue(str) );

   }
 
   // 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;
   }
 
   // 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 = m_keyLocal.GetNextValue(str, lIndex);

   lIndex |= LOCAL_MASK;
 
   return bOk;
 }
 
   lIndex |= LOCAL_MASK;
 
   return bOk;
 }
 

+size_t wxRegConfig::GetNumberOfEntries(bool bRecursive) const
+{
+  size_t nEntries = 0;
+
+  // dummy vars
+  wxString str;
+  long l;
+  bool bCont = ((wxRegConfig*)this)->GetFirstEntry(str, l);
+  while ( bCont ) {
+    nEntries++;
+
+    bCont = ((wxRegConfig*)this)->GetNextEntry(str, l);
+  }
+
+  return nEntries;
+}
+
+size_t wxRegConfig::GetNumberOfGroups(bool bRecursive) const
+{
+  size_t nGroups = 0;
+
+  // dummy vars
+  wxString str;
+  long l;
+  bool bCont = ((wxRegConfig*)this)->GetFirstGroup(str, l);
+  while ( bCont ) {
+    nGroups++;
+
+    bCont = ((wxRegConfig*)this)->GetNextGroup(str, l);
+  }
+
+  return nGroups;
+}
+
+// ----------------------------------------------------------------------------
+// tests for existence
+// ----------------------------------------------------------------------------
+
+bool wxRegConfig::HasGroup(const wxString& strName) const
+{
+  return m_keyLocal.HasSubKey(strName) || m_keyGlobal.HasSubKey(strName);
+}
+
+bool wxRegConfig::HasEntry(const wxString& strName) const
+{
+  return m_keyLocal.HasValue(strName) || m_keyGlobal.HasValue(strName);
+}
+

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

-bool wxRegConfig::Read(wxString& str,
-                     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;

 
   // 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 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(), str) ) {
+    if ( TryGetValue(m_keyGlobal, path.Name(), *pStr) ) {

       if ( m_keyLocal.HasValue(path.Name()) ) {
       if ( m_keyLocal.HasValue(path.Name()) ) {

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

                    path.Name().c_str());
       }
                    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
+
+    // TODO: do we return TRUE? Not in original implementation,
+    // but I don't see why not. -- JACS
+    *pStr = wxConfigBase::ExpandEnvVars(*pStr);
+    return TRUE;
+  }

 
 

-      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("User value for immutable key '%s' ignored.",
+                   path.Name().c_str());
+      }
+
+      return TRUE;

     }
     else {
       // don't waste time - it's not there anyhow
     }
     else {
       // don't waste time - it's not there anyhow

-      bQueryGlobal = false;
+      bQueryGlobal = FALSE;

     }
   }
 
   // first try local key
     }
   }
 
   // first try local key

-  if ( TryGetValue(m_keyLocal, path.Name(), str) ||
-       (bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), str)) ) {
-    return true;
+  if ( TryGetValue(m_keyLocal, 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
-  str = szDefault;
-  return false;
+    // default value
+    *pStr = szDefault;
+  }
+
+  *pStr = wxConfigBase::ExpandEnvVars(*pStr);
+
+  return FALSE;

 }
 
 }
 

-bool wxRegConfig::Read(long &lValue, 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;

 
   // 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 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(), &lValue) ) {
+    if ( TryGetValue(m_keyGlobal, path.Name(), plResult) ) {

       if ( m_keyLocal.HasValue(path.Name()) ) {
       if ( m_keyLocal.HasValue(path.Name()) ) {

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

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

-      return true;
+      return TRUE;

     }
     else {
       // don't waste time - it's not there anyhow
     }
     else {
       // don't waste time - it's not there anyhow

-      bQueryGlobal = false;
+      bQueryGlobal = FALSE;

     }
   }
 
   // first try local key
     }
   }
 
   // first try local key

-  if ( TryGetValue(m_keyLocal, path.Name(), &lValue) ||
-       (bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), &lValue)) ) {
-    return true;
+  if ( TryGetValue(m_keyLocal, path.Name(), plResult) ||
+       (bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), plResult)) ) {
+    return TRUE;

   }
   }

-
-  // default
-  lValue = 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()) ) {
     wxLogError("Can't change immutable entry '%s'.", path.Name().c_str());
 
   if ( IsImmutable(path.Name()) ) {
     wxLogError("Can't change immutable entry '%s'.", path.Name().c_str());

-    return false;
+    return FALSE;

   }
 
   return m_keyLocal.SetValue(path.Name(), szValue);
 }
 
   }
 
   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()) ) {
     wxLogError("Can't change immutable entry '%s'.", path.Name().c_str());
 
   if ( IsImmutable(path.Name()) ) {
     wxLogError("Can't change immutable entry '%s'.", path.Name().c_str());

-    return false;
+    return FALSE;

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


@@ -280,34 +436,31 @@ bool wxRegConfig::Write(const char *szKey, long lValue)
 // ----------------------------------------------------------------------------
 // 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()) )
 
   if ( !m_keyLocal.DeleteValue(path.Name()) )

-    return false;
+    return FALSE;

 
 

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

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

-  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());
 }
 
 bool wxRegConfig::DeleteAll()
 {
 
   return m_keyLocal.DeleteKey(path.Name());
 }
 
 bool wxRegConfig::DeleteAll()
 {

-  // first of all, prevent the creation of new registry entries
-  Config::EnableAutosave(false);
-

   m_keyLocal.Close();
   m_keyGlobal.Close();
 
   m_keyLocal.Close();
   m_keyGlobal.Close();