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 #include  <wx/dynarray.h>
  32 #include  <wx/log.h>
  33 #include  <wx/config.h>
  34
  35 #include  <wx/msw/iniconf.h>
  36
  37 // _WINDOWS_ is defined when windows.h is included,
  38 // __WXMSW__ is defined for MS Windows compilation
  39 #if       defined(__WXMSW__) && !defined(_WINDOWS_)
  40   #include  <windows.h>
  41 #endif  //windows.h
  42
  43 // ----------------------------------------------------------------------------
  44 // constants
  45 // ----------------------------------------------------------------------------
  46
  47 // we replace all path separators with this character
  48 #define PATH_SEP_REPLACE  '_'
  49
  50 // ============================================================================
  51 // implementation
  52 // ============================================================================
  53
  54 // ----------------------------------------------------------------------------
  55 // ctor & dtor
  56 // ----------------------------------------------------------------------------
  57
  58 wxIniConfig::wxIniConfig(const wxString& strAppName, const wxString& strVendor,
  59     const wxString& localFilename, const wxString& globalFilename, long style):
  60      wxConfigBase(strAppName, strVendor, localFilename, globalFilename, style)
  61 {
  62     if ( GetAppName().IsEmpty() )
  63     {
  64         wxString app;
  65         if (wxTheApp)
  66             app = wxTheApp->GetAppName();
  67         wxASSERT( !app.IsEmpty() );
  68         SetAppName(app);
  69     }
  70
  71     // Vendor name is required in wxIniConfig.
  72     // TODO: should it be required? Why isn't appName used instead? -- JACS
  73     if ( GetVendorName().IsEmpty() )
  74     {
  75         wxString vendor;
  76         if (wxTheApp)
  77             vendor = wxTheApp->GetVendorName();
  78         else
  79             vendor = strAppName;
  80         SetVendorName(vendor);
  81     }
  82
  83     m_strLocalFilename = localFilename;
  84     if (m_strLocalFilename.IsEmpty())
  85     {
  86         m_strLocalFilename = GetAppName() + ".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('.') == wxNOT_FOUND )
  93     {
  94         m_strLocalFilename << ".ini";
  95     }
  96
  97     // set root path
  98     SetPath("");
  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   // no, it was just returning the default value, so now look in win.ini
 367   *pl = GetProfileInt(GetVendorName(), GetKeyName(szKey), *pl);
 368
 369   return TRUE;
 370 }
 371
 372 bool wxIniConfig::Write(const wxString& szKey, const wxString& szValue)
 373 {
 374   wxConfigPathChanger path(this, szKey);
 375   wxString strKey = GetPrivateKeyName(path.Name());
 376
 377   bool bOk = WritePrivateProfileString(m_strGroup, strKey,
 378                                        szValue, m_strLocalFilename) != 0;
 379
 380   if ( !bOk )
 381     wxLogLastError("WritePrivateProfileString");
 382
 383   return bOk;
 384 }
 385
 386 bool wxIniConfig::Write(const wxString& szKey, long lValue)
 387 {
 388   // ltoa() is not ANSI :-(
 389   char szBuf[40];   // should be good for sizeof(long) <= 16 (128 bits)
 390   sprintf(szBuf, "%ld", lValue);
 391
 392   return Write(szKey, szBuf);
 393 }
 394
 395 bool wxIniConfig::Flush(bool /* bCurrentOnly */)
 396 {
 397   // this is just the way it works
 398   return WritePrivateProfileString(NULL, NULL, NULL, m_strLocalFilename) != 0;
 399 }
 400
 401 // ----------------------------------------------------------------------------
 402 // delete
 403 // ----------------------------------------------------------------------------
 404
 405 bool wxIniConfig::DeleteEntry(const wxString& szKey, bool bGroupIfEmptyAlso)
 406 {
 407   // passing NULL as value to WritePrivateProfileString deletes the key
 408 //  if ( !Write(szKey, (const char *)NULL) )
 409 //    return FALSE;
 410   wxConfigPathChanger path(this, szKey);
 411   wxString strKey = GetPrivateKeyName(path.Name());
 412
 413   if (WritePrivateProfileString(m_strGroup, szKey,
 414                                          (const char*) NULL, m_strLocalFilename) == 0)
 415     return FALSE;
 416
 417   if ( !bGroupIfEmptyAlso || !IsEmpty() )
 418     return TRUE;
 419
 420   // delete the current group too
 421   bool bOk = WritePrivateProfileString(m_strGroup, NULL,
 422                                        NULL, m_strLocalFilename) != 0;
 423
 424   if ( !bOk )
 425     wxLogLastError("WritePrivateProfileString");
 426
 427   return bOk;
 428 }
 429
 430 bool wxIniConfig::DeleteGroup(const wxString& szKey)
 431 {
 432   wxConfigPathChanger path(this, szKey);
 433
 434   // passing NULL as section name to WritePrivateProfileString deletes the
 435   // whole section according to the docs
 436   bool bOk = WritePrivateProfileString(path.Name(), NULL,
 437                                        NULL, m_strLocalFilename) != 0;
 438
 439   if ( !bOk )
 440     wxLogLastError("WritePrivateProfileString");
 441
 442   return bOk;
 443 }
 444
 445 #ifndef MAX_PATH
 446 #define MAX_PATH 256
 447 #endif
 448
 449 bool wxIniConfig::DeleteAll()
 450 {
 451   // first delete our group in win.ini
 452   WriteProfileString(GetVendorName(), NULL, NULL);
 453
 454   // then delete our own ini file
 455   char szBuf[MAX_PATH];
 456   size_t nRc = GetWindowsDirectory(szBuf, WXSIZEOF(szBuf));
 457   if ( nRc == 0 )
 458     wxLogLastError("GetWindowsDirectory");
 459   else if ( nRc > WXSIZEOF(szBuf) )
 460     wxFAIL_MSG("buffer is too small for Windows directory.");
 461
 462   wxString strFile = szBuf;
 463   strFile << '\\' << m_strLocalFilename;
 464
 465   if ( !wxRemoveFile(strFile) ) {
 466     wxLogSysError(_("Can't delete the INI file '%s'"), strFile.c_str());
 467     return FALSE;
 468   }
 469
 470   return TRUE;
 471 }
 472
 473 bool wxIniConfig::RenameEntry(const wxString& oldName, const wxString& newName)
 474 {
 475     // Not implemented
 476     return FALSE;
 477 }
 478
 479 bool wxIniConfig::RenameGroup(const wxString& oldName, const wxString& newName)
 480 {
 481     // Not implemented
 482     return FALSE;
 483 }