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 #ifdef  __WIN32__
 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   #ifdef  __WIN32__
 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   if ( CONST_CAST Open() ) {
 572     m_dwLastError = RegSetValueEx((HKEY) m_hKey, szValue, (DWORD) RESERVED, REG_DWORD,
 573                                   (RegString)&lValue, sizeof(lValue));
 574     if ( m_dwLastError == ERROR_SUCCESS )
 575       return TRUE;
 576   }
 577
 578   wxLogSysError(m_dwLastError, _("can't set value of '%s'"),
 579                 GetFullName(this, szValue));
 580   return FALSE;
 581 }
 582
 583 bool wxRegKey::QueryValue(const char *szValue, long *plValue) const
 584 {
 585   if ( CONST_CAST Open() ) {
 586     DWORD dwType, dwSize = sizeof(DWORD);
 587     RegString pBuf = (RegString)plValue;
 588     m_dwLastError = RegQueryValueEx((HKEY) m_hKey, (char*) (const char*) szValue, RESERVED,
 589                                     &dwType, pBuf, &dwSize);
 590     if ( m_dwLastError != ERROR_SUCCESS ) {
 591       wxLogSysError(m_dwLastError, _("can't read value of key '%s'"),
 592                     GetName().c_str());
 593       return FALSE;
 594     }
 595     else {
 596       // check that we read the value of right type
 597       wxASSERT_MSG( dwType == REG_DWORD,
 598                     "Type mismatch in wxRegKey::QueryValue()."  );
 599
 600       return TRUE;
 601     }
 602   }
 603   else
 604     return FALSE;
 605 }
 606
 607 #endif  //Win32
 608
 609 bool wxRegKey::QueryValue(const char *szValue, wxString& strValue) const
 610 {
 611   if ( CONST_CAST Open() ) {
 612     #ifdef  __WIN32__
 613       // first get the type and size of the data
 614       DWORD dwType, dwSize;
 615       m_dwLastError = RegQueryValueEx((HKEY) m_hKey, (char*) (const char*) szValue, RESERVED,
 616                                       &dwType, NULL, &dwSize);
 617       if ( m_dwLastError == ERROR_SUCCESS ) {
 618         RegString pBuf = (RegString)strValue.GetWriteBuf(dwSize);
 619         m_dwLastError = RegQueryValueEx((HKEY) m_hKey, (char*) (const char*) szValue, RESERVED,
 620                                         &dwType, pBuf, &dwSize);
 621         strValue.UngetWriteBuf();
 622         if ( m_dwLastError == ERROR_SUCCESS ) {
 623           // check that it was the right type
 624           wxASSERT_MSG( dwType == REG_SZ,
 625                         "Type mismatch in wxRegKey::QueryValue()." );
 626
 627           return TRUE;
 628         }
 629       }
 630     #else   //WIN16
 631       // named registry values don't exist in Win16
 632       wxASSERT( IsEmpty(szValue) );
 633
 634       m_dwLastError = RegQueryValue((HKEY) m_hKey, 0, strValue.GetWriteBuf(256), &l);
 635       strValue.UngetWriteBuf();
 636       if ( m_dwLastError == ERROR_SUCCESS )
 637         return TRUE;
 638     #endif  //WIN16/32
 639   }
 640
 641   wxLogSysError(m_dwLastError, _("can't read value of '%s'"),
 642                 GetFullName(this, szValue));
 643   return FALSE;
 644 }
 645
 646 bool wxRegKey::SetValue(const char *szValue, const wxString& strValue)
 647 {
 648   if ( CONST_CAST Open() ) {
 649     #ifdef  __WIN32__
 650       m_dwLastError = RegSetValueEx((HKEY) m_hKey, szValue, (DWORD) RESERVED, REG_SZ,
 651                                     (RegString)strValue.c_str(),
 652                                     strValue.Len() + 1);
 653       if ( m_dwLastError == ERROR_SUCCESS )
 654         return TRUE;
 655     #else   //WIN16
 656       // named registry values don't exist in Win16
 657       wxASSERT( IsEmpty(szValue) );
 658
 659       m_dwLastError = RegSetValue((HKEY) m_hKey, NULL, REG_SZ, strValue, NULL);
 660       if ( m_dwLastError == ERROR_SUCCESS )
 661         return TRUE;
 662     #endif  //WIN16/32
 663   }
 664
 665   wxLogSysError(m_dwLastError, _("can't set value of '%s'"),
 666                 GetFullName(this, szValue));
 667   return FALSE;
 668 }
 669
 670 wxRegKey::operator wxString() const
 671 {
 672   wxString str;
 673   QueryValue(NULL, str);
 674   return str;
 675 }
 676
 677 // ----------------------------------------------------------------------------
 678 // enumeration
 679 // NB: all these functions require an index variable which allows to have
 680 //     several concurrently running indexations on the same key
 681 // ----------------------------------------------------------------------------
 682
 683 bool wxRegKey::GetFirstValue(wxString& strValueName, long& lIndex)
 684 {
 685   if ( !Open() )
 686     return FALSE;
 687
 688   lIndex = 0;
 689   return GetNextValue(strValueName, lIndex);
 690 }
 691
 692 bool wxRegKey::GetNextValue(wxString& strValueName, long& lIndex) const
 693 {
 694   wxASSERT( IsOpened() );
 695
 696   // are we already at the end of enumeration?
 697   if ( lIndex == -1 )
 698     return FALSE;
 699
 700   #ifdef  __WIN32__
 701     char  szValueName[1024];                  // @@ use RegQueryInfoKey...
 702     DWORD dwValueLen = WXSIZEOF(szValueName);
 703
 704     lIndex++;
 705     m_dwLastError = RegEnumValue((HKEY) m_hKey, lIndex,
 706                                  szValueName, &dwValueLen,
 707                                  RESERVED,
 708                                  NULL,            // [out] type
 709                                  NULL,            // [out] buffer for value
 710                                  NULL);           // [i/o]  it's length
 711
 712     if ( m_dwLastError != ERROR_SUCCESS ) {
 713       if ( m_dwLastError == ERROR_NO_MORE_ITEMS ) {
 714         m_dwLastError = ERROR_SUCCESS;
 715         lIndex = -1;
 716       }
 717       else {
 718         wxLogSysError(m_dwLastError, _("can't enumerate values of key '%s'"),
 719                       GetName().c_str());
 720       }
 721
 722       return FALSE;
 723     }
 724
 725     strValueName = szValueName;
 726   #else   //WIN16
 727     // only one unnamed value
 728     wxASSERT( lIndex == 0 );
 729
 730     lIndex = -1;
 731     strValueName.Empty();
 732   #endif
 733
 734   return TRUE;
 735 }
 736
 737 bool wxRegKey::GetFirstKey(wxString& strKeyName, long& lIndex)
 738 {
 739   if ( !Open() )
 740     return FALSE;
 741
 742   lIndex = 0;
 743   return GetNextKey(strKeyName, lIndex);
 744 }
 745
 746 bool wxRegKey::GetNextKey(wxString& strKeyName, long& lIndex) const
 747 {
 748   wxASSERT( IsOpened() );
 749
 750   // are we already at the end of enumeration?
 751   if ( lIndex == -1 )
 752     return FALSE;
 753
 754   char szKeyName[_MAX_PATH + 1];
 755   m_dwLastError = RegEnumKey((HKEY) m_hKey, lIndex++, szKeyName, WXSIZEOF(szKeyName));
 756
 757   if ( m_dwLastError != ERROR_SUCCESS ) {
 758     if ( m_dwLastError == ERROR_NO_MORE_ITEMS ) {
 759       m_dwLastError = ERROR_SUCCESS;
 760       lIndex = -1;
 761     }
 762     else {
 763       wxLogSysError(m_dwLastError, _("can't enumerate subkeys of key '%s'"),
 764                     GetName().c_str());
 765     }
 766
 767     return FALSE;
 768   }
 769
 770   strKeyName = szKeyName;
 771   return TRUE;
 772 }
 773
 774 // ============================================================================
 775 // implementation of global private functions
 776 // ============================================================================
 777 bool KeyExists(WXHKEY hRootKey, const char *szKey)
 778 {
 779   HKEY hkeyDummy;
 780   if ( RegOpenKey( (HKEY) hRootKey, szKey, &hkeyDummy) == ERROR_SUCCESS ) {
 781     RegCloseKey(hkeyDummy);
 782     return TRUE;
 783   }
 784   else
 785     return FALSE;
 786 }
 787
 788 const char *GetFullName(const wxRegKey *pKey, const char *szValue)
 789 {
 790   static wxString s_str;
 791   s_str = pKey->GetName();
 792   if ( !IsEmpty(szValue) )
 793     s_str << "\\" << szValue;
 794
 795   return s_str.c_str();
 796 }
 797
 798 void RemoveTrailingSeparator(wxString& str)
 799 {
 800   if ( !str.IsEmpty() && str.Last() == REG_SEPARATOR )
 801     str.Truncate(str.Len() - 1);
 802 }
 803
 804 #endif
 805   // __WIN16__
 806