]> git.saurik.com Git - wxWidgets.git/blob - src/msw/registry.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
added the recangle fix
[wxWidgets.git] / src / msw / registry.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/registry.cpp
3 // Purpose: implementation of registry classes and functions
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 03.04.98
7 // RCS-ID: $Id$
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows licence
10 // TODO: - parsing of registry key names
11 // - support of other (than REG_SZ/REG_DWORD) registry types
12 // - add high level functions (RegisterOleServer, ...)
13 ///////////////////////////////////////////////////////////////////////////////
14
15 // for compilers that support precompilation, includes "wx.h".
16 #include "wx/wxprec.h"
17
18 #ifdef __BORLANDC__
19 #pragma hdrstop
20 #endif
21
22 #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
51 typedef unsigned char *RegString;
52 typedef BYTE* RegBinary;
53
54 // ----------------------------------------------------------------------------
55 // constants
56 // ----------------------------------------------------------------------------
57
58 // the standard key names, short names and handles all bundled together for
59 // convenient access
60 static struct
61 {
62 HKEY hkey;
63 const wxChar *szName;
64 const wxChar *szShortName;
65 }
66 aStdKeys[] =
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
105 static inline void RemoveTrailingSeparator(wxString& str);
106
107 // returns true if given registry key exists
108 static bool KeyExists(WXHKEY hRootKey, const wxChar *szKey);
109
110 // combines value and key name (uses static buffer!)
111 static 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
122 const 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.
126 const 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
134 const 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
142 wxRegKey::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
168 wxRegKey::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
184 wxRegKey::wxRegKey()
185 {
186 m_hRootKey = (WXHKEY) aStdKeys[HKCR].hkey;
187
188 Init();
189 }
190
191 wxRegKey::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
199 wxRegKey::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
208 wxRegKey::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
226 wxRegKey::~wxRegKey()
227 {
228 Close();
229 }
230
231 // ----------------------------------------------------------------------------
232 // change the key name/hkey
233 // ----------------------------------------------------------------------------
234
235 // set the full key name
236 void 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
245 void 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
255 void 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
278 void 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
290 bool 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)
297 wxString 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
308 bool 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)
359 bool 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
394 bool 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
430 bool 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
447 bool 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
468 bool 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
519 bool 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
574 bool 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
591 bool 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 // ----------------------------------------------------------------------------
640 bool 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
697 bool wxRegKey::DeleteKey(const wxChar *szKey)
698 {
699 if ( !Open() )
700 return false;
701
702 wxRegKey key(*this, szKey);
703 return key.DeleteSelf();
704 }
705
706 bool 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
730 bool 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
746 bool 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
758 bool 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
770 bool 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
781 wxRegKey::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
798 bool 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
812 bool 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
836 bool 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
855 bool 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
891 bool 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
960 bool 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
975 wxString 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
988 bool 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
997 bool 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
1033 bool 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
1042 bool 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)
1078 bool 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)
1099 static inline bool WriteAsciiChar(wxOutputStream& ostr, char ch)
1100 {
1101 ostr.PutC(ch);
1102 return ostr.IsOk();
1103 }
1104
1105 static 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
1111 static inline bool WriteAsciiString(wxOutputStream& ostr, const char *p)
1112 {
1113 return ostr.Write(p, strlen(p)).IsOk();
1114 }
1115
1116 static 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
1130 bool 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
1150 bool 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
1160 static
1161 wxString
1162 FormatAsHex(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
1191 static inline
1192 wxString FormatAsHex(const wxString& value, wxRegKey::ValueType type)
1193 {
1194 return FormatAsHex(value.c_str(), value.length() + 1, type);
1195 }
1196
1197 wxString 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
1291 bool 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
1327 bool 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
1376 bool 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
1400 const 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
1410 void RemoveTrailingSeparator(wxString& str)
1411 {
1412 if ( !str.empty() && str.Last() == REG_SEPARATOR )
1413 str.Truncate(str.Len() - 1);
1414 }
wxWidgets (Impactor)