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

#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>
#endif //WX_PRECOMP

#include <wx/app.h>
#include <wx/log.h>
#include <wx/config.h>
#include <wx/msw/registry.h>
#include <wx/msw/regconf.h>

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

// we put our data in HKLM\SOFTWARE_KEY\appname
#define SOFTWARE_KEY    wxString("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, "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();

  // 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()
{
  // nothing to do - key will be closed in their dtors
}

// ----------------------------------------------------------------------------
// path management
// ----------------------------------------------------------------------------
void wxRegConfig::SetPath(const wxString& strPath)
{
  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_strPath.Empty();
  for ( size_t n = 0; n < aParts.Count(); n++ ) {
    strRegPath << '\\' << aParts[n];
    m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n];
  }

  // change current key(s)
  m_keyLocal.SetName(m_keyLocalRoot, strRegPath);
  m_keyGlobal.SetName(m_keyGlobalRoot, strRegPath);
  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
    do {
      if ( !m_keyGlobal.GetNextKey(str, lIndex) ) {
        // no more global entries
        lIndex |= LOCAL_MASK;
        break;
      }
    } while( m_keyLocal.HasSubKey(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;
  bool bOk = m_keyLocal.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
    do {
      if ( !m_keyGlobal.GetNextValue(str, lIndex) ) {
        // no more global entries
        lIndex |= LOCAL_MASK;
        break;
      }
    } 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;
  bool bOk = m_keyLocal.GetNextValue(str, lIndex);
  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
// ----------------------------------------------------------------------------

bool wxRegConfig::Read(const wxString& key, wxString *pStr) 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());
      }
     *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 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
      bQueryGlobal = FALSE;
    }
  }

  // first try local key
  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
    *pStr = szDefault;
  }

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

  return FALSE;
}

bool wxRegConfig::Read(const wxString& key, long *plResult) 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(), plResult) ) {
      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
      bQueryGlobal = FALSE;
    }
  }

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

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

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

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

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

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

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

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

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

  if ( !m_keyLocal.HasSubkeys() ) {
    wxString strKey = GetPath().Right(wxCONFIG_PATH_SEPARATOR);
    SetPath("..");  // changes m_keyLocal
    return m_keyLocal.DeleteKey(strKey);
  }

  return TRUE;
}

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

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

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

  bool bOk = m_keyLocalRoot.DeleteSelf();
  if ( bOk )
    bOk = m_keyGlobalRoot.DeleteSelf();

  return bOk;
}
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 license
	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	#endif //WX_PRECOMP
	26
	27	#include <wx/app.h>
	28	#include <wx/log.h>
	29	#include <wx/config.h>
	30	#include <wx/msw/registry.h>
	31	#include <wx/msw/regconf.h>
	32
	33	// ----------------------------------------------------------------------------
	34	// constants
	35	// ----------------------------------------------------------------------------
	36
	37	// we put our data in HKLM\SOFTWARE_KEY\appname
	38	#define SOFTWARE_KEY wxString("Software\\")
	39
	40	// ----------------------------------------------------------------------------
	41	// global functions
	42	// ----------------------------------------------------------------------------
	43
	44	// get the value if the key is opened and it exists
	45	bool TryGetValue(const wxRegKey& key, const wxString& str, wxString& strVal)
	46	{
	47	return key.IsOpened() && key.HasValue(str) && key.QueryValue(str, strVal);
	48	}
	49
	50	bool TryGetValue(const wxRegKey& key, const wxString& str, long *plVal)
	51	{
	52	return key.IsOpened() && key.HasValue(str) && key.QueryValue(str, plVal);
	53	}
	54
	55	// ============================================================================
	56	// implementation
	57	// ============================================================================
	58
	59	// ----------------------------------------------------------------------------
	60	// ctor/dtor
	61	// ----------------------------------------------------------------------------
	62
	63	// create the config object which stores its data under HKCU\vendor\app and, if
	64	// style & wxCONFIG_USE_GLOBAL_FILE, under HKLM\vendor\app
	65	wxRegConfig::wxRegConfig(const wxString& appName, const wxString& vendorName,
	66	const wxString& strLocal, const wxString& strGlobal,
	67	long style)
	68	: wxConfigBase(appName, vendorName, strLocal, strGlobal, style)
	69	{
	70	wxString strRoot;
	71
	72	bool bDoUseGlobal = (style & wxCONFIG_USE_GLOBAL_FILE) != 0;
	73
	74	// the convention is to put the programs keys under <vendor>\<appname>
	75	// (but it can be overriden by specifying the pathes explicitly in strLocal
	76	// and/or strGlobal)
	77	if ( strLocal.IsEmpty() \|\| (strGlobal.IsEmpty() && bDoUseGlobal) )
	78	{
	79	if ( vendorName.IsEmpty() )
	80	{
	81	if ( wxTheApp )
	82	strRoot = wxTheApp->GetVendorName();
	83	}
	84	else
	85	{
	86	strRoot = vendorName;
	87	}
	88
	89	// no '\\' needed if no vendor name
	90	if ( !strRoot.IsEmpty() )
	91	{
	92	strRoot += '\\';
	93	}
	94
	95	if ( appName.IsEmpty() )
	96	{
	97	wxCHECK_RET( wxTheApp, "No application name in wxRegConfig ctor!" );
	98	strRoot << wxTheApp->GetAppName();
	99	}
	100	else
	101	{
	102	strRoot << appName;
	103	}
	104	}
	105	//else: we don't need to do all the complicated stuff above
	106
	107	wxString str = strLocal.IsEmpty() ? strRoot : strLocal;
	108	m_keyLocalRoot.SetName(wxRegKey::HKCU, SOFTWARE_KEY + str);
	109	m_keyLocal.SetName(m_keyLocalRoot, "");
	110
	111	if ( bDoUseGlobal )
	112	{
	113	str = strGlobal.IsEmpty() ? strRoot : strGlobal;
	114	m_keyGlobalRoot.SetName(wxRegKey::HKLM, SOFTWARE_KEY + str);
	115	m_keyGlobal.SetName(m_keyGlobalRoot, "");
	116	}
	117
	118	// Create() will Open() if key already exists
	119	m_keyLocalRoot.Create();
	120
	121	// as it's the same key, Open() shouldn't fail (i.e. no need for Create())
	122	m_keyLocal.Open();
	123
	124	// OTOH, this key may perfectly not exist, so suppress error messages the call
	125	// to Open() might generate
	126	if ( bDoUseGlobal )
	127	{
	128	wxLogNull nolog;
	129	m_keyGlobalRoot.Open();
	130	}
	131	}
	132
	133	wxRegConfig::~wxRegConfig()
	134	{
	135	// nothing to do - key will be closed in their dtors
	136	}
	137
	138	// ----------------------------------------------------------------------------
	139	// path management
	140	// ----------------------------------------------------------------------------
	141	void wxRegConfig::SetPath(const wxString& strPath)
	142	{
	143	wxArrayString aParts;
	144
	145	// because GetPath() returns "" when we're at root, we must understand
	146	// empty string as "/"
	147	if ( strPath.IsEmpty() \|\| (strPath[0] == wxCONFIG_PATH_SEPARATOR) ) {
	148	// absolute path
	149	wxSplitPath(aParts, strPath);
	150	}
	151	else {
	152	// relative path, combine with current one
	153	wxString strFullPath = GetPath();
	154	strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
	155	wxSplitPath(aParts, strFullPath);
	156	}
	157
	158	// recombine path parts in one variable
	159	wxString strRegPath;
	160	m_strPath.Empty();
	161	for ( size_t n = 0; n < aParts.Count(); n++ ) {
	162	strRegPath << '\\' << aParts[n];
	163	m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n];
	164	}
	165
	166	// change current key(s)
	167	m_keyLocal.SetName(m_keyLocalRoot, strRegPath);
	168	m_keyGlobal.SetName(m_keyGlobalRoot, strRegPath);
	169	m_keyLocal.Create();
	170
	171	wxLogNull nolog;
	172	m_keyGlobal.Open();
	173	}
	174
	175	// ----------------------------------------------------------------------------
	176	// enumeration (works only with current group)
	177	// ----------------------------------------------------------------------------
	178
	179	/*
	180	We want to enumerate all local keys/values after the global ones, but, of
	181	course, we don't want to repeat a key which appears locally as well as
	182	globally twice.
	183
	184	We use the 15th bit of lIndex for distinction between global and local.
	185	*/
	186
	187	#define LOCAL_MASK 0x8000
	188	#define IS_LOCAL_INDEX(l) (((l) & LOCAL_MASK) != 0)
	189
	190	bool wxRegConfig::GetFirstGroup(wxString& str, long& lIndex) const
	191	{
	192	lIndex = 0;
	193	return GetNextGroup(str, lIndex);
	194	}
	195
	196	bool wxRegConfig::GetNextGroup(wxString& str, long& lIndex) const
	197	{
	198	// are we already enumerating local entries?
	199	if ( m_keyGlobal.IsOpened() && !IS_LOCAL_INDEX(lIndex) ) {
	200	// try to find a global entry which doesn't appear locally
	201	do {
	202	if ( !m_keyGlobal.GetNextKey(str, lIndex) ) {
	203	// no more global entries
	204	lIndex \|= LOCAL_MASK;
	205	break;
	206	}
	207	} while( m_keyLocal.HasSubKey(str) );
	208	}
	209
	210	// much easier with local entries: get the next one we find
	211	// (don't forget to clear our flag bit and set it again later)
	212	lIndex &= ~LOCAL_MASK;
	213	bool bOk = m_keyLocal.GetNextKey(str, lIndex);
	214	lIndex \|= LOCAL_MASK;
	215
	216	return bOk;
	217	}
	218
	219	bool wxRegConfig::GetFirstEntry(wxString& str, long& lIndex) const
	220	{
	221	lIndex = 0;
	222	return GetNextEntry(str, lIndex);
	223	}
	224
	225	bool wxRegConfig::GetNextEntry(wxString& str, long& lIndex) const
	226	{
	227	// are we already enumerating local entries?
	228	if ( m_keyGlobal.IsOpened() && !IS_LOCAL_INDEX(lIndex) ) {
	229	// try to find a global entry which doesn't appear locally
	230	do {
	231	if ( !m_keyGlobal.GetNextValue(str, lIndex) ) {
	232	// no more global entries
	233	lIndex \|= LOCAL_MASK;
	234	break;
	235	}
	236	} while( m_keyLocal.HasValue(str) );
	237	}
	238
	239	// much easier with local entries: get the next one we find
	240	// (don't forget to clear our flag bit and set it again later)
	241	lIndex &= ~LOCAL_MASK;
	242	bool bOk = m_keyLocal.GetNextValue(str, lIndex);
	243	lIndex \|= LOCAL_MASK;
	244
	245	return bOk;
	246	}
	247
	248	size_t wxRegConfig::GetNumberOfEntries(bool bRecursive) const
	249	{
	250	size_t nEntries = 0;
	251
	252	// dummy vars
	253	wxString str;
	254	long l;
	255	bool bCont = ((wxRegConfig*)this)->GetFirstEntry(str, l);
	256	while ( bCont ) {
	257	nEntries++;
	258
	259	bCont = ((wxRegConfig*)this)->GetNextEntry(str, l);
	260	}
	261
	262	return nEntries;
	263	}
	264
	265	size_t wxRegConfig::GetNumberOfGroups(bool bRecursive) const
	266	{
	267	size_t nGroups = 0;
	268
	269	// dummy vars
	270	wxString str;
	271	long l;
	272	bool bCont = ((wxRegConfig*)this)->GetFirstGroup(str, l);
	273	while ( bCont ) {
	274	nGroups++;
	275
	276	bCont = ((wxRegConfig*)this)->GetNextGroup(str, l);
	277	}
	278
	279	return nGroups;
	280	}
	281
	282	// ----------------------------------------------------------------------------
	283	// tests for existence
	284	// ----------------------------------------------------------------------------
	285
	286	bool wxRegConfig::HasGroup(const wxString& strName) const
	287	{
	288	return m_keyLocal.HasSubKey(strName) \|\| m_keyGlobal.HasSubKey(strName);
	289	}
	290
	291	bool wxRegConfig::HasEntry(const wxString& strName) const
	292	{
	293	return m_keyLocal.HasValue(strName) \|\| m_keyGlobal.HasValue(strName);
	294	}
	295
	296	// ----------------------------------------------------------------------------
	297	// reading/writing
	298	// ----------------------------------------------------------------------------
	299
	300	bool wxRegConfig::Read(const wxString& key, wxString *pStr) const
	301	{
	302	wxConfigPathChanger path(this, key);
	303
	304	bool bQueryGlobal = TRUE;
	305
	306	// if immutable key exists in global key we must check that it's not
	307	// overriden by the local key with the same name
	308	if ( IsImmutable(path.Name()) ) {
	309	if ( TryGetValue(m_keyGlobal, path.Name(), *pStr) ) {
	310	if ( m_keyLocal.HasValue(path.Name()) ) {
	311	wxLogWarning("User value for immutable key '%s' ignored.",
	312	path.Name().c_str());
	313	}
	314	pStr = wxConfigBase::ExpandEnvVars(pStr);
	315	return TRUE;
	316	}
	317	else {
	318	// don't waste time - it's not there anyhow
	319	bQueryGlobal = FALSE;
	320	}
	321	}
	322
	323	// first try local key
	324	if ( TryGetValue(m_keyLocal, path.Name(), *pStr) \|\|
	325	(bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), *pStr)) ) {
	326	// nothing to do
	327
	328	// TODO: do we return TRUE? Not in original implementation,
	329	// but I don't see why not. -- JACS
	330	pStr = wxConfigBase::ExpandEnvVars(pStr);
	331	return TRUE;
	332	}
	333
	334	return FALSE;
	335	}
	336
	337	bool wxRegConfig::Read(const wxString& key, wxString *pStr,
	338	const wxString& szDefault) const
	339	{
	340	wxConfigPathChanger path(this, key);
	341
	342	bool bQueryGlobal = TRUE;
	343
	344	// if immutable key exists in global key we must check that it's not
	345	// overriden by the local key with the same name
	346	if ( IsImmutable(path.Name()) ) {
	347	if ( TryGetValue(m_keyGlobal, path.Name(), *pStr) ) {
	348	if ( m_keyLocal.HasValue(path.Name()) ) {
	349	wxLogWarning("User value for immutable key '%s' ignored.",
	350	path.Name().c_str());
	351	}
	352
	353	return TRUE;
	354	}
	355	else {
	356	// don't waste time - it's not there anyhow
	357	bQueryGlobal = FALSE;
	358	}
	359	}
	360
	361	// first try local key
	362	if ( TryGetValue(m_keyLocal, path.Name(), *pStr) \|\|
	363	(bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), *pStr)) ) {
	364	pStr = wxConfigBase::ExpandEnvVars(pStr);
	365	return TRUE;
	366	}
	367	else {
	368	if ( IsRecordingDefaults() ) {
	369	((wxRegConfig*)this)->Write(key, szDefault);
	370	}
	371
	372	// default value
	373	*pStr = szDefault;
	374	}
	375
	376	pStr = wxConfigBase::ExpandEnvVars(pStr);
	377
	378	return FALSE;
	379	}
	380
	381	bool wxRegConfig::Read(const wxString& key, long *plResult) const
	382	{
	383	wxConfigPathChanger path(this, key);
	384
	385	bool bQueryGlobal = TRUE;
	386
	387	// if immutable key exists in global key we must check that it's not
	388	// overriden by the local key with the same name
	389	if ( IsImmutable(path.Name()) ) {
	390	if ( TryGetValue(m_keyGlobal, path.Name(), plResult) ) {
	391	if ( m_keyLocal.HasValue(path.Name()) ) {
	392	wxLogWarning("User value for immutable key '%s' ignored.",
	393	path.Name().c_str());
	394	}
	395
	396	return TRUE;
	397	}
	398	else {
	399	// don't waste time - it's not there anyhow
	400	bQueryGlobal = FALSE;
	401	}
	402	}
	403
	404	// first try local key
	405	if ( TryGetValue(m_keyLocal, path.Name(), plResult) \|\|
	406	(bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), plResult)) ) {
	407	return TRUE;
	408	}
	409	return FALSE;
	410	}
	411
	412	bool wxRegConfig::Write(const wxString& key, const wxString& szValue)
	413	{
	414	wxConfigPathChanger path(this, key);
	415
	416	if ( IsImmutable(path.Name()) ) {
	417	wxLogError("Can't change immutable entry '%s'.", path.Name().c_str());
	418	return FALSE;
	419	}
	420
	421	return m_keyLocal.SetValue(path.Name(), szValue);
	422	}
	423
	424	bool wxRegConfig::Write(const wxString& key, long lValue)
	425	{
	426	wxConfigPathChanger path(this, key);
	427
	428	if ( IsImmutable(path.Name()) ) {
	429	wxLogError("Can't change immutable entry '%s'.", path.Name().c_str());
	430	return FALSE;
	431	}
	432
	433	return m_keyLocal.SetValue(path.Name(), lValue);
	434	}
	435
	436	// ----------------------------------------------------------------------------
	437	// deleting
	438	// ----------------------------------------------------------------------------
	439	bool wxRegConfig::DeleteEntry(const wxString& value, bool bGroupIfEmptyAlso)
	440	{
	441	wxConfigPathChanger path(this, value);
	442
	443	if ( !m_keyLocal.DeleteValue(path.Name()) )
	444	return FALSE;
	445
	446	if ( !m_keyLocal.HasSubkeys() ) {
	447	wxString strKey = GetPath().Right(wxCONFIG_PATH_SEPARATOR);
	448	SetPath(".."); // changes m_keyLocal
	449	return m_keyLocal.DeleteKey(strKey);
	450	}
	451
	452	return TRUE;
	453	}
	454
	455	bool wxRegConfig::DeleteGroup(const wxString& key)
	456	{
	457	wxConfigPathChanger path(this, key);
	458
	459	return m_keyLocal.DeleteKey(path.Name());
	460	}
	461
	462	bool wxRegConfig::DeleteAll()
	463	{
	464	m_keyLocal.Close();
	465	m_keyGlobal.Close();
	466
	467	bool bOk = m_keyLocalRoot.DeleteSelf();
	468	if ( bOk )
	469	bOk = m_keyGlobalRoot.DeleteSelf();
	470
	471	return bOk;
	472	}