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