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 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 ///////////////////////////////////////////////////////////////////////////////
15 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
16 #pragma implementation "registry.h"
19 // for compilers that support precompilation, includes "wx.h".
20 #include "wx/wxprec.h"
26 // other wxWidgets headers
27 #include "wx/string.h"
31 #include "wx/wfstream.h"
34 #include "wx/msw/wrapwin.h"
37 #include "wx/msw/private.h"
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
;
55 typedef BYTE
* RegBinary
;
57 // ----------------------------------------------------------------------------
59 // ----------------------------------------------------------------------------
61 // the standard key names, short names and handles all bundled together for
67 const wxChar
*szShortName
;
71 { HKEY_CLASSES_ROOT
, wxT("HKEY_CLASSES_ROOT"), wxT("HKCR") },
72 { HKEY_CURRENT_USER
, wxT("HKEY_CURRENT_USER"), wxT("HKCU") },
73 { HKEY_LOCAL_MACHINE
, wxT("HKEY_LOCAL_MACHINE"), wxT("HKLM") },
74 { HKEY_USERS
, wxT("HKEY_USERS"), wxT("HKU") }, // short name?
76 { HKEY_PERFORMANCE_DATA
, wxT("HKEY_PERFORMANCE_DATA"), wxT("HKPD") },
78 #if WINVER >= 0x0400 && !defined(__WXWINCE__)
79 { HKEY_CURRENT_CONFIG
, wxT("HKEY_CURRENT_CONFIG"), wxT("HKCC") },
80 #if !defined(__GNUWIN32__) && !defined(__WXWINCE__)
81 { HKEY_DYN_DATA
, wxT("HKEY_DYN_DATA"), wxT("HKDD") }, // short name?
83 #endif //WINVER >= 4.0
86 // the registry name separator (perhaps one day MS will change it to '/' ;-)
87 #define REG_SEPARATOR wxT('\\')
89 // useful for Windows programmers: makes somewhat more clear all these zeroes
90 // being passed to Windows APIs
93 // ----------------------------------------------------------------------------
95 // ----------------------------------------------------------------------------
97 // const_cast<> is not yet supported by all compilers
98 #define CONST_CAST ((wxRegKey *)this)->
100 // and neither is mutable which m_dwLastError should be
101 #define m_dwLastError CONST_CAST m_dwLastError
103 // ----------------------------------------------------------------------------
104 // non member functions
105 // ----------------------------------------------------------------------------
107 // removes the trailing backslash from the string if it has one
108 static inline void RemoveTrailingSeparator(wxString
& str
);
110 // returns true if given registry key exists
111 static bool KeyExists(WXHKEY hRootKey
, const wxChar
*szKey
);
113 // combines value and key name (uses static buffer!)
114 static const wxChar
*GetFullName(const wxRegKey
*pKey
,
115 const wxChar
*szValue
= NULL
);
117 // ============================================================================
118 // implementation of wxRegKey class
119 // ============================================================================
121 // ----------------------------------------------------------------------------
122 // static functions and variables
123 // ----------------------------------------------------------------------------
125 const size_t wxRegKey::nStdKeys
= WXSIZEOF(aStdKeys
);
127 // @@ should take a `StdKey key', but as it's often going to be used in loops
128 // it would require casts in user code.
129 const wxChar
*wxRegKey::GetStdKeyName(size_t key
)
131 // return empty string if key is invalid
132 wxCHECK_MSG( key
< nStdKeys
, wxEmptyString
, wxT("invalid key in wxRegKey::GetStdKeyName") );
134 return aStdKeys
[key
].szName
;
137 const wxChar
*wxRegKey::GetStdKeyShortName(size_t key
)
139 // return empty string if key is invalid
140 wxCHECK( key
< nStdKeys
, wxEmptyString
);
142 return aStdKeys
[key
].szShortName
;
145 wxRegKey::StdKey
wxRegKey::ExtractKeyName(wxString
& strKey
)
147 wxString strRoot
= strKey
.BeforeFirst(REG_SEPARATOR
);
151 for ( ui
= 0; ui
< nStdKeys
; ui
++ ) {
152 if ( strRoot
.CmpNoCase(aStdKeys
[ui
].szName
) == 0 ||
153 strRoot
.CmpNoCase(aStdKeys
[ui
].szShortName
) == 0 ) {
154 hRootKey
= aStdKeys
[ui
].hkey
;
159 if ( ui
== nStdKeys
) {
160 wxFAIL_MSG(wxT("invalid key prefix in wxRegKey::ExtractKeyName."));
162 hRootKey
= HKEY_CLASSES_ROOT
;
165 strKey
= strKey
.After(REG_SEPARATOR
);
166 if ( !strKey
.IsEmpty() && strKey
.Last() == REG_SEPARATOR
)
167 strKey
.Truncate(strKey
.Len() - 1);
170 return (wxRegKey::StdKey
)(int)hRootKey
;
173 wxRegKey::StdKey
wxRegKey::GetStdKeyFromHkey(WXHKEY hkey
)
175 for ( size_t ui
= 0; ui
< nStdKeys
; ui
++ ) {
176 if ( (int) aStdKeys
[ui
].hkey
== (int) hkey
)
180 wxFAIL_MSG(wxT("non root hkey passed to wxRegKey::GetStdKeyFromHkey."));
185 // ----------------------------------------------------------------------------
187 // ----------------------------------------------------------------------------
191 m_hRootKey
= (WXHKEY
) aStdKeys
[HKCR
].hkey
;
196 wxRegKey::wxRegKey(const wxString
& strKey
) : m_strKey(strKey
)
198 m_hRootKey
= (WXHKEY
) aStdKeys
[ExtractKeyName(m_strKey
)].hkey
;
203 // parent is a predefined (and preopened) key
204 wxRegKey::wxRegKey(StdKey keyParent
, const wxString
& strKey
) : m_strKey(strKey
)
206 RemoveTrailingSeparator(m_strKey
);
207 m_hRootKey
= (WXHKEY
) aStdKeys
[keyParent
].hkey
;
212 // parent is a normal regkey
213 wxRegKey::wxRegKey(const wxRegKey
& keyParent
, const wxString
& strKey
)
214 : m_strKey(keyParent
.m_strKey
)
216 // combine our name with parent's to get the full name
217 if ( !m_strKey
.IsEmpty() &&
218 (strKey
.IsEmpty() || strKey
[0] != REG_SEPARATOR
) ) {
219 m_strKey
+= REG_SEPARATOR
;
223 RemoveTrailingSeparator(m_strKey
);
225 m_hRootKey
= keyParent
.m_hRootKey
;
230 // dtor closes the key releasing system resource
231 wxRegKey::~wxRegKey()
236 // ----------------------------------------------------------------------------
237 // change the key name/hkey
238 // ----------------------------------------------------------------------------
240 // set the full key name
241 void wxRegKey::SetName(const wxString
& strKey
)
246 m_hRootKey
= (WXHKEY
) aStdKeys
[ExtractKeyName(m_strKey
)].hkey
;
249 // the name is relative to the parent key
250 void wxRegKey::SetName(StdKey keyParent
, const wxString
& strKey
)
255 RemoveTrailingSeparator(m_strKey
);
256 m_hRootKey
= (WXHKEY
) aStdKeys
[keyParent
].hkey
;
259 // the name is relative to the parent key
260 void wxRegKey::SetName(const wxRegKey
& keyParent
, const wxString
& strKey
)
264 // combine our name with parent's to get the full name
266 // NB: this method is called by wxRegConfig::SetPath() which is a performance
267 // critical function and so it preallocates space for our m_strKey to
268 // gain some speed - this is why we only use += here and not = which
269 // would just free the prealloc'd buffer and would have to realloc it the
272 m_strKey
+= keyParent
.m_strKey
;
273 if ( !strKey
.IsEmpty() && strKey
[0] != REG_SEPARATOR
)
274 m_strKey
+= REG_SEPARATOR
;
277 RemoveTrailingSeparator(m_strKey
);
279 m_hRootKey
= keyParent
.m_hRootKey
;
282 // hKey should be opened and will be closed in wxRegKey dtor
283 void wxRegKey::SetHkey(WXHKEY hKey
)
290 // ----------------------------------------------------------------------------
291 // info about the key
292 // ----------------------------------------------------------------------------
294 // returns true if the key exists
295 bool wxRegKey::Exists() const
297 // opened key has to exist, try to open it if not done yet
298 return IsOpened() ? true : KeyExists(m_hRootKey
, m_strKey
);
301 // returns the full name of the key (prefix is abbreviated if bShortPrefix)
302 wxString
wxRegKey::GetName(bool bShortPrefix
) const
304 StdKey key
= GetStdKeyFromHkey((WXHKEY
) m_hRootKey
);
305 wxString str
= bShortPrefix
? aStdKeys
[key
].szShortName
306 : aStdKeys
[key
].szName
;
307 if ( !m_strKey
.IsEmpty() )
308 str
<< _T("\\") << m_strKey
;
313 bool wxRegKey::GetKeyInfo(size_t *pnSubKeys
,
316 size_t *pnMaxValueLen
) const
318 // old gcc headers incorrectly prototype RegQueryInfoKey()
319 #if defined(__GNUWIN32_OLD__) && !defined(__CYGWIN10__)
320 #define REG_PARAM (size_t *)
322 #define REG_PARAM (LPDWORD)
325 // it might be unexpected to some that this function doesn't open the key
326 wxASSERT_MSG( IsOpened(), _T("key should be opened in GetKeyInfo") );
328 m_dwLastError
= ::RegQueryInfoKey
332 NULL
, // (ptr to) size of class name buffer
335 pnSubKeys
, // [out] number of subkeys
337 pnMaxKeyLen
, // [out] max length of a subkey name
338 NULL
, // longest subkey class name
340 pnValues
, // [out] number of values
342 pnMaxValueLen
, // [out] max length of a value name
343 NULL
, // longest value data
344 NULL
, // security descriptor
345 NULL
// time of last modification
350 if ( m_dwLastError
!= ERROR_SUCCESS
) {
351 wxLogSysError(m_dwLastError
, _("Can't get info about registry key '%s'"),
359 // ----------------------------------------------------------------------------
361 // ----------------------------------------------------------------------------
363 // opens key (it's not an error to call Open() on an already opened key)
364 bool wxRegKey::Open(AccessMode mode
)
370 m_dwLastError
= ::RegOpenKeyEx
375 mode
== Read
? KEY_READ
: KEY_ALL_ACCESS
,
379 if ( m_dwLastError
!= ERROR_SUCCESS
)
381 wxLogSysError(m_dwLastError
, _("Can't open registry key '%s'"),
386 m_hKey
= (WXHKEY
) tmpKey
;
390 // creates key, failing if it exists and !bOkIfExists
391 bool wxRegKey::Create(bool bOkIfExists
)
393 // check for existence only if asked (i.e. order is important!)
394 if ( !bOkIfExists
&& Exists() )
403 m_dwLastError
= RegCreateKeyEx((HKEY
) m_hRootKey
, m_strKey
,
405 NULL
, // class string
412 m_dwLastError
= RegCreateKey((HKEY
) m_hRootKey
, m_strKey
, &tmpKey
);
414 if ( m_dwLastError
!= ERROR_SUCCESS
) {
415 wxLogSysError(m_dwLastError
, _("Can't create registry key '%s'"),
421 m_hKey
= (WXHKEY
) tmpKey
;
426 // close the key, it's not an error to call it when not opened
427 bool wxRegKey::Close()
430 m_dwLastError
= RegCloseKey((HKEY
) m_hKey
);
433 if ( m_dwLastError
!= ERROR_SUCCESS
) {
434 wxLogSysError(m_dwLastError
, _("Can't close registry key '%s'"),
444 bool wxRegKey::RenameValue(const wxChar
*szValueOld
, const wxChar
*szValueNew
)
447 if ( HasValue(szValueNew
) ) {
448 wxLogError(_("Registry value '%s' already exists."), szValueNew
);
454 !CopyValue(szValueOld
, *this, szValueNew
) ||
455 !DeleteValue(szValueOld
) ) {
456 wxLogError(_("Failed to rename registry value '%s' to '%s'."),
457 szValueOld
, szValueNew
);
465 bool wxRegKey::CopyValue(const wxChar
*szValue
,
467 const wxChar
*szValueNew
)
470 // by default, use the same name
471 szValueNew
= szValue
;
474 switch ( GetValueType(szValue
) ) {
478 return QueryValue(szValue
, strVal
) &&
479 keyDst
.SetValue(szValueNew
, strVal
);
483 /* case Type_Dword_little_endian: == Type_Dword */
486 return QueryValue(szValue
, &dwVal
) &&
487 keyDst
.SetValue(szValueNew
, dwVal
);
493 return QueryValue(szValue
,buf
) &&
494 keyDst
.SetValue(szValueNew
,buf
);
497 // these types are unsupported because I am not sure about how
498 // exactly they should be copied and because they shouldn't
499 // occur among the application keys (supposedly created with
502 case Type_Expand_String
:
503 case Type_Dword_big_endian
:
505 case Type_Multi_String
:
506 case Type_Resource_list
:
507 case Type_Full_resource_descriptor
:
508 case Type_Resource_requirements_list
:
510 wxLogError(_("Can't copy values of unsupported type %d."),
511 GetValueType(szValue
));
516 bool wxRegKey::Rename(const wxChar
*szNewName
)
518 wxCHECK_MSG( !m_strKey
.IsEmpty(), false, _T("registry hives can't be renamed") );
521 wxLogError(_("Registry key '%s' does not exist, cannot rename it."),
527 // do we stay in the same hive?
528 bool inSameHive
= !wxStrchr(szNewName
, REG_SEPARATOR
);
530 // construct the full new name of the key
534 // rename the key to the new name under the same parent
535 wxString strKey
= m_strKey
.BeforeLast(REG_SEPARATOR
);
536 if ( !strKey
.IsEmpty() ) {
537 // don't add '\\' in the start if strFullNewName is empty
538 strKey
+= REG_SEPARATOR
;
543 keyDst
.SetName(GetStdKeyFromHkey(m_hRootKey
), strKey
);
546 // this is the full name already
547 keyDst
.SetName(szNewName
);
550 bool ok
= keyDst
.Create(false /* fail if alredy exists */);
552 wxLogError(_("Registry key '%s' already exists."),
553 GetFullName(&keyDst
));
556 ok
= Copy(keyDst
) && DeleteSelf();
560 wxLogError(_("Failed to rename the registry key '%s' to '%s'."),
561 GetFullName(this), GetFullName(&keyDst
));
564 m_hRootKey
= keyDst
.m_hRootKey
;
565 m_strKey
= keyDst
.m_strKey
;
571 bool wxRegKey::Copy(const wxChar
*szNewName
)
573 // create the new key first
574 wxRegKey
keyDst(szNewName
);
575 bool ok
= keyDst
.Create(false /* fail if alredy exists */);
579 // we created the dest key but copying to it failed - delete it
581 (void)keyDst
.DeleteSelf();
588 bool wxRegKey::Copy(wxRegKey
& keyDst
)
592 // copy all sub keys to the new location
595 bool bCont
= GetFirstKey(strKey
, lIndex
);
596 while ( ok
&& bCont
) {
597 wxRegKey
key(*this, strKey
);
599 keyName
<< GetFullName(&keyDst
) << REG_SEPARATOR
<< strKey
;
600 ok
= key
.Copy((const wxChar
*) keyName
);
603 bCont
= GetNextKey(strKey
, lIndex
);
605 wxLogError(_("Failed to copy the registry subkey '%s' to '%s'."),
606 GetFullName(&key
), keyName
.c_str());
612 bCont
= GetFirstValue(strVal
, lIndex
);
613 while ( ok
&& bCont
) {
614 ok
= CopyValue(strVal
, keyDst
);
617 wxLogSysError(m_dwLastError
,
618 _("Failed to copy registry value '%s'"),
622 bCont
= GetNextValue(strVal
, lIndex
);
627 wxLogError(_("Failed to copy the contents of registry key '%s' to '%s'."),
628 GetFullName(this), GetFullName(&keyDst
));
634 // ----------------------------------------------------------------------------
635 // delete keys/values
636 // ----------------------------------------------------------------------------
637 bool wxRegKey::DeleteSelf()
642 // it already doesn't exist - ok!
647 // prevent a buggy program from erasing one of the root registry keys or an
648 // immediate subkey (i.e. one which doesn't have '\\' inside) of any other
649 // key except HKCR (HKCR has some "deleteable" subkeys)
650 if ( m_strKey
.IsEmpty() ||
651 ((m_hRootKey
!= (WXHKEY
) aStdKeys
[HKCR
].hkey
) &&
652 (m_strKey
.Find(REG_SEPARATOR
) == wxNOT_FOUND
)) ) {
653 wxLogError(_("Registry key '%s' is needed for normal system operation,\ndeleting it will leave your system in unusable state:\noperation aborted."),
659 // we can't delete keys while enumerating because it confuses GetNextKey, so
660 // we first save the key names and then delete them all
661 wxArrayString astrSubkeys
;
665 bool bCont
= GetFirstKey(strKey
, lIndex
);
667 astrSubkeys
.Add(strKey
);
669 bCont
= GetNextKey(strKey
, lIndex
);
672 size_t nKeyCount
= astrSubkeys
.Count();
673 for ( size_t nKey
= 0; nKey
< nKeyCount
; nKey
++ ) {
674 wxRegKey
key(*this, astrSubkeys
[nKey
]);
675 if ( !key
.DeleteSelf() )
679 // now delete this key itself
682 m_dwLastError
= RegDeleteKey((HKEY
) m_hRootKey
, m_strKey
);
683 // deleting a key which doesn't exist is not considered an error
684 if ( m_dwLastError
!= ERROR_SUCCESS
&&
685 m_dwLastError
!= ERROR_FILE_NOT_FOUND
) {
686 wxLogSysError(m_dwLastError
, _("Can't delete key '%s'"),
694 bool wxRegKey::DeleteKey(const wxChar
*szKey
)
699 wxRegKey
key(*this, szKey
);
700 return key
.DeleteSelf();
703 bool wxRegKey::DeleteValue(const wxChar
*szValue
)
708 m_dwLastError
= RegDeleteValue((HKEY
) m_hKey
, WXSTRINGCAST szValue
);
710 // deleting a value which doesn't exist is not considered an error
711 if ( (m_dwLastError
!= ERROR_SUCCESS
) &&
712 (m_dwLastError
!= ERROR_FILE_NOT_FOUND
) ) {
713 wxLogSysError(m_dwLastError
, _("Can't delete value '%s' from key '%s'"),
714 szValue
, GetName().c_str());
721 // ----------------------------------------------------------------------------
722 // access to values and subkeys
723 // ----------------------------------------------------------------------------
725 // return true if value exists
726 bool wxRegKey::HasValue(const wxChar
*szValue
) const
728 // this function should be silent, so suppress possible messages from Open()
731 if ( !CONST_CAST
Open(Read
) )
734 LONG dwRet
= ::RegQueryValueEx((HKEY
) m_hKey
,
735 WXSTRINGCAST szValue
,
738 return dwRet
== ERROR_SUCCESS
;
741 // returns true if this key has any values
742 bool wxRegKey::HasValues() const
744 // suppress possible messages from GetFirstValue()
747 // just call GetFirstValue with dummy parameters
750 return CONST_CAST
GetFirstValue(str
, l
);
753 // returns true if this key has any subkeys
754 bool wxRegKey::HasSubkeys() const
756 // suppress possible messages from GetFirstKey()
759 // just call GetFirstKey with dummy parameters
762 return CONST_CAST
GetFirstKey(str
, l
);
765 // returns true if given subkey exists
766 bool wxRegKey::HasSubKey(const wxChar
*szKey
) const
768 // this function should be silent, so suppress possible messages from Open()
771 if ( !CONST_CAST
Open(Read
) )
774 return KeyExists(m_hKey
, szKey
);
777 wxRegKey::ValueType
wxRegKey::GetValueType(const wxChar
*szValue
) const
779 if ( ! CONST_CAST
Open(Read
) )
783 m_dwLastError
= RegQueryValueEx((HKEY
) m_hKey
, WXSTRINGCAST szValue
, RESERVED
,
784 &dwType
, NULL
, NULL
);
785 if ( m_dwLastError
!= ERROR_SUCCESS
) {
786 wxLogSysError(m_dwLastError
, _("Can't read value of key '%s'"),
791 return (ValueType
)dwType
;
794 bool wxRegKey::SetValue(const wxChar
*szValue
, long lValue
)
796 if ( CONST_CAST
Open() ) {
797 m_dwLastError
= RegSetValueEx((HKEY
) m_hKey
, szValue
, (DWORD
) RESERVED
, REG_DWORD
,
798 (RegString
)&lValue
, sizeof(lValue
));
799 if ( m_dwLastError
== ERROR_SUCCESS
)
803 wxLogSysError(m_dwLastError
, _("Can't set value of '%s'"),
804 GetFullName(this, szValue
));
808 bool wxRegKey::QueryValue(const wxChar
*szValue
, long *plValue
) const
810 if ( CONST_CAST
Open(Read
) ) {
811 DWORD dwType
, dwSize
= sizeof(DWORD
);
812 RegString pBuf
= (RegString
)plValue
;
813 m_dwLastError
= RegQueryValueEx((HKEY
) m_hKey
, WXSTRINGCAST szValue
, RESERVED
,
814 &dwType
, pBuf
, &dwSize
);
815 if ( m_dwLastError
!= ERROR_SUCCESS
) {
816 wxLogSysError(m_dwLastError
, _("Can't read value of key '%s'"),
821 // check that we read the value of right type
822 wxASSERT_MSG( IsNumericValue(szValue
),
823 wxT("Type mismatch in wxRegKey::QueryValue().") );
832 bool wxRegKey::SetValue(const wxChar
*szValue
,const wxMemoryBuffer
& buffer
)
835 wxFAIL_MSG("RegSetValueEx not implemented by TWIN32");
838 if ( CONST_CAST
Open() ) {
839 m_dwLastError
= RegSetValueEx((HKEY
) m_hKey
, szValue
, (DWORD
) RESERVED
, REG_BINARY
,
840 (RegBinary
)buffer
.GetData(),buffer
.GetDataLen());
841 if ( m_dwLastError
== ERROR_SUCCESS
)
845 wxLogSysError(m_dwLastError
, _("Can't set value of '%s'"),
846 GetFullName(this, szValue
));
851 bool wxRegKey::QueryValue(const wxChar
*szValue
, wxMemoryBuffer
& buffer
) const
853 if ( CONST_CAST
Open() ) {
854 // first get the type and size of the data
855 DWORD dwType
, dwSize
;
856 m_dwLastError
= RegQueryValueEx((HKEY
) m_hKey
, WXSTRINGCAST szValue
, RESERVED
,
857 &dwType
, NULL
, &dwSize
);
859 if ( m_dwLastError
== ERROR_SUCCESS
) {
861 const RegBinary pBuf
= (RegBinary
)buffer
.GetWriteBuf(dwSize
);
862 m_dwLastError
= RegQueryValueEx((HKEY
) m_hKey
,
863 WXSTRINGCAST szValue
,
868 buffer
.UngetWriteBuf(dwSize
);
870 buffer
.SetDataLen(0);
875 if ( m_dwLastError
!= ERROR_SUCCESS
) {
876 wxLogSysError(m_dwLastError
, _("Can't read value of key '%s'"),
887 bool wxRegKey::QueryValue(const wxChar
*szValue
,
891 if ( CONST_CAST
Open(Read
) ) {
893 // first get the type and size of the data
894 DWORD dwType
, dwSize
;
895 m_dwLastError
= RegQueryValueEx((HKEY
) m_hKey
, WXSTRINGCAST szValue
, RESERVED
,
896 &dwType
, NULL
, &dwSize
);
897 if ( m_dwLastError
== ERROR_SUCCESS
) {
899 // must treat this case specially as GetWriteBuf() doesn't like
900 // being called with 0 size
904 m_dwLastError
= RegQueryValueEx((HKEY
) m_hKey
,
905 WXSTRINGCAST szValue
,
908 (RegString
)(wxChar
*)wxStringBuffer(strValue
, dwSize
),
911 // expand the var expansions in the string unless disabled
913 if ( (dwType
== REG_EXPAND_SZ
) && !raw
)
915 DWORD dwExpSize
= ::ExpandEnvironmentStrings(strValue
, NULL
, 0);
916 bool ok
= dwExpSize
!= 0;
919 wxString strExpValue
;
920 ok
= ::ExpandEnvironmentStrings
923 wxStringBuffer(strExpValue
, dwExpSize
),
926 strValue
= strExpValue
;
931 wxLogLastError(_T("ExpandEnvironmentStrings"));
940 if ( m_dwLastError
== ERROR_SUCCESS
) {
941 // check that it was the right type
942 wxASSERT_MSG( !IsNumericValue(szValue
),
943 wxT("Type mismatch in wxRegKey::QueryValue().") );
950 wxLogSysError(m_dwLastError
, _("Can't read value of '%s'"),
951 GetFullName(this, szValue
));
955 bool wxRegKey::SetValue(const wxChar
*szValue
, const wxString
& strValue
)
957 if ( CONST_CAST
Open() ) {
958 m_dwLastError
= RegSetValueEx((HKEY
) m_hKey
, szValue
, (DWORD
) RESERVED
, REG_SZ
,
959 (RegString
)strValue
.c_str(),
960 (strValue
.Len() + 1)*sizeof(wxChar
));
961 if ( m_dwLastError
== ERROR_SUCCESS
)
965 wxLogSysError(m_dwLastError
, _("Can't set value of '%s'"),
966 GetFullName(this, szValue
));
970 wxString
wxRegKey::QueryDefaultValue() const
973 QueryValue(NULL
, str
);
977 // ----------------------------------------------------------------------------
979 // NB: all these functions require an index variable which allows to have
980 // several concurrently running indexations on the same key
981 // ----------------------------------------------------------------------------
983 bool wxRegKey::GetFirstValue(wxString
& strValueName
, long& lIndex
)
989 return GetNextValue(strValueName
, lIndex
);
992 bool wxRegKey::GetNextValue(wxString
& strValueName
, long& lIndex
) const
994 wxASSERT( IsOpened() );
996 // are we already at the end of enumeration?
1000 wxChar szValueName
[1024]; // @@ use RegQueryInfoKey...
1001 DWORD dwValueLen
= WXSIZEOF(szValueName
);
1003 m_dwLastError
= RegEnumValue((HKEY
) m_hKey
, lIndex
++,
1004 szValueName
, &dwValueLen
,
1007 NULL
, // [out] buffer for value
1008 NULL
); // [i/o] it's length
1010 if ( m_dwLastError
!= ERROR_SUCCESS
) {
1011 if ( m_dwLastError
== ERROR_NO_MORE_ITEMS
) {
1012 m_dwLastError
= ERROR_SUCCESS
;
1016 wxLogSysError(m_dwLastError
, _("Can't enumerate values of key '%s'"),
1023 strValueName
= szValueName
;
1028 bool wxRegKey::GetFirstKey(wxString
& strKeyName
, long& lIndex
)
1034 return GetNextKey(strKeyName
, lIndex
);
1037 bool wxRegKey::GetNextKey(wxString
& strKeyName
, long& lIndex
) const
1039 wxASSERT( IsOpened() );
1041 // are we already at the end of enumeration?
1045 wxChar szKeyName
[_MAX_PATH
+ 1];
1048 DWORD sizeName
= WXSIZEOF(szKeyName
);
1049 m_dwLastError
= RegEnumKeyEx((HKEY
) m_hKey
, lIndex
++, szKeyName
, & sizeName
,
1050 0, NULL
, NULL
, NULL
);
1052 m_dwLastError
= RegEnumKey((HKEY
) m_hKey
, lIndex
++, szKeyName
, WXSIZEOF(szKeyName
));
1055 if ( m_dwLastError
!= ERROR_SUCCESS
) {
1056 if ( m_dwLastError
== ERROR_NO_MORE_ITEMS
) {
1057 m_dwLastError
= ERROR_SUCCESS
;
1061 wxLogSysError(m_dwLastError
, _("Can't enumerate subkeys of key '%s'"),
1068 strKeyName
= szKeyName
;
1072 // returns true if the value contains a number (else it's some string)
1073 bool wxRegKey::IsNumericValue(const wxChar
*szValue
) const
1075 ValueType type
= GetValueType(szValue
);
1078 /* case Type_Dword_little_endian: == Type_Dword */
1079 case Type_Dword_big_endian
:
1087 // ----------------------------------------------------------------------------
1088 // exporting registry keys to file
1089 // ----------------------------------------------------------------------------
1091 // helper functions for writing ASCII strings (even in Unicode build)
1092 static inline bool WriteAsciiChar(wxOutputStream
& ostr
, char ch
)
1098 static inline bool WriteAsciiEOL(wxOutputStream
& ostr
)
1100 // as we open the file in text mode, it is enough to write LF without CR
1101 return WriteAsciiChar(ostr
, '\n');
1104 static inline bool WriteAsciiString(wxOutputStream
& ostr
, const char *p
)
1106 return ostr
.Write(p
, strlen(p
)).IsOk();
1109 static inline bool WriteAsciiString(wxOutputStream
& ostr
, const wxString
& s
)
1112 wxCharBuffer
name(s
.mb_str());
1113 ostr
.Write(name
, strlen(name
));
1115 ostr
.Write(s
, s
.length());
1121 bool wxRegKey::Export(const wxString
& filename
) const
1123 if ( wxFile::Exists(filename
) )
1125 wxLogError(_("Exporting registry key: file \"%s\" already exists and won't be overwritten."),
1130 wxFFileOutputStream
ostr(filename
, _T("w"));
1132 return ostr
.Ok() && Export(ostr
);
1135 bool wxRegKey::Export(wxOutputStream
& ostr
) const
1137 // write out the header
1138 if ( !WriteAsciiString(ostr
, "REGEDIT4\n\n") )
1141 return DoExport(ostr
);
1146 FormatAsHex(const void *data
,
1148 wxRegKey::ValueType type
= wxRegKey::Type_Binary
)
1150 wxString
value(_T("hex"));
1152 // binary values use just "hex:" prefix while the other ones must indicate
1154 if ( type
!= wxRegKey::Type_Binary
)
1155 value
<< _T('(') << type
<< _T(')');
1158 // write all the rest as comma-separated bytes
1159 value
.reserve(3*size
+ 10);
1160 const char * const p
= wx_static_cast(const char *, data
);
1161 for ( size_t n
= 0; n
< size
; n
++ )
1163 // TODO: line wrapping: although not required by regedit, this makes
1164 // the generated files easier to read and compare with the files
1165 // produced by regedit
1169 value
<< wxString::Format(_T("%02x"), (unsigned char)p
[n
]);
1176 wxString
FormatAsHex(const wxString
& value
, wxRegKey::ValueType type
)
1178 return FormatAsHex(value
.c_str(), value
.length() + 1, type
);
1181 wxString
wxRegKey::FormatValue(const wxString
& name
) const
1184 const ValueType type
= GetValueType(name
);
1190 if ( !QueryValue(name
, value
) )
1193 // quotes and backslashes must be quoted, linefeeds are not
1194 // allowed in string values
1195 rhs
.reserve(value
.length() + 2);
1198 // there can be no NULs here
1199 bool useHex
= false;
1200 for ( const wxChar
*p
= value
.c_str(); *p
&& !useHex
; p
++ )
1205 // we can only represent this string in hex
1211 // escape special symbol
1221 rhs
= FormatAsHex(value
, Type_String
);
1228 /* case Type_Dword_little_endian: == Type_Dword */
1231 if ( !QueryValue(name
, &value
) )
1234 rhs
.Printf(_T("dword:%08x"), value
);
1238 case Type_Expand_String
:
1239 case Type_Multi_String
:
1242 if ( !QueryRawValue(name
, value
) )
1245 rhs
= FormatAsHex(value
, type
);
1252 if ( !QueryValue(name
, buf
) )
1255 rhs
= FormatAsHex(buf
.GetData(), buf
.GetDataLen());
1259 // no idea how those appear in REGEDIT4 files
1261 case Type_Dword_big_endian
:
1263 case Type_Resource_list
:
1264 case Type_Full_resource_descriptor
:
1265 case Type_Resource_requirements_list
:
1267 wxLogWarning(_("Can't export value of unsupported type %d."), type
);
1273 bool wxRegKey::DoExportValue(wxOutputStream
& ostr
, const wxString
& name
) const
1275 // first examine the value type: if it's unsupported, simply skip it
1276 // instead of aborting the entire export process because we failed to
1277 // export a single value
1278 wxString value
= FormatValue(name
);
1279 if ( value
.empty() )
1281 wxLogWarning(_("Ignoring value \"%s\" of the key \"%s\"."),
1282 name
.c_str(), GetName().c_str());
1286 // we do have the text representation of the value, now write everything
1289 // special case: unnamed/default value is represented as just "@"
1292 if ( !WriteAsciiChar(ostr
, '@') )
1295 else // normal, named, value
1297 if ( !WriteAsciiChar(ostr
, '"') ||
1298 !WriteAsciiString(ostr
, name
) ||
1299 !WriteAsciiChar(ostr
, '"') )
1303 if ( !WriteAsciiChar(ostr
, '=') )
1306 return WriteAsciiString(ostr
, value
) && WriteAsciiEOL(ostr
);
1309 bool wxRegKey::DoExport(wxOutputStream
& ostr
) const
1311 // write out this key name
1312 if ( !WriteAsciiChar(ostr
, '[') )
1315 if ( !WriteAsciiString(ostr
, GetName(false /* no short prefix */)) )
1318 if ( !WriteAsciiChar(ostr
, ']') || !WriteAsciiEOL(ostr
) )
1321 // dump all our values
1324 wxRegKey
& self
= wx_const_cast(wxRegKey
&, *this);
1325 bool cont
= self
.GetFirstValue(name
, dummy
);
1328 if ( !DoExportValue(ostr
, name
) )
1331 cont
= GetNextValue(name
, dummy
);
1334 // always terminate values by blank line, even if there were no values
1335 if ( !WriteAsciiEOL(ostr
) )
1338 // recurse to subkeys
1339 cont
= self
.GetFirstKey(name
, dummy
);
1342 wxRegKey
subkey(*this, name
);
1343 if ( !subkey
.DoExport(ostr
) )
1346 cont
= GetNextKey(name
, dummy
);
1352 // ============================================================================
1353 // implementation of global private functions
1354 // ============================================================================
1356 bool KeyExists(WXHKEY hRootKey
, const wxChar
*szKey
)
1358 // don't close this key itself for the case of empty szKey!
1359 if ( wxIsEmpty(szKey
) )
1368 KEY_READ
, // we might not have enough rights for rw access
1370 ) == ERROR_SUCCESS
)
1372 ::RegCloseKey(hkeyDummy
);
1380 const wxChar
*GetFullName(const wxRegKey
*pKey
, const wxChar
*szValue
)
1382 static wxString s_str
;
1383 s_str
= pKey
->GetName();
1384 if ( !wxIsEmpty(szValue
) )
1385 s_str
<< wxT("\\") << szValue
;
1387 return s_str
.c_str();
1390 void RemoveTrailingSeparator(wxString
& str
)
1392 if ( !str
.IsEmpty() && str
.Last() == REG_SEPARATOR
)
1393 str
.Truncate(str
.Len() - 1);