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