src/msw/iniconf.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        src/msw/iniconf.cpp
// Purpose:     implementation of wxIniConfig class
// Author:      Vadim Zeitlin
// Modified by:
// Created:     27.07.98
// 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.t_str(), NULL, wxT(""),
                            szBuf, WXSIZEOF(szBuf),
                            m_strLocalFilename.t_str());
    if ( !wxIsEmpty(szBuf) )
        return false;

    GetProfileString(m_strGroup.t_str(), NULL, wxT(""), 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.t_str(), strKey.t_str(), wxT(""),
                          szBuf, WXSIZEOF(szBuf),
                          m_strLocalFilename.t_str());
  if ( wxIsEmpty(szBuf) ) {
    // now look in win.ini
    wxString strKey = GetKeyName(path.Name());
    GetProfileString(m_strGroup.t_str(), strKey.t_str(),
                     wxT(""), 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.t_str(), strKey.t_str(),
                                   nMagic, m_strLocalFilename.t_str());
  if ( lVal != nMagic ) {
    // the value was read from the file
    *pl = lVal;
    return true;
  }

  // is it really nMagic?
  lVal = GetPrivateProfileInt(m_strGroup.t_str(), strKey.t_str(),
                              nMagic2, m_strLocalFilename.t_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.t_str(), strKey.t_str(),
                                       szValue.t_str(),
                                       m_strLocalFilename.t_str()) != 0;

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

  return bOk;
}

bool wxIniConfig::DoWriteLong(const wxString& szKey, long lValue)
{
  return Write(szKey, wxString::Format(wxT("%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.t_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.t_str(), strKey.t_str(),
                                NULL, m_strLocalFilename.t_str()) == 0)
    return false;

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

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