src/msw/regconf.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        msw/regconf.cpp
// Purpose:
// Author:      Vadim Zeitlin
// Modified by:
// Created:     27.04.98
// RCS-ID:      $Id$
// Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "regconf.h"
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#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"

#if wxUSE_CONFIG

#include "wx/config.h"

#ifndef __WIN16__

#include "wx/msw/registry.h"
#include "wx/msw/regconf.h"

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

// we put our data in HKLM\SOFTWARE_KEY\appname
#define SOFTWARE_KEY    wxString(wxT("Software\\"))

// ----------------------------------------------------------------------------
// global functions
// ----------------------------------------------------------------------------

// get the value if the key is opened and it exists
bool TryGetValue(const wxRegKey& key, const wxString& str, wxString& strVal)
{
  return key.IsOpened() && key.HasValue(str) && key.QueryValue(str, strVal);
}

bool TryGetValue(const wxRegKey& key, const wxString& str, long *plVal)
{
  return key.IsOpened() && key.HasValue(str) && key.QueryValue(str, plVal);
}

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// ctor/dtor
// ----------------------------------------------------------------------------

// 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;

  // 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, 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, wxEmptyString);
  }

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

  // 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();
    m_keyGlobal.Open();
  }
}

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)
{
    // remember the old path
    wxString strOldPath = m_strPath;

#ifdef WX_DEBUG_SET_PATH // non optimized version kept here for testing
    wxString m_strPathAlt;

    {
        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

    // 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;

        wxChar *dst = m_strPath.GetWriteBuf(len);
        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');

        m_strPath.UngetWriteBuf(dst - start);
    }

#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();
        wxChar *dst = strRegPath.GetWriteBuf(len);

        const wxChar *end = src + len;
        for ( ; src < end; src++, dst++ )
        {
            if ( *src == wxCONFIG_PATH_SEPARATOR )
                *dst = _T('\\');
            else
                *dst = *src;
        }

        strRegPath.UngetWriteBuf(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);
    m_keyGlobal.SetName(m_keyGlobalRoot, strRegPath);

    // don't create it right now, wait until it is accessed
    //m_keyLocal.Create();

    wxLogNull nolog;
    m_keyGlobal.Open();
}

// ----------------------------------------------------------------------------
// enumeration (works only with current group)
// ----------------------------------------------------------------------------

/*
  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.

  We use the 15th bit of lIndex for distinction between global and local.
 */

#define LOCAL_MASK        0x8000
#define IS_LOCAL_INDEX(l) (((l) & LOCAL_MASK) != 0)

bool wxRegConfig::GetFirstGroup(wxString& str, long& lIndex) const
{
  lIndex = 0;
  return GetNextGroup(str, lIndex);
}

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
    while ( m_keyGlobal.GetNextKey(str, lIndex) ) {
      if ( !m_keyLocal.Exists() || !LocalKey().HasSubKey(str) ) {
        // ok, found one - return it
        return TRUE;
      }
    }

    // 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 = LocalKey().GetNextKey(str, lIndex);
  lIndex |= LOCAL_MASK;

  return bOk;
}

bool wxRegConfig::GetFirstEntry(wxString& str, long& lIndex) const
{
  lIndex = 0;
  return GetNextEntry(str, 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
    while ( m_keyGlobal.GetNextValue(str, lIndex) ) {
      if ( !m_keyLocal.Exists() || !LocalKey().HasValue(str) ) {
        // ok, found one - return it
        return TRUE;
      }
    }

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

  return bOk;
}

size_t wxRegConfig::GetNumberOfEntries(bool WXUNUSED(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 WXUNUSED(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& key) const
{
    wxConfigPathChanger path(this, key);

    wxString strName(path.Name());

    return (m_keyLocal.Exists() && LocalKey().HasSubKey(strName)) ||
           m_keyGlobal.HasSubKey(strName);
}

bool wxRegConfig::HasEntry(const wxString& key) const
{
    wxConfigPathChanger path(this, key);

    wxString strName(path.Name());

    return (m_keyLocal.Exists() && LocalKey().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.Exists() && LocalKey().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
// ----------------------------------------------------------------------------

bool wxRegConfig::DoReadString(const wxString& key, wxString *pStr) const
{
    wxCHECK_MSG( pStr, FALSE, _T("wxRegConfig::Read(): NULL param") );

  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.Exists() && LocalKey().HasValue(path.Name()) ) {
        wxLogWarning(wxT("User value for immutable key '%s' ignored."),
                   path.Name().c_str());
      }

      return TRUE;
    }
    else {
      // don't waste time - it's not there anyhow
      bQueryGlobal = FALSE;
    }
  }

  // first try local key
  if ( (m_keyLocal.Exists() && TryGetValue(LocalKey(), path.Name(), *pStr)) ||
       (bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), *pStr)) ) {
    return TRUE;
  }

  return FALSE;
}

// 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;

  // 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.Exists() && LocalKey().HasValue(path.Name()) ) {
        wxLogWarning(wxT("User value for immutable key '%s' ignored."),
                     path.Name().c_str());
      }

      return TRUE;
    }
    else {
      // don't waste time - it's not there anyhow
      bQueryGlobal = FALSE;
    }
  }

  // first try local key
  if ( (m_keyLocal.Exists() && TryGetValue(LocalKey(), path.Name(), plResult)) ||
       (bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), plResult)) ) {
    return TRUE;
  }

  return FALSE;
}

bool wxRegConfig::DoWriteString(const wxString& key, const wxString& szValue)
{
  wxConfigPathChanger path(this, key);

  if ( IsImmutable(path.Name()) ) {
    wxLogError(wxT("Can't change immutable entry '%s'."), path.Name().c_str());
    return FALSE;
  }

  return LocalKey().SetValue(path.Name(), szValue);
}

bool wxRegConfig::DoWriteLong(const wxString& key, long lValue)
{
  wxConfigPathChanger path(this, key);

  if ( IsImmutable(path.Name()) ) {
    wxLogError(wxT("Can't change immutable entry '%s'."), path.Name().c_str());
    return FALSE;
  }

  return LocalKey().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;

    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;

    // and that the new one doesn't
    if ( HasGroup(newName) )
        return FALSE;

    return wxRegKey(m_keyLocal, oldName).Rename(newName);
}

// ----------------------------------------------------------------------------
// deleting
// ----------------------------------------------------------------------------
bool wxRegConfig::DeleteEntry(const wxString& value, bool WXUNUSED(bGroupIfEmptyAlso))
{
  wxConfigPathChanger path(this, value);

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

    if ( m_keyLocal.IsEmpty() ) {
      wxString strKey = GetPath().AfterLast(wxCONFIG_PATH_SEPARATOR);
      SetPath(_T(".."));  // changes m_keyLocal
      return LocalKey().DeleteKey(strKey);
    }
  }

  return TRUE;
}

bool wxRegConfig::DeleteGroup(const wxString& key)
{
  wxConfigPathChanger path(this, key);

  return m_keyLocal.Exists() ? LocalKey().DeleteKey(path.Name()) : TRUE;
}

bool wxRegConfig::DeleteAll()
{
  m_keyLocal.Close();
  m_keyGlobal.Close();

  bool bOk = m_keyLocalRoot.DeleteSelf();

  // 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;
}

#endif
  // __WIN16__

#endif
  // wxUSE_CONFIG
Commit	Line	Data
	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: msw/regconf.cpp
	3	// Purpose:
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 27.04.98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
	9	// Licence: wxWindows licence
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "regconf.h"
	14	#endif
	15
	16	// For compilers that support precompilation, includes "wx.h".
	17	#include "wx/wxprec.h"
	18
	19	#ifdef __BORLANDC__
	20	#pragma hdrstop
	21	#endif
	22
	23	#ifndef WX_PRECOMP
	24	#include "wx/string.h"
	25	#include "wx/intl.h"
	26	#endif //WX_PRECOMP
	27
	28	#include "wx/event.h"
	29	#include "wx/app.h"
	30	#include "wx/log.h"
	31
	32	#if wxUSE_CONFIG
	33
	34	#include "wx/config.h"
	35
	36	#ifndef __WIN16__
	37
	38	#include "wx/msw/registry.h"
	39	#include "wx/msw/regconf.h"
	40
	41	// ----------------------------------------------------------------------------
	42	// constants
	43	// ----------------------------------------------------------------------------
	44
	45	// we put our data in HKLM\SOFTWARE_KEY\appname
	46	#define SOFTWARE_KEY wxString(wxT("Software\\"))
	47
	48	// ----------------------------------------------------------------------------
	49	// global functions
	50	// ----------------------------------------------------------------------------
	51
	52	// get the value if the key is opened and it exists
	53	bool TryGetValue(const wxRegKey& key, const wxString& str, wxString& strVal)
	54	{
	55	return key.IsOpened() && key.HasValue(str) && key.QueryValue(str, strVal);
	56	}
	57
	58	bool TryGetValue(const wxRegKey& key, const wxString& str, long *plVal)
	59	{
	60	return key.IsOpened() && key.HasValue(str) && key.QueryValue(str, plVal);
	61	}
	62
	63	// ============================================================================
	64	// implementation
	65	// ============================================================================
	66
	67	// ----------------------------------------------------------------------------
	68	// ctor/dtor
	69	// ----------------------------------------------------------------------------
	70
	71	// create the config object which stores its data under HKCU\vendor\app and, if
	72	// style & wxCONFIG_USE_GLOBAL_FILE, under HKLM\vendor\app
	73	wxRegConfig::wxRegConfig(const wxString& appName, const wxString& vendorName,
	74	const wxString& strLocal, const wxString& strGlobal,
	75	long style)
	76	: wxConfigBase(appName, vendorName, strLocal, strGlobal, style)
	77	{
	78	wxString strRoot;
	79
	80	bool bDoUseGlobal = (style & wxCONFIG_USE_GLOBAL_FILE) != 0;
	81
	82	// the convention is to put the programs keys under <vendor>\<appname>
	83	// (but it can be overriden by specifying the pathes explicitly in strLocal
	84	// and/or strGlobal)
	85	if ( strLocal.IsEmpty() \|\| (strGlobal.IsEmpty() && bDoUseGlobal) )
	86	{
	87	if ( vendorName.IsEmpty() )
	88	{
	89	if ( wxTheApp )
	90	strRoot = wxTheApp->GetVendorName();
	91	}
	92	else
	93	{
	94	strRoot = vendorName;
	95	}
	96
	97	// no '\\' needed if no vendor name
	98	if ( !strRoot.IsEmpty() )
	99	{
	100	strRoot += '\\';
	101	}
	102
	103	if ( appName.IsEmpty() )
	104	{
	105	wxCHECK_RET( wxTheApp, wxT("No application name in wxRegConfig ctor!") );
	106	strRoot << wxTheApp->GetAppName();
	107	}
	108	else
	109	{
	110	strRoot << appName;
	111	}
	112	}
	113	//else: we don't need to do all the complicated stuff above
	114
	115	wxString str = strLocal.IsEmpty() ? strRoot : strLocal;
	116
	117	// as we're going to change the name of these keys fairly often and as
	118	// there are only few of wxRegConfig objects (usually 1), we can allow
	119	// ourselves to be generous and spend some memory to significantly improve
	120	// performance of SetPath()
	121	static const size_t MEMORY_PREALLOC = 512;
	122
	123	m_keyLocalRoot.ReserveMemoryForName(MEMORY_PREALLOC);
	124	m_keyLocal.ReserveMemoryForName(MEMORY_PREALLOC);
	125
	126	m_keyLocalRoot.SetName(wxRegKey::HKCU, SOFTWARE_KEY + str);
	127	m_keyLocal.SetName(m_keyLocalRoot, wxEmptyString);
	128
	129	if ( bDoUseGlobal )
	130	{
	131	str = strGlobal.IsEmpty() ? strRoot : strGlobal;
	132
	133	m_keyGlobalRoot.ReserveMemoryForName(MEMORY_PREALLOC);
	134	m_keyGlobal.ReserveMemoryForName(MEMORY_PREALLOC);
	135
	136	m_keyGlobalRoot.SetName(wxRegKey::HKLM, SOFTWARE_KEY + str);
	137	m_keyGlobal.SetName(m_keyGlobalRoot, wxEmptyString);
	138	}
	139
	140	// Create() will Open() if key already exists
	141	m_keyLocalRoot.Create();
	142
	143	// as it's the same key, Open() shouldn't fail (i.e. no need for Create())
	144	m_keyLocal.Open();
	145
	146	// OTOH, this key may perfectly not exist, so suppress error messages the call
	147	// to Open() might generate
	148	if ( bDoUseGlobal )
	149	{
	150	wxLogNull nolog;
	151	m_keyGlobalRoot.Open();
	152	m_keyGlobal.Open();
	153	}
	154	}
	155
	156	wxRegConfig::~wxRegConfig()
	157	{
	158	// nothing to do - key will be closed in their dtors
	159	}
	160
	161	// ----------------------------------------------------------------------------
	162	// path management
	163	// ----------------------------------------------------------------------------
	164
	165	// this function is called a lot of times (as I learned after seeing from
	166	// profiler output that it is called ~12000 times from Mahogany start up code!)
	167	// so it is important to optimize it - in particular, avoid using generic
	168	// string functions here and do everything manually because it is faster
	169	//
	170	// I still kept the old version to be able to check that the optimized code has
	171	// the same output as the non optimized version.
	172	void wxRegConfig::SetPath(const wxString& strPath)
	173	{
	174	// remember the old path
	175	wxString strOldPath = m_strPath;
	176
	177	#ifdef WX_DEBUG_SET_PATH // non optimized version kept here for testing
	178	wxString m_strPathAlt;
	179
	180	{
	181	wxArrayString aParts;
	182
	183	// because GetPath() returns "" when we're at root, we must understand
	184	// empty string as "/"
	185	if ( strPath.IsEmpty() \|\| (strPath[0] == wxCONFIG_PATH_SEPARATOR) ) {
	186	// absolute path
	187	wxSplitPath(aParts, strPath);
	188	}
	189	else {
	190	// relative path, combine with current one
	191	wxString strFullPath = GetPath();
	192	strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
	193	wxSplitPath(aParts, strFullPath);
	194	}
	195
	196	// recombine path parts in one variable
	197	wxString strRegPath;
	198	m_strPathAlt.Empty();
	199	for ( size_t n = 0; n < aParts.Count(); n++ ) {
	200	strRegPath << '\\' << aParts[n];
	201	m_strPathAlt << wxCONFIG_PATH_SEPARATOR << aParts[n];
	202	}
	203	}
	204	#endif // 0
	205
	206	// check for the most common case first
	207	if ( strPath.empty() )
	208	{
	209	m_strPath = wxCONFIG_PATH_SEPARATOR;
	210	}
	211	else // not root
	212	{
	213	// construct the full path
	214	wxString strFullPath;
	215	if ( strPath[0u] == wxCONFIG_PATH_SEPARATOR )
	216	{
	217	// absolute path
	218	strFullPath = strPath;
	219	}
	220	else // relative path
	221	{
	222	strFullPath.reserve(2*m_strPath.length());
	223
	224	strFullPath << m_strPath;
	225	if ( strFullPath.Len() == 0 \|\|
	226	strFullPath.Last() != wxCONFIG_PATH_SEPARATOR )
	227	strFullPath << wxCONFIG_PATH_SEPARATOR;
	228	strFullPath << strPath;
	229	}
	230
	231	// simplify it: we need to handle ".." here
	232
	233	// count the total number of slashes we have to know if we can go upper
	234	size_t totalSlashes = 0;
	235
	236	// position of the last slash to be able to backtrack to it quickly if
	237	// needed, but we set it to -1 if we don't have a valid position
	238	//
	239	// we only remember the last position which means that we handle ".."
	240	// quite efficiently but not "../.." - however the latter should be
	241	// much more rare, so it is probably ok
	242	int posLastSlash = -1;
	243
	244	const wxChar *src = strFullPath.c_str();
	245	size_t len = strFullPath.length();
	246	const wxChar *end = src + len;
	247
	248	wxChar *dst = m_strPath.GetWriteBuf(len);
	249	wxChar *start = dst;
	250
	251	for ( ; src < end; src++, dst++ )
	252	{
	253	if ( *src == wxCONFIG_PATH_SEPARATOR )
	254	{
	255	// check for "/.."
	256
	257	// note that we don't have to check for src < end here as
	258	// *end == 0 so can't be '.'
	259	if ( src[1] == _T('.') && src[2] == _T('.') &&
	260	(src + 3 == end \|\| src[3] == wxCONFIG_PATH_SEPARATOR) )
	261	{
	262	if ( !totalSlashes )
	263	{
	264	wxLogWarning(_("'%s' has extra '..', ignored."),
	265	strFullPath.c_str());
	266	}
	267	else // return to the previous path component
	268	{
	269	// do we already have its position?
	270	if ( posLastSlash == -1 )
	271	{
	272	// no, find it: note that we are sure to have one
	273	// because totalSlashes > 0 so we don't have to
	274	// check the boundary condition below
	275
	276	// this is more efficient than strrchr()
	277	dst--;
	278	while ( *dst != wxCONFIG_PATH_SEPARATOR )
	279	{
	280	dst--;
	281	}
	282	}
	283	else // the position of last slash was stored
	284	{
	285	// go directly there
	286	dst = start + posLastSlash;
	287
	288	// invalidate posLastSlash
	289	posLastSlash = -1;
	290	}
	291
	292	// we must have found a slash one way or another!
	293	wxASSERT_MSG( *dst == wxCONFIG_PATH_SEPARATOR,
	294	_T("error in wxRegConfig::SetPath") );
	295
	296	// stay at the same position
	297	dst--;
	298
	299	// we killed one
	300	totalSlashes--;
	301	}
	302
	303	// skip both dots
	304	src += 2;
	305	}
	306	else // not "/.."
	307	{
	308	if ( (dst == start) \|\| (dst[-1] != wxCONFIG_PATH_SEPARATOR) )
	309	{
	310	*dst = wxCONFIG_PATH_SEPARATOR;
	311
	312	posLastSlash = dst - start;
	313
	314	totalSlashes++;
	315	}
	316	else // previous char was a slash too
	317	{
	318	// squeeze several subsequent slashes into one: i.e.
	319	// just ignore this one
	320	dst--;
	321	}
	322	}
	323	}
	324	else // normal character
	325	{
	326	// just copy
	327	dst = src;
	328	}
	329	}
	330
	331	// NUL terminate the string
	332	if ( dst[-1] == wxCONFIG_PATH_SEPARATOR && (dst != start + 1) )
	333	{
	334	// if it has a trailing slash we remove it unless it is the only
	335	// string character
	336	dst--;
	337	}
	338
	339	*dst = _T('\0');
	340
	341	m_strPath.UngetWriteBuf(dst - start);
	342	}
	343
	344	#ifdef WX_DEBUG_SET_PATH
	345	wxASSERT( m_strPath == m_strPathAlt );
	346	#endif
	347
	348	if ( m_strPath == strOldPath )
	349	return;
	350
	351	// registry APIs want backslashes instead of slashes
	352	wxString strRegPath;
	353	if ( !m_strPath.empty() )
	354	{
	355	size_t len = m_strPath.length();
	356
	357	const wxChar *src = m_strPath.c_str();
	358	wxChar *dst = strRegPath.GetWriteBuf(len);
	359
	360	const wxChar *end = src + len;
	361	for ( ; src < end; src++, dst++ )
	362	{
	363	if ( *src == wxCONFIG_PATH_SEPARATOR )
	364	*dst = _T('\\');
	365	else
	366	dst = src;
	367	}
	368
	369	strRegPath.UngetWriteBuf(len);
	370	}
	371
	372	// this is not needed any longer as we don't create keys unnecessarily any
	373	// more (now it is done on demand, i.e. only when they're going to contain
	374	// something)
	375	#if 0
	376	// as we create the registry key when SetPath(key) is done, we can be left
	377	// with plenty of empty keys if this was only done to try to read some
	378	// value which, in fact, doesn't exist - to prevent this from happening we
	379	// automatically delete the old key if it was empty
	380	if ( m_keyLocal.Exists() && LocalKey().IsEmpty() )
	381	{
	382	m_keyLocal.DeleteSelf();
	383	}
	384	#endif // 0
	385
	386	// change current key(s)
	387	m_keyLocal.SetName(m_keyLocalRoot, strRegPath);
	388	m_keyGlobal.SetName(m_keyGlobalRoot, strRegPath);
	389
	390	// don't create it right now, wait until it is accessed
	391	//m_keyLocal.Create();
	392
	393	wxLogNull nolog;
	394	m_keyGlobal.Open();
	395	}
	396
	397	// ----------------------------------------------------------------------------
	398	// enumeration (works only with current group)
	399	// ----------------------------------------------------------------------------
	400
	401	/*
	402	We want to enumerate all local keys/values after the global ones, but, of
	403	course, we don't want to repeat a key which appears locally as well as
	404	globally twice.
	405
	406	We use the 15th bit of lIndex for distinction between global and local.
	407	*/
	408
	409	#define LOCAL_MASK 0x8000
	410	#define IS_LOCAL_INDEX(l) (((l) & LOCAL_MASK) != 0)
	411
	412	bool wxRegConfig::GetFirstGroup(wxString& str, long& lIndex) const
	413	{
	414	lIndex = 0;
	415	return GetNextGroup(str, lIndex);
	416	}
	417
	418	bool wxRegConfig::GetNextGroup(wxString& str, long& lIndex) const
	419	{
	420	// are we already enumerating local entries?
	421	if ( m_keyGlobal.IsOpened() && !IS_LOCAL_INDEX(lIndex) ) {
	422	// try to find a global entry which doesn't appear locally
	423	while ( m_keyGlobal.GetNextKey(str, lIndex) ) {
	424	if ( !m_keyLocal.Exists() \|\| !LocalKey().HasSubKey(str) ) {
	425	// ok, found one - return it
	426	return TRUE;
	427	}
	428	}
	429
	430	// no more global entries
	431	lIndex \|= LOCAL_MASK;
	432	}
	433
	434	// if we don't have the key at all, don't try to enumerate anything under it
	435	if ( !m_keyLocal.Exists() )
	436	return FALSE;
	437
	438	// much easier with local entries: get the next one we find
	439	// (don't forget to clear our flag bit and set it again later)
	440	lIndex &= ~LOCAL_MASK;
	441	bool bOk = LocalKey().GetNextKey(str, lIndex);
	442	lIndex \|= LOCAL_MASK;
	443
	444	return bOk;
	445	}
	446
	447	bool wxRegConfig::GetFirstEntry(wxString& str, long& lIndex) const
	448	{
	449	lIndex = 0;
	450	return GetNextEntry(str, lIndex);
	451	}
	452
	453	bool wxRegConfig::GetNextEntry(wxString& str, long& lIndex) const
	454	{
	455	// are we already enumerating local entries?
	456	if ( m_keyGlobal.IsOpened() && !IS_LOCAL_INDEX(lIndex) ) {
	457	// try to find a global entry which doesn't appear locally
	458	while ( m_keyGlobal.GetNextValue(str, lIndex) ) {
	459	if ( !m_keyLocal.Exists() \|\| !LocalKey().HasValue(str) ) {
	460	// ok, found one - return it
	461	return TRUE;
	462	}
	463	}
	464
	465	// no more global entries
	466	lIndex \|= LOCAL_MASK;
	467	}
	468
	469	// if we don't have the key at all, don't try to enumerate anything under it
	470	if ( !m_keyLocal.Exists() )
	471	return FALSE;
	472
	473	// much easier with local entries: get the next one we find
	474	// (don't forget to clear our flag bit and set it again later)
	475	lIndex &= ~LOCAL_MASK;
	476	bool bOk = LocalKey().GetNextValue(str, lIndex);
	477	lIndex \|= LOCAL_MASK;
	478
	479	return bOk;
	480	}
	481
	482	size_t wxRegConfig::GetNumberOfEntries(bool WXUNUSED(bRecursive)) const
	483	{
	484	size_t nEntries = 0;
	485
	486	// dummy vars
	487	wxString str;
	488	long l;
	489	bool bCont = ((wxRegConfig*)this)->GetFirstEntry(str, l);
	490	while ( bCont ) {
	491	nEntries++;
	492
	493	bCont = ((wxRegConfig*)this)->GetNextEntry(str, l);
	494	}
	495
	496	return nEntries;
	497	}
	498
	499	size_t wxRegConfig::GetNumberOfGroups(bool WXUNUSED(bRecursive)) const
	500	{
	501	size_t nGroups = 0;
	502
	503	// dummy vars
	504	wxString str;
	505	long l;
	506	bool bCont = ((wxRegConfig*)this)->GetFirstGroup(str, l);
	507	while ( bCont ) {
	508	nGroups++;
	509
	510	bCont = ((wxRegConfig*)this)->GetNextGroup(str, l);
	511	}
	512
	513	return nGroups;
	514	}
	515
	516	// ----------------------------------------------------------------------------
	517	// tests for existence
	518	// ----------------------------------------------------------------------------
	519
	520	bool wxRegConfig::HasGroup(const wxString& key) const
	521	{
	522	wxConfigPathChanger path(this, key);
	523
	524	wxString strName(path.Name());
	525
	526	return (m_keyLocal.Exists() && LocalKey().HasSubKey(strName)) \|\|
	527	m_keyGlobal.HasSubKey(strName);
	528	}
	529
	530	bool wxRegConfig::HasEntry(const wxString& key) const
	531	{
	532	wxConfigPathChanger path(this, key);
	533
	534	wxString strName(path.Name());
	535
	536	return (m_keyLocal.Exists() && LocalKey().HasValue(strName)) \|\|
	537	m_keyGlobal.HasValue(strName);
	538	}
	539
	540	wxConfigBase::EntryType wxRegConfig::GetEntryType(const wxString& key) const
	541	{
	542	wxConfigPathChanger path(this, key);
	543
	544	wxString strName(path.Name());
	545
	546	bool isNumeric;
	547	if ( m_keyLocal.Exists() && LocalKey().HasValue(strName) )
	548	isNumeric = m_keyLocal.IsNumericValue(strName);
	549	else if ( m_keyGlobal.HasValue(strName) )
	550	isNumeric = m_keyGlobal.IsNumericValue(strName);
	551	else
	552	return wxConfigBase::Type_Unknown;
	553
	554	return isNumeric ? wxConfigBase::Type_Integer : wxConfigBase::Type_String;
	555	}
	556
	557	// ----------------------------------------------------------------------------
	558	// reading/writing
	559	// ----------------------------------------------------------------------------
	560
	561	bool wxRegConfig::DoReadString(const wxString& key, wxString *pStr) const
	562	{
	563	wxCHECK_MSG( pStr, FALSE, _T("wxRegConfig::Read(): NULL param") );
	564
	565	wxConfigPathChanger path(this, key);
	566
	567	bool bQueryGlobal = TRUE;
	568
	569	// if immutable key exists in global key we must check that it's not
	570	// overriden by the local key with the same name
	571	if ( IsImmutable(path.Name()) ) {
	572	if ( TryGetValue(m_keyGlobal, path.Name(), *pStr) ) {
	573	if ( m_keyLocal.Exists() && LocalKey().HasValue(path.Name()) ) {
	574	wxLogWarning(wxT("User value for immutable key '%s' ignored."),
	575	path.Name().c_str());
	576	}
	577
	578	return TRUE;
	579	}
	580	else {
	581	// don't waste time - it's not there anyhow
	582	bQueryGlobal = FALSE;
	583	}
	584	}
	585
	586	// first try local key
	587	if ( (m_keyLocal.Exists() && TryGetValue(LocalKey(), path.Name(), *pStr)) \|\|
	588	(bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), *pStr)) ) {
	589	return TRUE;
	590	}
	591
	592	return FALSE;
	593	}
	594
	595	// this exactly reproduces the string version above except for ExpandEnvVars(),
	596	// we really should avoid this code duplication somehow...
	597
	598	bool wxRegConfig::DoReadLong(const wxString& key, long *plResult) const
	599	{
	600	wxCHECK_MSG( plResult, FALSE, _T("wxRegConfig::Read(): NULL param") );
	601
	602	wxConfigPathChanger path(this, key);
	603
	604	bool bQueryGlobal = TRUE;
	605
	606	// if immutable key exists in global key we must check that it's not
	607	// overriden by the local key with the same name
	608	if ( IsImmutable(path.Name()) ) {
	609	if ( TryGetValue(m_keyGlobal, path.Name(), plResult) ) {
	610	if ( m_keyLocal.Exists() && LocalKey().HasValue(path.Name()) ) {
	611	wxLogWarning(wxT("User value for immutable key '%s' ignored."),
	612	path.Name().c_str());
	613	}
	614
	615	return TRUE;
	616	}
	617	else {
	618	// don't waste time - it's not there anyhow
	619	bQueryGlobal = FALSE;
	620	}
	621	}
	622
	623	// first try local key
	624	if ( (m_keyLocal.Exists() && TryGetValue(LocalKey(), path.Name(), plResult)) \|\|
	625	(bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), plResult)) ) {
	626	return TRUE;
	627	}
	628
	629	return FALSE;
	630	}
	631
	632	bool wxRegConfig::DoWriteString(const wxString& key, const wxString& szValue)
	633	{
	634	wxConfigPathChanger path(this, key);
	635
	636	if ( IsImmutable(path.Name()) ) {
	637	wxLogError(wxT("Can't change immutable entry '%s'."), path.Name().c_str());
	638	return FALSE;
	639	}
	640
	641	return LocalKey().SetValue(path.Name(), szValue);
	642	}
	643
	644	bool wxRegConfig::DoWriteLong(const wxString& key, long lValue)
	645	{
	646	wxConfigPathChanger path(this, key);
	647
	648	if ( IsImmutable(path.Name()) ) {
	649	wxLogError(wxT("Can't change immutable entry '%s'."), path.Name().c_str());
	650	return FALSE;
	651	}
	652
	653	return LocalKey().SetValue(path.Name(), lValue);
	654	}
	655
	656	// ----------------------------------------------------------------------------
	657	// renaming
	658	// ----------------------------------------------------------------------------
	659
	660	bool wxRegConfig::RenameEntry(const wxString& oldName, const wxString& newName)
	661	{
	662	// check that the old entry exists...
	663	if ( !HasEntry(oldName) )
	664	return FALSE;
	665
	666	// and that the new one doesn't
	667	if ( HasEntry(newName) )
	668	return FALSE;
	669
	670	return m_keyLocal.RenameValue(oldName, newName);
	671	}
	672
	673	bool wxRegConfig::RenameGroup(const wxString& oldName, const wxString& newName)
	674	{
	675	// check that the old group exists...
	676	if ( !HasGroup(oldName) )
	677	return FALSE;
	678
	679	// and that the new one doesn't
	680	if ( HasGroup(newName) )
	681	return FALSE;
	682
	683	return wxRegKey(m_keyLocal, oldName).Rename(newName);
	684	}
	685
	686	// ----------------------------------------------------------------------------
	687	// deleting
	688	// ----------------------------------------------------------------------------
	689	bool wxRegConfig::DeleteEntry(const wxString& value, bool WXUNUSED(bGroupIfEmptyAlso))
	690	{
	691	wxConfigPathChanger path(this, value);
	692
	693	if ( m_keyLocal.Exists() ) {
	694	if ( !m_keyLocal.DeleteValue(path.Name()) )
	695	return FALSE;
	696
	697	if ( m_keyLocal.IsEmpty() ) {
	698	wxString strKey = GetPath().AfterLast(wxCONFIG_PATH_SEPARATOR);
	699	SetPath(_T("..")); // changes m_keyLocal
	700	return LocalKey().DeleteKey(strKey);
	701	}
	702	}
	703
	704	return TRUE;
	705	}
	706
	707	bool wxRegConfig::DeleteGroup(const wxString& key)
	708	{
	709	wxConfigPathChanger path(this, key);
	710
	711	return m_keyLocal.Exists() ? LocalKey().DeleteKey(path.Name()) : TRUE;
	712	}
	713
	714	bool wxRegConfig::DeleteAll()
	715	{
	716	m_keyLocal.Close();
	717	m_keyGlobal.Close();
	718
	719	bool bOk = m_keyLocalRoot.DeleteSelf();
	720
	721	// make sure that we opened m_keyGlobalRoot and so it has a reasonable name:
	722	// otherwise we will delete HKEY_CLASSES_ROOT recursively
	723	if ( bOk && m_keyGlobalRoot.IsOpened() )
	724	bOk = m_keyGlobalRoot.DeleteSelf();
	725
	726	return bOk;
	727	}
	728
	729	#endif
	730	// __WIN16__
	731
	732	#endif
	733	// wxUSE_CONFIG