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::Read(const wxString& szKey, wxString *pstr) const
 286 {
 287   wxConfigPathChanger path(this, szKey);
 288   wxString strKey = GetPrivateKeyName(path.Name());
 289
 290   char szBuf[1024]; // @@ should dynamically allocate memory...
 291
 292   // first look in the private INI file
 293
 294   // NB: the lpDefault param to GetPrivateProfileString can't be NULL
 295   GetPrivateProfileString(m_strGroup, strKey, "",
 296                           szBuf, WXSIZEOF(szBuf), m_strLocalFilename);
 297   if ( ::IsEmpty(szBuf) ) {
 298     // now look in win.ini
 299     wxString strKey = GetKeyName(path.Name());
 300     GetProfileString(m_strGroup, strKey, "", szBuf, WXSIZEOF(szBuf));
 301   }
 302
 303   if ( ::IsEmpty(szBuf) ) {
 304     return FALSE;
 305   }
 306   else {
 307     *pstr = szBuf ;
 308     return TRUE;
 309   }
 310 }
 311
 312 bool wxIniConfig::Read(const wxString& szKey, wxString *pstr,
 313                        const wxString& szDefault) const
 314 {
 315   wxConfigPathChanger path(this, szKey);
 316   wxString strKey = GetPrivateKeyName(path.Name());
 317
 318   char szBuf[1024]; // @@ should dynamically allocate memory...
 319
 320   // first look in the private INI file
 321
 322   // NB: the lpDefault param to GetPrivateProfileString can't be NULL
 323   GetPrivateProfileString(m_strGroup, strKey, "",
 324                           szBuf, WXSIZEOF(szBuf), m_strLocalFilename);
 325   if ( ::IsEmpty(szBuf) ) {
 326     // now look in win.ini
 327     wxString strKey = GetKeyName(path.Name());
 328     GetProfileString(m_strGroup, strKey, "", szBuf, WXSIZEOF(szBuf));
 329   }
 330
 331   if ( ::IsEmpty(szBuf) ) {
 332     *pstr = szDefault;
 333     return FALSE;
 334   }
 335   else {
 336     *pstr = szBuf ;
 337     return TRUE;
 338   }
 339 }
 340
 341 bool wxIniConfig::Read(const wxString& szKey, long *pl) const
 342 {
 343   wxConfigPathChanger path(this, szKey);
 344   wxString strKey = GetPrivateKeyName(path.Name());
 345
 346   // hack: we have no mean to know if it really found the default value or
 347   // didn't find anything, so we call it twice
 348
 349   static const int nMagic  = 17; // 17 is some "rare" number
 350   static const int nMagic2 = 28; // arbitrary number != nMagic
 351   long lVal = GetPrivateProfileInt(m_strGroup, strKey, nMagic, m_strLocalFilename);
 352   if ( lVal != nMagic ) {
 353     // the value was read from the file
 354     *pl = lVal;
 355     return TRUE;
 356   }
 357
 358   // is it really nMagic?
 359   lVal = GetPrivateProfileInt(m_strGroup, strKey, nMagic2, m_strLocalFilename);
 360   if ( lVal != nMagic2 ) {
 361     // the nMagic it returned was indeed read from the file
 362     *pl = lVal;
 363     return TRUE;
 364   }
 365
 366   // CS : I have no idea why they should look up in win.ini
 367   // and if at all they have to do the same procedure using the two magic numbers
 368   // otherwise it always returns true, even if the key was not there at all
 369 #if 0
 370   // no, it was just returning the default value, so now look in win.ini
 371  *pl = GetProfileInt(GetVendorName(), GetKeyName(szKey), *pl);
 372
 373   return TRUE;
 374 #endif
 375   return FALSE ;
 376 }
 377
 378 bool wxIniConfig::Write(const wxString& szKey, const wxString& szValue)
 379 {
 380   wxConfigPathChanger path(this, szKey);
 381   wxString strKey = GetPrivateKeyName(path.Name());
 382
 383   bool bOk = WritePrivateProfileString(m_strGroup, strKey,
 384                                        szValue, m_strLocalFilename) != 0;
 385
 386   if ( !bOk )
 387     wxLogLastError(wxT("WritePrivateProfileString"));
 388
 389   return bOk;
 390 }
 391
 392 bool wxIniConfig::Write(const wxString& szKey, long lValue)
 393 {
 394   // ltoa() is not ANSI :-(
 395   char szBuf[40];   // should be good for sizeof(long) <= 16 (128 bits)
 396   sprintf(szBuf, "%ld", lValue);
 397
 398   return Write(szKey, szBuf);
 399 }
 400
 401 bool wxIniConfig::Flush(bool /* bCurrentOnly */)
 402 {
 403   // this is just the way it works
 404   return WritePrivateProfileString(NULL, NULL, NULL, m_strLocalFilename) != 0;
 405 }
 406
 407 // ----------------------------------------------------------------------------
 408 // delete
 409 // ----------------------------------------------------------------------------
 410
 411 bool wxIniConfig::DeleteEntry(const wxString& szKey, bool bGroupIfEmptyAlso)
 412 {
 413   // passing NULL as value to WritePrivateProfileString deletes the key
 414 //  if ( !Write(szKey, (const char *)NULL) )
 415 //    return FALSE;
 416   wxConfigPathChanger path(this, szKey);
 417   wxString strKey = GetPrivateKeyName(path.Name());
 418
 419   if (WritePrivateProfileString(m_strGroup, szKey,
 420                                          (const char*) NULL, m_strLocalFilename) == 0)
 421     return FALSE;
 422
 423   if ( !bGroupIfEmptyAlso || !IsEmpty() )
 424     return TRUE;
 425
 426   // delete the current group too
 427   bool bOk = WritePrivateProfileString(m_strGroup, NULL,
 428                                        NULL, m_strLocalFilename) != 0;
 429
 430   if ( !bOk )
 431     wxLogLastError(wxT("WritePrivateProfileString"));
 432
 433   return bOk;
 434 }
 435
 436 bool wxIniConfig::DeleteGroup(const wxString& szKey)
 437 {
 438   wxConfigPathChanger path(this, szKey);
 439
 440   // passing NULL as section name to WritePrivateProfileString deletes the
 441   // whole section according to the docs
 442   bool bOk = WritePrivateProfileString(path.Name(), NULL,
 443                                        NULL, m_strLocalFilename) != 0;
 444
 445   if ( !bOk )
 446     wxLogLastError(wxT("WritePrivateProfileString"));
 447
 448   return bOk;
 449 }
 450
 451 #ifndef MAX_PATH
 452 #define MAX_PATH 256
 453 #endif
 454
 455 bool wxIniConfig::DeleteAll()
 456 {
 457   // first delete our group in win.ini
 458   WriteProfileString(GetVendorName(), NULL, NULL);
 459
 460   // then delete our own ini file
 461   char szBuf[MAX_PATH];
 462   size_t nRc = GetWindowsDirectory(szBuf, WXSIZEOF(szBuf));
 463   if ( nRc == 0 )
 464   {
 465     wxLogLastError(wxT("GetWindowsDirectory"));
 466   }
 467   else if ( nRc > WXSIZEOF(szBuf) )
 468   {
 469     wxFAIL_MSG(wxT("buffer is too small for Windows directory."));
 470   }
 471
 472   wxString strFile = szBuf;
 473   strFile << '\\' << m_strLocalFilename;
 474
 475   if ( !wxRemoveFile(strFile) ) {
 476     wxLogSysError(_("Can't delete the INI file '%s'"), strFile.c_str());
 477     return FALSE;
 478   }
 479
 480   return TRUE;
 481 }
 482
 483 bool wxIniConfig::RenameEntry(const wxString& oldName, const wxString& newName)
 484 {
 485     // Not implemented
 486     return FALSE;
 487 }
 488
 489 bool wxIniConfig::RenameGroup(const wxString& oldName, const wxString& newName)
 490 {
 491     // Not implemented
 492     return FALSE;
 493 }
 494
 495 #endif
 496     // wxUSE_CONFIG && wxUSE_UNICODE