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