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   #include  "wx/intl.h"
  26 #endif //WX_PRECOMP
  27
  28 #include "wx/event.h"
  29 #include "wx/app.h"
  30 #include "wx/log.h"
  31
  32 #if wxUSE_CONFIG
  33
  34 #include "wx/config.h"
  35
  36 #ifndef __WIN16__
  37
  38 #include "wx/msw/registry.h"
  39 #include "wx/msw/regconf.h"
  40
  41 // ----------------------------------------------------------------------------
  42 // constants
  43 // ----------------------------------------------------------------------------
  44
  45 // we put our data in HKLM\SOFTWARE_KEY\appname
  46 #define SOFTWARE_KEY    wxString("Software\\")
  47
  48 // ----------------------------------------------------------------------------
  49 // global functions
  50 // ----------------------------------------------------------------------------
  51
  52 // get the value if the key is opened and it exists
  53 bool TryGetValue(const wxRegKey& key, const wxString& str, wxString& strVal)
  54 {
  55   return key.IsOpened() && key.HasValue(str) && key.QueryValue(str, strVal);
  56 }
  57
  58 bool TryGetValue(const wxRegKey& key, const wxString& str, long *plVal)
  59 {
  60   return key.IsOpened() && key.HasValue(str) && key.QueryValue(str, plVal);
  61 }
  62
  63 // ============================================================================
  64 // implementation
  65 // ============================================================================
  66
  67 // ----------------------------------------------------------------------------
  68 // ctor/dtor
  69 // ----------------------------------------------------------------------------
  70
  71 // create the config object which stores its data under HKCU\vendor\app and, if
  72 // style & wxCONFIG_USE_GLOBAL_FILE, under HKLM\vendor\app
  73 wxRegConfig::wxRegConfig(const wxString& appName, const wxString& vendorName,
  74                          const wxString& strLocal, const wxString& strGlobal,
  75                          long style)
  76            : wxConfigBase(appName, vendorName, strLocal, strGlobal, style)
  77 {
  78   wxString strRoot;
  79
  80   bool bDoUseGlobal = (style & wxCONFIG_USE_GLOBAL_FILE) != 0;
  81
  82   // the convention is to put the programs keys under <vendor>\<appname>
  83   // (but it can be overriden by specifying the pathes explicitly in strLocal
  84   // and/or strGlobal)
  85   if ( strLocal.IsEmpty() || (strGlobal.IsEmpty() && bDoUseGlobal) )
  86   {
  87     if ( vendorName.IsEmpty() )
  88     {
  89       if ( wxTheApp )
  90         strRoot = wxTheApp->GetVendorName();
  91     }
  92     else
  93     {
  94       strRoot = vendorName;
  95     }
  96
  97     // no '\\' needed if no vendor name
  98     if ( !strRoot.IsEmpty() )
  99     {
 100       strRoot += '\\';
 101     }
 102
 103     if ( appName.IsEmpty() )
 104     {
 105       wxCHECK_RET( wxTheApp, wxT("No application name in wxRegConfig ctor!") );
 106       strRoot << wxTheApp->GetAppName();
 107     }
 108     else
 109     {
 110       strRoot << appName;
 111     }
 112   }
 113   //else: we don't need to do all the complicated stuff above
 114
 115   wxString str = strLocal.IsEmpty() ? strRoot : strLocal;
 116
 117   // as we're going to change the name of these keys fairly often and as
 118   // there are only few of wxRegConfig objects (usually 1), we can allow
 119   // ourselves to be generous and spend some memory to significantly improve
 120   // performance of SetPath()
 121   static const size_t MEMORY_PREALLOC = 512;
 122
 123   m_keyLocalRoot.ReserveMemoryForName(MEMORY_PREALLOC);
 124   m_keyLocal.ReserveMemoryForName(MEMORY_PREALLOC);
 125
 126   m_keyLocalRoot.SetName(wxRegKey::HKCU, SOFTWARE_KEY + str);
 127   m_keyLocal.SetName(m_keyLocalRoot, _T(""));
 128
 129   if ( bDoUseGlobal )
 130   {
 131     str = strGlobal.IsEmpty() ? strRoot : strGlobal;
 132
 133     m_keyGlobalRoot.ReserveMemoryForName(MEMORY_PREALLOC);
 134     m_keyGlobal.ReserveMemoryForName(MEMORY_PREALLOC);
 135
 136     m_keyGlobalRoot.SetName(wxRegKey::HKLM, SOFTWARE_KEY + str);
 137     m_keyGlobal.SetName(m_keyGlobalRoot, _T(""));
 138   }
 139
 140   // Create() will Open() if key already exists
 141   m_keyLocalRoot.Create();
 142
 143   // as it's the same key, Open() shouldn't fail (i.e. no need for Create())
 144   m_keyLocal.Open();
 145
 146   // OTOH, this key may perfectly not exist, so suppress error messages the call
 147   // to Open() might generate
 148   if ( bDoUseGlobal )
 149   {
 150     wxLogNull nolog;
 151     m_keyGlobalRoot.Open();
 152     m_keyGlobal.Open();
 153   }
 154 }
 155
 156 wxRegConfig::~wxRegConfig()
 157 {
 158   // nothing to do - key will be closed in their dtors
 159 }
 160
 161 // ----------------------------------------------------------------------------
 162 // path management
 163 // ----------------------------------------------------------------------------
 164
 165 // this function is called a *lot* of times (as I learned after seeing from
 166 // profiler output that it is called ~12000 times from Mahogany start up code!)
 167 // so it is important to optimize it - in particular, avoid using generic
 168 // string functions here and do everything manually because it is faster
 169 //
 170 // I still kept the old version to be able to check that the optimized code has
 171 // the same output as the non optimized version.
 172 void wxRegConfig::SetPath(const wxString& strPath)
 173 {
 174     // remember the old path
 175     wxString strOldPath = m_strPath;
 176
 177 #ifdef WX_DEBUG_SET_PATH // non optimized version kept here for testing
 178     wxString m_strPathAlt;
 179
 180     {
 181         wxArrayString aParts;
 182
 183         // because GetPath() returns "" when we're at root, we must understand
 184         // empty string as "/"
 185         if ( strPath.IsEmpty() || (strPath[0] == wxCONFIG_PATH_SEPARATOR) ) {
 186             // absolute path
 187             wxSplitPath(aParts, strPath);
 188         }
 189         else {
 190             // relative path, combine with current one
 191             wxString strFullPath = GetPath();
 192             strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
 193             wxSplitPath(aParts, strFullPath);
 194         }
 195
 196         // recombine path parts in one variable
 197         wxString strRegPath;
 198         m_strPathAlt.Empty();
 199         for ( size_t n = 0; n < aParts.Count(); n++ ) {
 200             strRegPath << '\\' << aParts[n];
 201             m_strPathAlt << wxCONFIG_PATH_SEPARATOR << aParts[n];
 202         }
 203     }
 204 #endif // 0
 205
 206     // check for the most common case first
 207     if ( strPath.empty() )
 208     {
 209         m_strPath = wxCONFIG_PATH_SEPARATOR;
 210     }
 211     else // not root
 212     {
 213         // construct the full path
 214         wxString strFullPath;
 215         if ( strPath[0u] == wxCONFIG_PATH_SEPARATOR )
 216         {
 217             // absolute path
 218             strFullPath = strPath;
 219         }
 220         else // relative path
 221         {
 222             strFullPath.reserve(2*m_strPath.length());
 223
 224             strFullPath << m_strPath;
 225             if ( strFullPath.Len() == 0 ||
 226                  strFullPath.Last() != wxCONFIG_PATH_SEPARATOR )
 227                 strFullPath << wxCONFIG_PATH_SEPARATOR;
 228             strFullPath << strPath;
 229         }
 230
 231         // simplify it: we need to handle ".." here
 232
 233         // count the total number of slashes we have to know if we can go upper
 234         size_t totalSlashes = 0;
 235
 236         // position of the last slash to be able to backtrack to it quickly if
 237         // needed, but we set it to -1 if we don't have a valid position
 238         //
 239         // we only remember the last position which means that we handle ".."
 240         // quite efficiently but not "../.." - however the latter should be
 241         // much more rare, so it is probably ok
 242         int posLastSlash = -1;
 243
 244         const wxChar *src = strFullPath.c_str();
 245         size_t len = strFullPath.length();
 246         const wxChar *end = src + len;
 247
 248         wxChar *dst = m_strPath.GetWriteBuf(len);
 249         wxChar *start = dst;
 250
 251         for ( ; src < end; src++, dst++ )
 252         {
 253             if ( *src == wxCONFIG_PATH_SEPARATOR )
 254             {
 255                 // check for "/.."
 256
 257                 // note that we don't have to check for src < end here as
 258                 // *end == 0 so can't be '.'
 259                 if ( src[1] == _T('.') && src[2] == _T('.') &&
 260                      (src + 3 == end || src[3] == wxCONFIG_PATH_SEPARATOR) )
 261                 {
 262                     if ( !totalSlashes )
 263                     {
 264                         wxLogWarning(_("'%s' has extra '..', ignored."),
 265                                      strFullPath.c_str());
 266                     }
 267                     else // return to the previous path component
 268                     {
 269                         // do we already have its position?
 270                         if ( posLastSlash == -1 )
 271                         {
 272                             // no, find it: note that we are sure to have one
 273                             // because totalSlashes > 0 so we don't have to
 274                             // check the boundary condition below
 275
 276                             // this is more efficient than strrchr()
 277                             dst--;
 278                             while ( *dst != wxCONFIG_PATH_SEPARATOR )
 279                             {
 280                                 dst--;
 281                             }
 282                         }
 283                         else // the position of last slash was stored
 284                         {
 285                             // go directly there
 286                             dst = start + posLastSlash;
 287
 288                             // invalidate posLastSlash
 289                             posLastSlash = -1;
 290                         }
 291
 292                         // we must have found a slash one way or another!
 293                         wxASSERT_MSG( *dst == wxCONFIG_PATH_SEPARATOR,
 294                                       _T("error in wxRegConfig::SetPath") );
 295
 296                         // stay at the same position
 297                         dst--;
 298
 299                         // we killed one
 300                         totalSlashes--;
 301                     }
 302
 303                     // skip both dots
 304                     src += 2;
 305                 }
 306                 else // not "/.."
 307                 {
 308                     if ( (dst == start) || (dst[-1] != wxCONFIG_PATH_SEPARATOR) )
 309                     {
 310                         *dst = wxCONFIG_PATH_SEPARATOR;
 311
 312                         posLastSlash = dst - start;
 313
 314                         totalSlashes++;
 315                     }
 316                     else // previous char was a slash too
 317                     {
 318                         // squeeze several subsequent slashes into one: i.e.
 319                         // just ignore this one
 320                         dst--;
 321                     }
 322                 }
 323             }
 324             else // normal character
 325             {
 326                 // just copy
 327                 *dst = *src;
 328             }
 329         }
 330
 331         // NUL terminate the string
 332         if ( dst[-1] == wxCONFIG_PATH_SEPARATOR && (dst != start + 1) )
 333         {
 334             // if it has a trailing slash we remove it unless it is the only
 335             // string character
 336             dst--;
 337         }
 338
 339         *dst = _T('\0');
 340
 341         m_strPath.UngetWriteBuf(dst - start);
 342     }
 343
 344 #ifdef WX_DEBUG_SET_PATH
 345     wxASSERT( m_strPath == m_strPathAlt );
 346 #endif
 347
 348     if ( m_strPath == strOldPath )
 349         return;
 350
 351     // registry APIs want backslashes instead of slashes
 352     wxString strRegPath;
 353     size_t len = m_strPath.length();
 354
 355     const wxChar *src = m_strPath.c_str();
 356     wxChar *dst = strRegPath.GetWriteBuf(len);
 357
 358     const wxChar *end = src + len;
 359     for ( ; src < end; src++, dst++ )
 360     {
 361         if ( *src == wxCONFIG_PATH_SEPARATOR )
 362             *dst = _T('\\');
 363         else
 364             *dst = *src;
 365     }
 366
 367     strRegPath.UngetWriteBuf(len);
 368
 369     // this is not needed any longer as we don't create keys unnecessarily any
 370     // more (now it is done on demand, i.e. only when they're going to contain
 371     // something)
 372 #if 0
 373     // as we create the registry key when SetPath(key) is done, we can be left
 374     // with plenty of empty keys if this was only done to try to read some
 375     // value which, in fact, doesn't exist - to prevent this from happening we
 376     // automatically delete the old key if it was empty
 377     if ( m_keyLocal.Exists() && LocalKey().IsEmpty() )
 378     {
 379         m_keyLocal.DeleteSelf();
 380     }
 381 #endif // 0
 382
 383     // change current key(s)
 384     m_keyLocal.SetName(m_keyLocalRoot, strRegPath);
 385     m_keyGlobal.SetName(m_keyGlobalRoot, strRegPath);
 386
 387     // don't create it right now, wait until it is accessed
 388     //m_keyLocal.Create();
 389
 390     wxLogNull nolog;
 391     m_keyGlobal.Open();
 392 }
 393
 394 // ----------------------------------------------------------------------------
 395 // enumeration (works only with current group)
 396 // ----------------------------------------------------------------------------
 397
 398 /*
 399   We want to enumerate all local keys/values after the global ones, but, of
 400   course, we don't want to repeat a key which appears locally as well as
 401   globally twice.
 402
 403   We use the 15th bit of lIndex for distinction between global and local.
 404  */
 405
 406 #define LOCAL_MASK        0x8000
 407 #define IS_LOCAL_INDEX(l) (((l) & LOCAL_MASK) != 0)
 408
 409 bool wxRegConfig::GetFirstGroup(wxString& str, long& lIndex) const
 410 {
 411   lIndex = 0;
 412   return GetNextGroup(str, lIndex);
 413 }
 414
 415 bool wxRegConfig::GetNextGroup(wxString& str, long& lIndex) const
 416 {
 417   // are we already enumerating local entries?
 418   if ( m_keyGlobal.IsOpened() && !IS_LOCAL_INDEX(lIndex) ) {
 419     // try to find a global entry which doesn't appear locally
 420     while ( m_keyGlobal.GetNextKey(str, lIndex) ) {
 421       if ( !m_keyLocal.Exists() || !LocalKey().HasSubKey(str) ) {
 422         // ok, found one - return it
 423         return TRUE;
 424       }
 425     }
 426
 427     // no more global entries
 428     lIndex |= LOCAL_MASK;
 429   }
 430
 431   // if we don't have the key at all, don't try to enumerate anything under it
 432   if ( !m_keyLocal.Exists() )
 433       return FALSE;
 434
 435   // much easier with local entries: get the next one we find
 436   // (don't forget to clear our flag bit and set it again later)
 437   lIndex &= ~LOCAL_MASK;
 438   bool bOk = LocalKey().GetNextKey(str, lIndex);
 439   lIndex |= LOCAL_MASK;
 440
 441   return bOk;
 442 }
 443
 444 bool wxRegConfig::GetFirstEntry(wxString& str, long& lIndex) const
 445 {
 446   lIndex = 0;
 447   return GetNextEntry(str, lIndex);
 448 }
 449
 450 bool wxRegConfig::GetNextEntry(wxString& str, long& lIndex) const
 451 {
 452   // are we already enumerating local entries?
 453   if ( m_keyGlobal.IsOpened() && !IS_LOCAL_INDEX(lIndex) ) {
 454     // try to find a global entry which doesn't appear locally
 455     while ( m_keyGlobal.GetNextValue(str, lIndex) ) {
 456       if ( !m_keyLocal.Exists() || !LocalKey().HasValue(str) ) {
 457         // ok, found one - return it
 458         return TRUE;
 459       }
 460     }
 461
 462     // no more global entries
 463     lIndex |= LOCAL_MASK;
 464   }
 465
 466   // if we don't have the key at all, don't try to enumerate anything under it
 467   if ( !m_keyLocal.Exists() )
 468       return FALSE;
 469
 470   // much easier with local entries: get the next one we find
 471   // (don't forget to clear our flag bit and set it again later)
 472   lIndex &= ~LOCAL_MASK;
 473   bool bOk = LocalKey().GetNextValue(str, lIndex);
 474   lIndex |= LOCAL_MASK;
 475
 476   return bOk;
 477 }
 478
 479 size_t wxRegConfig::GetNumberOfEntries(bool WXUNUSED(bRecursive)) const
 480 {
 481   size_t nEntries = 0;
 482
 483   // dummy vars
 484   wxString str;
 485   long l;
 486   bool bCont = ((wxRegConfig*)this)->GetFirstEntry(str, l);
 487   while ( bCont ) {
 488     nEntries++;
 489
 490     bCont = ((wxRegConfig*)this)->GetNextEntry(str, l);
 491   }
 492
 493   return nEntries;
 494 }
 495
 496 size_t wxRegConfig::GetNumberOfGroups(bool WXUNUSED(bRecursive)) const
 497 {
 498   size_t nGroups = 0;
 499
 500   // dummy vars
 501   wxString str;
 502   long l;
 503   bool bCont = ((wxRegConfig*)this)->GetFirstGroup(str, l);
 504   while ( bCont ) {
 505     nGroups++;
 506
 507     bCont = ((wxRegConfig*)this)->GetNextGroup(str, l);
 508   }
 509
 510   return nGroups;
 511 }
 512
 513 // ----------------------------------------------------------------------------
 514 // tests for existence
 515 // ----------------------------------------------------------------------------
 516
 517 bool wxRegConfig::HasGroup(const wxString& key) const
 518 {
 519     wxConfigPathChanger path(this, key);
 520
 521     wxString strName(path.Name());
 522
 523     return (m_keyLocal.Exists() && LocalKey().HasSubKey(strName)) ||
 524            m_keyGlobal.HasSubKey(strName);
 525 }
 526
 527 bool wxRegConfig::HasEntry(const wxString& key) const
 528 {
 529     wxConfigPathChanger path(this, key);
 530
 531     wxString strName(path.Name());
 532
 533     return (m_keyLocal.Exists() && LocalKey().HasValue(strName)) ||
 534            m_keyGlobal.HasValue(strName);
 535 }
 536
 537 wxConfigBase::EntryType wxRegConfig::GetEntryType(const wxString& key) const
 538 {
 539     wxConfigPathChanger path(this, key);
 540
 541     wxString strName(path.Name());
 542
 543     bool isNumeric;
 544     if ( m_keyLocal.Exists() && LocalKey().HasValue(strName) )
 545         isNumeric = m_keyLocal.IsNumericValue(strName);
 546     else if ( m_keyGlobal.HasValue(strName) )
 547         isNumeric = m_keyGlobal.IsNumericValue(strName);
 548     else
 549         return wxConfigBase::Type_Unknown;
 550
 551     return isNumeric ? wxConfigBase::Type_Integer : wxConfigBase::Type_String;
 552 }
 553
 554 // ----------------------------------------------------------------------------
 555 // reading/writing
 556 // ----------------------------------------------------------------------------
 557
 558 bool wxRegConfig::Read(const wxString& key, wxString *pStr) const
 559 {
 560   wxConfigPathChanger path(this, key);
 561
 562   bool bQueryGlobal = TRUE;
 563
 564   // if immutable key exists in global key we must check that it's not
 565   // overriden by the local key with the same name
 566   if ( IsImmutable(path.Name()) ) {
 567     if ( TryGetValue(m_keyGlobal, path.Name(), *pStr) ) {
 568       if ( m_keyLocal.Exists() && LocalKey().HasValue(path.Name()) ) {
 569         wxLogWarning(wxT("User value for immutable key '%s' ignored."),
 570                    path.Name().c_str());
 571       }
 572      *pStr = wxConfigBase::ExpandEnvVars(*pStr);
 573       return TRUE;
 574     }
 575     else {
 576       // don't waste time - it's not there anyhow
 577       bQueryGlobal = FALSE;
 578     }
 579   }
 580
 581   // first try local key
 582   if ( (m_keyLocal.Exists() && TryGetValue(LocalKey(), path.Name(), *pStr)) ||
 583        (bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), *pStr)) ) {
 584     // nothing to do
 585
 586     *pStr = wxConfigBase::ExpandEnvVars(*pStr);
 587     return TRUE;
 588   }
 589
 590   return FALSE;
 591 }
 592
 593 bool wxRegConfig::Read(const wxString& key, wxString *pStr,
 594                        const wxString& szDefault) const
 595 {
 596   wxConfigPathChanger path(this, key);
 597
 598   bool bQueryGlobal = TRUE;
 599
 600   // if immutable key exists in global key we must check that it's not
 601   // overriden by the local key with the same name
 602   if ( IsImmutable(path.Name()) ) {
 603     if ( TryGetValue(m_keyGlobal, path.Name(), *pStr) ) {
 604       if ( m_keyLocal.Exists() && LocalKey().HasValue(path.Name()) ) {
 605         wxLogWarning(wxT("User value for immutable key '%s' ignored."),
 606                    path.Name().c_str());
 607       }
 608
 609       return TRUE;
 610     }
 611     else {
 612       // don't waste time - it's not there anyhow
 613       bQueryGlobal = FALSE;
 614     }
 615   }
 616
 617   // first try local key
 618   if ( (m_keyLocal.Exists() && TryGetValue(LocalKey(), path.Name(), *pStr)) ||
 619        (bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), *pStr)) ) {
 620     *pStr = wxConfigBase::ExpandEnvVars(*pStr);
 621     return TRUE;
 622   }
 623   else {
 624     if ( IsRecordingDefaults() ) {
 625       ((wxRegConfig*)this)->Write(key, szDefault);
 626     }
 627
 628     // default value
 629     *pStr = szDefault;
 630   }
 631
 632   *pStr = wxConfigBase::ExpandEnvVars(*pStr);
 633
 634   return FALSE;
 635 }
 636
 637 bool wxRegConfig::Read(const wxString& key, long *plResult) const
 638 {
 639   wxConfigPathChanger path(this, key);
 640
 641   bool bQueryGlobal = TRUE;
 642
 643   // if immutable key exists in global key we must check that it's not
 644   // overriden by the local key with the same name
 645   if ( IsImmutable(path.Name()) ) {
 646     if ( TryGetValue(m_keyGlobal, path.Name(), plResult) ) {
 647       if ( m_keyLocal.Exists() && LocalKey().HasValue(path.Name()) ) {
 648         wxLogWarning(wxT("User value for immutable key '%s' ignored."),
 649                      path.Name().c_str());
 650       }
 651
 652       return TRUE;
 653     }
 654     else {
 655       // don't waste time - it's not there anyhow
 656       bQueryGlobal = FALSE;
 657     }
 658   }
 659
 660   // first try local key
 661   if ( (m_keyLocal.Exists() && TryGetValue(LocalKey(), path.Name(), plResult)) ||
 662        (bQueryGlobal && TryGetValue(m_keyGlobal, path.Name(), plResult)) ) {
 663     return TRUE;
 664   }
 665   return FALSE;
 666 }
 667
 668 bool wxRegConfig::Write(const wxString& key, const wxString& szValue)
 669 {
 670   wxConfigPathChanger path(this, key);
 671
 672   if ( IsImmutable(path.Name()) ) {
 673     wxLogError(wxT("Can't change immutable entry '%s'."), path.Name().c_str());
 674     return FALSE;
 675   }
 676
 677   return LocalKey().SetValue(path.Name(), szValue);
 678 }
 679
 680 bool wxRegConfig::Write(const wxString& key, long lValue)
 681 {
 682   wxConfigPathChanger path(this, key);
 683
 684   if ( IsImmutable(path.Name()) ) {
 685     wxLogError(wxT("Can't change immutable entry '%s'."), path.Name().c_str());
 686     return FALSE;
 687   }
 688
 689   return LocalKey().SetValue(path.Name(), lValue);
 690 }
 691
 692 // ----------------------------------------------------------------------------
 693 // renaming
 694 // ----------------------------------------------------------------------------
 695
 696 bool wxRegConfig::RenameEntry(const wxString& oldName, const wxString& newName)
 697 {
 698     // check that the old entry exists...
 699     if ( !HasEntry(oldName) )
 700         return FALSE;
 701
 702     // and that the new one doesn't
 703     if ( HasEntry(newName) )
 704         return FALSE;
 705
 706     return m_keyLocal.RenameValue(oldName, newName);
 707 }
 708
 709 bool wxRegConfig::RenameGroup(const wxString& oldName, const wxString& newName)
 710 {
 711     // check that the old group exists...
 712     if ( !HasGroup(oldName) )
 713         return FALSE;
 714
 715     // and that the new one doesn't
 716     if ( HasGroup(newName) )
 717         return FALSE;
 718
 719     return wxRegKey(m_keyLocal, oldName).Rename(newName);
 720 }
 721
 722 // ----------------------------------------------------------------------------
 723 // deleting
 724 // ----------------------------------------------------------------------------
 725 bool wxRegConfig::DeleteEntry(const wxString& value, bool WXUNUSED(bGroupIfEmptyAlso))
 726 {
 727   wxConfigPathChanger path(this, value);
 728
 729   if ( m_keyLocal.Exists() ) {
 730     if ( !m_keyLocal.DeleteValue(path.Name()) )
 731       return FALSE;
 732
 733     if ( m_keyLocal.IsEmpty() ) {
 734       wxString strKey = GetPath().AfterLast(wxCONFIG_PATH_SEPARATOR);
 735       SetPath("..");  // changes m_keyLocal
 736       return LocalKey().DeleteKey(strKey);
 737     }
 738   }
 739
 740   return TRUE;
 741 }
 742
 743 bool wxRegConfig::DeleteGroup(const wxString& key)
 744 {
 745   wxConfigPathChanger path(this, key);
 746
 747   return m_keyLocal.Exists() ? LocalKey().DeleteKey(path.Name()) : TRUE;
 748 }
 749
 750 bool wxRegConfig::DeleteAll()
 751 {
 752   m_keyLocal.Close();
 753   m_keyGlobal.Close();
 754
 755   bool bOk = m_keyLocalRoot.DeleteSelf();
 756
 757   // make sure that we opened m_keyGlobalRoot and so it has a reasonable name:
 758   // otherwise we will delete HKEY_CLASSES_ROOT recursively
 759   if ( bOk && m_keyGlobalRoot.IsOpened() )
 760     bOk = m_keyGlobalRoot.DeleteSelf();
 761
 762   return bOk;
 763 }
 764
 765 #endif
 766   // __WIN16__
 767
 768 #endif
 769   // wxUSE_CONFIG