1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: msw/registry.cpp
3 // Purpose: implementation of registry classes and functions
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows license
10 // TODO: - parsing of registry key names
11 // - support of other (than REG_SZ/REG_DWORD) registry types
12 // - add high level functions (RegisterOleServer, ...)
13 ///////////////////////////////////////////////////////////////////////////////
16 #pragma implementation "registry.h"
19 // for compilers that support precompilation, includes "wx.h".
20 #include "wx/wxprec.h"
26 // other wxWindows headers
27 #include "wx/string.h"
30 #include "wx/config.h" // for wxExpandEnvVars
37 #define WIN32_LEAN_AND_MEAN
43 #include <stdlib.h> // for _MAX_PATH
50 #define HKEY_DEFINED // already defined in windows.h
51 #include "wx/msw/registry.h"
53 // some registry functions don't like signed chars
54 typedef unsigned char *RegString
;
56 // ----------------------------------------------------------------------------
58 // ----------------------------------------------------------------------------
60 // the standard key names, short names and handles all bundled together for
66 const wxChar
*szShortName
;
70 { HKEY_CLASSES_ROOT
, wxT("HKEY_CLASSES_ROOT"), wxT("HKCR") },
72 { HKEY_CURRENT_USER
, wxT("HKEY_CURRENT_USER"), wxT("HKCU") },
73 { HKEY_LOCAL_MACHINE
, wxT("HKEY_LOCAL_MACHINE"), wxT("HKLM") },
74 { HKEY_USERS
, wxT("HKEY_USERS"), wxT("HKU") }, // short name?
75 { HKEY_PERFORMANCE_DATA
, wxT("HKEY_PERFORMANCE_DATA"), wxT("HKPD") },
77 { HKEY_CURRENT_CONFIG
, wxT("HKEY_CURRENT_CONFIG"), wxT("HKCC") },
79 { HKEY_DYN_DATA
, wxT("HKEY_DYN_DATA"), wxT("HKDD") }, // short name?
81 #endif //WINVER >= 4.0
85 // the registry name separator (perhaps one day MS will change it to '/' ;-)
86 #define REG_SEPARATOR wxT('\\')
88 // useful for Windows programmers: makes somewhat more clear all these zeroes
89 // being passed to Windows APIs
90 #define RESERVED (NULL)
92 // ----------------------------------------------------------------------------
94 // ----------------------------------------------------------------------------
95 // @ const_cast<> is not yet supported by all compilers
96 #define CONST_CAST ((wxRegKey *)this)->
99 #define m_dwLastError CONST_CAST m_dwLastError
102 // ----------------------------------------------------------------------------
103 // non member functions
104 // ----------------------------------------------------------------------------
106 // removes the trailing backslash from the string if it has one
107 static inline void RemoveTrailingSeparator(wxString
& str
);
109 // returns TRUE if given registry key exists
110 static bool KeyExists(WXHKEY hRootKey
, const wxChar
*szKey
);
112 // combines value and key name (uses static buffer!)
113 static const wxChar
*GetFullName(const wxRegKey
*pKey
,
114 const wxChar
*szValue
= NULL
);
116 // ============================================================================
117 // implementation of wxRegKey class
118 // ============================================================================
120 // ----------------------------------------------------------------------------
121 // static functions and variables
122 // ----------------------------------------------------------------------------
124 const size_t wxRegKey::nStdKeys
= WXSIZEOF(aStdKeys
);
126 // @@ should take a `StdKey key', but as it's often going to be used in loops
127 // it would require casts in user code.
128 const wxChar
*wxRegKey::GetStdKeyName(size_t key
)
130 // return empty string if key is invalid
131 wxCHECK_MSG( key
< nStdKeys
, wxT(""), wxT("invalid key in wxRegKey::GetStdKeyName") );
133 return aStdKeys
[key
].szName
;
136 const wxChar
*wxRegKey::GetStdKeyShortName(size_t key
)
138 // return empty string if key is invalid
139 wxCHECK( key
< nStdKeys
, wxT("") );
141 return aStdKeys
[key
].szShortName
;
144 wxRegKey::StdKey
wxRegKey::ExtractKeyName(wxString
& strKey
)
146 wxString strRoot
= strKey
.BeforeFirst(REG_SEPARATOR
);
150 for ( ui
= 0; ui
< nStdKeys
; ui
++ ) {
151 if ( strRoot
.CmpNoCase(aStdKeys
[ui
].szName
) == 0 ||
152 strRoot
.CmpNoCase(aStdKeys
[ui
].szShortName
) == 0 ) {
153 hRootKey
= aStdKeys
[ui
].hkey
;
158 if ( ui
== nStdKeys
) {
159 wxFAIL_MSG(wxT("invalid key prefix in wxRegKey::ExtractKeyName."));
161 hRootKey
= HKEY_CLASSES_ROOT
;
164 strKey
= strKey
.After(REG_SEPARATOR
);
165 if ( !strKey
.IsEmpty() && strKey
.Last() == REG_SEPARATOR
)
166 strKey
.Truncate(strKey
.Len() - 1);
169 return (wxRegKey::StdKey
)(int)hRootKey
;
172 wxRegKey::StdKey
wxRegKey::GetStdKeyFromHkey(WXHKEY hkey
)
174 for ( size_t ui
= 0; ui
< nStdKeys
; ui
++ ) {
175 if ( (int) aStdKeys
[ui
].hkey
== (int) hkey
)
179 wxFAIL_MSG(wxT("non root hkey passed to wxRegKey::GetStdKeyFromHkey."));
184 // ----------------------------------------------------------------------------
186 // ----------------------------------------------------------------------------
191 m_hRootKey
= (WXHKEY
) aStdKeys
[HKCR
].hkey
;
195 wxRegKey::wxRegKey(const wxString
& strKey
) : m_strKey(strKey
)
197 m_hRootKey
= (WXHKEY
) aStdKeys
[ExtractKeyName(m_strKey
)].hkey
;
198 m_hKey
= (WXHKEY
) NULL
;
202 // parent is a predefined (and preopened) key
203 wxRegKey::wxRegKey(StdKey keyParent
, const wxString
& strKey
) : m_strKey(strKey
)
205 RemoveTrailingSeparator(m_strKey
);
206 m_hRootKey
= (WXHKEY
) aStdKeys
[keyParent
].hkey
;
207 m_hKey
= (WXHKEY
) NULL
;
211 // parent is a normal regkey
212 wxRegKey::wxRegKey(const wxRegKey
& keyParent
, const wxString
& strKey
)
213 : m_strKey(keyParent
.m_strKey
)
215 // combine our name with parent's to get the full name
216 if ( !m_strKey
.IsEmpty() &&
217 (strKey
.IsEmpty() || strKey
[0] != REG_SEPARATOR
) ) {
218 m_strKey
+= REG_SEPARATOR
;
222 RemoveTrailingSeparator(m_strKey
);
224 m_hRootKey
= keyParent
.m_hRootKey
;
225 m_hKey
= (WXHKEY
) NULL
;
229 // dtor closes the key releasing system resource
230 wxRegKey::~wxRegKey()
235 // ----------------------------------------------------------------------------
236 // change the key name/hkey
237 // ----------------------------------------------------------------------------
239 // set the full key name
240 void wxRegKey::SetName(const wxString
& strKey
)
245 m_hRootKey
= (WXHKEY
) aStdKeys
[ExtractKeyName(m_strKey
)].hkey
;
248 // the name is relative to the parent key
249 void wxRegKey::SetName(StdKey keyParent
, const wxString
& strKey
)
254 RemoveTrailingSeparator(m_strKey
);
255 m_hRootKey
= (WXHKEY
) aStdKeys
[keyParent
].hkey
;
258 // the name is relative to the parent key
259 void wxRegKey::SetName(const wxRegKey
& keyParent
, const wxString
& strKey
)
263 // combine our name with parent's to get the full name
264 m_strKey
= keyParent
.m_strKey
;
265 if ( !strKey
.IsEmpty() && strKey
[0] != REG_SEPARATOR
)
266 m_strKey
+= REG_SEPARATOR
;
269 RemoveTrailingSeparator(m_strKey
);
271 m_hRootKey
= keyParent
.m_hRootKey
;
274 // hKey should be opened and will be closed in wxRegKey dtor
275 void wxRegKey::SetHkey(WXHKEY hKey
)
282 // ----------------------------------------------------------------------------
283 // info about the key
284 // ----------------------------------------------------------------------------
286 // returns TRUE if the key exists
287 bool wxRegKey::Exists() const
289 // opened key has to exist, try to open it if not done yet
290 return IsOpened() ? TRUE
: KeyExists(m_hRootKey
, m_strKey
);
293 // returns the full name of the key (prefix is abbreviated if bShortPrefix)
294 wxString
wxRegKey::GetName(bool bShortPrefix
) const
296 StdKey key
= GetStdKeyFromHkey((StdKey
) m_hRootKey
);
297 wxString str
= bShortPrefix
? aStdKeys
[key
].szShortName
298 : aStdKeys
[key
].szName
;
299 if ( !m_strKey
.IsEmpty() )
300 str
<< "\\" << m_strKey
;
305 bool wxRegKey::GetKeyInfo(size_t *pnSubKeys
,
308 size_t *pnMaxValueLen
) const
310 #if defined(__WIN32__) && !defined(__TWIN32__)
312 // old gcc headers incorrectly prototype RegQueryInfoKey()
313 #ifdef __GNUWIN32_OLD__
314 #define REG_PARAM (size_t *)
316 #define REG_PARAM (LPDWORD)
319 m_dwLastError
= ::RegQueryInfoKey
323 NULL
, // (ptr to) size of class name buffer
326 pnSubKeys
, // [out] number of subkeys
328 pnMaxKeyLen
, // [out] max length of a subkey name
329 NULL
, // longest subkey class name
331 pnValues
, // [out] number of values
333 pnMaxValueLen
, // [out] max length of a value name
334 NULL
, // longest value data
335 NULL
, // security descriptor
336 NULL
// time of last modification
341 if ( m_dwLastError
!= ERROR_SUCCESS
) {
342 wxLogSysError(m_dwLastError
, _("Can't get info about registry key '%s'"),
349 wxFAIL_MSG("GetKeyInfo() not implemented");
355 // ----------------------------------------------------------------------------
357 // ----------------------------------------------------------------------------
359 // opens key (it's not an error to call Open() on an already opened key)
360 bool wxRegKey::Open()
366 m_dwLastError
= RegOpenKey((HKEY
) m_hRootKey
, m_strKey
, &tmpKey
);
367 if ( m_dwLastError
!= ERROR_SUCCESS
) {
368 wxLogSysError(m_dwLastError
, _("Can't open registry key '%s'"),
374 m_hKey
= (WXHKEY
) tmpKey
;
379 // creates key, failing if it exists and !bOkIfExists
380 bool wxRegKey::Create(bool bOkIfExists
)
382 // check for existence only if asked (i.e. order is important!)
383 if ( !bOkIfExists
&& Exists() ) {
391 m_dwLastError
= RegCreateKey((HKEY
) m_hRootKey
, m_strKey
, &tmpKey
);
392 if ( m_dwLastError
!= ERROR_SUCCESS
) {
393 wxLogSysError(m_dwLastError
, _("Can't create registry key '%s'"),
399 m_hKey
= (WXHKEY
) tmpKey
;
404 // close the key, it's not an error to call it when not opened
405 bool wxRegKey::Close()
408 m_dwLastError
= RegCloseKey((HKEY
) m_hKey
);
409 if ( m_dwLastError
!= ERROR_SUCCESS
) {
410 wxLogSysError(m_dwLastError
, _("Can't close registry key '%s'"),
424 bool wxRegKey::RenameValue(const wxChar
*szValueOld
, const wxChar
*szValueNew
)
427 if ( HasValue(szValueNew
) ) {
428 wxLogError(_("Registry value '%s' already exists."), szValueNew
);
433 if ( !ok
|| !CopyValue(szValueOld
, *this, szValueNew
) ) {
434 wxLogError(_("Failed to rename registry value '%s' to '%s'."),
435 szValueOld
, szValueNew
);
443 bool wxRegKey::CopyValue(const wxChar
*szValue
,
445 const wxChar
*szValueNew
)
448 // by default, use the same name
449 szValueNew
= szValue
;
452 switch ( GetValueType(szValue
) ) {
456 return QueryValue(szValue
, strVal
) &&
457 keyDst
.SetValue(szValueNew
, strVal
);
461 /* case Type_Dword_little_endian: == Type_Dword */
464 return QueryValue(szValue
, &dwVal
) &&
465 keyDst
.SetValue(szValueNew
, dwVal
);
468 // these types are unsupported because I am not sure about how
469 // exactly they should be copied and because they shouldn't
470 // occur among the application keys (supposedly created with
474 case Type_Expand_String
:
476 case Type_Dword_big_endian
:
478 case Type_Multi_String
:
479 case Type_Resource_list
:
480 case Type_Full_resource_descriptor
:
481 case Type_Resource_requirements_list
:
484 wxLogError(_("Can't copy values of unsupported type %d."),
485 GetValueType(szValue
));
490 bool wxRegKey::Copy(const wxString
& strNewName
)
492 // create the new key first
493 wxRegKey
keyDst(strNewName
);
494 bool ok
= keyDst
.Create(FALSE
/* fail if alredy exists */);
498 // we created the dest key but copying to it failed - delete it
500 (void)keyDst
.DeleteSelf();
507 bool wxRegKey::Copy(wxRegKey
& keyDst
)
511 // copy all sub keys to the new location
514 bool bCont
= GetFirstKey(strKey
, lIndex
);
515 while ( ok
&& bCont
) {
516 wxRegKey
key(*this, strKey
);
518 keyName
<< GetFullName(&keyDst
) << REG_SEPARATOR
<< strKey
;
519 ok
= key
.Copy(keyName
);
522 bCont
= GetNextKey(strKey
, lIndex
);
527 bCont
= GetFirstValue(strVal
, lIndex
);
528 while ( ok
&& bCont
) {
529 ok
= CopyValue(strVal
, keyDst
);
532 wxLogSysError(m_dwLastError
,
533 _("Failed to copy registry value '%s'"),
537 bCont
= GetNextValue(strVal
, lIndex
);
542 wxLogError(_("Failed to copy the contents of registry key '%s' to "
543 "'%s'."), GetFullName(this), GetFullName(&keyDst
));
549 // ----------------------------------------------------------------------------
550 // delete keys/values
551 // ----------------------------------------------------------------------------
552 bool wxRegKey::DeleteSelf()
557 // it already doesn't exist - ok!
562 // prevent a buggy program from erasing one of the root registry keys or an
563 // immediate subkey (i.e. one which doesn't have '\\' inside) of any other
564 // key except HKCR (HKCR has some "deleteable" subkeys)
565 if ( m_strKey
.IsEmpty() || (m_hRootKey
!= HKCR
&&
566 m_strKey
.Find(REG_SEPARATOR
) == wxNOT_FOUND
) ) {
567 wxLogError(_("Registry key '%s' is needed for normal system operation,\n"
568 "deleting it will leave your system in unusable state:\n"
569 "operation aborted."), GetFullName(this));
574 // we can't delete keys while enumerating because it confuses GetNextKey, so
575 // we first save the key names and then delete them all
576 wxArrayString astrSubkeys
;
580 bool bCont
= GetFirstKey(strKey
, lIndex
);
582 astrSubkeys
.Add(strKey
);
584 bCont
= GetNextKey(strKey
, lIndex
);
587 size_t nKeyCount
= astrSubkeys
.Count();
588 for ( size_t nKey
= 0; nKey
< nKeyCount
; nKey
++ ) {
589 wxRegKey
key(*this, astrSubkeys
[nKey
]);
590 if ( !key
.DeleteSelf() )
594 // now delete this key itself
597 m_dwLastError
= RegDeleteKey((HKEY
) m_hRootKey
, m_strKey
);
598 if ( m_dwLastError
!= ERROR_SUCCESS
) {
599 wxLogSysError(m_dwLastError
, _("Can't delete key '%s'"),
607 bool wxRegKey::DeleteKey(const wxChar
*szKey
)
612 wxRegKey
key(*this, szKey
);
613 return key
.DeleteSelf();
616 bool wxRegKey::DeleteValue(const wxChar
*szValue
)
621 #if defined(__WIN32__) && !defined(__TWIN32__)
622 m_dwLastError
= RegDeleteValue((HKEY
) m_hKey
, WXSTRINGCAST szValue
);
623 if ( m_dwLastError
!= ERROR_SUCCESS
) {
624 wxLogSysError(m_dwLastError
, _("Can't delete value '%s' from key '%s'"),
625 szValue
, GetName().c_str());
629 // named registry values don't exist in Win16 world
630 wxASSERT( IsEmpty(szValue
) );
632 // just set the (default and unique) value of the key to ""
633 m_dwLastError
= RegSetValue((HKEY
) m_hKey
, NULL
, REG_SZ
, "", RESERVED
);
634 if ( m_dwLastError
!= ERROR_SUCCESS
) {
635 wxLogSysError(m_dwLastError
, _("Can't delete value of key '%s'"),
644 // ----------------------------------------------------------------------------
645 // access to values and subkeys
646 // ----------------------------------------------------------------------------
648 // return TRUE if value exists
649 bool wxRegKey::HasValue(const wxChar
*szValue
) const
651 // this function should be silent, so suppress possible messages from Open()
655 if ( CONST_CAST
Open() ) {
656 return RegQueryValueEx((HKEY
) m_hKey
, WXSTRINGCAST szValue
, RESERVED
,
657 NULL
, NULL
, NULL
) == ERROR_SUCCESS
;
662 // only unnamed value exists
663 return IsEmpty(szValue
);
667 // returns TRUE if this key has any values
668 bool wxRegKey::HasValues() const
670 // suppress possible messages from GetFirstValue()
673 // just call GetFirstValue with dummy parameters
676 return CONST_CAST
GetFirstValue(str
, l
);
679 // returns TRUE if this key has any subkeys
680 bool wxRegKey::HasSubkeys() const
682 // suppress possible messages from GetFirstKey()
685 // just call GetFirstKey with dummy parameters
688 return CONST_CAST
GetFirstKey(str
, l
);
691 // returns TRUE if given subkey exists
692 bool wxRegKey::HasSubKey(const wxChar
*szKey
) const
694 // this function should be silent, so suppress possible messages from Open()
697 if ( CONST_CAST
Open() )
698 return KeyExists(m_hKey
, szKey
);
703 wxRegKey::ValueType
wxRegKey::GetValueType(const wxChar
*szValue
) const
706 if ( ! CONST_CAST
Open() )
710 m_dwLastError
= RegQueryValueEx((HKEY
) m_hKey
, WXSTRINGCAST szValue
, RESERVED
,
711 &dwType
, NULL
, NULL
);
712 if ( m_dwLastError
!= ERROR_SUCCESS
) {
713 wxLogSysError(m_dwLastError
, _("Can't read value of key '%s'"),
718 return (ValueType
)dwType
;
720 return IsEmpty(szValue
) ? Type_String
: Type_None
;
725 bool wxRegKey::SetValue(const wxChar
*szValue
, long lValue
)
728 wxFAIL_MSG("RegSetValueEx not implemented by TWIN32");
731 if ( CONST_CAST
Open() ) {
732 m_dwLastError
= RegSetValueEx((HKEY
) m_hKey
, szValue
, (DWORD
) RESERVED
, REG_DWORD
,
733 (RegString
)&lValue
, sizeof(lValue
));
734 if ( m_dwLastError
== ERROR_SUCCESS
)
738 wxLogSysError(m_dwLastError
, _("Can't set value of '%s'"),
739 GetFullName(this, szValue
));
744 bool wxRegKey::QueryValue(const wxChar
*szValue
, long *plValue
) const
746 if ( CONST_CAST
Open() ) {
747 DWORD dwType
, dwSize
= sizeof(DWORD
);
748 RegString pBuf
= (RegString
)plValue
;
749 m_dwLastError
= RegQueryValueEx((HKEY
) m_hKey
, WXSTRINGCAST szValue
, RESERVED
,
750 &dwType
, pBuf
, &dwSize
);
751 if ( m_dwLastError
!= ERROR_SUCCESS
) {
752 wxLogSysError(m_dwLastError
, _("Can't read value of key '%s'"),
757 // check that we read the value of right type
758 wxASSERT_MSG( IsNumericValue(szValue
),
759 wxT("Type mismatch in wxRegKey::QueryValue().") );
770 bool wxRegKey::QueryValue(const wxChar
*szValue
, wxString
& strValue
) const
772 if ( CONST_CAST
Open() ) {
774 // first get the type and size of the data
775 DWORD dwType
, dwSize
;
776 m_dwLastError
= RegQueryValueEx((HKEY
) m_hKey
, WXSTRINGCAST szValue
, RESERVED
,
777 &dwType
, NULL
, &dwSize
);
778 if ( m_dwLastError
== ERROR_SUCCESS
) {
780 // must treat this case specially as GetWriteBuf() doesn't like
781 // being called with 0 size
785 RegString pBuf
= (RegString
)strValue
.GetWriteBuf(dwSize
);
786 m_dwLastError
= RegQueryValueEx((HKEY
) m_hKey
,
787 WXSTRINGCAST szValue
,
792 strValue
.UngetWriteBuf();
795 if ( m_dwLastError
== ERROR_SUCCESS
) {
796 // check that it was the right type
797 wxASSERT_MSG( !IsNumericValue(szValue
),
798 wxT("Type mismatch in wxRegKey::QueryValue().") );
804 // named registry values don't exist in Win16
805 wxASSERT( IsEmpty(szValue
) );
807 m_dwLastError
= RegQueryValue((HKEY
) m_hKey
, 0, strValue
.GetWriteBuf(256), &l
);
808 strValue
.UngetWriteBuf();
809 if ( m_dwLastError
== ERROR_SUCCESS
)
814 wxLogSysError(m_dwLastError
, _("Can't read value of '%s'"),
815 GetFullName(this, szValue
));
819 bool wxRegKey::SetValue(const wxChar
*szValue
, const wxString
& strValue
)
821 if ( CONST_CAST
Open() ) {
822 #if defined( __WIN32__) && !defined(__TWIN32__)
823 m_dwLastError
= RegSetValueEx((HKEY
) m_hKey
, szValue
, (DWORD
) RESERVED
, REG_SZ
,
824 (RegString
)strValue
.c_str(),
826 if ( m_dwLastError
== ERROR_SUCCESS
)
829 // named registry values don't exist in Win16
830 wxASSERT( IsEmpty(szValue
) );
832 m_dwLastError
= RegSetValue((HKEY
) m_hKey
, NULL
, REG_SZ
, strValue
, NULL
);
833 if ( m_dwLastError
== ERROR_SUCCESS
)
838 wxLogSysError(m_dwLastError
, _("Can't set value of '%s'"),
839 GetFullName(this, szValue
));
843 wxRegKey::operator wxString() const
846 QueryValue(NULL
, str
);
850 // ----------------------------------------------------------------------------
852 // NB: all these functions require an index variable which allows to have
853 // several concurrently running indexations on the same key
854 // ----------------------------------------------------------------------------
856 bool wxRegKey::GetFirstValue(wxString
& strValueName
, long& lIndex
)
862 return GetNextValue(strValueName
, lIndex
);
865 bool wxRegKey::GetNextValue(wxString
& strValueName
, long& lIndex
) const
867 wxASSERT( IsOpened() );
869 // are we already at the end of enumeration?
873 #if defined( __WIN32__) && !defined(__TWIN32__)
874 wxChar szValueName
[1024]; // @@ use RegQueryInfoKey...
875 DWORD dwValueLen
= WXSIZEOF(szValueName
);
877 m_dwLastError
= RegEnumValue((HKEY
) m_hKey
, lIndex
++,
878 szValueName
, &dwValueLen
,
881 NULL
, // [out] buffer for value
882 NULL
); // [i/o] it's length
884 if ( m_dwLastError
!= ERROR_SUCCESS
) {
885 if ( m_dwLastError
== ERROR_NO_MORE_ITEMS
) {
886 m_dwLastError
= ERROR_SUCCESS
;
890 wxLogSysError(m_dwLastError
, _("Can't enumerate values of key '%s'"),
897 strValueName
= szValueName
;
899 // only one unnamed value
900 wxASSERT( lIndex
== 0 );
903 strValueName
.Empty();
909 bool wxRegKey::GetFirstKey(wxString
& strKeyName
, long& lIndex
)
915 return GetNextKey(strKeyName
, lIndex
);
918 bool wxRegKey::GetNextKey(wxString
& strKeyName
, long& lIndex
) const
920 wxASSERT( IsOpened() );
922 // are we already at the end of enumeration?
926 wxChar szKeyName
[_MAX_PATH
+ 1];
927 m_dwLastError
= RegEnumKey((HKEY
) m_hKey
, lIndex
++, szKeyName
, WXSIZEOF(szKeyName
));
929 if ( m_dwLastError
!= ERROR_SUCCESS
) {
930 if ( m_dwLastError
== ERROR_NO_MORE_ITEMS
) {
931 m_dwLastError
= ERROR_SUCCESS
;
935 wxLogSysError(m_dwLastError
, _("Can't enumerate subkeys of key '%s'"),
942 strKeyName
= szKeyName
;
946 // returns TRUE if the value contains a number (else it's some string)
947 bool wxRegKey::IsNumericValue(const wxChar
*szValue
) const
949 ValueType type
= GetValueType(szValue
);
952 /* case Type_Dword_little_endian: == Type_Dword */
953 case Type_Dword_big_endian
:
961 // ============================================================================
962 // implementation of global private functions
963 // ============================================================================
964 bool KeyExists(WXHKEY hRootKey
, const wxChar
*szKey
)
967 if ( RegOpenKey( (HKEY
) hRootKey
, szKey
, &hkeyDummy
) == ERROR_SUCCESS
) {
968 RegCloseKey(hkeyDummy
);
975 const wxChar
*GetFullName(const wxRegKey
*pKey
, const wxChar
*szValue
)
977 static wxString s_str
;
978 s_str
= pKey
->GetName();
979 if ( !wxIsEmpty(szValue
) )
980 s_str
<< wxT("\\") << szValue
;
982 return s_str
.c_str();
985 void RemoveTrailingSeparator(wxString
& str
)
987 if ( !str
.IsEmpty() && str
.Last() == REG_SEPARATOR
)
988 str
.Truncate(str
.Len() - 1);