src/msw/regconf.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        msw/regconf.cpp
   3 // Purpose:
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     27.04.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 "regconf.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 #endif //WX_PRECOMP
  26
  27 #include "wx/event.h"
  28 #include "wx/app.h"
  29 #include "wx/log.h"
  30
  31 #if wxUSE_CONFIG
  32
  33 #include "wx/config.h"
  34
  35 #ifndef __WIN16__
  36
  37 #include "wx/msw/registry.h"
  38 #include "wx/msw/regconf.h"
  39
  40 // ----------------------------------------------------------------------------
  41 // constants
  42 // ----------------------------------------------------------------------------
  43
  44 // we put our data in HKLM\SOFTWARE_KEY\appname
  45 #define SOFTWARE_KEY    wxString("Software\\")
  46
  47 // ----------------------------------------------------------------------------
  48 // global functions
  49 // ----------------------------------------------------------------------------
  50
  51 // get the value if the key is opened and it exists
  52 bool TryGetValue(const wxRegKey& key, const wxString& str, wxString& strVal)
  53 {
  54   return key.IsOpened() && key.HasValue(str) && key.QueryValue(str, strVal);
  55 }
  56
  57 bool TryGetValue(const wxRegKey& key, const wxString& str, long *plVal)
  58 {
  59   return key.IsOpened() && key.HasValue(str) && key.QueryValue(str, plVal);
  60 }
  61
  62 // ============================================================================
  63 // implementation
  64 // ============================================================================
  65
  66 // ----------------------------------------------------------------------------
  67 // ctor/dtor
  68 // ----------------------------------------------------------------------------
  69
  70 // create the config object which stores its data under HKCU\vendor\app and, if
  71 // style & wxCONFIG_USE_GLOBAL_FILE, under HKLM\vendor\app
  72 wxRegConfig::wxRegConfig(const wxString& appName, const wxString& vendorName,
  73                          const wxString& strLocal, const wxString& strGlobal,
  74                          long style)
  75            : wxConfigBase(appName, vendorName, strLocal, strGlobal, style)
  76 {
  77   wxString strRoot;
  78
  79   bool bDoUseGlobal = (style & wxCONFIG_USE_GLOBAL_FILE) != 0;
  80
  81   // the convention is to put the programs keys under <vendor>\<appname>
  82   // (but it can be overriden by specifying the pathes explicitly in strLocal
  83   // and/or strGlobal)
  84   if ( strLocal.IsEmpty() || (strGlobal.IsEmpty() && bDoUseGlobal) )
  85   {
  86     if ( vendorName.IsEmpty() )
  87     {
  88       if ( wxTheApp )
  89         strRoot = wxTheApp->GetVendorName();
  90     }
  91     else
  92     {
  93       strRoot = vendorName;
  94     }
  95
  96     // no '\\' needed if no vendor name
  97     if ( !strRoot.IsEmpty() )
  98     {
  99       strRoot += '\\';
 100     }
 101
 102     if ( appName.IsEmpty() )
 103     {
 104       wxCHECK_RET( wxTheApp, wxT("No application name in wxRegConfig ctor!") );
 105       strRoot << wxTheApp->GetAppName();
 106     }
 107     else
 108     {
 109       strRoot << appName;
 110     }
 111   }
 112   //else: we don't need to do all the complicated stuff above
 113
 114   wxString str = strLocal.IsEmpty() ? strRoot : strLocal;
 115   m_keyLocalRoot.SetName(wxRegKey::HKCU, SOFTWARE_KEY + str);
 116   m_keyLocal.SetName(m_keyLocalRoot, "");
 117
 118   if ( bDoUseGlobal )
 119   {
 120     str = strGlobal.IsEmpty() ? strRoot : strGlobal;
 121     m_keyGlobalRoot.SetName(wxRegKey::HKLM, SOFTWARE_KEY + str);
 122     m_keyGlobal.SetName(m_keyGlobalRoot, "");
 123   }
 124
 125   // Create() will Open() if key already exists
 126   m_keyLocalRoot.Create();
 127
 128   // as it's the same key, Open() shouldn't fail (i.e. no need for Create())
 129   m_keyLocal.Open();
 130
 131   // OTOH, this key may perfectly not exist, so suppress error messages the call
 132   // to Open() might generate
 133   if ( bDoUseGlobal )
 134   {
 135     wxLogNull nolog;
 136     m_keyGlobalRoot.Open();
 137   }
 138 }
 139
 140 wxRegConfig::~wxRegConfig()
 141 {
 142   // nothing to do - key will be closed in their dtors
 143 }
 144
 145 // ----------------------------------------------------------------------------
 146 // path management
 147 // ----------------------------------------------------------------------------
 148 void wxRegConfig::SetPath(const wxString& strPath)
 149 {
 150   wxArrayString aParts;
 151
 152   // because GetPath() returns "" when we're at root, we must understand
 153   // empty string as "/"
 154   if ( strPath.IsEmpty() || (strPath[0] == wxCONFIG_PATH_SEPARATOR) ) {
 155     // absolute path
 156     wxSplitPath(aParts, strPath);
 157   }
 158   else {
 159     // relative path, combine with current one
 160     wxString strFullPath = GetPath();
 161     strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
 162     wxSplitPath(aParts, strFullPath);
 163   }
 164
 165   // recombine path parts in one variable
 166   wxString strOldPath = m_strPath, strRegPath;
 167   m_strPath.Empty();
 168   for ( size_t n = 0; n < aParts.Count(); n++ ) {
 169     strRegPath << '\\' << aParts[n];
 170     m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n];
 171   }
 172
 173   if ( m_strPath == strOldPath )
 174       return;
 175
 176   // as we create the registry key when SetPath(key) is done, we can be left
 177   // with plenty of empty keys if this was only done to try to read some value
 178   // which, in fact, doesn't exist - to prevent this from happening we
 179   // automatically delete the old key if it was empty
 180   if ( m_keyLocal.IsEmpty() )
 181   {
 182       m_keyLocal.DeleteSelf();
 183   }
 184
 185   // change current key(s)
 186   m_keyLocal.SetName(m_keyLocalRoot, strRegPath);
 187   m_keyGlobal.SetName(m_keyGlobalRoot, strRegPath);
 188   m_keyLocal.Create();
 189
 190   wxLogNull nolog;
 191   m_keyGlobal.Open();
 192 }
 193
 194 // ----------------------------------------------------------------------------
 195 // enumeration (works only with current group)
 196 // ----------------------------------------------------------------------------
 197
 198 /*
 199   We want to enumerate all local keys/values after the global ones, but, of
 200   course, we don't want to repeat a key which appears locally as well as
 201   globally twice.
 202
 203   We use the 15th bit of lIndex for distinction between global and local.
 204  */
 205
 206 #define LOCAL_MASK        0x8000
 207 #define IS_LOCAL_INDEX(l) (((l) & LOCAL_MASK) != 0)
 208
 209 bool wxRegConfig::GetFirstGroup(wxString& str, long& lIndex) const
 210 {
 211   lIndex = 0;
 212   return GetNextGroup(str, lIndex);
 213 }
 214
 215 bool wxRegConfig::GetNextGroup(wxString& str, long& lIndex) const
 216 {
 217   // are we already enumerating local entries?
 218   if ( m_keyGlobal.IsOpened() && !IS_LOCAL_INDEX(lIndex) ) {
 219     // try to find a global entry which doesn't appear locally
 220     while ( m_keyGlobal.GetNextKey(str, lIndex) ) {
 221       if ( !m_keyLocal.HasSubKey(str) ) {
 222         // ok, found one - return it
 223         return TRUE;
 224       }
 225     }
 226
 227     // no more global entries
 228     lIndex |= LOCAL_MASK;
 229   }
 230
 231   // much easier with local entries: get the next one we find
 232   // (don't forget to clear our flag bit and set it again later)
 233   lIndex &= ~LOCAL_MASK;
 234   bool bOk = m_keyLocal.GetNextKey(str, lIndex);
 235   lIndex |= LOCAL_MASK;
 236
 237   return bOk;
 238 }
 239
 240 bool wxRegConfig::GetFirstEntry(wxString& str, long& lIndex) const
 241 {
 242   lIndex = 0;
 243   return GetNextEntry(str, lIndex);
 244 }
 245
 246 bool wxRegConfig::GetNextEntry(wxString& str, long& lIndex) const
 247 {
 248   // are we already enumerating local entries?
 249   if ( m_keyGlobal.IsOpened() && !IS_LOCAL_INDEX(lIndex) ) {
 250     // try to find a global entry which doesn't appear locally
 251     do {
 252       if ( !m_keyGlobal.GetNextValue(str, lIndex) ) {
 253         // no more global entries
 254         lIndex |= LOCAL_MASK;
 255         break;
 256       }
 257     } while( m_keyLocal.HasValue(str) );
 258   }
 259
 260   // much easier with local entries: get the next one we find
 261   // (don't forget to clear our flag bit and set it again later)
 262   lIndex &= ~LOCAL_MASK;
 263   bool bOk = m_keyLocal.GetNextValue(str, lIndex);
 264   lIndex |= LOCAL_MASK;
 265
 266   return bOk;
 267 }
 268
 269 size_t wxRegConfig::GetNumberOfEntries(bool bRecursive) const
 270 {
 271   size_t nEntries = 0;
 272
 273   // dummy vars
 274   wxString str;
 275   long l;
 276   bool bCont = ((wxRegConfig*)this)->GetFirstEntry(str, l);
 277   while ( bCont ) {
 278     nEntries++;
 279
 280     bCont = ((wxRegConfig*)this)->GetNextEntry(str, l);
 281   }
 282
 283   return nEntries;
 284 }
 285
 286 size_t wxRegConfig::GetNumberOfGroups(bool bRecursive) const
 287 {
 288   size_t nGroups = 0;
 289
 290   // dummy vars
 291   wxString str;
 292   long l;
 293   bool bCont = ((wxRegConfig*)this)->GetFirstGroup(str, l);
 294   while ( bCont ) {
 295     nGroups++;
 296
 297     bCont = ((wxRegConfig*)this)->GetNextGroup(str, l);
 298   }
 299
 300   return nGroups;
 301 }
 302
 303 // ----------------------------------------------------------------------------
 304 // tests for existence
 305 // ----------------------------------------------------------------------------
 306
 307 bool wxRegConfig::HasGroup(const wxString& key) const
 308 {
 309     wxConfigPathChanger path(this, key);
 310
 311     wxString strName(path.Name());
 312
 313     return m_keyLocal.HasSubKey(strName) || m_keyGlobal.HasSubKey(strName);
 314 }
 315
 316 bool wxRegConfig::HasEntry(const wxString& key) const
 317 {
 318     wxConfigPathChanger path(this, key);
 319
 320     wxString strName(path.Name());
 321
 322     return m_keyLocal.HasValue(strName) || m_keyGlobal.HasValue(strName);
 323 }
 324
 325 wxConfigBase::EntryType wxRegConfig::GetEntryType(const wxString& key) const
 326 {
 327     wxConfigPathChanger path(this, key);
 328
 329     wxString strName(path.Name());
 330
 331     bool isNumeric;
 332     if ( m_keyLocal.HasValue(strName) )
 333         isNumeric = m_keyLocal.IsNumericValue(strName);
 334     else if ( m_keyGlobal.HasValue(strName) )
 335         isNumeric = m_keyGlobal.IsNumericValue(strName);
 336     else
 337         return wxConfigBase::Type_Unknown;
 338
 339     return isNumeric ? wxConfigBase::Type_Integer : wxConfigBase::Type_String;
 340 }
 341
 342 // ----------------------------------------------------------------------------
 343 // reading/writing
 344 // ----------------------------------------------------------------------------
 345
 346 bool wxRegConfig::Read(const wxString& key, wxString *pStr) const
 347 {
 348   wxConfigPathChanger path(this, key);
 349
 350   bool bQueryGlobal = TRUE;
 351
 352   // if immutable key exists in global key we must check that it's not
 353   // overriden by the local key with the same name
 354   if ( IsImmutable(path.Name()) ) {
 355     if ( TryGetValue(m_keyGlobal, path.Name(), *pStr) ) {
 356       if ( m_keyLocal.HasValue(path.Name()) ) {
 357         wxLogWarning(wxT("User value for immutable key '%s' ignored."),
 358                    path.Name().c_str());
 359       }
 360      *pStr = wxConfigBase::ExpandEnvVars(*pStr);
 361       return TRUE;
 362     }
 363     else {
 364       // don't waste time - it's not there anyhow
 365       bQueryGlobal = FALSE;
 366     }
 367   }
 368
 369   // first try local key
 370   if ( TryGetValue(m_keyLocal, path.Name(), *pStr) ||
 371        (bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), *pStr)) ) {
 372     // nothing to do
 373
 374     *pStr = wxConfigBase::ExpandEnvVars(*pStr);
 375     return TRUE;
 376   }
 377
 378   return FALSE;
 379 }
 380
 381 bool wxRegConfig::Read(const wxString& key, wxString *pStr,
 382                        const wxString& szDefault) const
 383 {
 384   wxConfigPathChanger path(this, key);
 385
 386   bool bQueryGlobal = TRUE;
 387
 388   // if immutable key exists in global key we must check that it's not
 389   // overriden by the local key with the same name
 390   if ( IsImmutable(path.Name()) ) {
 391     if ( TryGetValue(m_keyGlobal, path.Name(), *pStr) ) {
 392       if ( m_keyLocal.HasValue(path.Name()) ) {
 393         wxLogWarning(wxT("User value for immutable key '%s' ignored."),
 394                    path.Name().c_str());
 395       }
 396
 397       return TRUE;
 398     }
 399     else {
 400       // don't waste time - it's not there anyhow
 401       bQueryGlobal = FALSE;
 402     }
 403   }
 404
 405   // first try local key
 406   if ( TryGetValue(m_keyLocal, path.Name(), *pStr) ||
 407        (bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), *pStr)) ) {
 408     *pStr = wxConfigBase::ExpandEnvVars(*pStr);
 409     return TRUE;
 410   }
 411   else {
 412     if ( IsRecordingDefaults() ) {
 413       ((wxRegConfig*)this)->Write(key, szDefault);
 414     }
 415
 416     // default value
 417     *pStr = szDefault;
 418   }
 419
 420   *pStr = wxConfigBase::ExpandEnvVars(*pStr);
 421
 422   return FALSE;
 423 }
 424
 425 bool wxRegConfig::Read(const wxString& key, long *plResult) const
 426 {
 427   wxConfigPathChanger path(this, key);
 428
 429   bool bQueryGlobal = TRUE;
 430
 431   // if immutable key exists in global key we must check that it's not
 432   // overriden by the local key with the same name
 433   if ( IsImmutable(path.Name()) ) {
 434     if ( TryGetValue(m_keyGlobal, path.Name(), plResult) ) {
 435       if ( m_keyLocal.HasValue(path.Name()) ) {
 436         wxLogWarning(wxT("User value for immutable key '%s' ignored."),
 437                      path.Name().c_str());
 438       }
 439
 440       return TRUE;
 441     }
 442     else {
 443       // don't waste time - it's not there anyhow
 444       bQueryGlobal = FALSE;
 445     }
 446   }
 447
 448   // first try local key
 449   if ( TryGetValue(m_keyLocal, path.Name(), plResult) ||
 450        (bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), plResult)) ) {
 451     return TRUE;
 452   }
 453   return FALSE;
 454 }
 455
 456 bool wxRegConfig::Write(const wxString& key, const wxString& szValue)
 457 {
 458   wxConfigPathChanger path(this, key);
 459
 460   if ( IsImmutable(path.Name()) ) {
 461     wxLogError(wxT("Can't change immutable entry '%s'."), path.Name().c_str());
 462     return FALSE;
 463   }
 464
 465   return m_keyLocal.SetValue(path.Name(), szValue);
 466 }
 467
 468 bool wxRegConfig::Write(const wxString& key, long lValue)
 469 {
 470   wxConfigPathChanger path(this, key);
 471
 472   if ( IsImmutable(path.Name()) ) {
 473     wxLogError(wxT("Can't change immutable entry '%s'."), path.Name().c_str());
 474     return FALSE;
 475   }
 476
 477   return m_keyLocal.SetValue(path.Name(), lValue);
 478 }
 479
 480 // ----------------------------------------------------------------------------
 481 // renaming
 482 // ----------------------------------------------------------------------------
 483
 484 bool wxRegConfig::RenameEntry(const wxString& oldName, const wxString& newName)
 485 {
 486     // check that the old entry exists...
 487     if ( !HasEntry(oldName) )
 488         return FALSE;
 489
 490     // and that the new one doesn't
 491     if ( HasEntry(newName) )
 492         return FALSE;
 493
 494     // delete the old entry and create the new one - but do in the reverse
 495     // order to not lose the data if Create() fails
 496
 497     bool ok;
 498     if ( m_keyLocal.IsNumericValue(oldName) )
 499     {
 500         long val;
 501         ok = m_keyLocal.QueryValue(oldName, &val) &&
 502              m_keyLocal.SetValue(newName, val);
 503     }
 504     else
 505     {
 506         wxString val;
 507         ok = m_keyLocal.QueryValue(oldName, val) &&
 508              m_keyLocal.SetValue(newName, val);
 509     }
 510
 511     if ( !ok )
 512         return FALSE;
 513
 514     if ( !m_keyLocal.DeleteValue(oldName) )
 515     {
 516         m_keyLocal.DeleteValue(newName);
 517
 518         return FALSE;
 519     }
 520
 521     return TRUE;
 522 }
 523
 524 bool wxRegConfig::RenameGroup(const wxString& oldName, const wxString& newName)
 525 {
 526     // check that the old group exists...
 527     if ( !HasGroup(oldName) )
 528         return FALSE;
 529
 530     // and that the new one doesn't
 531     if ( HasGroup(newName) )
 532         return FALSE;
 533
 534     // TODO there is no way to rename a registry key - we must do a deep copy
 535     //      ourselves
 536     wxFAIL_MSG(wxT("Registry key renaming not implemented"));
 537
 538     return FALSE;
 539 }
 540
 541 // ----------------------------------------------------------------------------
 542 // deleting
 543 // ----------------------------------------------------------------------------
 544 bool wxRegConfig::DeleteEntry(const wxString& value, bool bGroupIfEmptyAlso)
 545 {
 546   wxConfigPathChanger path(this, value);
 547
 548   if ( !m_keyLocal.DeleteValue(path.Name()) )
 549     return FALSE;
 550
 551   if ( m_keyLocal.IsEmpty() ) {
 552     wxString strKey = GetPath().AfterLast(wxCONFIG_PATH_SEPARATOR);
 553     SetPath("..");  // changes m_keyLocal
 554     return m_keyLocal.DeleteKey(strKey);
 555   }
 556
 557   return TRUE;
 558 }
 559
 560 bool wxRegConfig::DeleteGroup(const wxString& key)
 561 {
 562   wxConfigPathChanger path(this, key);
 563
 564   return m_keyLocal.DeleteKey(path.Name());
 565 }
 566
 567 bool wxRegConfig::DeleteAll()
 568 {
 569   m_keyLocal.Close();
 570   m_keyGlobal.Close();
 571
 572   bool bOk = m_keyLocalRoot.DeleteSelf();
 573
 574   // make sure that we opened m_keyGlobalRoot and so it has a reasonable name:
 575   // otherwise we will delete HKEY_CLASSES_ROOT recursively
 576   if ( bOk && m_keyGlobalRoot.IsOpened() )
 577     bOk = m_keyGlobalRoot.DeleteSelf();
 578
 579   return bOk;
 580 }
 581
 582 #endif
 583   // __WIN16__
 584
 585 #endif
 586   // wxUSE_CONFIG