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