[wxWidgets.git] / src / os2 / iniconf.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        src/os2/iniconf.cpp
// Purpose:     implementation of wxIniConfig class
// Author:      David Webster
// Modified by:
// Created:     10/09/99
// Copyright:   David Webster
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

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

#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>
#if wxUSE_CONFIG

#include  <wx/os2/iniconf.h>

#define INCL_PM
#include  <os2.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 && wxTheApp ? wxTheApp->GetAppName()
                                               : strAppName,
                          !strVendor ? (wxTheApp ? wxTheApp->GetVendorName()
                                                  : strAppName)
                                      : strVendor,
                          localFilename, globalFilename, style)
{
    m_strLocalFilename = localFilename;
    if (m_strLocalFilename.IsEmpty())
    {
        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[(size_t) 0]) &&
        m_strLocalFilename.Find('.') == wxNOT_FOUND )
    {
        m_strLocalFilename << wxT(".ini");
    }

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

wxIniConfig::~wxIniConfig()
{
}

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

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

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

  size_t nPartsCount = aParts.Count();
  m_strPath.Empty();
  if ( nPartsCount == 0 ) {
    // go to the root
    m_strGroup = (wxChar*)PATH_SEP_REPLACE;
  }
  else {
    // translate
    m_strGroup = aParts[(size_t) 0];
    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((wxChar)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((wxChar)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 wxChar *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((wxChar)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(wxT("not implemeted"));

  return FALSE;
}

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

  return FALSE;
}

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

  return FALSE;
}

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

  return FALSE;
}

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

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

  return (size_t)-1;
}

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

  return (size_t)-1;
}

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

  return FALSE;
}

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

  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());

  wxChar 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((PSZ)szBuf) ) {
    // now look in win.ini
    wxString strKey = GetKeyName(path.Name());
//    GetProfileString(m_strGroup, strKey, "", szBuf, WXSIZEOF(szBuf));
  }

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

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

  wxChar 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((PSZ)szBuf) ) {
    // now look in win.ini
    wxString strKey = GetKeyName(path.Name());
//    GetProfileString(m_strGroup, strKey, "", szBuf, WXSIZEOF(szBuf));
  }

  if ( ::IsEmpty((PSZ)szBuf) ) {
    *pstr = szDefault;
    return FALSE;
  }
  else {
    *pstr = szBuf ;
    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 = 0; // = 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 = FALSE; // = 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 :-(
  wxChar szBuf[40];   // should be good for sizeof(long) <= 16 (128 bits)
  wxSprintf(szBuf, wxT("%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;
  return FALSE;
}

// ----------------------------------------------------------------------------
// 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 = FALSE; // = 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 = FALSE; // = 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
  wxChar szBuf[MAX_PATH];
  size_t nRc = 0; // = 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 << wxT('\\') << 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;
}

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