src/msw/iniconf.cpp

   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 // Doesn't yet compile in Unicode mode
  32
  33 #if wxUSE_CONFIG && !wxUSE_UNICODE
  34
  35 #include  "wx/dynarray.h"
  36 #include  "wx/log.h"
  37 #include  "wx/config.h"
  38
  39 #include  "wx/msw/iniconf.h"
  40
  41 // _WINDOWS_ is defined when windows.h is included,
  42 // __WXMSW__ is defined for MS Windows compilation
  43 #if       defined(__WXMSW__) && !defined(_WINDOWS_)
  44   #include  <windows.h>
  45 #endif  //windows.h
  46
  47 // ----------------------------------------------------------------------------
  48 // constants
  49 // ----------------------------------------------------------------------------
  50
  51 // we replace all path separators with this character
  52 #define PATH_SEP_REPLACE  '_'
  53
  54 // ============================================================================
  55 // implementation
  56 // ============================================================================
  57
  58 // ----------------------------------------------------------------------------
  59 // ctor & dtor
  60 // ----------------------------------------------------------------------------
  61
  62 wxIniConfig::wxIniConfig(const wxString& strAppName,
  63                          const wxString& strVendor,
  64                          const wxString& localFilename,
  65                          const wxString& globalFilename,
  66                          long style)
  67            : wxConfigBase(strAppName, strVendor, localFilename, globalFilename, style)
  68
  69 #if 0 // This is too complex for some compilers, e.g. BC++ 5.01
  70            : wxConfigBase((strAppName.IsEmpty() && wxTheApp) ? wxTheApp->GetAppName()
  71                                                : strAppName,
  72                           strVendor.IsEmpty() ? (wxTheApp ? wxTheApp->GetVendorName()
  73                                                   : strAppName)
  74                                       : strVendor,
  75                           localFilename, globalFilename, style)
  76 #endif
  77 {
  78     if (strAppName.IsEmpty() && wxTheApp)
  79         SetAppName(wxTheApp->GetAppName());
  80     if (strVendor.IsEmpty() && wxTheApp)
  81         SetVendorName(wxTheApp->GetVendorName());
  82
  83     m_strLocalFilename = localFilename;
  84     if (m_strLocalFilename.IsEmpty())
  85     {
  86         m_strLocalFilename = GetAppName() + wxT(".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(wxT('.')) == wxNOT_FOUND )
  93     {
  94         m_strLocalFilename << wxT(".ini");
  95     }
  96
  97     // set root path
  98     SetPath(wxT(""));
  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::DoReadString(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     *pstr = szBuf ;
 308     return TRUE;
 309   }
 310 }
 311
 312 bool wxIniConfig::DoReadLong(const wxString& szKey, long *pl) const
 313 {
 314   wxConfigPathChanger path(this, szKey);
 315   wxString strKey = GetPrivateKeyName(path.Name());
 316
 317   // hack: we have no mean to know if it really found the default value or
 318   // didn't find anything, so we call it twice
 319
 320   static const int nMagic  = 17; // 17 is some "rare" number
 321   static const int nMagic2 = 28; // arbitrary number != nMagic
 322   long lVal = GetPrivateProfileInt(m_strGroup, strKey, nMagic, m_strLocalFilename);
 323   if ( lVal != nMagic ) {
 324     // the value was read from the file
 325     *pl = lVal;
 326     return TRUE;
 327   }
 328
 329   // is it really nMagic?
 330   lVal = GetPrivateProfileInt(m_strGroup, strKey, nMagic2, m_strLocalFilename);
 331   if ( lVal != nMagic2 ) {
 332     // the nMagic it returned was indeed read from the file
 333     *pl = lVal;
 334     return TRUE;
 335   }
 336
 337   // CS : I have no idea why they should look up in win.ini
 338   // and if at all they have to do the same procedure using the two magic numbers
 339   // otherwise it always returns true, even if the key was not there at all
 340 #if 0
 341   // no, it was just returning the default value, so now look in win.ini
 342  *pl = GetProfileInt(GetVendorName(), GetKeyName(szKey), *pl);
 343
 344   return TRUE;
 345 #endif
 346   return FALSE ;
 347 }
 348
 349 bool wxIniConfig::DoWriteString(const wxString& szKey, const wxString& szValue)
 350 {
 351   wxConfigPathChanger path(this, szKey);
 352   wxString strKey = GetPrivateKeyName(path.Name());
 353
 354   bool bOk = WritePrivateProfileString(m_strGroup, strKey,
 355                                        szValue, m_strLocalFilename) != 0;
 356
 357   if ( !bOk )
 358     wxLogLastError(wxT("WritePrivateProfileString"));
 359
 360   return bOk;
 361 }
 362
 363 bool wxIniConfig::DoWriteLong(const wxString& szKey, long lValue)
 364 {
 365   // ltoa() is not ANSI :-(
 366   char szBuf[40];   // should be good for sizeof(long) <= 16 (128 bits)
 367   sprintf(szBuf, "%ld", lValue);
 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 }
 377
 378 // ----------------------------------------------------------------------------
 379 // delete
 380 // ----------------------------------------------------------------------------
 381
 382 bool wxIniConfig::DeleteEntry(const wxString& szKey, bool bGroupIfEmptyAlso)
 383 {
 384   // passing NULL as value to WritePrivateProfileString deletes the key
 385 //  if ( !Write(szKey, (const char *)NULL) )
 386 //    return FALSE;
 387   wxConfigPathChanger path(this, szKey);
 388   wxString strKey = GetPrivateKeyName(path.Name());
 389
 390   if (WritePrivateProfileString(m_strGroup, szKey,
 391                                          (const char*) NULL, m_strLocalFilename) == 0)
 392     return FALSE;
 393
 394   if ( !bGroupIfEmptyAlso || !IsEmpty() )
 395     return TRUE;
 396
 397   // delete the current group too
 398   bool bOk = WritePrivateProfileString(m_strGroup, NULL,
 399                                        NULL, m_strLocalFilename) != 0;
 400
 401   if ( !bOk )
 402     wxLogLastError(wxT("WritePrivateProfileString"));
 403
 404   return bOk;
 405 }
 406
 407 bool wxIniConfig::DeleteGroup(const wxString& szKey)
 408 {
 409   wxConfigPathChanger path(this, szKey);
 410
 411   // passing NULL as section name to WritePrivateProfileString deletes the
 412   // whole section according to the docs
 413   bool bOk = WritePrivateProfileString(path.Name(), NULL,
 414                                        NULL, m_strLocalFilename) != 0;
 415
 416   if ( !bOk )
 417     wxLogLastError(wxT("WritePrivateProfileString"));
 418
 419   return bOk;
 420 }
 421
 422 #ifndef MAX_PATH
 423 #define MAX_PATH 256
 424 #endif
 425
 426 bool wxIniConfig::DeleteAll()
 427 {
 428   // first delete our group in win.ini
 429   WriteProfileString(GetVendorName(), NULL, NULL);
 430
 431   // then delete our own ini file
 432   char szBuf[MAX_PATH];
 433   size_t nRc = GetWindowsDirectory(szBuf, WXSIZEOF(szBuf));
 434   if ( nRc == 0 )
 435   {
 436     wxLogLastError(wxT("GetWindowsDirectory"));
 437   }
 438   else if ( nRc > WXSIZEOF(szBuf) )
 439   {
 440     wxFAIL_MSG(wxT("buffer is too small for Windows directory."));
 441   }
 442
 443   wxString strFile = szBuf;
 444   strFile << '\\' << m_strLocalFilename;
 445
 446   if ( !wxRemoveFile(strFile) ) {
 447     wxLogSysError(_("Can't delete the INI file '%s'"), strFile.c_str());
 448     return FALSE;
 449   }
 450
 451   return TRUE;
 452 }
 453
 454 bool wxIniConfig::RenameEntry(const wxString& oldName, const wxString& newName)
 455 {
 456     // Not implemented
 457     return FALSE;
 458 }
 459
 460 bool wxIniConfig::RenameGroup(const wxString& oldName, const wxString& newName)
 461 {
 462     // Not implemented
 463     return FALSE;
 464 }
 465
 466 #endif
 467     // wxUSE_CONFIG && wxUSE_UNICODE