src/msw/registry.cpp

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