src/msw/iniconf.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        src/msw/iniconf.cpp
// Purpose:     implementation of wxIniConfig class
// Author:      Vadim Zeitlin
// Modified by:
// Created:     27.07.98
// RCS-ID:      $Id$
// Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence:     wxWindows license
///////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "iniconf.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>
  #include  <wx/event.h>
  #include  <wx/app.h>
  #include  <wx/utils.h>
#endif  //WX_PRECOMP

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

#include  <wx/msw/iniconf.h>

// _WINDOWS_ is defined when windows.h is included,
// __WXMSW__ is defined for MS Windows compilation
#if       defined(__WXMSW__) && !defined(_WINDOWS_)
  #include  <windows.h>
#endif  //windows.h

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

// we replace all path separators with this character
#define PATH_SEP_REPLACE  '_'

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

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

wxIniConfig::wxIniConfig(const wxString& strAppName, const wxString& strVendor,
    const wxString& localFilename, const wxString& globalFilename, long style):
     wxConfigBase(strAppName, strVendor, localFilename, globalFilename, style)
{
    if ( GetAppName().IsEmpty() )
    {
        wxString app;
        if (wxTheApp)
            app = wxTheApp->GetAppName();
        wxASSERT( !app.IsEmpty() );
        SetAppName(app);
    }

    // Vendor name is required in wxIniConfig.
    // TODO: should it be required? Why isn't appName used instead? -- JACS
    if ( GetVendorName().IsEmpty() )
    {
        wxString vendor;
        if (wxTheApp)
            vendor = wxTheApp->GetVendorName();
        else
            vendor = strAppName;
        SetVendorName(vendor);
    }

    m_strLocalFilename = localFilename;
    if (m_strLocalFilename.IsEmpty())
    {
        m_strLocalFilename = GetAppName() + ".ini";
    }

    // append the extension if none given and it's not an absolute file name
    // (otherwise we assume that they know what they're doing)
    if ( !wxIsPathSeparator(m_strLocalFilename[0u]) &&
        m_strLocalFilename.Find('.') == wxNOT_FOUND )
    {
        m_strLocalFilename << ".ini";
    }

    // set root path
    SetPath("");
}

wxIniConfig::~wxIniConfig()
{
}

// ----------------------------------------------------------------------------
// path management
// ----------------------------------------------------------------------------

void wxIniConfig::SetPath(const wxString& strPath)
{
  wxArrayString aParts;

  if ( strPath.IsEmpty() ) {
    // nothing
  }
  else if ( strPath[0u] == 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);
  }

  size_t nPartsCount = aParts.Count();
  m_strPath.Empty();
  if ( nPartsCount == 0 ) {
    // go to the root
    m_strGroup = PATH_SEP_REPLACE;
  }
  else {
    // translate
    m_strGroup = aParts[0u];
    for ( size_t nPart = 1; nPart < nPartsCount; nPart++ ) {
      if ( nPart > 1 )
        m_strPath << PATH_SEP_REPLACE;
      m_strPath << aParts[nPart];
    }
  }

  // other functions assume that all this is true, i.e. there are no trailing
  // underscores at the end except if the group is the root one
  wxASSERT( (m_strPath.IsEmpty() || m_strPath.Last() != PATH_SEP_REPLACE) &&
            (m_strGroup == wxString(PATH_SEP_REPLACE) ||
             m_strGroup.Last() != PATH_SEP_REPLACE) );
}

const wxString& wxIniConfig::GetPath() const
{
  static wxString s_str;

  // always return abs path
  s_str = wxCONFIG_PATH_SEPARATOR;

  if ( m_strGroup == wxString(PATH_SEP_REPLACE) ) {
    // we're at the root level, nothing to do
  }
  else {
    s_str << m_strGroup;
    if ( !m_strPath.IsEmpty() )
      s_str << wxCONFIG_PATH_SEPARATOR;
    for ( const char *p = m_strPath; *p != '\0'; p++ ) {
      s_str << (*p == PATH_SEP_REPLACE ? wxCONFIG_PATH_SEPARATOR : *p);
    }
  }

  return s_str;
}

wxString wxIniConfig::GetPrivateKeyName(const wxString& szKey) const
{
  wxString strKey;

  if ( !m_strPath.IsEmpty() )
    strKey << m_strPath << PATH_SEP_REPLACE;

  strKey << szKey;

  return strKey;
}

wxString wxIniConfig::GetKeyName(const wxString& szKey) const
{
  wxString strKey;

  if ( m_strGroup != wxString(PATH_SEP_REPLACE) )
    strKey << m_strGroup << PATH_SEP_REPLACE;
  if ( !m_strPath.IsEmpty() )
    strKey << m_strPath << PATH_SEP_REPLACE;

  strKey << szKey;

  return strKey;
}

// ----------------------------------------------------------------------------
// enumeration
// ----------------------------------------------------------------------------

// not implemented
bool wxIniConfig::GetFirstGroup(wxString& str, long& lIndex) const
{
  wxFAIL_MSG("not implemented");

  return FALSE;
}

bool wxIniConfig::GetNextGroup (wxString& str, long& lIndex) const
{
  wxFAIL_MSG("not implemented");

  return FALSE;
}

bool wxIniConfig::GetFirstEntry(wxString& str, long& lIndex) const
{
  wxFAIL_MSG("not implemented");

  return FALSE;
}

bool wxIniConfig::GetNextEntry (wxString& str, long& lIndex) const
{
  wxFAIL_MSG("not implemented");

  return FALSE;
}

// ----------------------------------------------------------------------------
// misc info
// ----------------------------------------------------------------------------

// not implemented
size_t wxIniConfig::GetNumberOfEntries(bool bRecursive) const
{
  wxFAIL_MSG("not implemented");

  return (size_t)-1;
}

size_t wxIniConfig::GetNumberOfGroups(bool bRecursive) const
{
  wxFAIL_MSG("not implemented");

  return (size_t)-1;
}

bool wxIniConfig::HasGroup(const wxString& strName) const
{
  wxFAIL_MSG("not implemented");

  return FALSE;
}

bool wxIniConfig::HasEntry(const wxString& strName) const
{
  wxFAIL_MSG("not implemented");

  return FALSE;
}

// is current group empty?
bool wxIniConfig::IsEmpty() const
{
  char szBuf[1024];

  GetPrivateProfileString(m_strGroup, NULL, "",
                          szBuf, WXSIZEOF(szBuf), m_strLocalFilename);
  if ( !::IsEmpty(szBuf) )
    return FALSE;

  GetProfileString(m_strGroup, NULL, "", szBuf, WXSIZEOF(szBuf));
  if ( !::IsEmpty(szBuf) )
    return FALSE;

  return TRUE;
}

// ----------------------------------------------------------------------------
// read/write
// ----------------------------------------------------------------------------

bool wxIniConfig::Read(const wxString& szKey, wxString *pstr) const
{
  wxConfigPathChanger path(this, szKey);
  wxString strKey = GetPrivateKeyName(path.Name());

  char szBuf[1024]; // @@ should dynamically allocate memory...

  // first look in the private INI file

  // NB: the lpDefault param to GetPrivateProfileString can't be NULL
  GetPrivateProfileString(m_strGroup, strKey, "",
                          szBuf, WXSIZEOF(szBuf), m_strLocalFilename);
  if ( ::IsEmpty(szBuf) ) {
    // now look in win.ini
    wxString strKey = GetKeyName(path.Name());
    GetProfileString(m_strGroup, strKey, "", szBuf, WXSIZEOF(szBuf));
  }

  if ( ::IsEmpty(szBuf) ) {
    return FALSE;
  }
  else {
    return TRUE;
  }
}

bool wxIniConfig::Read(const wxString& szKey, wxString *pstr,
                       const wxString& szDefault) const
{
  wxConfigPathChanger path(this, szKey);
  wxString strKey = GetPrivateKeyName(path.Name());

  char szBuf[1024]; // @@ should dynamically allocate memory...

  // first look in the private INI file

  // NB: the lpDefault param to GetPrivateProfileString can't be NULL
  GetPrivateProfileString(m_strGroup, strKey, "",
                          szBuf, WXSIZEOF(szBuf), m_strLocalFilename);
  if ( ::IsEmpty(szBuf) ) {
    // now look in win.ini
    wxString strKey = GetKeyName(path.Name());
    GetProfileString(m_strGroup, strKey, "", szBuf, WXSIZEOF(szBuf));
  }

  if ( ::IsEmpty(szBuf) ) {
    *pstr = szDefault;
    return FALSE;
  }
  else {
    return TRUE;
  }
}

bool wxIniConfig::Read(const wxString& szKey, long *pl) const
{
  wxConfigPathChanger path(this, szKey);
  wxString strKey = GetPrivateKeyName(path.Name());

  // hack: we have no mean to know if it really found the default value or
  // didn't find anything, so we call it twice

  static const int nMagic  = 17; // 17 is some "rare" number
  static const int nMagic2 = 28; // arbitrary number != nMagic
  long lVal = GetPrivateProfileInt(m_strGroup, strKey, nMagic, m_strLocalFilename);
  if ( lVal != nMagic ) {
    // the value was read from the file
    *pl = lVal;
    return TRUE;
  }

  // is it really nMagic?
  lVal = GetPrivateProfileInt(m_strGroup, strKey, nMagic2, m_strLocalFilename);
  if ( lVal == nMagic2 ) {
    // the nMagic it returned was indeed read from the file
    *pl = lVal;
    return TRUE;
  }

  // no, it was just returning the default value, so now look in win.ini
  *pl = GetProfileInt(GetVendorName(), GetKeyName(szKey), *pl);

  return TRUE;
}

bool wxIniConfig::Write(const wxString& szKey, const wxString& szValue)
{
  wxConfigPathChanger path(this, szKey);
  wxString strKey = GetPrivateKeyName(path.Name());

  bool bOk = WritePrivateProfileString(m_strGroup, strKey,
                                       szValue, m_strLocalFilename) != 0;

  if ( !bOk )
    wxLogLastError("WritePrivateProfileString");

  return bOk;
}

bool wxIniConfig::Write(const wxString& szKey, long lValue)
{
  // ltoa() is not ANSI :-(
  char szBuf[40];   // should be good for sizeof(long) <= 16 (128 bits)
  sprintf(szBuf, "%ld", lValue);

  return Write(szKey, szBuf);
}

bool wxIniConfig::Flush(bool /* bCurrentOnly */)
{
  // this is just the way it works
  return WritePrivateProfileString(NULL, NULL, NULL, m_strLocalFilename) != 0;
}

// ----------------------------------------------------------------------------
// delete
// ----------------------------------------------------------------------------

bool wxIniConfig::DeleteEntry(const wxString& szKey, bool bGroupIfEmptyAlso)
{
  // passing NULL as value to WritePrivateProfileString deletes the key
//  if ( !Write(szKey, (const char *)NULL) )
//    return FALSE;
  wxConfigPathChanger path(this, szKey);
  wxString strKey = GetPrivateKeyName(path.Name());

  if (WritePrivateProfileString(m_strGroup, szKey,
                                         (const char*) NULL, m_strLocalFilename) == 0)
    return FALSE;

  if ( !bGroupIfEmptyAlso || !IsEmpty() )
    return TRUE;

  // delete the current group too
  bool bOk = WritePrivateProfileString(m_strGroup, NULL,
                                       NULL, m_strLocalFilename) != 0;

  if ( !bOk )
    wxLogLastError("WritePrivateProfileString");

  return bOk;
}

bool wxIniConfig::DeleteGroup(const wxString& szKey)
{
  wxConfigPathChanger path(this, szKey);

  // passing NULL as section name to WritePrivateProfileString deletes the
  // whole section according to the docs
  bool bOk = WritePrivateProfileString(path.Name(), NULL,
                                       NULL, m_strLocalFilename) != 0;

  if ( !bOk )
    wxLogLastError("WritePrivateProfileString");

  return bOk;
}

#ifndef MAX_PATH
#define MAX_PATH 256
#endif

bool wxIniConfig::DeleteAll()
{
  // first delete our group in win.ini
  WriteProfileString(GetVendorName(), NULL, NULL);

  // then delete our own ini file
  char szBuf[MAX_PATH];
  size_t nRc = GetWindowsDirectory(szBuf, WXSIZEOF(szBuf));
  if ( nRc == 0 )
    wxLogLastError("GetWindowsDirectory");
  else if ( nRc > WXSIZEOF(szBuf) )
    wxFAIL_MSG("buffer is too small for Windows directory.");

  wxString strFile = szBuf;
  strFile << '\\' << m_strLocalFilename;

  if ( !wxRemoveFile(strFile) ) {
    wxLogSysError(_("Can't delete the INI file '%s'"), strFile.c_str());
    return FALSE;
  }

  return TRUE;
}

bool wxIniConfig::RenameEntry(const wxString& oldName, const wxString& newName)
{
    // Not implemented
    return FALSE;
}

bool wxIniConfig::RenameGroup(const wxString& oldName, const wxString& newName)
{
    // Not implemented
    return FALSE;
}
Commit	Line	Data
	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: src/msw/iniconf.cpp
	3	// Purpose: implementation of wxIniConfig class
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 27.07.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 "iniconf.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	#include <wx/event.h>
	27	#include <wx/app.h>
	28	#include <wx/utils.h>
	29	#endif //WX_PRECOMP
	30
	31	#include <wx/dynarray.h>
	32	#include <wx/log.h>
	33	#include <wx/config.h>
	34
	35	#include <wx/msw/iniconf.h>
	36
	37	// _WINDOWS_ is defined when windows.h is included,
	38	// __WXMSW__ is defined for MS Windows compilation
	39	#if defined(__WXMSW__) && !defined(_WINDOWS_)
	40	#include <windows.h>
	41	#endif //windows.h
	42
	43	// ----------------------------------------------------------------------------
	44	// constants
	45	// ----------------------------------------------------------------------------
	46
	47	// we replace all path separators with this character
	48	#define PATH_SEP_REPLACE '_'
	49
	50	// ============================================================================
	51	// implementation
	52	// ============================================================================
	53
	54	// ----------------------------------------------------------------------------
	55	// ctor & dtor
	56	// ----------------------------------------------------------------------------
	57
	58	wxIniConfig::wxIniConfig(const wxString& strAppName, const wxString& strVendor,
	59	const wxString& localFilename, const wxString& globalFilename, long style):
	60	wxConfigBase(strAppName, strVendor, localFilename, globalFilename, style)
	61	{
	62	if ( GetAppName().IsEmpty() )
	63	{
	64	wxString app;
	65	if (wxTheApp)
	66	app = wxTheApp->GetAppName();
	67	wxASSERT( !app.IsEmpty() );
	68	SetAppName(app);
	69	}
	70
	71	// Vendor name is required in wxIniConfig.
	72	// TODO: should it be required? Why isn't appName used instead? -- JACS
	73	if ( GetVendorName().IsEmpty() )
	74	{
	75	wxString vendor;
	76	if (wxTheApp)
	77	vendor = wxTheApp->GetVendorName();
	78	else
	79	vendor = strAppName;
	80	SetVendorName(vendor);
	81	}
	82
	83	m_strLocalFilename = localFilename;
	84	if (m_strLocalFilename.IsEmpty())
	85	{
	86	m_strLocalFilename = GetAppName() + ".ini";
	87	}
	88
	89	// append the extension if none given and it's not an absolute file name
	90	// (otherwise we assume that they know what they're doing)
	91	if ( !wxIsPathSeparator(m_strLocalFilename[0u]) &&
	92	m_strLocalFilename.Find('.') == wxNOT_FOUND )
	93	{
	94	m_strLocalFilename << ".ini";
	95	}
	96
	97	// set root path
	98	SetPath("");
	99	}
	100
	101	wxIniConfig::~wxIniConfig()
	102	{
	103	}
	104
	105	// ----------------------------------------------------------------------------
	106	// path management
	107	// ----------------------------------------------------------------------------
	108
	109	void wxIniConfig::SetPath(const wxString& strPath)
	110	{
	111	wxArrayString aParts;
	112
	113	if ( strPath.IsEmpty() ) {
	114	// nothing
	115	}
	116	else if ( strPath[0u] == wxCONFIG_PATH_SEPARATOR ) {
	117	// absolute path
	118	wxSplitPath(aParts, strPath);
	119	}
	120	else {
	121	// relative path, combine with current one
	122	wxString strFullPath = GetPath();
	123	strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
	124	wxSplitPath(aParts, strFullPath);
	125	}
	126
	127	size_t nPartsCount = aParts.Count();
	128	m_strPath.Empty();
	129	if ( nPartsCount == 0 ) {
	130	// go to the root
	131	m_strGroup = PATH_SEP_REPLACE;
	132	}
	133	else {
	134	// translate
	135	m_strGroup = aParts[0u];
	136	for ( size_t nPart = 1; nPart < nPartsCount; nPart++ ) {
	137	if ( nPart > 1 )
	138	m_strPath << PATH_SEP_REPLACE;
	139	m_strPath << aParts[nPart];
	140	}
	141	}
	142
	143	// other functions assume that all this is true, i.e. there are no trailing
	144	// underscores at the end except if the group is the root one
	145	wxASSERT( (m_strPath.IsEmpty() \|\| m_strPath.Last() != PATH_SEP_REPLACE) &&
	146	(m_strGroup == wxString(PATH_SEP_REPLACE) \|\|
	147	m_strGroup.Last() != PATH_SEP_REPLACE) );
	148	}
	149
	150	const wxString& wxIniConfig::GetPath() const
	151	{
	152	static wxString s_str;
	153
	154	// always return abs path
	155	s_str = wxCONFIG_PATH_SEPARATOR;
	156
	157	if ( m_strGroup == wxString(PATH_SEP_REPLACE) ) {
	158	// we're at the root level, nothing to do
	159	}
	160	else {
	161	s_str << m_strGroup;
	162	if ( !m_strPath.IsEmpty() )
	163	s_str << wxCONFIG_PATH_SEPARATOR;
	164	for ( const char p = m_strPath; p != '\0'; p++ ) {
	165	s_str << (p == PATH_SEP_REPLACE ? wxCONFIG_PATH_SEPARATOR : p);
	166	}
	167	}
	168
	169	return s_str;
	170	}
	171
	172	wxString wxIniConfig::GetPrivateKeyName(const wxString& szKey) const
	173	{
	174	wxString strKey;
	175
	176	if ( !m_strPath.IsEmpty() )
	177	strKey << m_strPath << PATH_SEP_REPLACE;
	178
	179	strKey << szKey;
	180
	181	return strKey;
	182	}
	183
	184	wxString wxIniConfig::GetKeyName(const wxString& szKey) const
	185	{
	186	wxString strKey;
	187
	188	if ( m_strGroup != wxString(PATH_SEP_REPLACE) )
	189	strKey << m_strGroup << PATH_SEP_REPLACE;
	190	if ( !m_strPath.IsEmpty() )
	191	strKey << m_strPath << PATH_SEP_REPLACE;
	192
	193	strKey << szKey;
	194
	195	return strKey;
	196	}
	197
	198	// ----------------------------------------------------------------------------
	199	// enumeration
	200	// ----------------------------------------------------------------------------
	201
	202	// not implemented
	203	bool wxIniConfig::GetFirstGroup(wxString& str, long& lIndex) const
	204	{
	205	wxFAIL_MSG("not implemented");
	206
	207	return FALSE;
	208	}
	209
	210	bool wxIniConfig::GetNextGroup (wxString& str, long& lIndex) const
	211	{
	212	wxFAIL_MSG("not implemented");
	213
	214	return FALSE;
	215	}
	216
	217	bool wxIniConfig::GetFirstEntry(wxString& str, long& lIndex) const
	218	{
	219	wxFAIL_MSG("not implemented");
	220
	221	return FALSE;
	222	}
	223
	224	bool wxIniConfig::GetNextEntry (wxString& str, long& lIndex) const
	225	{
	226	wxFAIL_MSG("not implemented");
	227
	228	return FALSE;
	229	}
	230
	231	// ----------------------------------------------------------------------------
	232	// misc info
	233	// ----------------------------------------------------------------------------
	234
	235	// not implemented
	236	size_t wxIniConfig::GetNumberOfEntries(bool bRecursive) const
	237	{
	238	wxFAIL_MSG("not implemented");
	239
	240	return (size_t)-1;
	241	}
	242
	243	size_t wxIniConfig::GetNumberOfGroups(bool bRecursive) const
	244	{
	245	wxFAIL_MSG("not implemented");
	246
	247	return (size_t)-1;
	248	}
	249
	250	bool wxIniConfig::HasGroup(const wxString& strName) const
	251	{
	252	wxFAIL_MSG("not implemented");
	253
	254	return FALSE;
	255	}
	256
	257	bool wxIniConfig::HasEntry(const wxString& strName) const
	258	{
	259	wxFAIL_MSG("not implemented");
	260
	261	return FALSE;
	262	}
	263
	264	// is current group empty?
	265	bool wxIniConfig::IsEmpty() const
	266	{
	267	char szBuf[1024];
	268
	269	GetPrivateProfileString(m_strGroup, NULL, "",
	270	szBuf, WXSIZEOF(szBuf), m_strLocalFilename);
	271	if ( !::IsEmpty(szBuf) )
	272	return FALSE;
	273
	274	GetProfileString(m_strGroup, NULL, "", szBuf, WXSIZEOF(szBuf));
	275	if ( !::IsEmpty(szBuf) )
	276	return FALSE;
	277
	278	return TRUE;
	279	}
	280
	281	// ----------------------------------------------------------------------------
	282	// read/write
	283	// ----------------------------------------------------------------------------
	284
	285	bool wxIniConfig::Read(const wxString& szKey, wxString *pstr) const
	286	{
	287	wxConfigPathChanger path(this, szKey);
	288	wxString strKey = GetPrivateKeyName(path.Name());
	289
	290	char szBuf[1024]; // @@ should dynamically allocate memory...
	291
	292	// first look in the private INI file
	293
	294	// NB: the lpDefault param to GetPrivateProfileString can't be NULL
	295	GetPrivateProfileString(m_strGroup, strKey, "",
	296	szBuf, WXSIZEOF(szBuf), m_strLocalFilename);
	297	if ( ::IsEmpty(szBuf) ) {
	298	// now look in win.ini
	299	wxString strKey = GetKeyName(path.Name());
	300	GetProfileString(m_strGroup, strKey, "", szBuf, WXSIZEOF(szBuf));
	301	}
	302
	303	if ( ::IsEmpty(szBuf) ) {
	304	return FALSE;
	305	}
	306	else {
	307	return TRUE;
	308	}
	309	}
	310
	311	bool wxIniConfig::Read(const wxString& szKey, wxString *pstr,
	312	const wxString& szDefault) const
	313	{
	314	wxConfigPathChanger path(this, szKey);
	315	wxString strKey = GetPrivateKeyName(path.Name());
	316
	317	char szBuf[1024]; // @@ should dynamically allocate memory...
	318
	319	// first look in the private INI file
	320
	321	// NB: the lpDefault param to GetPrivateProfileString can't be NULL
	322	GetPrivateProfileString(m_strGroup, strKey, "",
	323	szBuf, WXSIZEOF(szBuf), m_strLocalFilename);
	324	if ( ::IsEmpty(szBuf) ) {
	325	// now look in win.ini
	326	wxString strKey = GetKeyName(path.Name());
	327	GetProfileString(m_strGroup, strKey, "", szBuf, WXSIZEOF(szBuf));
	328	}
	329
	330	if ( ::IsEmpty(szBuf) ) {
	331	*pstr = szDefault;
	332	return FALSE;
	333	}
	334	else {
	335	return TRUE;
	336	}
	337	}
	338
	339	bool wxIniConfig::Read(const wxString& szKey, long *pl) const
	340	{
	341	wxConfigPathChanger path(this, szKey);
	342	wxString strKey = GetPrivateKeyName(path.Name());
	343
	344	// hack: we have no mean to know if it really found the default value or
	345	// didn't find anything, so we call it twice
	346
	347	static const int nMagic = 17; // 17 is some "rare" number
	348	static const int nMagic2 = 28; // arbitrary number != nMagic
	349	long lVal = GetPrivateProfileInt(m_strGroup, strKey, nMagic, m_strLocalFilename);
	350	if ( lVal != nMagic ) {
	351	// the value was read from the file
	352	*pl = lVal;
	353	return TRUE;
	354	}
	355
	356	// is it really nMagic?
	357	lVal = GetPrivateProfileInt(m_strGroup, strKey, nMagic2, m_strLocalFilename);
	358	if ( lVal == nMagic2 ) {
	359	// the nMagic it returned was indeed read from the file
	360	*pl = lVal;
	361	return TRUE;
	362	}
	363
	364	// no, it was just returning the default value, so now look in win.ini
	365	pl = GetProfileInt(GetVendorName(), GetKeyName(szKey), pl);
	366
	367	return TRUE;
	368	}
	369
	370	bool wxIniConfig::Write(const wxString& szKey, const wxString& szValue)
	371	{
	372	wxConfigPathChanger path(this, szKey);
	373	wxString strKey = GetPrivateKeyName(path.Name());
	374
	375	bool bOk = WritePrivateProfileString(m_strGroup, strKey,
	376	szValue, m_strLocalFilename) != 0;
	377
	378	if ( !bOk )
	379	wxLogLastError("WritePrivateProfileString");
	380
	381	return bOk;
	382	}
	383
	384	bool wxIniConfig::Write(const wxString& szKey, long lValue)
	385	{
	386	// ltoa() is not ANSI :-(
	387	char szBuf[40]; // should be good for sizeof(long) <= 16 (128 bits)
	388	sprintf(szBuf, "%ld", lValue);
	389
	390	return Write(szKey, szBuf);
	391	}
	392
	393	bool wxIniConfig::Flush(bool /* bCurrentOnly */)
	394	{
	395	// this is just the way it works
	396	return WritePrivateProfileString(NULL, NULL, NULL, m_strLocalFilename) != 0;
	397	}
	398
	399	// ----------------------------------------------------------------------------
	400	// delete
	401	// ----------------------------------------------------------------------------
	402
	403	bool wxIniConfig::DeleteEntry(const wxString& szKey, bool bGroupIfEmptyAlso)
	404	{
	405	// passing NULL as value to WritePrivateProfileString deletes the key
	406	// if ( !Write(szKey, (const char *)NULL) )
	407	// return FALSE;
	408	wxConfigPathChanger path(this, szKey);
	409	wxString strKey = GetPrivateKeyName(path.Name());
	410
	411	if (WritePrivateProfileString(m_strGroup, szKey,
	412	(const char*) NULL, m_strLocalFilename) == 0)
	413	return FALSE;
	414
	415	if ( !bGroupIfEmptyAlso \|\| !IsEmpty() )
	416	return TRUE;
	417
	418	// delete the current group too
	419	bool bOk = WritePrivateProfileString(m_strGroup, NULL,
	420	NULL, m_strLocalFilename) != 0;
	421
	422	if ( !bOk )
	423	wxLogLastError("WritePrivateProfileString");
	424
	425	return bOk;
	426	}
	427
	428	bool wxIniConfig::DeleteGroup(const wxString& szKey)
	429	{
	430	wxConfigPathChanger path(this, szKey);
	431
	432	// passing NULL as section name to WritePrivateProfileString deletes the
	433	// whole section according to the docs
	434	bool bOk = WritePrivateProfileString(path.Name(), NULL,
	435	NULL, m_strLocalFilename) != 0;
	436
	437	if ( !bOk )
	438	wxLogLastError("WritePrivateProfileString");
	439
	440	return bOk;
	441	}
	442
	443	#ifndef MAX_PATH
	444	#define MAX_PATH 256
	445	#endif
	446
	447	bool wxIniConfig::DeleteAll()
	448	{
	449	// first delete our group in win.ini
	450	WriteProfileString(GetVendorName(), NULL, NULL);
	451
	452	// then delete our own ini file
	453	char szBuf[MAX_PATH];
	454	size_t nRc = GetWindowsDirectory(szBuf, WXSIZEOF(szBuf));
	455	if ( nRc == 0 )
	456	wxLogLastError("GetWindowsDirectory");
	457	else if ( nRc > WXSIZEOF(szBuf) )
	458	wxFAIL_MSG("buffer is too small for Windows directory.");
	459
	460	wxString strFile = szBuf;
	461	strFile << '\\' << m_strLocalFilename;
	462
	463	if ( !wxRemoveFile(strFile) ) {
	464	wxLogSysError(_("Can't delete the INI file '%s'"), strFile.c_str());
	465	return FALSE;
	466	}
	467
	468	return TRUE;
	469	}
	470
	471	bool wxIniConfig::RenameEntry(const wxString& oldName, const wxString& newName)
	472	{
	473	// Not implemented
	474	return FALSE;
	475	}
	476
	477	bool wxIniConfig::RenameGroup(const wxString& oldName, const wxString& newName)
	478	{
	479	// Not implemented
	480	return FALSE;
	481	}