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

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

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_INICONF

#ifndef   WX_PRECOMP
    #include "wx/msw/wrapwin.h"
    #include "wx/dynarray.h"
    #include "wx/string.h"
    #include "wx/intl.h"
    #include "wx/event.h"
    #include "wx/app.h"
    #include "wx/utils.h"
    #include "wx/log.h"
#endif  //WX_PRECOMP

#include  "wx/config.h"
#include  "wx/file.h"

#include  "wx/msw/iniconf.h"

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

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

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

// ----------------------------------------------------------------------------
// ctor & dtor
// ----------------------------------------------------------------------------
IMPLEMENT_ABSTRACT_CLASS(wxIniConfig, wxConfigBase)

wxIniConfig::wxIniConfig(const wxString& strAppName,
                         const wxString& strVendor,
                         const wxString& localFilename,
                         const wxString& globalFilename,
                         long style)
           : wxConfigBase(strAppName, strVendor, localFilename, globalFilename, style)

#if 0 // This is too complex for some compilers, e.g. BC++ 5.01
           : wxConfigBase((strAppName.empty() && wxTheApp) ? wxTheApp->GetAppName()
                                               : strAppName,
                          strVendor.empty() ? (wxTheApp ? wxTheApp->GetVendorName()
                                                  : strAppName)
                                      : strVendor,
                          localFilename, globalFilename, style)
#endif
{
    if (strAppName.empty() && wxTheApp)
        SetAppName(wxTheApp->GetAppName());
    if (strVendor.empty() && wxTheApp)
        SetVendorName(wxTheApp->GetVendorName());

    m_strLocalFilename = localFilename;
    if (m_strLocalFilename.empty())
    {
        m_strLocalFilename = GetAppName() + wxT(".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(wxT('.')) == wxNOT_FOUND )
    {
        m_strLocalFilename << wxT(".ini");
    }

    // set root path
    SetPath(wxEmptyString);
}

wxIniConfig::~wxIniConfig()
{
}

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

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

  if ( strPath.empty() ) {
    // 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.empty() || 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.empty() )
      s_str << wxCONFIG_PATH_SEPARATOR;
    for ( const wxStringCharType *p = m_strPath.wx_str(); *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.empty() )
    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.empty() )
    strKey << m_strPath << PATH_SEP_REPLACE;

  strKey << szKey;

  return strKey;
}

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

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

    return false;
}

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

    return false;
}

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

    return false;
}

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

    return false;
}

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

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

    return (size_t)-1;
}

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

    return (size_t)-1;
}

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

    return false;
}

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

    return false;
}

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

    GetPrivateProfileString(m_strGroup.wx_str(), NULL, _T(""),
                            szBuf, WXSIZEOF(szBuf),
                            m_strLocalFilename.wx_str());
    if ( !wxIsEmpty(szBuf) )
        return false;

    GetProfileString(m_strGroup.wx_str(), NULL, _T(""), szBuf, WXSIZEOF(szBuf));
    if ( !wxIsEmpty(szBuf) )
        return false;

    return true;
}

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

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

  wxChar szBuf[1024]; // FIXME: should dynamically allocate memory...

  // first look in the private INI file

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

  if ( wxIsEmpty(szBuf) )
    return false;

  *pstr = szBuf;
  return true;
}

bool wxIniConfig::DoReadLong(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.wx_str(), strKey.wx_str(),
                                   nMagic, m_strLocalFilename.wx_str());
  if ( lVal != nMagic ) {
    // the value was read from the file
    *pl = lVal;
    return true;
  }

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

  // CS : I have no idea why they should look up in win.ini
  // and if at all they have to do the same procedure using the two magic numbers
  // otherwise it always returns true, even if the key was not there at all
#if 0
  // no, it was just returning the default value, so now look in win.ini
 *pl = GetProfileInt(GetVendorName(), GetKeyName(szKey), *pl);

  return true;
#endif
  return false ;
}

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

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

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

  return bOk;
}

bool wxIniConfig::DoWriteLong(const wxString& szKey, long lValue)
{
  return Write(szKey, wxString::Format(_T("%ld"), lValue));
}

bool wxIniConfig::DoReadBinary(const wxString& WXUNUSED(key),
                               wxMemoryBuffer * WXUNUSED(buf)) const
{
    wxFAIL_MSG("not implemented");

    return false;
}

bool wxIniConfig::DoWriteBinary(const wxString& WXUNUSED(key),
                                const wxMemoryBuffer& WXUNUSED(buf))
{
    wxFAIL_MSG("not implemented");

    return false;
}

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

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

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

  if (WritePrivateProfileString(m_strGroup.wx_str(), strKey.wx_str(),
                                NULL, m_strLocalFilename.wx_str()) == 0)
    return false;

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

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

  if ( !bOk )
    wxLogLastError(wxT("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().wx_str(), NULL,
                                       NULL, m_strLocalFilename.wx_str()) != 0;

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

  return bOk;
}

#ifndef MAX_PATH
#define MAX_PATH 256
#endif

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

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

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

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

  return true;
}

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

bool wxIniConfig::RenameGroup(const wxString& WXUNUSED(oldName),
                              const wxString& WXUNUSED(newName))
{
    // Not implemented
    return false;
}

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