]> git.saurik.com Git - wxWidgets.git/blob - src/msw/registry.cpp
In wxPGProperty::SetValueImage(), use wxImage::Rescale() for scaling down the bitmap...
[wxWidgets.git] / 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 // old gcc headers incorrectly prototype RegQueryInfoKey()
364 #if defined(__GNUWIN32_OLD__) && !defined(__CYGWIN10__)
365 #define REG_PARAM (size_t *)
366 #else
367 #define REG_PARAM (LPDWORD)
368 #endif
369
370 // it might be unexpected to some that this function doesn't open the key
371 wxASSERT_MSG( IsOpened(), wxT("key should be opened in GetKeyInfo") );
372
373 m_dwLastError = ::RegQueryInfoKey
374 (
375 (HKEY) m_hKey,
376 NULL, // class name
377 NULL, // (ptr to) size of class name buffer
378 RESERVED,
379 REG_PARAM
380 pnSubKeys, // [out] number of subkeys
381 REG_PARAM
382 pnMaxKeyLen, // [out] max length of a subkey name
383 NULL, // longest subkey class name
384 REG_PARAM
385 pnValues, // [out] number of values
386 REG_PARAM
387 pnMaxValueLen, // [out] max length of a value name
388 NULL, // longest value data
389 NULL, // security descriptor
390 NULL // time of last modification
391 );
392
393 #undef REG_PARAM
394
395 if ( m_dwLastError != ERROR_SUCCESS ) {
396 wxLogSysError(m_dwLastError, _("Can't get info about registry key '%s'"),
397 GetName().c_str());
398 return false;
399 }
400
401 return true;
402 }
403
404 // ----------------------------------------------------------------------------
405 // operations
406 // ----------------------------------------------------------------------------
407
408 // opens key (it's not an error to call Open() on an already opened key)
409 bool wxRegKey::Open(AccessMode mode)
410 {
411 if ( IsOpened() )
412 {
413 if ( mode <= m_mode )
414 return true;
415
416 // we had been opened in read mode but now must be reopened in write
417 Close();
418 }
419
420 HKEY tmpKey;
421 m_dwLastError = ::RegOpenKeyEx
422 (
423 (HKEY) m_hRootKey,
424 m_strKey.t_str(),
425 RESERVED,
426 GetMSWAccessFlags(mode, m_viewMode),
427 &tmpKey
428 );
429
430 if ( m_dwLastError != ERROR_SUCCESS )
431 {
432 wxLogSysError(m_dwLastError, _("Can't open registry key '%s'"),
433 GetName().c_str());
434 return false;
435 }
436
437 m_hKey = (WXHKEY) tmpKey;
438 m_mode = mode;
439
440 return true;
441 }
442
443 // creates key, failing if it exists and !bOkIfExists
444 bool wxRegKey::Create(bool bOkIfExists)
445 {
446 // check for existence only if asked (i.e. order is important!)
447 if ( !bOkIfExists && Exists() )
448 return false;
449
450 if ( IsOpened() )
451 return true;
452
453 HKEY tmpKey;
454 DWORD disposition;
455 // Minimum supported OS for RegCreateKeyEx: Win 95, Win NT 3.1, Win CE 1.0
456 m_dwLastError = RegCreateKeyEx((HKEY) m_hRootKey, m_strKey.t_str(),
457 0, // reserved and must be 0
458 NULL, // The user-defined class type of this key.
459 REG_OPTION_NON_VOLATILE, // supports other values as well; see MS docs
460 GetMSWAccessFlags(wxRegKey::Write, m_viewMode),
461 NULL, // pointer to a SECURITY_ATTRIBUTES structure
462 &tmpKey,
463 &disposition);
464
465 if ( m_dwLastError != ERROR_SUCCESS ) {
466 wxLogSysError(m_dwLastError, _("Can't create registry key '%s'"),
467 GetName().c_str());
468 return false;
469 }
470 else
471 {
472 m_hKey = (WXHKEY) tmpKey;
473 return true;
474 }
475 }
476
477 // close the key, it's not an error to call it when not opened
478 bool wxRegKey::Close()
479 {
480 if ( IsOpened() ) {
481 m_dwLastError = RegCloseKey((HKEY) m_hKey);
482 m_hKey = 0;
483
484 if ( m_dwLastError != ERROR_SUCCESS ) {
485 wxLogSysError(m_dwLastError, _("Can't close registry key '%s'"),
486 GetName().c_str());
487
488 return false;
489 }
490 }
491
492 return true;
493 }
494
495 bool
496 wxRegKey::RenameValue(const wxString& szValueOld, const wxString& szValueNew)
497 {
498 bool ok = true;
499 if ( HasValue(szValueNew) ) {
500 wxLogError(_("Registry value '%s' already exists."), szValueNew);
501
502 ok = false;
503 }
504
505 if ( !ok ||
506 !CopyValue(szValueOld, *this, szValueNew) ||
507 !DeleteValue(szValueOld) ) {
508 wxLogError(_("Failed to rename registry value '%s' to '%s'."),
509 szValueOld, szValueNew);
510
511 return false;
512 }
513
514 return true;
515 }
516
517 bool wxRegKey::CopyValue(const wxString& szValue,
518 wxRegKey& keyDst,
519 const wxString& szValueNew)
520 {
521 wxString valueNew(szValueNew);
522 if ( valueNew.empty() ) {
523 // by default, use the same name
524 valueNew = szValue;
525 }
526
527 switch ( GetValueType(szValue) ) {
528 case Type_String:
529 {
530 wxString strVal;
531 return QueryValue(szValue, strVal) &&
532 keyDst.SetValue(valueNew, strVal);
533 }
534
535 case Type_Dword:
536 /* case Type_Dword_little_endian: == Type_Dword */
537 {
538 long dwVal;
539 return QueryValue(szValue, &dwVal) &&
540 keyDst.SetValue(valueNew, dwVal);
541 }
542
543 case Type_Binary:
544 {
545 wxMemoryBuffer buf;
546 return QueryValue(szValue,buf) &&
547 keyDst.SetValue(valueNew,buf);
548 }
549
550 // these types are unsupported because I am not sure about how
551 // exactly they should be copied and because they shouldn't
552 // occur among the application keys (supposedly created with
553 // this class)
554 case Type_None:
555 case Type_Expand_String:
556 case Type_Dword_big_endian:
557 case Type_Link:
558 case Type_Multi_String:
559 case Type_Resource_list:
560 case Type_Full_resource_descriptor:
561 case Type_Resource_requirements_list:
562 default:
563 wxLogError(_("Can't copy values of unsupported type %d."),
564 GetValueType(szValue));
565 return false;
566 }
567 }
568
569 bool wxRegKey::Rename(const wxString& szNewName)
570 {
571 wxCHECK_MSG( !m_strKey.empty(), false, wxT("registry hives can't be renamed") );
572
573 if ( !Exists() ) {
574 wxLogError(_("Registry key '%s' does not exist, cannot rename it."),
575 GetFullName(this));
576
577 return false;
578 }
579
580 // do we stay in the same hive?
581 bool inSameHive = !wxStrchr(szNewName, REG_SEPARATOR);
582
583 // construct the full new name of the key
584 wxRegKey keyDst;
585
586 if ( inSameHive ) {
587 // rename the key to the new name under the same parent
588 wxString strKey = m_strKey.BeforeLast(REG_SEPARATOR);
589 if ( !strKey.empty() ) {
590 // don't add '\\' in the start if strFullNewName is empty
591 strKey += REG_SEPARATOR;
592 }
593
594 strKey += szNewName;
595
596 keyDst.SetName(GetStdKeyFromHkey(m_hRootKey), strKey);
597 }
598 else {
599 // this is the full name already
600 keyDst.SetName(szNewName);
601 }
602
603 bool ok = keyDst.Create(false /* fail if alredy exists */);
604 if ( !ok ) {
605 wxLogError(_("Registry key '%s' already exists."),
606 GetFullName(&keyDst));
607 }
608 else {
609 ok = Copy(keyDst) && DeleteSelf();
610 }
611
612 if ( !ok ) {
613 wxLogError(_("Failed to rename the registry key '%s' to '%s'."),
614 GetFullName(this), GetFullName(&keyDst));
615 }
616 else {
617 m_hRootKey = keyDst.m_hRootKey;
618 m_strKey = keyDst.m_strKey;
619 }
620
621 return ok;
622 }
623
624 bool wxRegKey::Copy(const wxString& szNewName)
625 {
626 // create the new key first
627 wxRegKey keyDst(szNewName);
628 bool ok = keyDst.Create(false /* fail if alredy exists */);
629 if ( ok ) {
630 ok = Copy(keyDst);
631
632 // we created the dest key but copying to it failed - delete it
633 if ( !ok ) {
634 (void)keyDst.DeleteSelf();
635 }
636 }
637
638 return ok;
639 }
640
641 bool wxRegKey::Copy(wxRegKey& keyDst)
642 {
643 bool ok = true;
644
645 // copy all sub keys to the new location
646 wxString strKey;
647 long lIndex;
648 bool bCont = GetFirstKey(strKey, lIndex);
649 while ( ok && bCont ) {
650 wxRegKey key(*this, strKey);
651 wxString keyName;
652 keyName << GetFullName(&keyDst) << REG_SEPARATOR << strKey;
653 ok = key.Copy(keyName);
654
655 if ( ok )
656 bCont = GetNextKey(strKey, lIndex);
657 else
658 wxLogError(_("Failed to copy the registry subkey '%s' to '%s'."),
659 GetFullName(&key), keyName.c_str());
660
661 }
662
663 // copy all values
664 wxString strVal;
665 bCont = GetFirstValue(strVal, lIndex);
666 while ( ok && bCont ) {
667 ok = CopyValue(strVal, keyDst);
668
669 if ( !ok ) {
670 wxLogSysError(m_dwLastError,
671 _("Failed to copy registry value '%s'"),
672 strVal.c_str());
673 }
674 else {
675 bCont = GetNextValue(strVal, lIndex);
676 }
677 }
678
679 if ( !ok ) {
680 wxLogError(_("Failed to copy the contents of registry key '%s' to '%s'."),
681 GetFullName(this), GetFullName(&keyDst));
682 }
683
684 return ok;
685 }
686
687 // ----------------------------------------------------------------------------
688 // delete keys/values
689 // ----------------------------------------------------------------------------
690 bool wxRegKey::DeleteSelf()
691 {
692 {
693 wxLogNull nolog;
694 if ( !Open() ) {
695 // it already doesn't exist - ok!
696 return true;
697 }
698 }
699
700 // prevent a buggy program from erasing one of the root registry keys or an
701 // immediate subkey (i.e. one which doesn't have '\\' inside) of any other
702 // key except HKCR (HKCR has some "deleteable" subkeys)
703 if ( m_strKey.empty() ||
704 ((m_hRootKey != (WXHKEY) aStdKeys[HKCR].hkey) &&
705 (m_strKey.Find(REG_SEPARATOR) == wxNOT_FOUND)) ) {
706 wxLogError(_("Registry key '%s' is needed for normal system operation,\ndeleting it will leave your system in unusable state:\noperation aborted."),
707 GetFullName(this));
708
709 return false;
710 }
711
712 // we can't delete keys while enumerating because it confuses GetNextKey, so
713 // we first save the key names and then delete them all
714 wxArrayString astrSubkeys;
715
716 wxString strKey;
717 long lIndex;
718 bool bCont = GetFirstKey(strKey, lIndex);
719 while ( bCont ) {
720 astrSubkeys.Add(strKey);
721
722 bCont = GetNextKey(strKey, lIndex);
723 }
724
725 size_t nKeyCount = astrSubkeys.Count();
726 for ( size_t nKey = 0; nKey < nKeyCount; nKey++ ) {
727 wxRegKey key(*this, astrSubkeys[nKey]);
728 if ( !key.DeleteSelf() )
729 return false;
730 }
731
732 // now delete this key itself
733 Close();
734
735 // deleting a key which doesn't exist is not considered an error
736 #if wxUSE_DYNLIB_CLASS
737 wxDynamicLibrary dllAdvapi32(wxT("advapi32"));
738 // Minimum supported OS for RegDeleteKeyEx: Vista, XP Pro x64, Win Server 2008, Win Server 2003 SP1
739 if(dllAdvapi32.HasSymbol(wxT("RegDeleteKeyEx")))
740 {
741 typedef LONG (WINAPI *RegDeleteKeyEx_t)(HKEY, LPCTSTR, REGSAM, DWORD);
742 wxDYNLIB_FUNCTION(RegDeleteKeyEx_t, RegDeleteKeyEx, dllAdvapi32);
743
744 m_dwLastError = (*pfnRegDeleteKeyEx)((HKEY) m_hRootKey, m_strKey.t_str(),
745 GetMSWViewFlags(m_viewMode),
746 0); // This parameter is reserved and must be zero.
747 }
748 else
749 #endif // wxUSE_DYNLIB_CLASS
750 {
751 m_dwLastError = RegDeleteKey((HKEY) m_hRootKey, m_strKey.t_str());
752 }
753
754 if ( m_dwLastError != ERROR_SUCCESS &&
755 m_dwLastError != ERROR_FILE_NOT_FOUND ) {
756 wxLogSysError(m_dwLastError, _("Can't delete key '%s'"),
757 GetName().c_str());
758 return false;
759 }
760
761 return true;
762 }
763
764 bool wxRegKey::DeleteKey(const wxString& szKey)
765 {
766 if ( !Open() )
767 return false;
768
769 wxRegKey key(*this, szKey);
770 return key.DeleteSelf();
771 }
772
773 bool wxRegKey::DeleteValue(const wxString& szValue)
774 {
775 if ( !Open() )
776 return false;
777
778 m_dwLastError = RegDeleteValue((HKEY) m_hKey, RegValueStr(szValue));
779
780 // deleting a value which doesn't exist is not considered an error
781 if ( (m_dwLastError != ERROR_SUCCESS) &&
782 (m_dwLastError != ERROR_FILE_NOT_FOUND) )
783 {
784 wxLogSysError(m_dwLastError, _("Can't delete value '%s' from key '%s'"),
785 szValue, GetName().c_str());
786 return false;
787 }
788
789 return true;
790 }
791
792 // ----------------------------------------------------------------------------
793 // access to values and subkeys
794 // ----------------------------------------------------------------------------
795
796 // return true if value exists
797 bool wxRegKey::HasValue(const wxString& szValue) const
798 {
799 // this function should be silent, so suppress possible messages from Open()
800 wxLogNull nolog;
801
802 if ( !CONST_CAST Open(Read) )
803 return false;
804
805 LONG dwRet = ::RegQueryValueEx((HKEY) m_hKey,
806 RegValueStr(szValue),
807 RESERVED,
808 NULL, NULL, NULL);
809 return dwRet == ERROR_SUCCESS;
810 }
811
812 // returns true if this key has any values
813 bool wxRegKey::HasValues() const
814 {
815 // suppress possible messages from GetFirstValue()
816 wxLogNull nolog;
817
818 // just call GetFirstValue with dummy parameters
819 wxString str;
820 long l;
821 return CONST_CAST GetFirstValue(str, l);
822 }
823
824 // returns true if this key has any subkeys
825 bool wxRegKey::HasSubkeys() const
826 {
827 // suppress possible messages from GetFirstKey()
828 wxLogNull nolog;
829
830 // just call GetFirstKey with dummy parameters
831 wxString str;
832 long l;
833 return CONST_CAST GetFirstKey(str, l);
834 }
835
836 // returns true if given subkey exists
837 bool wxRegKey::HasSubKey(const wxString& szKey) const
838 {
839 // this function should be silent, so suppress possible messages from Open()
840 wxLogNull nolog;
841
842 if ( !CONST_CAST Open(Read) )
843 return false;
844
845 return KeyExists(m_hKey, szKey, m_viewMode);
846 }
847
848 wxRegKey::ValueType wxRegKey::GetValueType(const wxString& szValue) const
849 {
850 if ( ! CONST_CAST Open(Read) )
851 return Type_None;
852
853 DWORD dwType;
854 m_dwLastError = RegQueryValueEx((HKEY) m_hKey, RegValueStr(szValue), RESERVED,
855 &dwType, NULL, NULL);
856 if ( m_dwLastError != ERROR_SUCCESS ) {
857 wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"),
858 GetName().c_str());
859 return Type_None;
860 }
861
862 return (ValueType)dwType;
863 }
864
865 bool wxRegKey::SetValue(const wxString& szValue, long lValue)
866 {
867 if ( CONST_CAST Open() ) {
868 m_dwLastError = RegSetValueEx((HKEY) m_hKey, RegValueStr(szValue),
869 (DWORD) RESERVED, REG_DWORD,
870 (RegString)&lValue, sizeof(lValue));
871 if ( m_dwLastError == ERROR_SUCCESS )
872 return true;
873 }
874
875 wxLogSysError(m_dwLastError, _("Can't set value of '%s'"),
876 GetFullName(this, szValue));
877 return false;
878 }
879
880 bool wxRegKey::QueryValue(const wxString& szValue, long *plValue) const
881 {
882 if ( CONST_CAST Open(Read) ) {
883 DWORD dwType, dwSize = sizeof(DWORD);
884 RegString pBuf = (RegString)plValue;
885 m_dwLastError = RegQueryValueEx((HKEY) m_hKey, RegValueStr(szValue),
886 RESERVED,
887 &dwType, pBuf, &dwSize);
888 if ( m_dwLastError != ERROR_SUCCESS ) {
889 wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"),
890 GetName().c_str());
891 return false;
892 }
893 else {
894 // check that we read the value of right type
895 wxASSERT_MSG( IsNumericValue(szValue),
896 wxT("Type mismatch in wxRegKey::QueryValue().") );
897
898 return true;
899 }
900 }
901 else
902 return false;
903 }
904
905 bool wxRegKey::SetValue(const wxString& szValue, const wxMemoryBuffer& buffer)
906 {
907 #ifdef __TWIN32__
908 wxFAIL_MSG("RegSetValueEx not implemented by TWIN32");
909 return false;
910 #else
911 if ( CONST_CAST Open() ) {
912 m_dwLastError = RegSetValueEx((HKEY) m_hKey, RegValueStr(szValue),
913 (DWORD) RESERVED, REG_BINARY,
914 (RegBinary)buffer.GetData(),buffer.GetDataLen());
915 if ( m_dwLastError == ERROR_SUCCESS )
916 return true;
917 }
918
919 wxLogSysError(m_dwLastError, _("Can't set value of '%s'"),
920 GetFullName(this, szValue));
921 return false;
922 #endif
923 }
924
925 bool wxRegKey::QueryValue(const wxString& szValue, wxMemoryBuffer& buffer) const
926 {
927 if ( CONST_CAST Open(Read) ) {
928 // first get the type and size of the data
929 DWORD dwType, dwSize;
930 m_dwLastError = RegQueryValueEx((HKEY) m_hKey, RegValueStr(szValue),
931 RESERVED,
932 &dwType, NULL, &dwSize);
933
934 if ( m_dwLastError == ERROR_SUCCESS ) {
935 if ( dwSize ) {
936 const RegBinary pBuf = (RegBinary)buffer.GetWriteBuf(dwSize);
937 m_dwLastError = RegQueryValueEx((HKEY) m_hKey,
938 RegValueStr(szValue),
939 RESERVED,
940 &dwType,
941 pBuf,
942 &dwSize);
943 buffer.UngetWriteBuf(dwSize);
944 } else {
945 buffer.SetDataLen(0);
946 }
947 }
948
949
950 if ( m_dwLastError != ERROR_SUCCESS ) {
951 wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"),
952 GetName().c_str());
953 return false;
954 }
955 return true;
956 }
957 return false;
958 }
959
960
961
962 bool wxRegKey::QueryValue(const wxString& szValue,
963 wxString& strValue,
964 bool WXUNUSED_IN_WINCE(raw)) const
965 {
966 if ( CONST_CAST Open(Read) )
967 {
968
969 // first get the type and size of the data
970 DWORD dwType=REG_NONE, dwSize=0;
971 m_dwLastError = RegQueryValueEx((HKEY) m_hKey,
972 RegValueStr(szValue),
973 RESERVED,
974 &dwType, NULL, &dwSize);
975 if ( m_dwLastError == ERROR_SUCCESS )
976 {
977 if ( !dwSize )
978 {
979 // must treat this case specially as GetWriteBuf() doesn't like
980 // being called with 0 size
981 strValue.Empty();
982 }
983 else
984 {
985 m_dwLastError = RegQueryValueEx((HKEY) m_hKey,
986 RegValueStr(szValue),
987 RESERVED,
988 &dwType,
989 (RegString)(wxChar*)wxStringBuffer(strValue, dwSize),
990 &dwSize);
991
992 // expand the var expansions in the string unless disabled
993 #ifndef __WXWINCE__
994 if ( (dwType == REG_EXPAND_SZ) && !raw )
995 {
996 DWORD dwExpSize = ::ExpandEnvironmentStrings(strValue.t_str(), NULL, 0);
997 bool ok = dwExpSize != 0;
998 if ( ok )
999 {
1000 wxString strExpValue;
1001 ok = ::ExpandEnvironmentStrings(strValue.t_str(),
1002 wxStringBuffer(strExpValue, dwExpSize),
1003 dwExpSize
1004 ) != 0;
1005 strValue = strExpValue;
1006 }
1007
1008 if ( !ok )
1009 {
1010 wxLogLastError(wxT("ExpandEnvironmentStrings"));
1011 }
1012 }
1013 #endif
1014 // __WXWINCE__
1015 }
1016
1017 if ( m_dwLastError == ERROR_SUCCESS )
1018 {
1019 // check that it was the right type
1020 wxASSERT_MSG( !IsNumericValue(szValue),
1021 wxT("Type mismatch in wxRegKey::QueryValue().") );
1022
1023 return true;
1024 }
1025 }
1026 }
1027
1028 wxLogSysError(m_dwLastError, _("Can't read value of '%s'"),
1029 GetFullName(this, szValue));
1030 return false;
1031 }
1032
1033 bool wxRegKey::SetValue(const wxString& szValue, const wxString& strValue)
1034 {
1035 if ( CONST_CAST Open() ) {
1036 m_dwLastError = RegSetValueEx((HKEY) m_hKey,
1037 RegValueStr(szValue),
1038 (DWORD) RESERVED, REG_SZ,
1039 (RegString)strValue.t_str(),
1040 (strValue.Len() + 1)*sizeof(wxChar));
1041 if ( m_dwLastError == ERROR_SUCCESS )
1042 return true;
1043 }
1044
1045 wxLogSysError(m_dwLastError, _("Can't set value of '%s'"),
1046 GetFullName(this, szValue));
1047 return false;
1048 }
1049
1050 wxString wxRegKey::QueryDefaultValue() const
1051 {
1052 wxString str;
1053 QueryValue(wxEmptyString, str, false);
1054 return str;
1055 }
1056
1057 // ----------------------------------------------------------------------------
1058 // enumeration
1059 // NB: all these functions require an index variable which allows to have
1060 // several concurrently running indexations on the same key
1061 // ----------------------------------------------------------------------------
1062
1063 bool wxRegKey::GetFirstValue(wxString& strValueName, long& lIndex)
1064 {
1065 if ( !Open(Read) )
1066 return false;
1067
1068 lIndex = 0;
1069 return GetNextValue(strValueName, lIndex);
1070 }
1071
1072 bool wxRegKey::GetNextValue(wxString& strValueName, long& lIndex) const
1073 {
1074 wxASSERT( IsOpened() );
1075
1076 // are we already at the end of enumeration?
1077 if ( lIndex == -1 )
1078 return false;
1079
1080 wxChar szValueName[1024]; // @@ use RegQueryInfoKey...
1081 DWORD dwValueLen = WXSIZEOF(szValueName);
1082
1083 m_dwLastError = RegEnumValue((HKEY) m_hKey, lIndex++,
1084 szValueName, &dwValueLen,
1085 RESERVED,
1086 NULL, // [out] type
1087 NULL, // [out] buffer for value
1088 NULL); // [i/o] it's length
1089
1090 if ( m_dwLastError != ERROR_SUCCESS ) {
1091 if ( m_dwLastError == ERROR_NO_MORE_ITEMS ) {
1092 m_dwLastError = ERROR_SUCCESS;
1093 lIndex = -1;
1094 }
1095 else {
1096 wxLogSysError(m_dwLastError, _("Can't enumerate values of key '%s'"),
1097 GetName().c_str());
1098 }
1099
1100 return false;
1101 }
1102
1103 strValueName = szValueName;
1104
1105 return true;
1106 }
1107
1108 bool wxRegKey::GetFirstKey(wxString& strKeyName, long& lIndex)
1109 {
1110 if ( !Open(Read) )
1111 return false;
1112
1113 lIndex = 0;
1114 return GetNextKey(strKeyName, lIndex);
1115 }
1116
1117 bool wxRegKey::GetNextKey(wxString& strKeyName, long& lIndex) const
1118 {
1119 wxASSERT( IsOpened() );
1120
1121 // are we already at the end of enumeration?
1122 if ( lIndex == -1 )
1123 return false;
1124
1125 wxChar szKeyName[_MAX_PATH + 1];
1126
1127 #ifdef __WXWINCE__
1128 DWORD sizeName = WXSIZEOF(szKeyName);
1129 m_dwLastError = RegEnumKeyEx((HKEY) m_hKey, lIndex++, szKeyName, & sizeName,
1130 0, NULL, NULL, NULL);
1131 #else
1132 m_dwLastError = RegEnumKey((HKEY) m_hKey, lIndex++, szKeyName, WXSIZEOF(szKeyName));
1133 #endif
1134
1135 if ( m_dwLastError != ERROR_SUCCESS ) {
1136 if ( m_dwLastError == ERROR_NO_MORE_ITEMS ) {
1137 m_dwLastError = ERROR_SUCCESS;
1138 lIndex = -1;
1139 }
1140 else {
1141 wxLogSysError(m_dwLastError, _("Can't enumerate subkeys of key '%s'"),
1142 GetName().c_str());
1143 }
1144
1145 return false;
1146 }
1147
1148 strKeyName = szKeyName;
1149 return true;
1150 }
1151
1152 // returns true if the value contains a number (else it's some string)
1153 bool wxRegKey::IsNumericValue(const wxString& szValue) const
1154 {
1155 ValueType type = GetValueType(szValue);
1156 switch ( type ) {
1157 case Type_Dword:
1158 /* case Type_Dword_little_endian: == Type_Dword */
1159 case Type_Dword_big_endian:
1160 return true;
1161
1162 default:
1163 return false;
1164 }
1165 }
1166
1167 // ----------------------------------------------------------------------------
1168 // exporting registry keys to file
1169 // ----------------------------------------------------------------------------
1170
1171 #if wxUSE_STREAMS
1172
1173 // helper functions for writing ASCII strings (even in Unicode build)
1174 static inline bool WriteAsciiChar(wxOutputStream& ostr, char ch)
1175 {
1176 ostr.PutC(ch);
1177 return ostr.IsOk();
1178 }
1179
1180 static inline bool WriteAsciiEOL(wxOutputStream& ostr)
1181 {
1182 // as we open the file in text mode, it is enough to write LF without CR
1183 return WriteAsciiChar(ostr, '\n');
1184 }
1185
1186 static inline bool WriteAsciiString(wxOutputStream& ostr, const char *p)
1187 {
1188 return ostr.Write(p, strlen(p)).IsOk();
1189 }
1190
1191 static inline bool WriteAsciiString(wxOutputStream& ostr, const wxString& s)
1192 {
1193 #if wxUSE_UNICODE
1194 wxCharBuffer name(s.mb_str());
1195 ostr.Write(name, strlen(name));
1196 #else
1197 ostr.Write(s.mb_str(), s.length());
1198 #endif
1199
1200 return ostr.IsOk();
1201 }
1202
1203 #endif // wxUSE_STREAMS
1204
1205 bool wxRegKey::Export(const wxString& filename) const
1206 {
1207 #if wxUSE_FFILE && wxUSE_STREAMS
1208 if ( wxFile::Exists(filename) )
1209 {
1210 wxLogError(_("Exporting registry key: file \"%s\" already exists and won't be overwritten."),
1211 filename.c_str());
1212 return false;
1213 }
1214
1215 wxFFileOutputStream ostr(filename, wxT("w"));
1216
1217 return ostr.Ok() && Export(ostr);
1218 #else
1219 wxUnusedVar(filename);
1220 return false;
1221 #endif
1222 }
1223
1224 #if wxUSE_STREAMS
1225 bool wxRegKey::Export(wxOutputStream& ostr) const
1226 {
1227 // write out the header
1228 if ( !WriteAsciiString(ostr, "REGEDIT4\n\n") )
1229 return false;
1230
1231 return DoExport(ostr);
1232 }
1233 #endif // wxUSE_STREAMS
1234
1235 static
1236 wxString
1237 FormatAsHex(const void *data,
1238 size_t size,
1239 wxRegKey::ValueType type = wxRegKey::Type_Binary)
1240 {
1241 wxString value(wxT("hex"));
1242
1243 // binary values use just "hex:" prefix while the other ones must indicate
1244 // the real type
1245 if ( type != wxRegKey::Type_Binary )
1246 value << wxT('(') << type << wxT(')');
1247 value << wxT(':');
1248
1249 // write all the rest as comma-separated bytes
1250 value.reserve(3*size + 10);
1251 const char * const p = static_cast<const char *>(data);
1252 for ( size_t n = 0; n < size; n++ )
1253 {
1254 // TODO: line wrapping: although not required by regedit, this makes
1255 // the generated files easier to read and compare with the files
1256 // produced by regedit
1257 if ( n )
1258 value << wxT(',');
1259
1260 value << wxString::Format(wxT("%02x"), (unsigned char)p[n]);
1261 }
1262
1263 return value;
1264 }
1265
1266 static inline
1267 wxString FormatAsHex(const wxString& value, wxRegKey::ValueType type)
1268 {
1269 return FormatAsHex(value.c_str(), value.length() + 1, type);
1270 }
1271
1272 wxString wxRegKey::FormatValue(const wxString& name) const
1273 {
1274 wxString rhs;
1275 const ValueType type = GetValueType(name);
1276 switch ( type )
1277 {
1278 case Type_String:
1279 {
1280 wxString value;
1281 if ( !QueryValue(name, value) )
1282 break;
1283
1284 // quotes and backslashes must be quoted, linefeeds are not
1285 // allowed in string values
1286 rhs.reserve(value.length() + 2);
1287 rhs = wxT('"');
1288
1289 // there can be no NULs here
1290 bool useHex = false;
1291 for ( wxString::const_iterator p = value.begin();
1292 p != value.end() && !useHex; ++p )
1293 {
1294 switch ( (*p).GetValue() )
1295 {
1296 case wxT('\n'):
1297 // we can only represent this string in hex
1298 useHex = true;
1299 break;
1300
1301 case wxT('"'):
1302 case wxT('\\'):
1303 // escape special symbol
1304 rhs += wxT('\\');
1305 // fall through
1306
1307 default:
1308 rhs += *p;
1309 }
1310 }
1311
1312 if ( useHex )
1313 rhs = FormatAsHex(value, Type_String);
1314 else
1315 rhs += wxT('"');
1316 }
1317 break;
1318
1319 case Type_Dword:
1320 /* case Type_Dword_little_endian: == Type_Dword */
1321 {
1322 long value;
1323 if ( !QueryValue(name, &value) )
1324 break;
1325
1326 rhs.Printf(wxT("dword:%08x"), (unsigned int)value);
1327 }
1328 break;
1329
1330 case Type_Expand_String:
1331 case Type_Multi_String:
1332 {
1333 wxString value;
1334 if ( !QueryRawValue(name, value) )
1335 break;
1336
1337 rhs = FormatAsHex(value, type);
1338 }
1339 break;
1340
1341 case Type_Binary:
1342 {
1343 wxMemoryBuffer buf;
1344 if ( !QueryValue(name, buf) )
1345 break;
1346
1347 rhs = FormatAsHex(buf.GetData(), buf.GetDataLen());
1348 }
1349 break;
1350
1351 // no idea how those appear in REGEDIT4 files
1352 case Type_None:
1353 case Type_Dword_big_endian:
1354 case Type_Link:
1355 case Type_Resource_list:
1356 case Type_Full_resource_descriptor:
1357 case Type_Resource_requirements_list:
1358 default:
1359 wxLogWarning(_("Can't export value of unsupported type %d."), type);
1360 }
1361
1362 return rhs;
1363 }
1364
1365 #if wxUSE_STREAMS
1366
1367 bool wxRegKey::DoExportValue(wxOutputStream& ostr, const wxString& name) const
1368 {
1369 // first examine the value type: if it's unsupported, simply skip it
1370 // instead of aborting the entire export process because we failed to
1371 // export a single value
1372 wxString value = FormatValue(name);
1373 if ( value.empty() )
1374 {
1375 wxLogWarning(_("Ignoring value \"%s\" of the key \"%s\"."),
1376 name.c_str(), GetName().c_str());
1377 return true;
1378 }
1379
1380 // we do have the text representation of the value, now write everything
1381 // out
1382
1383 // special case: unnamed/default value is represented as just "@"
1384 if ( name.empty() )
1385 {
1386 if ( !WriteAsciiChar(ostr, '@') )
1387 return false;
1388 }
1389 else // normal, named, value
1390 {
1391 if ( !WriteAsciiChar(ostr, '"') ||
1392 !WriteAsciiString(ostr, name) ||
1393 !WriteAsciiChar(ostr, '"') )
1394 return false;
1395 }
1396
1397 if ( !WriteAsciiChar(ostr, '=') )
1398 return false;
1399
1400 return WriteAsciiString(ostr, value) && WriteAsciiEOL(ostr);
1401 }
1402
1403 bool wxRegKey::DoExport(wxOutputStream& ostr) const
1404 {
1405 // write out this key name
1406 if ( !WriteAsciiChar(ostr, '[') )
1407 return false;
1408
1409 if ( !WriteAsciiString(ostr, GetName(false /* no short prefix */)) )
1410 return false;
1411
1412 if ( !WriteAsciiChar(ostr, ']') || !WriteAsciiEOL(ostr) )
1413 return false;
1414
1415 // dump all our values
1416 long dummy;
1417 wxString name;
1418 wxRegKey& self = const_cast<wxRegKey&>(*this);
1419 bool cont = self.GetFirstValue(name, dummy);
1420 while ( cont )
1421 {
1422 if ( !DoExportValue(ostr, name) )
1423 return false;
1424
1425 cont = GetNextValue(name, dummy);
1426 }
1427
1428 // always terminate values by blank line, even if there were no values
1429 if ( !WriteAsciiEOL(ostr) )
1430 return false;
1431
1432 // recurse to subkeys
1433 cont = self.GetFirstKey(name, dummy);
1434 while ( cont )
1435 {
1436 wxRegKey subkey(*this, name);
1437 if ( !subkey.DoExport(ostr) )
1438 return false;
1439
1440 cont = GetNextKey(name, dummy);
1441 }
1442
1443 return true;
1444 }
1445
1446 #endif // wxUSE_STREAMS
1447
1448 // ============================================================================
1449 // implementation of global private functions
1450 // ============================================================================
1451
1452 bool KeyExists(WXHKEY hRootKey,
1453 const wxString& szKey,
1454 wxRegKey::WOW64ViewMode viewMode)
1455 {
1456 // don't close this key itself for the case of empty szKey!
1457 if ( szKey.empty() )
1458 return true;
1459
1460 HKEY hkeyDummy;
1461 if ( ::RegOpenKeyEx
1462 (
1463 (HKEY)hRootKey,
1464 szKey.t_str(),
1465 RESERVED,
1466 // we might not have enough rights for rw access
1467 GetMSWAccessFlags(wxRegKey::Read, viewMode),
1468 &hkeyDummy
1469 ) == ERROR_SUCCESS )
1470 {
1471 ::RegCloseKey(hkeyDummy);
1472
1473 return true;
1474 }
1475
1476 return false;
1477 }
1478
1479 long GetMSWViewFlags(wxRegKey::WOW64ViewMode viewMode)
1480 {
1481 long samWOW64ViewMode = 0;
1482
1483 switch ( viewMode )
1484 {
1485 case wxRegKey::WOW64ViewMode_32:
1486 #ifdef __WIN64__ // the flag is only needed by 64 bit apps
1487 samWOW64ViewMode = KEY_WOW64_32KEY;
1488 #endif // Win64
1489 break;
1490
1491 case wxRegKey::WOW64ViewMode_64:
1492 #ifndef __WIN64__ // the flag is only needed by 32 bit apps
1493 // 64 bit registry can only be accessed under 64 bit platforms
1494 if ( wxIsPlatform64Bit() )
1495 samWOW64ViewMode = KEY_WOW64_64KEY;
1496 #endif // Win32
1497 break;
1498
1499 default:
1500 wxFAIL_MSG("Unknown registry view.");
1501 // fall through
1502
1503 case wxRegKey::WOW64ViewMode_Default:
1504 // Use default registry view for the current application,
1505 // i.e. 32 bits for 32 bit ones and 64 bits for 64 bit apps
1506 ;
1507 }
1508
1509 return samWOW64ViewMode;
1510 }
1511
1512 long GetMSWAccessFlags(wxRegKey::AccessMode mode,
1513 wxRegKey::WOW64ViewMode viewMode)
1514 {
1515 long sam = mode == wxRegKey::Read ? KEY_READ : KEY_ALL_ACCESS;
1516
1517 sam |= GetMSWViewFlags(viewMode);
1518
1519 return sam;
1520 }
1521
1522 wxString GetFullName(const wxRegKey *pKey, const wxString& szValue)
1523 {
1524 wxString str(pKey->GetName());
1525 if ( !szValue.empty() )
1526 str << wxT("\\") << szValue;
1527
1528 return str;
1529 }
1530
1531 wxString GetFullName(const wxRegKey *pKey)
1532 {
1533 return pKey->GetName();
1534 }
1535
1536 inline void RemoveTrailingSeparator(wxString& str)
1537 {
1538 if ( !str.empty() && str.Last() == REG_SEPARATOR )
1539 str.Truncate(str.Len() - 1);
1540 }
1541
1542 inline const wxChar *RegValueStr(const wxString& szValue)
1543 {
1544 return szValue.empty() ? (const wxChar*)NULL : szValue.t_str();
1545 }
1546
1547 #endif // wxUSE_REGKEY