src/msw/registry.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        msw/registry.cpp
   3 // Purpose:     implementation of registry classes and functions
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     03.04.98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 // Licence:     wxWindows license
  10 // TODO:        - parsing of registry key names
  11 //              - support of other (than REG_SZ/REG_DWORD) registry types
  12 //              - add high level functions (RegisterOleServer, ...)
  13 ///////////////////////////////////////////////////////////////////////////////
  14
  15 #ifdef __GNUG__
  16 #pragma implementation "registry.h"
  17 #endif
  18
  19 // for compilers that support precompilation, includes "wx.h".
  20 #include  "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23 #pragma hdrstop
  24 #endif
  25
  26 // other wxWindows headers
  27 #include  "wx/string.h"
  28 #include  "wx/intl.h"
  29 #include  "wx/log.h"
  30 #include  "wx/config.h"    // for wxExpandEnvVars
  31
  32 #ifndef __WIN16__
  33
  34 // Windows headers
  35 /*
  36 #define   STRICT
  37 #define   WIN32_LEAN_AND_MEAN
  38 */
  39
  40 #include  <windows.h>
  41
  42 // other std headers
  43 #include  <stdlib.h>      // for _MAX_PATH
  44
  45 #ifndef _MAX_PATH
  46         #define _MAX_PATH 512
  47 #endif
  48
  49 // our header
  50 #define   HKEY_DEFINED    // already defined in windows.h
  51 #include  "wx/msw/registry.h"
  52
  53 // some registry functions don't like signed chars
  54 typedef unsigned char *RegString;
  55
  56 // ----------------------------------------------------------------------------
  57 // constants
  58 // ----------------------------------------------------------------------------
  59
  60 // the standard key names, short names and handles all bundled together for
  61 // convenient access
  62 static struct
  63 {
  64   HKEY        hkey;
  65   const char *szName;
  66   const char *szShortName;
  67 }
  68 aStdKeys[] =
  69 {
  70   { HKEY_CLASSES_ROOT,      "HKEY_CLASSES_ROOT",      "HKCR" },
  71 #ifdef  __WIN32__
  72   { HKEY_CURRENT_USER,      "HKEY_CURRENT_USER",      "HKCU" },
  73   { HKEY_LOCAL_MACHINE,     "HKEY_LOCAL_MACHINE",     "HKLM" },
  74   { HKEY_USERS,             "HKEY_USERS",             "HKU"  }, // short name?
  75   { HKEY_PERFORMANCE_DATA,  "HKEY_PERFORMANCE_DATA",  "HKPD" },
  76 #if     WINVER >= 0x0400
  77   { HKEY_CURRENT_CONFIG,    "HKEY_CURRENT_CONFIG",    "HKCC" },
  78 #ifndef __GNUWIN32__
  79   { HKEY_DYN_DATA,          "HKEY_DYN_DATA",          "HKDD" }, // short name?
  80 #endif  //GNUWIN32
  81 #endif  //WINVER >= 4.0
  82 #endif  //WIN32
  83 };
  84
  85 // the registry name separator (perhaps one day MS will change it to '/' ;-)
  86 #define   REG_SEPARATOR     '\\'
  87
  88 // useful for Windows programmers: makes somewhat more clear all these zeroes
  89 // being passed to Windows APIs
  90 #define   RESERVED        (NULL)
  91
  92 // ----------------------------------------------------------------------------
  93 // macros
  94 // ----------------------------------------------------------------------------
  95 // @ const_cast<> is not yet supported by all compilers
  96 #define CONST_CAST    ((wxRegKey *)this)->
  97
  98 #if   !USE_MUTABLE
  99   #define m_dwLastError   CONST_CAST m_dwLastError
 100 #endif
 101
 102 // ----------------------------------------------------------------------------
 103 // non member functions
 104 // ----------------------------------------------------------------------------
 105
 106 // removes the trailing backslash from the string if it has one
 107 static inline void RemoveTrailingSeparator(wxString& str);
 108
 109 // returns TRUE if given registry key exists
 110 static bool KeyExists(WXHKEY hRootKey, const char *szKey);
 111
 112 // combines value and key name (uses static buffer!)
 113 static const char *GetFullName(const wxRegKey *pKey,
 114                                const char *szValue = NULL);
 115
 116 // ============================================================================
 117 // implementation of wxRegKey class
 118 // ============================================================================
 119
 120 // ----------------------------------------------------------------------------
 121 // static functions and variables
 122 // ----------------------------------------------------------------------------
 123
 124 const size_t wxRegKey::nStdKeys = WXSIZEOF(aStdKeys);
 125
 126 // @@ should take a `StdKey key', but as it's often going to be used in loops
 127 //    it would require casts in user code.
 128 const char *wxRegKey::GetStdKeyName(size_t key)
 129 {
 130   // return empty string if key is invalid
 131   wxCHECK_MSG( key < nStdKeys, "", "invalid key in wxRegKey::GetStdKeyName" );
 132
 133   return aStdKeys[key].szName;
 134 }
 135
 136 const char *wxRegKey::GetStdKeyShortName(size_t key)
 137 {
 138   // return empty string if key is invalid
 139   wxCHECK( key < nStdKeys, "" );
 140
 141   return aStdKeys[key].szShortName;
 142 }
 143
 144 wxRegKey::StdKey wxRegKey::ExtractKeyName(wxString& strKey)
 145 {
 146   wxString strRoot = strKey.Left(REG_SEPARATOR);
 147
 148   HKEY hRootKey = 0;
 149   size_t ui;
 150   for ( ui = 0; ui < nStdKeys; ui++ ) {
 151     if ( strRoot.CmpNoCase(aStdKeys[ui].szName) == 0 ||
 152          strRoot.CmpNoCase(aStdKeys[ui].szShortName) == 0 ) {
 153       hRootKey = aStdKeys[ui].hkey;
 154       break;
 155     }
 156   }
 157
 158   if ( ui == nStdKeys ) {
 159     wxFAIL_MSG("invalid key prefix in wxRegKey::ExtractKeyName.");
 160
 161     hRootKey = HKEY_CLASSES_ROOT;
 162   }
 163   else {
 164     strKey = strKey.After(REG_SEPARATOR);
 165     if ( !strKey.IsEmpty() && strKey.Last() == REG_SEPARATOR )
 166       strKey.Truncate(strKey.Len() - 1);
 167   }
 168
 169   return (wxRegKey::StdKey)(int)hRootKey;
 170 }
 171
 172 wxRegKey::StdKey wxRegKey::GetStdKeyFromHkey(WXHKEY hkey)
 173 {
 174   for ( size_t ui = 0; ui < nStdKeys; ui++ ) {
 175     if ( (int) aStdKeys[ui].hkey == (int) hkey )
 176       return (StdKey)ui;
 177   }
 178
 179   wxFAIL_MSG("non root hkey passed to wxRegKey::GetStdKeyFromHkey.");
 180
 181   return HKCR;
 182 }
 183
 184 // ----------------------------------------------------------------------------
 185 // ctors and dtor
 186 // ----------------------------------------------------------------------------
 187
 188 wxRegKey::wxRegKey()
 189 {
 190   m_hKey = 0;
 191   m_hRootKey = (WXHKEY) aStdKeys[HKCR].hkey;
 192   m_dwLastError = 0;
 193 }
 194
 195 wxRegKey::wxRegKey(const wxString& strKey) : m_strKey(strKey)
 196 {
 197   m_hRootKey  = (WXHKEY) aStdKeys[ExtractKeyName(m_strKey)].hkey;
 198   m_hKey      = (WXHKEY) NULL;
 199   m_dwLastError = 0;
 200 }
 201
 202 // parent is a predefined (and preopened) key
 203 wxRegKey::wxRegKey(StdKey keyParent, const wxString& strKey) : m_strKey(strKey)
 204 {
 205   RemoveTrailingSeparator(m_strKey);
 206   m_hRootKey  = (WXHKEY) aStdKeys[keyParent].hkey;
 207   m_hKey      = (WXHKEY) NULL;
 208   m_dwLastError = 0;
 209 }
 210
 211 // parent is a normal regkey
 212 wxRegKey::wxRegKey(const wxRegKey& keyParent, const wxString& strKey)
 213         : m_strKey(keyParent.m_strKey)
 214 {
 215   // combine our name with parent's to get the full name
 216   if ( !m_strKey.IsEmpty() &&
 217        (strKey.IsEmpty() || strKey[0] != REG_SEPARATOR) ) {
 218       m_strKey += REG_SEPARATOR;
 219   }
 220
 221   m_strKey += strKey;
 222   RemoveTrailingSeparator(m_strKey);
 223
 224   m_hRootKey  = keyParent.m_hRootKey;
 225   m_hKey      = (WXHKEY) NULL;
 226   m_dwLastError = 0;
 227 }
 228
 229 // dtor closes the key releasing system resource
 230 wxRegKey::~wxRegKey()
 231 {
 232   Close();
 233 }
 234
 235 // ----------------------------------------------------------------------------
 236 // change the key name/hkey
 237 // ----------------------------------------------------------------------------
 238
 239 // set the full key name
 240 void wxRegKey::SetName(const wxString& strKey)
 241 {
 242   Close();
 243
 244   m_strKey = strKey;
 245   m_hRootKey = (WXHKEY) aStdKeys[ExtractKeyName(m_strKey)].hkey;
 246 }
 247
 248 // the name is relative to the parent key
 249 void wxRegKey::SetName(StdKey keyParent, const wxString& strKey)
 250 {
 251   Close();
 252
 253   m_strKey = strKey;
 254   RemoveTrailingSeparator(m_strKey);
 255   m_hRootKey = (WXHKEY) aStdKeys[keyParent].hkey;
 256 }
 257
 258 // the name is relative to the parent key
 259 void wxRegKey::SetName(const wxRegKey& keyParent, const wxString& strKey)
 260 {
 261   Close();
 262
 263   // combine our name with parent's to get the full name
 264   m_strKey = keyParent.m_strKey;
 265   if ( !strKey.IsEmpty() && strKey[0] != REG_SEPARATOR )
 266     m_strKey += REG_SEPARATOR;
 267   m_strKey += strKey;
 268
 269   RemoveTrailingSeparator(m_strKey);
 270
 271   m_hRootKey = keyParent.m_hRootKey;
 272 }
 273
 274 // hKey should be opened and will be closed in wxRegKey dtor
 275 void wxRegKey::SetHkey(WXHKEY hKey)
 276 {
 277   Close();
 278
 279   m_hKey = hKey;
 280 }
 281
 282 // ----------------------------------------------------------------------------
 283 // info about the key
 284 // ----------------------------------------------------------------------------
 285
 286 // returns TRUE if the key exists
 287 bool wxRegKey::Exists() const
 288 {
 289   // opened key has to exist, try to open it if not done yet
 290   return IsOpened() ? TRUE : KeyExists(m_hRootKey, m_strKey);
 291 }
 292
 293 // returns the full name of the key (prefix is abbreviated if bShortPrefix)
 294 wxString wxRegKey::GetName(bool bShortPrefix) const
 295 {
 296   StdKey key = GetStdKeyFromHkey((StdKey) m_hRootKey);
 297   wxString str = bShortPrefix ? aStdKeys[key].szShortName
 298                               : aStdKeys[key].szName;
 299   if ( !m_strKey.IsEmpty() )
 300     str << "\\" << m_strKey;
 301
 302   return str;
 303 }
 304
 305 #ifdef __GNUWIN32__
 306 bool wxRegKey::GetKeyInfo(size_t* pnSubKeys,
 307                           size_t* pnMaxKeyLen,
 308                           size_t* pnValues,
 309                           size_t* pnMaxValueLen) const
 310 #else
 311 bool wxRegKey::GetKeyInfo(ulong *pnSubKeys,
 312                           ulong *pnMaxKeyLen,
 313                           ulong *pnValues,
 314                           ulong *pnMaxValueLen) const
 315 #endif
 316 {
 317 #if defined(__WIN32__) && !defined(__TWIN32__)
 318   m_dwLastError = ::RegQueryInfoKey
 319                   (
 320                     (HKEY) m_hKey,
 321                     NULL,           // class name
 322                     NULL,           // (ptr to) size of class name buffer
 323                     RESERVED,
 324                     pnSubKeys,      // [out] number of subkeys
 325                     pnMaxKeyLen,    // [out] max length of a subkey name
 326                     NULL,           // longest subkey class name
 327                     pnValues,       // [out] number of values
 328                     pnMaxValueLen,  // [out] max length of a value name
 329                     NULL,           // longest value data
 330                     NULL,           // security descriptor
 331                     NULL            // time of last modification
 332                   );
 333
 334   if ( m_dwLastError != ERROR_SUCCESS ) {
 335     wxLogSysError(m_dwLastError, _("can't get info about registry key '%s'"),
 336                   GetName().c_str());
 337     return FALSE;
 338   }
 339   else
 340     return TRUE;
 341 #else // Win16
 342   wxFAIL_MSG("GetKeyInfo() not implemented");
 343
 344   return FALSE;
 345 #endif
 346 }
 347
 348 // ----------------------------------------------------------------------------
 349 // operations
 350 // ----------------------------------------------------------------------------
 351
 352 // opens key (it's not an error to call Open() on an already opened key)
 353 bool wxRegKey::Open()
 354 {
 355   if ( IsOpened() )
 356     return TRUE;
 357
 358   HKEY tmpKey;
 359   m_dwLastError = RegOpenKey((HKEY) m_hRootKey, m_strKey, &tmpKey);
 360   if ( m_dwLastError != ERROR_SUCCESS ) {
 361     wxLogSysError(m_dwLastError, _("can't open registry key '%s'"),
 362                   GetName().c_str());
 363     return FALSE;
 364   }
 365   else
 366   {
 367     m_hKey = (WXHKEY) tmpKey;
 368     return TRUE;
 369   }
 370 }
 371
 372 // creates key, failing if it exists and !bOkIfExists
 373 bool wxRegKey::Create(bool bOkIfExists)
 374 {
 375   // check for existence only if asked (i.e. order is important!)
 376   if ( !bOkIfExists && Exists() ) {
 377     return FALSE;
 378   }
 379
 380   if ( IsOpened() )
 381     return TRUE;
 382
 383   HKEY tmpKey;
 384   m_dwLastError = RegCreateKey((HKEY) m_hRootKey, m_strKey, &tmpKey);
 385   if ( m_dwLastError != ERROR_SUCCESS ) {
 386     wxLogSysError(m_dwLastError, _("can't create registry key '%s'"),
 387                   GetName().c_str());
 388     return FALSE;
 389   }
 390   else
 391   {
 392     m_hKey = (WXHKEY) tmpKey;
 393     return TRUE;
 394   }
 395 }
 396
 397 // close the key, it's not an error to call it when not opened
 398 bool wxRegKey::Close()
 399 {
 400   if ( IsOpened() ) {
 401     m_dwLastError = RegCloseKey((HKEY) m_hKey);
 402     if ( m_dwLastError != ERROR_SUCCESS ) {
 403       wxLogSysError(m_dwLastError, _("can't close registry key '%s'"),
 404                     GetName().c_str());
 405
 406       m_hKey = 0;
 407       return FALSE;
 408     }
 409     else {
 410       m_hKey = 0;
 411     }
 412   }
 413
 414   return TRUE;
 415 }
 416
 417 // ----------------------------------------------------------------------------
 418 // delete keys/values
 419 // ----------------------------------------------------------------------------
 420 bool wxRegKey::DeleteSelf()
 421 {
 422   {
 423     wxLogNull nolog;
 424     if ( !Open() ) {
 425       // it already doesn't exist - ok!
 426       return TRUE;
 427     }
 428   }
 429
 430   // we can't delete keys while enumerating because it confuses GetNextKey, so
 431   // we first save the key names and then delete them all
 432   wxArrayString astrSubkeys;
 433
 434   wxString strKey;
 435   long lIndex;
 436   bool bCont = GetFirstKey(strKey, lIndex);
 437   while ( bCont ) {
 438     astrSubkeys.Add(strKey);
 439
 440     bCont = GetNextKey(strKey, lIndex);
 441   }
 442
 443   size_t nKeyCount = astrSubkeys.Count();
 444   for ( size_t nKey = 0; nKey < nKeyCount; nKey++ ) {
 445     wxRegKey key(*this, astrSubkeys[nKey]);
 446     if ( !key.DeleteSelf() )
 447       return FALSE;
 448   }
 449
 450   // now delete this key itself
 451   Close();
 452
 453   m_dwLastError = RegDeleteKey((HKEY) m_hRootKey, m_strKey);
 454   if ( m_dwLastError != ERROR_SUCCESS ) {
 455     wxLogSysError(m_dwLastError, _("can't delete key '%s'"),
 456                   GetName().c_str());
 457     return FALSE;
 458   }
 459
 460   return TRUE;
 461 }
 462
 463 bool wxRegKey::DeleteKey(const char *szKey)
 464 {
 465   if ( !Open() )
 466     return FALSE;
 467
 468   wxRegKey key(*this, szKey);
 469   return key.DeleteSelf();
 470 }
 471
 472 bool wxRegKey::DeleteValue(const char *szValue)
 473 {
 474   if ( !Open() )
 475     return FALSE;
 476
 477 #if defined(__WIN32__) && !defined(__TWIN32__)
 478     m_dwLastError = RegDeleteValue((HKEY) m_hKey, (char*) (const char*) szValue);
 479     if ( m_dwLastError != ERROR_SUCCESS ) {
 480       wxLogSysError(m_dwLastError, _("can't delete value '%s' from key '%s'"),
 481                     szValue, GetName().c_str());
 482       return FALSE;
 483     }
 484   #else   //WIN16
 485     // named registry values don't exist in Win16 world
 486     wxASSERT( IsEmpty(szValue) );
 487
 488     // just set the (default and unique) value of the key to ""
 489     m_dwLastError = RegSetValue((HKEY) m_hKey, NULL, REG_SZ, "", RESERVED);
 490     if ( m_dwLastError != ERROR_SUCCESS ) {
 491       wxLogSysError(m_dwLastError, _("can't delete value of key '%s'"),
 492                     GetName().c_str());
 493       return FALSE;
 494     }
 495   #endif  //WIN16/32
 496
 497   return TRUE;
 498 }
 499
 500 // ----------------------------------------------------------------------------
 501 // access to values and subkeys
 502 // ----------------------------------------------------------------------------
 503
 504 // return TRUE if value exists
 505 bool wxRegKey::HasValue(const char *szValue) const
 506 {
 507   // this function should be silent, so suppress possible messages from Open()
 508   wxLogNull nolog;
 509
 510   #ifdef  __WIN32__
 511     if ( CONST_CAST Open() ) {
 512       return RegQueryValueEx((HKEY) m_hKey, (char*) (const char*) szValue, RESERVED,
 513                              NULL, NULL, NULL) == ERROR_SUCCESS;
 514     }
 515     else
 516       return FALSE;
 517   #else   // WIN16
 518     // only unnamed value exists
 519     return IsEmpty(szValue);
 520   #endif  // WIN16/32
 521 }
 522
 523 // returns TRUE if this key has any subkeys
 524 bool wxRegKey::HasSubkeys() const
 525 {
 526   // suppress possible messages from GetFirstKey()
 527   wxLogNull nolog;
 528
 529   // just call GetFirstKey with dummy parameters
 530   wxString str;
 531   long     l;
 532   return CONST_CAST GetFirstKey(str, l);
 533 }
 534
 535 // returns TRUE if given subkey exists
 536 bool wxRegKey::HasSubKey(const char *szKey) const
 537 {
 538   // this function should be silent, so suppress possible messages from Open()
 539   wxLogNull nolog;
 540
 541   if ( CONST_CAST Open() )
 542     return KeyExists(m_hKey, szKey);
 543   else
 544     return FALSE;
 545 }
 546
 547 wxRegKey::ValueType wxRegKey::GetValueType(const char *szValue)
 548 {
 549   #ifdef  __WIN32__
 550     if ( !Open() )
 551       return Type_None;
 552
 553     DWORD dwType;
 554     m_dwLastError = RegQueryValueEx((HKEY) m_hKey, (char*) (const char*) szValue, RESERVED,
 555                                     &dwType, NULL, NULL);
 556     if ( m_dwLastError != ERROR_SUCCESS ) {
 557       wxLogSysError(m_dwLastError, _("can't read value of key '%s'"),
 558                     GetName().c_str());
 559       return Type_None;
 560     }
 561
 562     return (ValueType)dwType;
 563   #else   //WIN16
 564     return IsEmpty(szValue) ? Type_String : Type_None;
 565   #endif  //WIN16/32
 566 }
 567
 568 #ifdef  __WIN32__
 569 bool wxRegKey::SetValue(const char *szValue, long lValue)
 570 {
 571 #ifdef __TWIN32__
 572   wxFAIL_MSG("RegSetValueEx not implemented by TWIN32");
 573   return FALSE;
 574 #else
 575   if ( CONST_CAST Open() ) {
 576     m_dwLastError = RegSetValueEx((HKEY) m_hKey, szValue, (DWORD) RESERVED, REG_DWORD,
 577                                   (RegString)&lValue, sizeof(lValue));
 578     if ( m_dwLastError == ERROR_SUCCESS )
 579       return TRUE;
 580   }
 581
 582   wxLogSysError(m_dwLastError, _("can't set value of '%s'"),
 583                 GetFullName(this, szValue));
 584   return FALSE;
 585 #endif
 586 }
 587
 588 bool wxRegKey::QueryValue(const char *szValue, long *plValue) const
 589 {
 590   if ( CONST_CAST Open() ) {
 591     DWORD dwType, dwSize = sizeof(DWORD);
 592     RegString pBuf = (RegString)plValue;
 593     m_dwLastError = RegQueryValueEx((HKEY) m_hKey, (char*) (const char*) szValue, RESERVED,
 594                                     &dwType, pBuf, &dwSize);
 595     if ( m_dwLastError != ERROR_SUCCESS ) {
 596       wxLogSysError(m_dwLastError, _("can't read value of key '%s'"),
 597                     GetName().c_str());
 598       return FALSE;
 599     }
 600     else {
 601       // check that we read the value of right type
 602       wxASSERT_MSG( dwType == REG_DWORD,
 603                     "Type mismatch in wxRegKey::QueryValue()."  );
 604
 605       return TRUE;
 606     }
 607   }
 608   else
 609     return FALSE;
 610 }
 611
 612 #endif  //Win32
 613
 614 bool wxRegKey::QueryValue(const char *szValue, wxString& strValue) const
 615 {
 616   if ( CONST_CAST Open() ) {
 617     #ifdef  __WIN32__
 618       // first get the type and size of the data
 619       DWORD dwType, dwSize;
 620       m_dwLastError = RegQueryValueEx((HKEY) m_hKey, (char*) (const char*) szValue, RESERVED,
 621                                       &dwType, NULL, &dwSize);
 622       if ( m_dwLastError == ERROR_SUCCESS ) {
 623         RegString pBuf = (RegString)strValue.GetWriteBuf(dwSize);
 624         m_dwLastError = RegQueryValueEx((HKEY) m_hKey, (char*) (const char*) szValue, RESERVED,
 625                                         &dwType, pBuf, &dwSize);
 626         strValue.UngetWriteBuf();
 627         if ( m_dwLastError == ERROR_SUCCESS ) {
 628           // check that it was the right type
 629           wxASSERT_MSG( dwType == REG_SZ,
 630                         "Type mismatch in wxRegKey::QueryValue()." );
 631
 632           return TRUE;
 633         }
 634       }
 635     #else   //WIN16
 636       // named registry values don't exist in Win16
 637       wxASSERT( IsEmpty(szValue) );
 638
 639       m_dwLastError = RegQueryValue((HKEY) m_hKey, 0, strValue.GetWriteBuf(256), &l);
 640       strValue.UngetWriteBuf();
 641       if ( m_dwLastError == ERROR_SUCCESS )
 642         return TRUE;
 643     #endif  //WIN16/32
 644   }
 645
 646   wxLogSysError(m_dwLastError, _("can't read value of '%s'"),
 647                 GetFullName(this, szValue));
 648   return FALSE;
 649 }
 650
 651 bool wxRegKey::SetValue(const char *szValue, const wxString& strValue)
 652 {
 653   if ( CONST_CAST Open() ) {
 654 #if defined( __WIN32__) && !defined(__TWIN32__)
 655       m_dwLastError = RegSetValueEx((HKEY) m_hKey, szValue, (DWORD) RESERVED, REG_SZ,
 656                                     (RegString)strValue.c_str(),
 657                                     strValue.Len() + 1);
 658       if ( m_dwLastError == ERROR_SUCCESS )
 659         return TRUE;
 660     #else   //WIN16
 661       // named registry values don't exist in Win16
 662       wxASSERT( IsEmpty(szValue) );
 663
 664       m_dwLastError = RegSetValue((HKEY) m_hKey, NULL, REG_SZ, strValue, NULL);
 665       if ( m_dwLastError == ERROR_SUCCESS )
 666         return TRUE;
 667     #endif  //WIN16/32
 668   }
 669
 670   wxLogSysError(m_dwLastError, _("can't set value of '%s'"),
 671                 GetFullName(this, szValue));
 672   return FALSE;
 673 }
 674
 675 wxRegKey::operator wxString() const
 676 {
 677   wxString str;
 678   QueryValue(NULL, str);
 679   return str;
 680 }
 681
 682 // ----------------------------------------------------------------------------
 683 // enumeration
 684 // NB: all these functions require an index variable which allows to have
 685 //     several concurrently running indexations on the same key
 686 // ----------------------------------------------------------------------------
 687
 688 bool wxRegKey::GetFirstValue(wxString& strValueName, long& lIndex)
 689 {
 690   if ( !Open() )
 691     return FALSE;
 692
 693   lIndex = 0;
 694   return GetNextValue(strValueName, lIndex);
 695 }
 696
 697 bool wxRegKey::GetNextValue(wxString& strValueName, long& lIndex) const
 698 {
 699   wxASSERT( IsOpened() );
 700
 701   // are we already at the end of enumeration?
 702   if ( lIndex == -1 )
 703     return FALSE;
 704
 705 #if defined( __WIN32__) && !defined(__TWIN32__)
 706     char  szValueName[1024];                  // @@ use RegQueryInfoKey...
 707     DWORD dwValueLen = WXSIZEOF(szValueName);
 708
 709     lIndex++;
 710     m_dwLastError = RegEnumValue((HKEY) m_hKey, lIndex,
 711                                  szValueName, &dwValueLen,
 712                                  RESERVED,
 713                                  NULL,            // [out] type
 714                                  NULL,            // [out] buffer for value
 715                                  NULL);           // [i/o]  it's length
 716
 717     if ( m_dwLastError != ERROR_SUCCESS ) {
 718       if ( m_dwLastError == ERROR_NO_MORE_ITEMS ) {
 719         m_dwLastError = ERROR_SUCCESS;
 720         lIndex = -1;
 721       }
 722       else {
 723         wxLogSysError(m_dwLastError, _("can't enumerate values of key '%s'"),
 724                       GetName().c_str());
 725       }
 726
 727       return FALSE;
 728     }
 729
 730     strValueName = szValueName;
 731   #else   //WIN16
 732     // only one unnamed value
 733     wxASSERT( lIndex == 0 );
 734
 735     lIndex = -1;
 736     strValueName.Empty();
 737   #endif
 738
 739   return TRUE;
 740 }
 741
 742 bool wxRegKey::GetFirstKey(wxString& strKeyName, long& lIndex)
 743 {
 744   if ( !Open() )
 745     return FALSE;
 746
 747   lIndex = 0;
 748   return GetNextKey(strKeyName, lIndex);
 749 }
 750
 751 bool wxRegKey::GetNextKey(wxString& strKeyName, long& lIndex) const
 752 {
 753   wxASSERT( IsOpened() );
 754
 755   // are we already at the end of enumeration?
 756   if ( lIndex == -1 )
 757     return FALSE;
 758
 759   char szKeyName[_MAX_PATH + 1];
 760   m_dwLastError = RegEnumKey((HKEY) m_hKey, lIndex++, szKeyName, WXSIZEOF(szKeyName));
 761
 762   if ( m_dwLastError != ERROR_SUCCESS ) {
 763     if ( m_dwLastError == ERROR_NO_MORE_ITEMS ) {
 764       m_dwLastError = ERROR_SUCCESS;
 765       lIndex = -1;
 766     }
 767     else {
 768       wxLogSysError(m_dwLastError, _("can't enumerate subkeys of key '%s'"),
 769                     GetName().c_str());
 770     }
 771
 772     return FALSE;
 773   }
 774
 775   strKeyName = szKeyName;
 776   return TRUE;
 777 }
 778
 779 // ============================================================================
 780 // implementation of global private functions
 781 // ============================================================================
 782 bool KeyExists(WXHKEY hRootKey, const char *szKey)
 783 {
 784   HKEY hkeyDummy;
 785   if ( RegOpenKey( (HKEY) hRootKey, szKey, &hkeyDummy) == ERROR_SUCCESS ) {
 786     RegCloseKey(hkeyDummy);
 787     return TRUE;
 788   }
 789   else
 790     return FALSE;
 791 }
 792
 793 const char *GetFullName(const wxRegKey *pKey, const char *szValue)
 794 {
 795   static wxString s_str;
 796   s_str = pKey->GetName();
 797   if ( !IsEmpty(szValue) )
 798     s_str << "\\" << szValue;
 799
 800   return s_str.c_str();
 801 }
 802
 803 void RemoveTrailingSeparator(wxString& str)
 804 {
 805   if ( !str.IsEmpty() && str.Last() == REG_SEPARATOR )
 806     str.Truncate(str.Len() - 1);
 807 }
 808
 809 #endif
 810   // __WIN16__
 811