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 licence
  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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  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 wxWidgets headers
  27 #include  "wx/string.h"
  28 #include  "wx/intl.h"
  29 #include  "wx/log.h"
  30 #include  "wx/file.h"
  31 #include  "wx/wfstream.h"
  32
  33 // Windows headers
  34 #include  "wx/msw/wrapwin.h"
  35
  36 #ifdef __WXWINCE__
  37 #include "wx/msw/private.h"
  38 #include <winbase.h>
  39 #include <winreg.h>
  40 #endif
  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 typedef BYTE* RegBinary;
  56
  57 // ----------------------------------------------------------------------------
  58 // constants
  59 // ----------------------------------------------------------------------------
  60
  61 // the standard key names, short names and handles all bundled together for
  62 // convenient access
  63 static struct
  64 {
  65   HKEY        hkey;
  66   const wxChar *szName;
  67   const wxChar *szShortName;
  68 }
  69 aStdKeys[] =
  70 {
  71   { HKEY_CLASSES_ROOT,      wxT("HKEY_CLASSES_ROOT"),      wxT("HKCR") },
  72   { HKEY_CURRENT_USER,      wxT("HKEY_CURRENT_USER"),      wxT("HKCU") },
  73   { HKEY_LOCAL_MACHINE,     wxT("HKEY_LOCAL_MACHINE"),     wxT("HKLM") },
  74   { HKEY_USERS,             wxT("HKEY_USERS"),             wxT("HKU")  }, // short name?
  75 #ifndef __WXWINCE__
  76   { HKEY_PERFORMANCE_DATA,  wxT("HKEY_PERFORMANCE_DATA"),  wxT("HKPD") },
  77 #endif
  78 #ifdef HKEY_CURRENT_CONFIG
  79   { HKEY_CURRENT_CONFIG,    wxT("HKEY_CURRENT_CONFIG"),    wxT("HKCC") },
  80 #endif
  81 #ifdef HKEY_DYN_DATA
  82   { HKEY_DYN_DATA,          wxT("HKEY_DYN_DATA"),          wxT("HKDD") }, // short name?
  83 #endif
  84 };
  85
  86 // the registry name separator (perhaps one day MS will change it to '/' ;-)
  87 #define   REG_SEPARATOR     wxT('\\')
  88
  89 // useful for Windows programmers: makes somewhat more clear all these zeroes
  90 // being passed to Windows APIs
  91 #define   RESERVED        (0)
  92
  93 // ----------------------------------------------------------------------------
  94 // macros
  95 // ----------------------------------------------------------------------------
  96
  97 // const_cast<> is not yet supported by all compilers
  98 #define CONST_CAST    ((wxRegKey *)this)->
  99
 100 // and neither is mutable which m_dwLastError should be
 101 #define m_dwLastError   CONST_CAST m_dwLastError
 102
 103 // ----------------------------------------------------------------------------
 104 // non member functions
 105 // ----------------------------------------------------------------------------
 106
 107 // removes the trailing backslash from the string if it has one
 108 static inline void RemoveTrailingSeparator(wxString& str);
 109
 110 // returns true if given registry key exists
 111 static bool KeyExists(WXHKEY hRootKey, const wxChar *szKey);
 112
 113 // combines value and key name (uses static buffer!)
 114 static const wxChar *GetFullName(const wxRegKey *pKey,
 115                                const wxChar *szValue = NULL);
 116
 117 // ============================================================================
 118 // implementation of wxRegKey class
 119 // ============================================================================
 120
 121 // ----------------------------------------------------------------------------
 122 // static functions and variables
 123 // ----------------------------------------------------------------------------
 124
 125 const size_t wxRegKey::nStdKeys = WXSIZEOF(aStdKeys);
 126
 127 // @@ should take a `StdKey key', but as it's often going to be used in loops
 128 //    it would require casts in user code.
 129 const wxChar *wxRegKey::GetStdKeyName(size_t key)
 130 {
 131   // return empty string if key is invalid
 132   wxCHECK_MSG( key < nStdKeys, wxEmptyString, wxT("invalid key in wxRegKey::GetStdKeyName") );
 133
 134   return aStdKeys[key].szName;
 135 }
 136
 137 const wxChar *wxRegKey::GetStdKeyShortName(size_t key)
 138 {
 139   // return empty string if key is invalid
 140   wxCHECK( key < nStdKeys, wxEmptyString );
 141
 142   return aStdKeys[key].szShortName;
 143 }
 144
 145 wxRegKey::StdKey wxRegKey::ExtractKeyName(wxString& strKey)
 146 {
 147   wxString strRoot = strKey.BeforeFirst(REG_SEPARATOR);
 148
 149   HKEY hRootKey = 0;
 150   size_t ui;
 151   for ( ui = 0; ui < nStdKeys; ui++ ) {
 152     if ( strRoot.CmpNoCase(aStdKeys[ui].szName) == 0 ||
 153          strRoot.CmpNoCase(aStdKeys[ui].szShortName) == 0 ) {
 154       hRootKey = aStdKeys[ui].hkey;
 155       break;
 156     }
 157   }
 158
 159   if ( ui == nStdKeys ) {
 160     wxFAIL_MSG(wxT("invalid key prefix in wxRegKey::ExtractKeyName."));
 161
 162     hRootKey = HKEY_CLASSES_ROOT;
 163   }
 164   else {
 165     strKey = strKey.After(REG_SEPARATOR);
 166     if ( !strKey.empty() && strKey.Last() == REG_SEPARATOR )
 167       strKey.Truncate(strKey.Len() - 1);
 168   }
 169
 170   return (wxRegKey::StdKey)(int)hRootKey;
 171 }
 172
 173 wxRegKey::StdKey wxRegKey::GetStdKeyFromHkey(WXHKEY hkey)
 174 {
 175   for ( size_t ui = 0; ui < nStdKeys; ui++ ) {
 176     if ( (int) aStdKeys[ui].hkey == (int) hkey )
 177       return (StdKey)ui;
 178   }
 179
 180   wxFAIL_MSG(wxT("non root hkey passed to wxRegKey::GetStdKeyFromHkey."));
 181
 182   return HKCR;
 183 }
 184
 185 // ----------------------------------------------------------------------------
 186 // ctors and dtor
 187 // ----------------------------------------------------------------------------
 188
 189 wxRegKey::wxRegKey()
 190 {
 191   m_hRootKey = (WXHKEY) aStdKeys[HKCR].hkey;
 192
 193   Init();
 194 }
 195
 196 wxRegKey::wxRegKey(const wxString& strKey) : m_strKey(strKey)
 197 {
 198   m_hRootKey  = (WXHKEY) aStdKeys[ExtractKeyName(m_strKey)].hkey;
 199
 200   Init();
 201 }
 202
 203 // parent is a predefined (and preopened) key
 204 wxRegKey::wxRegKey(StdKey keyParent, const wxString& strKey) : m_strKey(strKey)
 205 {
 206   RemoveTrailingSeparator(m_strKey);
 207   m_hRootKey  = (WXHKEY) aStdKeys[keyParent].hkey;
 208
 209   Init();
 210 }
 211
 212 // parent is a normal regkey
 213 wxRegKey::wxRegKey(const wxRegKey& keyParent, const wxString& strKey)
 214         : m_strKey(keyParent.m_strKey)
 215 {
 216   // combine our name with parent's to get the full name
 217   if ( !m_strKey.empty() &&
 218        (strKey.empty() || strKey[0] != REG_SEPARATOR) ) {
 219       m_strKey += REG_SEPARATOR;
 220   }
 221
 222   m_strKey += strKey;
 223   RemoveTrailingSeparator(m_strKey);
 224
 225   m_hRootKey  = keyParent.m_hRootKey;
 226
 227   Init();
 228 }
 229
 230 // dtor closes the key releasing system resource
 231 wxRegKey::~wxRegKey()
 232 {
 233   Close();
 234 }
 235
 236 // ----------------------------------------------------------------------------
 237 // change the key name/hkey
 238 // ----------------------------------------------------------------------------
 239
 240 // set the full key name
 241 void wxRegKey::SetName(const wxString& strKey)
 242 {
 243   Close();
 244
 245   m_strKey = strKey;
 246   m_hRootKey = (WXHKEY) aStdKeys[ExtractKeyName(m_strKey)].hkey;
 247 }
 248
 249 // the name is relative to the parent key
 250 void wxRegKey::SetName(StdKey keyParent, const wxString& strKey)
 251 {
 252   Close();
 253
 254   m_strKey = strKey;
 255   RemoveTrailingSeparator(m_strKey);
 256   m_hRootKey = (WXHKEY) aStdKeys[keyParent].hkey;
 257 }
 258
 259 // the name is relative to the parent key
 260 void wxRegKey::SetName(const wxRegKey& keyParent, const wxString& strKey)
 261 {
 262   Close();
 263
 264   // combine our name with parent's to get the full name
 265
 266   // NB: this method is called by wxRegConfig::SetPath() which is a performance
 267   //     critical function and so it preallocates space for our m_strKey to
 268   //     gain some speed - this is why we only use += here and not = which
 269   //     would just free the prealloc'd buffer and would have to realloc it the
 270   //     next line!
 271   m_strKey.clear();
 272   m_strKey += keyParent.m_strKey;
 273   if ( !strKey.empty() && strKey[0] != REG_SEPARATOR )
 274     m_strKey += REG_SEPARATOR;
 275   m_strKey += strKey;
 276
 277   RemoveTrailingSeparator(m_strKey);
 278
 279   m_hRootKey = keyParent.m_hRootKey;
 280 }
 281
 282 // hKey should be opened and will be closed in wxRegKey dtor
 283 void wxRegKey::SetHkey(WXHKEY hKey)
 284 {
 285   Close();
 286
 287   m_hKey = hKey;
 288 }
 289
 290 // ----------------------------------------------------------------------------
 291 // info about the key
 292 // ----------------------------------------------------------------------------
 293
 294 // returns true if the key exists
 295 bool wxRegKey::Exists() const
 296 {
 297   // opened key has to exist, try to open it if not done yet
 298   return IsOpened() ? true : KeyExists(m_hRootKey, m_strKey);
 299 }
 300
 301 // returns the full name of the key (prefix is abbreviated if bShortPrefix)
 302 wxString wxRegKey::GetName(bool bShortPrefix) const
 303 {
 304   StdKey key = GetStdKeyFromHkey((WXHKEY) m_hRootKey);
 305   wxString str = bShortPrefix ? aStdKeys[key].szShortName
 306                               : aStdKeys[key].szName;
 307   if ( !m_strKey.empty() )
 308     str << _T("\\") << m_strKey;
 309
 310   return str;
 311 }
 312
 313 bool wxRegKey::GetKeyInfo(size_t *pnSubKeys,
 314                           size_t *pnMaxKeyLen,
 315                           size_t *pnValues,
 316                           size_t *pnMaxValueLen) const
 317 {
 318     // old gcc headers incorrectly prototype RegQueryInfoKey()
 319 #if defined(__GNUWIN32_OLD__) && !defined(__CYGWIN10__)
 320     #define REG_PARAM   (size_t *)
 321 #else
 322     #define REG_PARAM   (LPDWORD)
 323 #endif
 324
 325   // it might be unexpected to some that this function doesn't open the key
 326   wxASSERT_MSG( IsOpened(), _T("key should be opened in GetKeyInfo") );
 327
 328   m_dwLastError = ::RegQueryInfoKey
 329                   (
 330                     (HKEY) m_hKey,
 331                     NULL,           // class name
 332                     NULL,           // (ptr to) size of class name buffer
 333                     RESERVED,
 334                     REG_PARAM
 335                     pnSubKeys,      // [out] number of subkeys
 336                     REG_PARAM
 337                     pnMaxKeyLen,    // [out] max length of a subkey name
 338                     NULL,           // longest subkey class name
 339                     REG_PARAM
 340                     pnValues,       // [out] number of values
 341                     REG_PARAM
 342                     pnMaxValueLen,  // [out] max length of a value name
 343                     NULL,           // longest value data
 344                     NULL,           // security descriptor
 345                     NULL            // time of last modification
 346                   );
 347
 348 #undef REG_PARAM
 349
 350   if ( m_dwLastError != ERROR_SUCCESS ) {
 351     wxLogSysError(m_dwLastError, _("Can't get info about registry key '%s'"),
 352                   GetName().c_str());
 353     return false;
 354   }
 355
 356   return true;
 357 }
 358
 359 // ----------------------------------------------------------------------------
 360 // operations
 361 // ----------------------------------------------------------------------------
 362
 363 // opens key (it's not an error to call Open() on an already opened key)
 364 bool wxRegKey::Open(AccessMode mode)
 365 {
 366     if ( IsOpened() )
 367     {
 368         if ( mode <= m_mode )
 369             return true;
 370
 371         // we had been opened in read mode but now must be reopened in write
 372         Close();
 373     }
 374
 375     HKEY tmpKey;
 376     m_dwLastError = ::RegOpenKeyEx
 377                     (
 378                         (HKEY) m_hRootKey,
 379                         m_strKey,
 380                         RESERVED,
 381                         mode == Read ? KEY_READ : KEY_ALL_ACCESS,
 382                         &tmpKey
 383                     );
 384
 385     if ( m_dwLastError != ERROR_SUCCESS )
 386     {
 387         wxLogSysError(m_dwLastError, _("Can't open registry key '%s'"),
 388                       GetName().c_str());
 389         return false;
 390     }
 391
 392     m_hKey = (WXHKEY) tmpKey;
 393     m_mode = mode;
 394
 395     return true;
 396 }
 397
 398 // creates key, failing if it exists and !bOkIfExists
 399 bool wxRegKey::Create(bool bOkIfExists)
 400 {
 401   // check for existence only if asked (i.e. order is important!)
 402   if ( !bOkIfExists && Exists() )
 403     return false;
 404
 405   if ( IsOpened() )
 406     return true;
 407
 408   HKEY tmpKey;
 409 #ifdef __WXWINCE__
 410   DWORD disposition;
 411   m_dwLastError = RegCreateKeyEx((HKEY) m_hRootKey, m_strKey,
 412       NULL, // reserved
 413       NULL, // class string
 414       0,
 415       0,
 416       NULL,
 417       &tmpKey,
 418       &disposition);
 419 #else
 420   m_dwLastError = RegCreateKey((HKEY) m_hRootKey, m_strKey, &tmpKey);
 421 #endif
 422   if ( m_dwLastError != ERROR_SUCCESS ) {
 423     wxLogSysError(m_dwLastError, _("Can't create registry key '%s'"),
 424                   GetName().c_str());
 425     return false;
 426   }
 427   else
 428   {
 429     m_hKey = (WXHKEY) tmpKey;
 430     return true;
 431   }
 432 }
 433
 434 // close the key, it's not an error to call it when not opened
 435 bool wxRegKey::Close()
 436 {
 437   if ( IsOpened() ) {
 438     m_dwLastError = RegCloseKey((HKEY) m_hKey);
 439     m_hKey = 0;
 440
 441     if ( m_dwLastError != ERROR_SUCCESS ) {
 442       wxLogSysError(m_dwLastError, _("Can't close registry key '%s'"),
 443                     GetName().c_str());
 444
 445       return false;
 446     }
 447   }
 448
 449   return true;
 450 }
 451
 452 bool wxRegKey::RenameValue(const wxChar *szValueOld, const wxChar *szValueNew)
 453 {
 454     bool ok = true;
 455     if ( HasValue(szValueNew) ) {
 456         wxLogError(_("Registry value '%s' already exists."), szValueNew);
 457
 458         ok = false;
 459     }
 460
 461     if ( !ok ||
 462          !CopyValue(szValueOld, *this, szValueNew) ||
 463          !DeleteValue(szValueOld) ) {
 464         wxLogError(_("Failed to rename registry value '%s' to '%s'."),
 465                    szValueOld, szValueNew);
 466
 467         return false;
 468     }
 469
 470     return true;
 471 }
 472
 473 bool wxRegKey::CopyValue(const wxChar *szValue,
 474                          wxRegKey& keyDst,
 475                          const wxChar *szValueNew)
 476 {
 477     if ( !szValueNew ) {
 478         // by default, use the same name
 479         szValueNew = szValue;
 480     }
 481
 482     switch ( GetValueType(szValue) ) {
 483         case Type_String:
 484             {
 485                 wxString strVal;
 486                 return QueryValue(szValue, strVal) &&
 487                        keyDst.SetValue(szValueNew, strVal);
 488             }
 489
 490         case Type_Dword:
 491         /* case Type_Dword_little_endian: == Type_Dword */
 492             {
 493                 long dwVal;
 494                 return QueryValue(szValue, &dwVal) &&
 495                        keyDst.SetValue(szValueNew, dwVal);
 496             }
 497
 498         case Type_Binary:
 499         {
 500             wxMemoryBuffer buf;
 501             return QueryValue(szValue,buf) &&
 502                    keyDst.SetValue(szValueNew,buf);
 503         }
 504
 505         // these types are unsupported because I am not sure about how
 506         // exactly they should be copied and because they shouldn't
 507         // occur among the application keys (supposedly created with
 508         // this class)
 509         case Type_None:
 510         case Type_Expand_String:
 511         case Type_Dword_big_endian:
 512         case Type_Link:
 513         case Type_Multi_String:
 514         case Type_Resource_list:
 515         case Type_Full_resource_descriptor:
 516         case Type_Resource_requirements_list:
 517         default:
 518             wxLogError(_("Can't copy values of unsupported type %d."),
 519                        GetValueType(szValue));
 520             return false;
 521     }
 522 }
 523
 524 bool wxRegKey::Rename(const wxChar *szNewName)
 525 {
 526     wxCHECK_MSG( !m_strKey.empty(), false, _T("registry hives can't be renamed") );
 527
 528     if ( !Exists() ) {
 529         wxLogError(_("Registry key '%s' does not exist, cannot rename it."),
 530                    GetFullName(this));
 531
 532         return false;
 533     }
 534
 535     // do we stay in the same hive?
 536     bool inSameHive = !wxStrchr(szNewName, REG_SEPARATOR);
 537
 538     // construct the full new name of the key
 539     wxRegKey keyDst;
 540
 541     if ( inSameHive ) {
 542         // rename the key to the new name under the same parent
 543         wxString strKey = m_strKey.BeforeLast(REG_SEPARATOR);
 544         if ( !strKey.empty() ) {
 545             // don't add '\\' in the start if strFullNewName is empty
 546             strKey += REG_SEPARATOR;
 547         }
 548
 549         strKey += szNewName;
 550
 551         keyDst.SetName(GetStdKeyFromHkey(m_hRootKey), strKey);
 552     }
 553     else {
 554         // this is the full name already
 555         keyDst.SetName(szNewName);
 556     }
 557
 558     bool ok = keyDst.Create(false /* fail if alredy exists */);
 559     if ( !ok ) {
 560         wxLogError(_("Registry key '%s' already exists."),
 561                    GetFullName(&keyDst));
 562     }
 563     else {
 564         ok = Copy(keyDst) && DeleteSelf();
 565     }
 566
 567     if ( !ok ) {
 568         wxLogError(_("Failed to rename the registry key '%s' to '%s'."),
 569                    GetFullName(this), GetFullName(&keyDst));
 570     }
 571     else {
 572         m_hRootKey = keyDst.m_hRootKey;
 573         m_strKey = keyDst.m_strKey;
 574     }
 575
 576     return ok;
 577 }
 578
 579 bool wxRegKey::Copy(const wxChar *szNewName)
 580 {
 581     // create the new key first
 582     wxRegKey keyDst(szNewName);
 583     bool ok = keyDst.Create(false /* fail if alredy exists */);
 584     if ( ok ) {
 585         ok = Copy(keyDst);
 586
 587         // we created the dest key but copying to it failed - delete it
 588         if ( !ok ) {
 589             (void)keyDst.DeleteSelf();
 590         }
 591     }
 592
 593     return ok;
 594 }
 595
 596 bool wxRegKey::Copy(wxRegKey& keyDst)
 597 {
 598     bool ok = true;
 599
 600     // copy all sub keys to the new location
 601     wxString strKey;
 602     long lIndex;
 603     bool bCont = GetFirstKey(strKey, lIndex);
 604     while ( ok && bCont ) {
 605         wxRegKey key(*this, strKey);
 606         wxString keyName;
 607         keyName << GetFullName(&keyDst) << REG_SEPARATOR << strKey;
 608         ok = key.Copy((const wxChar*) keyName);
 609
 610         if ( ok )
 611             bCont = GetNextKey(strKey, lIndex);
 612         else
 613             wxLogError(_("Failed to copy the registry subkey '%s' to '%s'."),
 614                    GetFullName(&key), keyName.c_str());
 615
 616     }
 617
 618     // copy all values
 619     wxString strVal;
 620     bCont = GetFirstValue(strVal, lIndex);
 621     while ( ok && bCont ) {
 622         ok = CopyValue(strVal, keyDst);
 623
 624         if ( !ok ) {
 625             wxLogSysError(m_dwLastError,
 626                           _("Failed to copy registry value '%s'"),
 627                           strVal.c_str());
 628         }
 629         else {
 630             bCont = GetNextValue(strVal, lIndex);
 631         }
 632     }
 633
 634     if ( !ok ) {
 635         wxLogError(_("Failed to copy the contents of registry key '%s' to '%s'."),
 636                    GetFullName(this), GetFullName(&keyDst));
 637     }
 638
 639     return ok;
 640 }
 641
 642 // ----------------------------------------------------------------------------
 643 // delete keys/values
 644 // ----------------------------------------------------------------------------
 645 bool wxRegKey::DeleteSelf()
 646 {
 647   {
 648     wxLogNull nolog;
 649     if ( !Open() ) {
 650       // it already doesn't exist - ok!
 651       return true;
 652     }
 653   }
 654
 655   // prevent a buggy program from erasing one of the root registry keys or an
 656   // immediate subkey (i.e. one which doesn't have '\\' inside) of any other
 657   // key except HKCR (HKCR has some "deleteable" subkeys)
 658   if ( m_strKey.empty() ||
 659        ((m_hRootKey != (WXHKEY) aStdKeys[HKCR].hkey) &&
 660         (m_strKey.Find(REG_SEPARATOR) == wxNOT_FOUND)) ) {
 661       wxLogError(_("Registry key '%s' is needed for normal system operation,\ndeleting it will leave your system in unusable state:\noperation aborted."),
 662                  GetFullName(this));
 663
 664       return false;
 665   }
 666
 667   // we can't delete keys while enumerating because it confuses GetNextKey, so
 668   // we first save the key names and then delete them all
 669   wxArrayString astrSubkeys;
 670
 671   wxString strKey;
 672   long lIndex;
 673   bool bCont = GetFirstKey(strKey, lIndex);
 674   while ( bCont ) {
 675     astrSubkeys.Add(strKey);
 676
 677     bCont = GetNextKey(strKey, lIndex);
 678   }
 679
 680   size_t nKeyCount = astrSubkeys.Count();
 681   for ( size_t nKey = 0; nKey < nKeyCount; nKey++ ) {
 682     wxRegKey key(*this, astrSubkeys[nKey]);
 683     if ( !key.DeleteSelf() )
 684       return false;
 685   }
 686
 687   // now delete this key itself
 688   Close();
 689
 690   m_dwLastError = RegDeleteKey((HKEY) m_hRootKey, m_strKey);
 691   // deleting a key which doesn't exist is not considered an error
 692   if ( m_dwLastError != ERROR_SUCCESS &&
 693           m_dwLastError != ERROR_FILE_NOT_FOUND ) {
 694     wxLogSysError(m_dwLastError, _("Can't delete key '%s'"),
 695                   GetName().c_str());
 696     return false;
 697   }
 698
 699   return true;
 700 }
 701
 702 bool wxRegKey::DeleteKey(const wxChar *szKey)
 703 {
 704   if ( !Open() )
 705     return false;
 706
 707   wxRegKey key(*this, szKey);
 708   return key.DeleteSelf();
 709 }
 710
 711 bool wxRegKey::DeleteValue(const wxChar *szValue)
 712 {
 713   if ( !Open() )
 714     return false;
 715
 716     m_dwLastError = RegDeleteValue((HKEY) m_hKey, WXSTRINGCAST szValue);
 717
 718     // deleting a value which doesn't exist is not considered an error
 719     if ( (m_dwLastError != ERROR_SUCCESS) &&
 720          (m_dwLastError != ERROR_FILE_NOT_FOUND) ) {
 721       wxLogSysError(m_dwLastError, _("Can't delete value '%s' from key '%s'"),
 722                     szValue, GetName().c_str());
 723       return false;
 724     }
 725
 726   return true;
 727 }
 728
 729 // ----------------------------------------------------------------------------
 730 // access to values and subkeys
 731 // ----------------------------------------------------------------------------
 732
 733 // return true if value exists
 734 bool wxRegKey::HasValue(const wxChar *szValue) const
 735 {
 736   // this function should be silent, so suppress possible messages from Open()
 737   wxLogNull nolog;
 738
 739     if ( !CONST_CAST Open(Read) )
 740         return false;
 741
 742     LONG dwRet = ::RegQueryValueEx((HKEY) m_hKey,
 743                                    WXSTRINGCAST szValue,
 744                                    RESERVED,
 745                                    NULL, NULL, NULL);
 746     return dwRet == ERROR_SUCCESS;
 747 }
 748
 749 // returns true if this key has any values
 750 bool wxRegKey::HasValues() const
 751 {
 752   // suppress possible messages from GetFirstValue()
 753   wxLogNull nolog;
 754
 755   // just call GetFirstValue with dummy parameters
 756   wxString str;
 757   long     l;
 758   return CONST_CAST GetFirstValue(str, l);
 759 }
 760
 761 // returns true if this key has any subkeys
 762 bool wxRegKey::HasSubkeys() const
 763 {
 764   // suppress possible messages from GetFirstKey()
 765   wxLogNull nolog;
 766
 767   // just call GetFirstKey with dummy parameters
 768   wxString str;
 769   long     l;
 770   return CONST_CAST GetFirstKey(str, l);
 771 }
 772
 773 // returns true if given subkey exists
 774 bool wxRegKey::HasSubKey(const wxChar *szKey) const
 775 {
 776   // this function should be silent, so suppress possible messages from Open()
 777   wxLogNull nolog;
 778
 779   if ( !CONST_CAST Open(Read) )
 780     return false;
 781
 782   return KeyExists(m_hKey, szKey);
 783 }
 784
 785 wxRegKey::ValueType wxRegKey::GetValueType(const wxChar *szValue) const
 786 {
 787     if ( ! CONST_CAST Open(Read) )
 788       return Type_None;
 789
 790     DWORD dwType;
 791     m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED,
 792                                     &dwType, NULL, NULL);
 793     if ( m_dwLastError != ERROR_SUCCESS ) {
 794       wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"),
 795                     GetName().c_str());
 796       return Type_None;
 797     }
 798
 799     return (ValueType)dwType;
 800 }
 801
 802 bool wxRegKey::SetValue(const wxChar *szValue, long lValue)
 803 {
 804   if ( CONST_CAST Open() ) {
 805     m_dwLastError = RegSetValueEx((HKEY) m_hKey, szValue, (DWORD) RESERVED, REG_DWORD,
 806                                   (RegString)&lValue, sizeof(lValue));
 807     if ( m_dwLastError == ERROR_SUCCESS )
 808       return true;
 809   }
 810
 811   wxLogSysError(m_dwLastError, _("Can't set value of '%s'"),
 812                 GetFullName(this, szValue));
 813   return false;
 814 }
 815
 816 bool wxRegKey::QueryValue(const wxChar *szValue, long *plValue) const
 817 {
 818   if ( CONST_CAST Open(Read) ) {
 819     DWORD dwType, dwSize = sizeof(DWORD);
 820     RegString pBuf = (RegString)plValue;
 821     m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED,
 822                                     &dwType, pBuf, &dwSize);
 823     if ( m_dwLastError != ERROR_SUCCESS ) {
 824       wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"),
 825                     GetName().c_str());
 826       return false;
 827     }
 828     else {
 829       // check that we read the value of right type
 830       wxASSERT_MSG( IsNumericValue(szValue),
 831                     wxT("Type mismatch in wxRegKey::QueryValue().")  );
 832
 833       return true;
 834     }
 835   }
 836   else
 837     return false;
 838 }
 839
 840 bool wxRegKey::SetValue(const wxChar *szValue,const wxMemoryBuffer& buffer)
 841 {
 842 #ifdef __TWIN32__
 843   wxFAIL_MSG("RegSetValueEx not implemented by TWIN32");
 844   return false;
 845 #else
 846   if ( CONST_CAST Open() ) {
 847     m_dwLastError = RegSetValueEx((HKEY) m_hKey, szValue, (DWORD) RESERVED, REG_BINARY,
 848                                   (RegBinary)buffer.GetData(),buffer.GetDataLen());
 849     if ( m_dwLastError == ERROR_SUCCESS )
 850       return true;
 851   }
 852
 853   wxLogSysError(m_dwLastError, _("Can't set value of '%s'"),
 854                 GetFullName(this, szValue));
 855   return false;
 856 #endif
 857 }
 858
 859 bool wxRegKey::QueryValue(const wxChar *szValue, wxMemoryBuffer& buffer) const
 860 {
 861   if ( CONST_CAST Open(Read) ) {
 862     // first get the type and size of the data
 863     DWORD dwType, dwSize;
 864     m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED,
 865                                       &dwType, NULL, &dwSize);
 866
 867     if ( m_dwLastError == ERROR_SUCCESS ) {
 868         if ( dwSize ) {
 869             const RegBinary pBuf = (RegBinary)buffer.GetWriteBuf(dwSize);
 870             m_dwLastError = RegQueryValueEx((HKEY) m_hKey,
 871                                             WXSTRINGCAST szValue,
 872                                             RESERVED,
 873                                             &dwType,
 874                                             pBuf,
 875                                             &dwSize);
 876             buffer.UngetWriteBuf(dwSize);
 877         } else {
 878             buffer.SetDataLen(0);
 879         }
 880     }
 881
 882
 883     if ( m_dwLastError != ERROR_SUCCESS ) {
 884       wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"),
 885                     GetName().c_str());
 886       return false;
 887     }
 888     return true;
 889   }
 890   return false;
 891 }
 892
 893
 894
 895 bool wxRegKey::QueryValue(const wxChar *szValue,
 896                           wxString& strValue,
 897                           bool WXUNUSED_IN_WINCE(raw)) const
 898 {
 899     if ( CONST_CAST Open(Read) )
 900     {
 901
 902         // first get the type and size of the data
 903         DWORD dwType, dwSize;
 904         m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED,
 905                                         &dwType, NULL, &dwSize);
 906         if ( m_dwLastError == ERROR_SUCCESS )
 907         {
 908             if ( !dwSize )
 909             {
 910                 // must treat this case specially as GetWriteBuf() doesn't like
 911                 // being called with 0 size
 912                 strValue.Empty();
 913             }
 914             else
 915             {
 916                 m_dwLastError = RegQueryValueEx((HKEY) m_hKey,
 917                                                 WXSTRINGCAST szValue,
 918                                                 RESERVED,
 919                                                 &dwType,
 920                                                 (RegString)(wxChar*)wxStringBuffer(strValue, dwSize),
 921                                                 &dwSize);
 922
 923                 // expand the var expansions in the string unless disabled
 924 #ifndef __WXWINCE__
 925                 if ( (dwType == REG_EXPAND_SZ) && !raw )
 926                 {
 927                     DWORD dwExpSize = ::ExpandEnvironmentStrings(strValue, NULL, 0);
 928                     bool ok = dwExpSize != 0;
 929                     if ( ok )
 930                     {
 931                         wxString strExpValue;
 932                         ok = ::ExpandEnvironmentStrings(strValue,
 933                                                         wxStringBuffer(strExpValue, dwExpSize),
 934                                                         dwExpSize
 935                                                         ) != 0;
 936                         strValue = strExpValue;
 937                     }
 938
 939                     if ( !ok )
 940                     {
 941                         wxLogLastError(_T("ExpandEnvironmentStrings"));
 942                     }
 943                 }
 944 #endif
 945                 // __WXWINCE__
 946             }
 947
 948             if ( m_dwLastError == ERROR_SUCCESS )
 949             {
 950                 // check that it was the right type
 951                 wxASSERT_MSG( !IsNumericValue(szValue),
 952                               wxT("Type mismatch in wxRegKey::QueryValue().") );
 953
 954               return true;
 955             }
 956         }
 957     }
 958
 959     wxLogSysError(m_dwLastError, _("Can't read value of '%s'"),
 960                   GetFullName(this, szValue));
 961     return false;
 962 }
 963
 964 bool wxRegKey::SetValue(const wxChar *szValue, const wxString& strValue)
 965 {
 966   if ( CONST_CAST Open() ) {
 967       m_dwLastError = RegSetValueEx((HKEY) m_hKey, szValue, (DWORD) RESERVED, REG_SZ,
 968                                     (RegString)strValue.c_str(),
 969                                     (strValue.Len() + 1)*sizeof(wxChar));
 970       if ( m_dwLastError == ERROR_SUCCESS )
 971         return true;
 972   }
 973
 974   wxLogSysError(m_dwLastError, _("Can't set value of '%s'"),
 975                 GetFullName(this, szValue));
 976   return false;
 977 }
 978
 979 wxString wxRegKey::QueryDefaultValue() const
 980 {
 981   wxString str;
 982   QueryValue(NULL, str);
 983   return str;
 984 }
 985
 986 // ----------------------------------------------------------------------------
 987 // enumeration
 988 // NB: all these functions require an index variable which allows to have
 989 //     several concurrently running indexations on the same key
 990 // ----------------------------------------------------------------------------
 991
 992 bool wxRegKey::GetFirstValue(wxString& strValueName, long& lIndex)
 993 {
 994   if ( !Open(Read) )
 995     return false;
 996
 997   lIndex = 0;
 998   return GetNextValue(strValueName, lIndex);
 999 }
1000
1001 bool wxRegKey::GetNextValue(wxString& strValueName, long& lIndex) const
1002 {
1003   wxASSERT( IsOpened() );
1004
1005   // are we already at the end of enumeration?
1006   if ( lIndex == -1 )
1007     return false;
1008
1009     wxChar  szValueName[1024];                  // @@ use RegQueryInfoKey...
1010     DWORD dwValueLen = WXSIZEOF(szValueName);
1011
1012     m_dwLastError = RegEnumValue((HKEY) m_hKey, lIndex++,
1013                                  szValueName, &dwValueLen,
1014                                  RESERVED,
1015                                  NULL,            // [out] type
1016                                  NULL,            // [out] buffer for value
1017                                  NULL);           // [i/o]  it's length
1018
1019     if ( m_dwLastError != ERROR_SUCCESS ) {
1020       if ( m_dwLastError == ERROR_NO_MORE_ITEMS ) {
1021         m_dwLastError = ERROR_SUCCESS;
1022         lIndex = -1;
1023       }
1024       else {
1025         wxLogSysError(m_dwLastError, _("Can't enumerate values of key '%s'"),
1026                       GetName().c_str());
1027       }
1028
1029       return false;
1030     }
1031
1032     strValueName = szValueName;
1033
1034   return true;
1035 }
1036
1037 bool wxRegKey::GetFirstKey(wxString& strKeyName, long& lIndex)
1038 {
1039   if ( !Open(Read) )
1040     return false;
1041
1042   lIndex = 0;
1043   return GetNextKey(strKeyName, lIndex);
1044 }
1045
1046 bool wxRegKey::GetNextKey(wxString& strKeyName, long& lIndex) const
1047 {
1048   wxASSERT( IsOpened() );
1049
1050   // are we already at the end of enumeration?
1051   if ( lIndex == -1 )
1052     return false;
1053
1054   wxChar szKeyName[_MAX_PATH + 1];
1055
1056 #ifdef __WXWINCE__
1057   DWORD sizeName = WXSIZEOF(szKeyName);
1058   m_dwLastError = RegEnumKeyEx((HKEY) m_hKey, lIndex++, szKeyName, & sizeName,
1059       0, NULL, NULL, NULL);
1060 #else
1061   m_dwLastError = RegEnumKey((HKEY) m_hKey, lIndex++, szKeyName, WXSIZEOF(szKeyName));
1062 #endif
1063
1064   if ( m_dwLastError != ERROR_SUCCESS ) {
1065     if ( m_dwLastError == ERROR_NO_MORE_ITEMS ) {
1066       m_dwLastError = ERROR_SUCCESS;
1067       lIndex = -1;
1068     }
1069     else {
1070       wxLogSysError(m_dwLastError, _("Can't enumerate subkeys of key '%s'"),
1071                     GetName().c_str());
1072     }
1073
1074     return false;
1075   }
1076
1077   strKeyName = szKeyName;
1078   return true;
1079 }
1080
1081 // returns true if the value contains a number (else it's some string)
1082 bool wxRegKey::IsNumericValue(const wxChar *szValue) const
1083 {
1084     ValueType type = GetValueType(szValue);
1085     switch ( type ) {
1086         case Type_Dword:
1087         /* case Type_Dword_little_endian: == Type_Dword */
1088         case Type_Dword_big_endian:
1089             return true;
1090
1091         default:
1092             return false;
1093     }
1094 }
1095
1096 // ----------------------------------------------------------------------------
1097 // exporting registry keys to file
1098 // ----------------------------------------------------------------------------
1099
1100 #if wxUSE_STREAMS
1101
1102 // helper functions for writing ASCII strings (even in Unicode build)
1103 static inline bool WriteAsciiChar(wxOutputStream& ostr, char ch)
1104 {
1105     ostr.PutC(ch);
1106     return ostr.IsOk();
1107 }
1108
1109 static inline bool WriteAsciiEOL(wxOutputStream& ostr)
1110 {
1111     // as we open the file in text mode, it is enough to write LF without CR
1112     return WriteAsciiChar(ostr, '\n');
1113 }
1114
1115 static inline bool WriteAsciiString(wxOutputStream& ostr, const char *p)
1116 {
1117     return ostr.Write(p, strlen(p)).IsOk();
1118 }
1119
1120 static inline bool WriteAsciiString(wxOutputStream& ostr, const wxString& s)
1121 {
1122 #if wxUSE_UNICODE
1123     wxCharBuffer name(s.mb_str());
1124     ostr.Write(name, strlen(name));
1125 #else
1126     ostr.Write(s, s.length());
1127 #endif
1128
1129     return ostr.IsOk();
1130 }
1131
1132 #endif // wxUSE_STREAMS
1133
1134 bool wxRegKey::Export(const wxString& filename) const
1135 {
1136 #if wxUSE_FFILE && wxUSE_STREAMS
1137     if ( wxFile::Exists(filename) )
1138     {
1139         wxLogError(_("Exporting registry key: file \"%s\" already exists and won't be overwritten."),
1140                    filename.c_str());
1141         return false;
1142     }
1143
1144     wxFFileOutputStream ostr(filename, _T("w"));
1145
1146     return ostr.Ok() && Export(ostr);
1147 #else
1148     wxUnusedVar(filename);
1149     return false;
1150 #endif
1151 }
1152
1153 #if wxUSE_STREAMS
1154 bool wxRegKey::Export(wxOutputStream& ostr) const
1155 {
1156     // write out the header
1157     if ( !WriteAsciiString(ostr, "REGEDIT4\n\n") )
1158         return false;
1159
1160     return DoExport(ostr);
1161 }
1162 #endif // wxUSE_STREAMS
1163
1164 static
1165 wxString
1166 FormatAsHex(const void *data,
1167             size_t size,
1168             wxRegKey::ValueType type = wxRegKey::Type_Binary)
1169 {
1170     wxString value(_T("hex"));
1171
1172     // binary values use just "hex:" prefix while the other ones must indicate
1173     // the real type
1174     if ( type != wxRegKey::Type_Binary )
1175         value << _T('(') << type << _T(')');
1176     value << _T(':');
1177
1178     // write all the rest as comma-separated bytes
1179     value.reserve(3*size + 10);
1180     const char * const p = wx_static_cast(const char *, data);
1181     for ( size_t n = 0; n < size; n++ )
1182     {
1183         // TODO: line wrapping: although not required by regedit, this makes
1184         //       the generated files easier to read and compare with the files
1185         //       produced by regedit
1186         if ( n )
1187             value << _T(',');
1188
1189         value << wxString::Format(_T("%02x"), (unsigned char)p[n]);
1190     }
1191
1192     return value;
1193 }
1194
1195 static inline
1196 wxString FormatAsHex(const wxString& value, wxRegKey::ValueType type)
1197 {
1198     return FormatAsHex(value.c_str(), value.length() + 1, type);
1199 }
1200
1201 wxString wxRegKey::FormatValue(const wxString& name) const
1202 {
1203     wxString rhs;
1204     const ValueType type = GetValueType(name);
1205     switch ( type )
1206     {
1207         case Type_String:
1208             {
1209                 wxString value;
1210                 if ( !QueryValue(name, value) )
1211                     break;
1212
1213                 // quotes and backslashes must be quoted, linefeeds are not
1214                 // allowed in string values
1215                 rhs.reserve(value.length() + 2);
1216                 rhs = _T('"');
1217
1218                 // there can be no NULs here
1219                 bool useHex = false;
1220                 for ( const wxChar *p = value.c_str(); *p && !useHex; p++ )
1221                 {
1222                     switch ( *p )
1223                     {
1224                         case _T('\n'):
1225                             // we can only represent this string in hex
1226                             useHex = true;
1227                             break;
1228
1229                         case _T('"'):
1230                         case _T('\\'):
1231                             // escape special symbol
1232                             rhs += _T('\\');
1233                             // fall through
1234
1235                         default:
1236                             rhs += *p;
1237                     }
1238                 }
1239
1240                 if ( useHex )
1241                     rhs = FormatAsHex(value, Type_String);
1242                 else
1243                     rhs += _T('"');
1244             }
1245             break;
1246
1247         case Type_Dword:
1248         /* case Type_Dword_little_endian: == Type_Dword */
1249             {
1250                 long value;
1251                 if ( !QueryValue(name, &value) )
1252                     break;
1253
1254                 rhs.Printf(_T("dword:%08x"), (unsigned int)value);
1255             }
1256             break;
1257
1258         case Type_Expand_String:
1259         case Type_Multi_String:
1260             {
1261                 wxString value;
1262                 if ( !QueryRawValue(name, value) )
1263                     break;
1264
1265                 rhs = FormatAsHex(value, type);
1266             }
1267             break;
1268
1269         case Type_Binary:
1270             {
1271                 wxMemoryBuffer buf;
1272                 if ( !QueryValue(name, buf) )
1273                     break;
1274
1275                 rhs = FormatAsHex(buf.GetData(), buf.GetDataLen());
1276             }
1277             break;
1278
1279         // no idea how those appear in REGEDIT4 files
1280         case Type_None:
1281         case Type_Dword_big_endian:
1282         case Type_Link:
1283         case Type_Resource_list:
1284         case Type_Full_resource_descriptor:
1285         case Type_Resource_requirements_list:
1286         default:
1287             wxLogWarning(_("Can't export value of unsupported type %d."), type);
1288     }
1289
1290     return rhs;
1291 }
1292
1293 #if wxUSE_STREAMS
1294
1295 bool wxRegKey::DoExportValue(wxOutputStream& ostr, const wxString& name) const
1296 {
1297     // first examine the value type: if it's unsupported, simply skip it
1298     // instead of aborting the entire export process because we failed to
1299     // export a single value
1300     wxString value = FormatValue(name);
1301     if ( value.empty() )
1302     {
1303         wxLogWarning(_("Ignoring value \"%s\" of the key \"%s\"."),
1304                      name.c_str(), GetName().c_str());
1305         return true;
1306     }
1307
1308     // we do have the text representation of the value, now write everything
1309     // out
1310
1311     // special case: unnamed/default value is represented as just "@"
1312     if ( name.empty() )
1313     {
1314         if ( !WriteAsciiChar(ostr, '@') )
1315             return false;
1316     }
1317     else // normal, named, value
1318     {
1319         if ( !WriteAsciiChar(ostr, '"') ||
1320                 !WriteAsciiString(ostr, name) ||
1321                     !WriteAsciiChar(ostr, '"') )
1322             return false;
1323     }
1324
1325     if ( !WriteAsciiChar(ostr, '=') )
1326         return false;
1327
1328     return WriteAsciiString(ostr, value) && WriteAsciiEOL(ostr);
1329 }
1330
1331 bool wxRegKey::DoExport(wxOutputStream& ostr) const
1332 {
1333     // write out this key name
1334     if ( !WriteAsciiChar(ostr, '[') )
1335         return false;
1336
1337     if ( !WriteAsciiString(ostr, GetName(false /* no short prefix */)) )
1338         return false;
1339
1340     if ( !WriteAsciiChar(ostr, ']') || !WriteAsciiEOL(ostr) )
1341         return false;
1342
1343     // dump all our values
1344     long dummy;
1345     wxString name;
1346     wxRegKey& self = wx_const_cast(wxRegKey&, *this);
1347     bool cont = self.GetFirstValue(name, dummy);
1348     while ( cont )
1349     {
1350         if ( !DoExportValue(ostr, name) )
1351             return false;
1352
1353         cont = GetNextValue(name, dummy);
1354     }
1355
1356     // always terminate values by blank line, even if there were no values
1357     if ( !WriteAsciiEOL(ostr) )
1358         return false;
1359
1360     // recurse to subkeys
1361     cont = self.GetFirstKey(name, dummy);
1362     while ( cont )
1363     {
1364         wxRegKey subkey(*this, name);
1365         if ( !subkey.DoExport(ostr) )
1366             return false;
1367
1368         cont = GetNextKey(name, dummy);
1369     }
1370
1371     return true;
1372 }
1373
1374 #endif // wxUSE_STREAMS
1375
1376 // ============================================================================
1377 // implementation of global private functions
1378 // ============================================================================
1379
1380 bool KeyExists(WXHKEY hRootKey, const wxChar *szKey)
1381 {
1382     // don't close this key itself for the case of empty szKey!
1383     if ( wxIsEmpty(szKey) )
1384         return true;
1385
1386     HKEY hkeyDummy;
1387     if ( ::RegOpenKeyEx
1388          (
1389             (HKEY)hRootKey,
1390             szKey,
1391             RESERVED,
1392             KEY_READ,        // we might not have enough rights for rw access
1393             &hkeyDummy
1394          ) == ERROR_SUCCESS )
1395     {
1396         ::RegCloseKey(hkeyDummy);
1397
1398         return true;
1399     }
1400
1401     return false;
1402 }
1403
1404 const wxChar *GetFullName(const wxRegKey *pKey, const wxChar *szValue)
1405 {
1406   static wxString s_str;
1407   s_str = pKey->GetName();
1408   if ( !wxIsEmpty(szValue) )
1409     s_str << wxT("\\") << szValue;
1410
1411   return s_str.c_str();
1412 }
1413
1414 void RemoveTrailingSeparator(wxString& str)
1415 {
1416   if ( !str.empty() && str.Last() == REG_SEPARATOR )
1417     str.Truncate(str.Len() - 1);
1418 }
1419