]> git.saurik.com Git - wxWidgets.git/blob - src/msw/registry.cpp
projects / wxWidgets.git / blob
? search:


a8e077e8c80205937d9018aff40e68b165821353
[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 #ifdef HKEY_CURRENT_CONFIG
79 { HKEY_CURRENT_CONFIG, wxT("HKEY_CURRENT_CONFIG"), wxT("HKCC") },
80 #endif
81 #ifdef HKEY_DYN_DATA
82 { HKEY_DYN_DATA, wxT("HKEY_DYN_DATA"), wxT("HKDD") }, // short name?
83 #endif
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.empty() && 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.empty() &&
218 (strKey.empty() || 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.empty() && 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.empty() )
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 {
368 if ( mode <= m_mode )
369 return true;
370
371 // we had been opened in read mode but now must be reopened in write
372 Close();
373 }
374
375 HKEY tmpKey;
376 m_dwLastError = ::RegOpenKeyEx
377 (
378 (HKEY) m_hRootKey,
379 m_strKey,
380 RESERVED,
381 mode == Read ? KEY_READ : KEY_ALL_ACCESS,
382 &tmpKey
383 );
384
385 if ( m_dwLastError != ERROR_SUCCESS )
386 {
387 wxLogSysError(m_dwLastError, _("Can't open registry key '%s'"),
388 GetName().c_str());
389 return false;
390 }
391
392 m_hKey = (WXHKEY) tmpKey;
393 m_mode = mode;
394
395 return true;
396 }
397
398 // creates key, failing if it exists and !bOkIfExists
399 bool wxRegKey::Create(bool bOkIfExists)
400 {
401 // check for existence only if asked (i.e. order is important!)
402 if ( !bOkIfExists && Exists() )
403 return false;
404
405 if ( IsOpened() )
406 return true;
407
408 HKEY tmpKey;
409 #ifdef __WXWINCE__
410 DWORD disposition;
411 m_dwLastError = RegCreateKeyEx((HKEY) m_hRootKey, m_strKey,
412 NULL, // reserved
413 NULL, // class string
414 0,
415 0,
416 NULL,
417 &tmpKey,
418 &disposition);
419 #else
420 m_dwLastError = RegCreateKey((HKEY) m_hRootKey, m_strKey, &tmpKey);
421 #endif
422 if ( m_dwLastError != ERROR_SUCCESS ) {
423 wxLogSysError(m_dwLastError, _("Can't create registry key '%s'"),
424 GetName().c_str());
425 return false;
426 }
427 else
428 {
429 m_hKey = (WXHKEY) tmpKey;
430 return true;
431 }
432 }
433
434 // close the key, it's not an error to call it when not opened
435 bool wxRegKey::Close()
436 {
437 if ( IsOpened() ) {
438 m_dwLastError = RegCloseKey((HKEY) m_hKey);
439 m_hKey = 0;
440
441 if ( m_dwLastError != ERROR_SUCCESS ) {
442 wxLogSysError(m_dwLastError, _("Can't close registry key '%s'"),
443 GetName().c_str());
444
445 return false;
446 }
447 }
448
449 return true;
450 }
451
452 bool wxRegKey::RenameValue(const wxChar *szValueOld, const wxChar *szValueNew)
453 {
454 bool ok = true;
455 if ( HasValue(szValueNew) ) {
456 wxLogError(_("Registry value '%s' already exists."), szValueNew);
457
458 ok = false;
459 }
460
461 if ( !ok ||
462 !CopyValue(szValueOld, *this, szValueNew) ||
463 !DeleteValue(szValueOld) ) {
464 wxLogError(_("Failed to rename registry value '%s' to '%s'."),
465 szValueOld, szValueNew);
466
467 return false;
468 }
469
470 return true;
471 }
472
473 bool wxRegKey::CopyValue(const wxChar *szValue,
474 wxRegKey& keyDst,
475 const wxChar *szValueNew)
476 {
477 if ( !szValueNew ) {
478 // by default, use the same name
479 szValueNew = szValue;
480 }
481
482 switch ( GetValueType(szValue) ) {
483 case Type_String:
484 {
485 wxString strVal;
486 return QueryValue(szValue, strVal) &&
487 keyDst.SetValue(szValueNew, strVal);
488 }
489
490 case Type_Dword:
491 /* case Type_Dword_little_endian: == Type_Dword */
492 {
493 long dwVal;
494 return QueryValue(szValue, &dwVal) &&
495 keyDst.SetValue(szValueNew, dwVal);
496 }
497
498 case Type_Binary:
499 {
500 wxMemoryBuffer buf;
501 return QueryValue(szValue,buf) &&
502 keyDst.SetValue(szValueNew,buf);
503 }
504
505 // these types are unsupported because I am not sure about how
506 // exactly they should be copied and because they shouldn't
507 // occur among the application keys (supposedly created with
508 // this class)
509 case Type_None:
510 case Type_Expand_String:
511 case Type_Dword_big_endian:
512 case Type_Link:
513 case Type_Multi_String:
514 case Type_Resource_list:
515 case Type_Full_resource_descriptor:
516 case Type_Resource_requirements_list:
517 default:
518 wxLogError(_("Can't copy values of unsupported type %d."),
519 GetValueType(szValue));
520 return false;
521 }
522 }
523
524 bool wxRegKey::Rename(const wxChar *szNewName)
525 {
526 wxCHECK_MSG( !m_strKey.empty(), false, _T("registry hives can't be renamed") );
527
528 if ( !Exists() ) {
529 wxLogError(_("Registry key '%s' does not exist, cannot rename it."),
530 GetFullName(this));
531
532 return false;
533 }
534
535 // do we stay in the same hive?
536 bool inSameHive = !wxStrchr(szNewName, REG_SEPARATOR);
537
538 // construct the full new name of the key
539 wxRegKey keyDst;
540
541 if ( inSameHive ) {
542 // rename the key to the new name under the same parent
543 wxString strKey = m_strKey.BeforeLast(REG_SEPARATOR);
544 if ( !strKey.empty() ) {
545 // don't add '\\' in the start if strFullNewName is empty
546 strKey += REG_SEPARATOR;
547 }
548
549 strKey += szNewName;
550
551 keyDst.SetName(GetStdKeyFromHkey(m_hRootKey), strKey);
552 }
553 else {
554 // this is the full name already
555 keyDst.SetName(szNewName);
556 }
557
558 bool ok = keyDst.Create(false /* fail if alredy exists */);
559 if ( !ok ) {
560 wxLogError(_("Registry key '%s' already exists."),
561 GetFullName(&keyDst));
562 }
563 else {
564 ok = Copy(keyDst) && DeleteSelf();
565 }
566
567 if ( !ok ) {
568 wxLogError(_("Failed to rename the registry key '%s' to '%s'."),
569 GetFullName(this), GetFullName(&keyDst));
570 }
571 else {
572 m_hRootKey = keyDst.m_hRootKey;
573 m_strKey = keyDst.m_strKey;
574 }
575
576 return ok;
577 }
578
579 bool wxRegKey::Copy(const wxChar *szNewName)
580 {
581 // create the new key first
582 wxRegKey keyDst(szNewName);
583 bool ok = keyDst.Create(false /* fail if alredy exists */);
584 if ( ok ) {
585 ok = Copy(keyDst);
586
587 // we created the dest key but copying to it failed - delete it
588 if ( !ok ) {
589 (void)keyDst.DeleteSelf();
590 }
591 }
592
593 return ok;
594 }
595
596 bool wxRegKey::Copy(wxRegKey& keyDst)
597 {
598 bool ok = true;
599
600 // copy all sub keys to the new location
601 wxString strKey;
602 long lIndex;
603 bool bCont = GetFirstKey(strKey, lIndex);
604 while ( ok && bCont ) {
605 wxRegKey key(*this, strKey);
606 wxString keyName;
607 keyName << GetFullName(&keyDst) << REG_SEPARATOR << strKey;
608 ok = key.Copy((const wxChar*) keyName);
609
610 if ( ok )
611 bCont = GetNextKey(strKey, lIndex);
612 else
613 wxLogError(_("Failed to copy the registry subkey '%s' to '%s'."),
614 GetFullName(&key), keyName.c_str());
615
616 }
617
618 // copy all values
619 wxString strVal;
620 bCont = GetFirstValue(strVal, lIndex);
621 while ( ok && bCont ) {
622 ok = CopyValue(strVal, keyDst);
623
624 if ( !ok ) {
625 wxLogSysError(m_dwLastError,
626 _("Failed to copy registry value '%s'"),
627 strVal.c_str());
628 }
629 else {
630 bCont = GetNextValue(strVal, lIndex);
631 }
632 }
633
634 if ( !ok ) {
635 wxLogError(_("Failed to copy the contents of registry key '%s' to '%s'."),
636 GetFullName(this), GetFullName(&keyDst));
637 }
638
639 return ok;
640 }
641
642 // ----------------------------------------------------------------------------
643 // delete keys/values
644 // ----------------------------------------------------------------------------
645 bool wxRegKey::DeleteSelf()
646 {
647 {
648 wxLogNull nolog;
649 if ( !Open() ) {
650 // it already doesn't exist - ok!
651 return true;
652 }
653 }
654
655 // prevent a buggy program from erasing one of the root registry keys or an
656 // immediate subkey (i.e. one which doesn't have '\\' inside) of any other
657 // key except HKCR (HKCR has some "deleteable" subkeys)
658 if ( m_strKey.empty() ||
659 ((m_hRootKey != (WXHKEY) aStdKeys[HKCR].hkey) &&
660 (m_strKey.Find(REG_SEPARATOR) == wxNOT_FOUND)) ) {
661 wxLogError(_("Registry key '%s' is needed for normal system operation,\ndeleting it will leave your system in unusable state:\noperation aborted."),
662 GetFullName(this));
663
664 return false;
665 }
666
667 // we can't delete keys while enumerating because it confuses GetNextKey, so
668 // we first save the key names and then delete them all
669 wxArrayString astrSubkeys;
670
671 wxString strKey;
672 long lIndex;
673 bool bCont = GetFirstKey(strKey, lIndex);
674 while ( bCont ) {
675 astrSubkeys.Add(strKey);
676
677 bCont = GetNextKey(strKey, lIndex);
678 }
679
680 size_t nKeyCount = astrSubkeys.Count();
681 for ( size_t nKey = 0; nKey < nKeyCount; nKey++ ) {
682 wxRegKey key(*this, astrSubkeys[nKey]);
683 if ( !key.DeleteSelf() )
684 return false;
685 }
686
687 // now delete this key itself
688 Close();
689
690 m_dwLastError = RegDeleteKey((HKEY) m_hRootKey, m_strKey);
691 // deleting a key which doesn't exist is not considered an error
692 if ( m_dwLastError != ERROR_SUCCESS &&
693 m_dwLastError != ERROR_FILE_NOT_FOUND ) {
694 wxLogSysError(m_dwLastError, _("Can't delete key '%s'"),
695 GetName().c_str());
696 return false;
697 }
698
699 return true;
700 }
701
702 bool wxRegKey::DeleteKey(const wxChar *szKey)
703 {
704 if ( !Open() )
705 return false;
706
707 wxRegKey key(*this, szKey);
708 return key.DeleteSelf();
709 }
710
711 bool wxRegKey::DeleteValue(const wxChar *szValue)
712 {
713 if ( !Open() )
714 return false;
715
716 m_dwLastError = RegDeleteValue((HKEY) m_hKey, WXSTRINGCAST szValue);
717
718 // deleting a value which doesn't exist is not considered an error
719 if ( (m_dwLastError != ERROR_SUCCESS) &&
720 (m_dwLastError != ERROR_FILE_NOT_FOUND) )
721 {
722 wxLogSysError(m_dwLastError, _("Can't delete value '%s' from key '%s'"),
723 szValue, GetName().c_str());
724 return false;
725 }
726
727 return true;
728 }
729
730 // ----------------------------------------------------------------------------
731 // access to values and subkeys
732 // ----------------------------------------------------------------------------
733
734 // return true if value exists
735 bool wxRegKey::HasValue(const wxChar *szValue) const
736 {
737 // this function should be silent, so suppress possible messages from Open()
738 wxLogNull nolog;
739
740 if ( !CONST_CAST Open(Read) )
741 return false;
742
743 LONG dwRet = ::RegQueryValueEx((HKEY) m_hKey,
744 WXSTRINGCAST szValue,
745 RESERVED,
746 NULL, NULL, NULL);
747 return dwRet == ERROR_SUCCESS;
748 }
749
750 // returns true if this key has any values
751 bool wxRegKey::HasValues() const
752 {
753 // suppress possible messages from GetFirstValue()
754 wxLogNull nolog;
755
756 // just call GetFirstValue with dummy parameters
757 wxString str;
758 long l;
759 return CONST_CAST GetFirstValue(str, l);
760 }
761
762 // returns true if this key has any subkeys
763 bool wxRegKey::HasSubkeys() const
764 {
765 // suppress possible messages from GetFirstKey()
766 wxLogNull nolog;
767
768 // just call GetFirstKey with dummy parameters
769 wxString str;
770 long l;
771 return CONST_CAST GetFirstKey(str, l);
772 }
773
774 // returns true if given subkey exists
775 bool wxRegKey::HasSubKey(const wxChar *szKey) const
776 {
777 // this function should be silent, so suppress possible messages from Open()
778 wxLogNull nolog;
779
780 if ( !CONST_CAST Open(Read) )
781 return false;
782
783 return KeyExists(m_hKey, szKey);
784 }
785
786 wxRegKey::ValueType wxRegKey::GetValueType(const wxChar *szValue) const
787 {
788 if ( ! CONST_CAST Open(Read) )
789 return Type_None;
790
791 DWORD dwType;
792 m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED,
793 &dwType, NULL, NULL);
794 if ( m_dwLastError != ERROR_SUCCESS ) {
795 wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"),
796 GetName().c_str());
797 return Type_None;
798 }
799
800 return (ValueType)dwType;
801 }
802
803 bool wxRegKey::SetValue(const wxChar *szValue, long lValue)
804 {
805 if ( CONST_CAST Open() ) {
806 m_dwLastError = RegSetValueEx((HKEY) m_hKey, szValue, (DWORD) RESERVED, REG_DWORD,
807 (RegString)&lValue, sizeof(lValue));
808 if ( m_dwLastError == ERROR_SUCCESS )
809 return true;
810 }
811
812 wxLogSysError(m_dwLastError, _("Can't set value of '%s'"),
813 GetFullName(this, szValue));
814 return false;
815 }
816
817 bool wxRegKey::QueryValue(const wxChar *szValue, long *plValue) const
818 {
819 if ( CONST_CAST Open(Read) ) {
820 DWORD dwType, dwSize = sizeof(DWORD);
821 RegString pBuf = (RegString)plValue;
822 m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED,
823 &dwType, pBuf, &dwSize);
824 if ( m_dwLastError != ERROR_SUCCESS ) {
825 wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"),
826 GetName().c_str());
827 return false;
828 }
829 else {
830 // check that we read the value of right type
831 wxASSERT_MSG( IsNumericValue(szValue),
832 wxT("Type mismatch in wxRegKey::QueryValue().") );
833
834 return true;
835 }
836 }
837 else
838 return false;
839 }
840
841 bool wxRegKey::SetValue(const wxChar *szValue,const wxMemoryBuffer& buffer)
842 {
843 #ifdef __TWIN32__
844 wxFAIL_MSG("RegSetValueEx not implemented by TWIN32");
845 return false;
846 #else
847 if ( CONST_CAST Open() ) {
848 m_dwLastError = RegSetValueEx((HKEY) m_hKey, szValue, (DWORD) RESERVED, REG_BINARY,
849 (RegBinary)buffer.GetData(),buffer.GetDataLen());
850 if ( m_dwLastError == ERROR_SUCCESS )
851 return true;
852 }
853
854 wxLogSysError(m_dwLastError, _("Can't set value of '%s'"),
855 GetFullName(this, szValue));
856 return false;
857 #endif
858 }
859
860 bool wxRegKey::QueryValue(const wxChar *szValue, wxMemoryBuffer& buffer) const
861 {
862 if ( CONST_CAST Open(Read) ) {
863 // first get the type and size of the data
864 DWORD dwType, dwSize;
865 m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED,
866 &dwType, NULL, &dwSize);
867
868 if ( m_dwLastError == ERROR_SUCCESS ) {
869 if ( dwSize ) {
870 const RegBinary pBuf = (RegBinary)buffer.GetWriteBuf(dwSize);
871 m_dwLastError = RegQueryValueEx((HKEY) m_hKey,
872 WXSTRINGCAST szValue,
873 RESERVED,
874 &dwType,
875 pBuf,
876 &dwSize);
877 buffer.UngetWriteBuf(dwSize);
878 } else {
879 buffer.SetDataLen(0);
880 }
881 }
882
883
884 if ( m_dwLastError != ERROR_SUCCESS ) {
885 wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"),
886 GetName().c_str());
887 return false;
888 }
889 return true;
890 }
891 return false;
892 }
893
894
895
896 bool wxRegKey::QueryValue(const wxChar *szValue,
897 wxString& strValue,
898 bool WXUNUSED_IN_WINCE(raw)) const
899 {
900 if ( CONST_CAST Open(Read) )
901 {
902
903 // first get the type and size of the data
904 DWORD dwType, dwSize;
905 m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED,
906 &dwType, NULL, &dwSize);
907 if ( m_dwLastError == ERROR_SUCCESS )
908 {
909 if ( !dwSize )
910 {
911 // must treat this case specially as GetWriteBuf() doesn't like
912 // being called with 0 size
913 strValue.Empty();
914 }
915 else
916 {
917 m_dwLastError = RegQueryValueEx((HKEY) m_hKey,
918 WXSTRINGCAST szValue,
919 RESERVED,
920 &dwType,
921 (RegString)(wxChar*)wxStringBuffer(strValue, dwSize),
922 &dwSize);
923
924 // expand the var expansions in the string unless disabled
925 #ifndef __WXWINCE__
926 if ( (dwType == REG_EXPAND_SZ) && !raw )
927 {
928 DWORD dwExpSize = ::ExpandEnvironmentStrings(strValue, NULL, 0);
929 bool ok = dwExpSize != 0;
930 if ( ok )
931 {
932 wxString strExpValue;
933 ok = ::ExpandEnvironmentStrings(strValue,
934 wxStringBuffer(strExpValue, dwExpSize),
935 dwExpSize
936 ) != 0;
937 strValue = strExpValue;
938 }
939
940 if ( !ok )
941 {
942 wxLogLastError(_T("ExpandEnvironmentStrings"));
943 }
944 }
945 #endif
946 // __WXWINCE__
947 }
948
949 if ( m_dwLastError == ERROR_SUCCESS )
950 {
951 // check that it was the right type
952 wxASSERT_MSG( !IsNumericValue(szValue),
953 wxT("Type mismatch in wxRegKey::QueryValue().") );
954
955 return true;
956 }
957 }
958 }
959
960 wxLogSysError(m_dwLastError, _("Can't read value of '%s'"),
961 GetFullName(this, szValue));
962 return false;
963 }
964
965 bool wxRegKey::SetValue(const wxChar *szValue, const wxString& strValue)
966 {
967 if ( CONST_CAST Open() ) {
968 m_dwLastError = RegSetValueEx((HKEY) m_hKey, szValue, (DWORD) RESERVED, REG_SZ,
969 (RegString)strValue.c_str(),
970 (strValue.Len() + 1)*sizeof(wxChar));
971 if ( m_dwLastError == ERROR_SUCCESS )
972 return true;
973 }
974
975 wxLogSysError(m_dwLastError, _("Can't set value of '%s'"),
976 GetFullName(this, szValue));
977 return false;
978 }
979
980 wxString wxRegKey::QueryDefaultValue() const
981 {
982 wxString str;
983 QueryValue(NULL, str);
984 return str;
985 }
986
987 // ----------------------------------------------------------------------------
988 // enumeration
989 // NB: all these functions require an index variable which allows to have
990 // several concurrently running indexations on the same key
991 // ----------------------------------------------------------------------------
992
993 bool wxRegKey::GetFirstValue(wxString& strValueName, long& lIndex)
994 {
995 if ( !Open(Read) )
996 return false;
997
998 lIndex = 0;
999 return GetNextValue(strValueName, lIndex);
1000 }
1001
1002 bool wxRegKey::GetNextValue(wxString& strValueName, long& lIndex) const
1003 {
1004 wxASSERT( IsOpened() );
1005
1006 // are we already at the end of enumeration?
1007 if ( lIndex == -1 )
1008 return false;
1009
1010 wxChar szValueName[1024]; // @@ use RegQueryInfoKey...
1011 DWORD dwValueLen = WXSIZEOF(szValueName);
1012
1013 m_dwLastError = RegEnumValue((HKEY) m_hKey, lIndex++,
1014 szValueName, &dwValueLen,
1015 RESERVED,
1016 NULL, // [out] type
1017 NULL, // [out] buffer for value
1018 NULL); // [i/o] it's length
1019
1020 if ( m_dwLastError != ERROR_SUCCESS ) {
1021 if ( m_dwLastError == ERROR_NO_MORE_ITEMS ) {
1022 m_dwLastError = ERROR_SUCCESS;
1023 lIndex = -1;
1024 }
1025 else {
1026 wxLogSysError(m_dwLastError, _("Can't enumerate values of key '%s'"),
1027 GetName().c_str());
1028 }
1029
1030 return false;
1031 }
1032
1033 strValueName = szValueName;
1034
1035 return true;
1036 }
1037
1038 bool wxRegKey::GetFirstKey(wxString& strKeyName, long& lIndex)
1039 {
1040 if ( !Open(Read) )
1041 return false;
1042
1043 lIndex = 0;
1044 return GetNextKey(strKeyName, lIndex);
1045 }
1046
1047 bool wxRegKey::GetNextKey(wxString& strKeyName, long& lIndex) const
1048 {
1049 wxASSERT( IsOpened() );
1050
1051 // are we already at the end of enumeration?
1052 if ( lIndex == -1 )
1053 return false;
1054
1055 wxChar szKeyName[_MAX_PATH + 1];
1056
1057 #ifdef __WXWINCE__
1058 DWORD sizeName = WXSIZEOF(szKeyName);
1059 m_dwLastError = RegEnumKeyEx((HKEY) m_hKey, lIndex++, szKeyName, & sizeName,
1060 0, NULL, NULL, NULL);
1061 #else
1062 m_dwLastError = RegEnumKey((HKEY) m_hKey, lIndex++, szKeyName, WXSIZEOF(szKeyName));
1063 #endif
1064
1065 if ( m_dwLastError != ERROR_SUCCESS ) {
1066 if ( m_dwLastError == ERROR_NO_MORE_ITEMS ) {
1067 m_dwLastError = ERROR_SUCCESS;
1068 lIndex = -1;
1069 }
1070 else {
1071 wxLogSysError(m_dwLastError, _("Can't enumerate subkeys of key '%s'"),
1072 GetName().c_str());
1073 }
1074
1075 return false;
1076 }
1077
1078 strKeyName = szKeyName;
1079 return true;
1080 }
1081
1082 // returns true if the value contains a number (else it's some string)
1083 bool wxRegKey::IsNumericValue(const wxChar *szValue) const
1084 {
1085 ValueType type = GetValueType(szValue);
1086 switch ( type ) {
1087 case Type_Dword:
1088 /* case Type_Dword_little_endian: == Type_Dword */
1089 case Type_Dword_big_endian:
1090 return true;
1091
1092 default:
1093 return false;
1094 }
1095 }
1096
1097 // ----------------------------------------------------------------------------
1098 // exporting registry keys to file
1099 // ----------------------------------------------------------------------------
1100
1101 #if wxUSE_STREAMS
1102
1103 // helper functions for writing ASCII strings (even in Unicode build)
1104 static inline bool WriteAsciiChar(wxOutputStream& ostr, char ch)
1105 {
1106 ostr.PutC(ch);
1107 return ostr.IsOk();
1108 }
1109
1110 static inline bool WriteAsciiEOL(wxOutputStream& ostr)
1111 {
1112 // as we open the file in text mode, it is enough to write LF without CR
1113 return WriteAsciiChar(ostr, '\n');
1114 }
1115
1116 static inline bool WriteAsciiString(wxOutputStream& ostr, const char *p)
1117 {
1118 return ostr.Write(p, strlen(p)).IsOk();
1119 }
1120
1121 static inline bool WriteAsciiString(wxOutputStream& ostr, const wxString& s)
1122 {
1123 #if wxUSE_UNICODE
1124 wxCharBuffer name(s.mb_str());
1125 ostr.Write(name, strlen(name));
1126 #else
1127 ostr.Write(s, s.length());
1128 #endif
1129
1130 return ostr.IsOk();
1131 }
1132
1133 #endif // wxUSE_STREAMS
1134
1135 bool wxRegKey::Export(const wxString& filename) const
1136 {
1137 #if wxUSE_FFILE && wxUSE_STREAMS
1138 if ( wxFile::Exists(filename) )
1139 {
1140 wxLogError(_("Exporting registry key: file \"%s\" already exists and won't be overwritten."),
1141 filename.c_str());
1142 return false;
1143 }
1144
1145 wxFFileOutputStream ostr(filename, _T("w"));
1146
1147 return ostr.Ok() && Export(ostr);
1148 #else
1149 wxUnusedVar(filename);
1150 return false;
1151 #endif
1152 }
1153
1154 #if wxUSE_STREAMS
1155 bool wxRegKey::Export(wxOutputStream& ostr) const
1156 {
1157 // write out the header
1158 if ( !WriteAsciiString(ostr, "REGEDIT4\n\n") )
1159 return false;
1160
1161 return DoExport(ostr);
1162 }
1163 #endif // wxUSE_STREAMS
1164
1165 static
1166 wxString
1167 FormatAsHex(const void *data,
1168 size_t size,
1169 wxRegKey::ValueType type = wxRegKey::Type_Binary)
1170 {
1171 wxString value(_T("hex"));
1172
1173 // binary values use just "hex:" prefix while the other ones must indicate
1174 // the real type
1175 if ( type != wxRegKey::Type_Binary )
1176 value << _T('(') << type << _T(')');
1177 value << _T(':');
1178
1179 // write all the rest as comma-separated bytes
1180 value.reserve(3*size + 10);
1181 const char * const p = wx_static_cast(const char *, data);
1182 for ( size_t n = 0; n < size; n++ )
1183 {
1184 // TODO: line wrapping: although not required by regedit, this makes
1185 // the generated files easier to read and compare with the files
1186 // produced by regedit
1187 if ( n )
1188 value << _T(',');
1189
1190 value << wxString::Format(_T("%02x"), (unsigned char)p[n]);
1191 }
1192
1193 return value;
1194 }
1195
1196 static inline
1197 wxString FormatAsHex(const wxString& value, wxRegKey::ValueType type)
1198 {
1199 return FormatAsHex(value.c_str(), value.length() + 1, type);
1200 }
1201
1202 wxString wxRegKey::FormatValue(const wxString& name) const
1203 {
1204 wxString rhs;
1205 const ValueType type = GetValueType(name);
1206 switch ( type )
1207 {
1208 case Type_String:
1209 {
1210 wxString value;
1211 if ( !QueryValue(name, value) )
1212 break;
1213
1214 // quotes and backslashes must be quoted, linefeeds are not
1215 // allowed in string values
1216 rhs.reserve(value.length() + 2);
1217 rhs = _T('"');
1218
1219 // there can be no NULs here
1220 bool useHex = false;
1221 for ( const wxChar *p = value.c_str(); *p && !useHex; p++ )
1222 {
1223 switch ( *p )
1224 {
1225 case _T('\n'):
1226 // we can only represent this string in hex
1227 useHex = true;
1228 break;
1229
1230 case _T('"'):
1231 case _T('\\'):
1232 // escape special symbol
1233 rhs += _T('\\');
1234 // fall through
1235
1236 default:
1237 rhs += *p;
1238 }
1239 }
1240
1241 if ( useHex )
1242 rhs = FormatAsHex(value, Type_String);
1243 else
1244 rhs += _T('"');
1245 }
1246 break;
1247
1248 case Type_Dword:
1249 /* case Type_Dword_little_endian: == Type_Dword */
1250 {
1251 long value;
1252 if ( !QueryValue(name, &value) )
1253 break;
1254
1255 rhs.Printf(_T("dword:%08x"), (unsigned int)value);
1256 }
1257 break;
1258
1259 case Type_Expand_String:
1260 case Type_Multi_String:
1261 {
1262 wxString value;
1263 if ( !QueryRawValue(name, value) )
1264 break;
1265
1266 rhs = FormatAsHex(value, type);
1267 }
1268 break;
1269
1270 case Type_Binary:
1271 {
1272 wxMemoryBuffer buf;
1273 if ( !QueryValue(name, buf) )
1274 break;
1275
1276 rhs = FormatAsHex(buf.GetData(), buf.GetDataLen());
1277 }
1278 break;
1279
1280 // no idea how those appear in REGEDIT4 files
1281 case Type_None:
1282 case Type_Dword_big_endian:
1283 case Type_Link:
1284 case Type_Resource_list:
1285 case Type_Full_resource_descriptor:
1286 case Type_Resource_requirements_list:
1287 default:
1288 wxLogWarning(_("Can't export value of unsupported type %d."), type);
1289 }
1290
1291 return rhs;
1292 }
1293
1294 #if wxUSE_STREAMS
1295
1296 bool wxRegKey::DoExportValue(wxOutputStream& ostr, const wxString& name) const
1297 {
1298 // first examine the value type: if it's unsupported, simply skip it
1299 // instead of aborting the entire export process because we failed to
1300 // export a single value
1301 wxString value = FormatValue(name);
1302 if ( value.empty() )
1303 {
1304 wxLogWarning(_("Ignoring value \"%s\" of the key \"%s\"."),
1305 name.c_str(), GetName().c_str());
1306 return true;
1307 }
1308
1309 // we do have the text representation of the value, now write everything
1310 // out
1311
1312 // special case: unnamed/default value is represented as just "@"
1313 if ( name.empty() )
1314 {
1315 if ( !WriteAsciiChar(ostr, '@') )
1316 return false;
1317 }
1318 else // normal, named, value
1319 {
1320 if ( !WriteAsciiChar(ostr, '"') ||
1321 !WriteAsciiString(ostr, name) ||
1322 !WriteAsciiChar(ostr, '"') )
1323 return false;
1324 }
1325
1326 if ( !WriteAsciiChar(ostr, '=') )
1327 return false;
1328
1329 return WriteAsciiString(ostr, value) && WriteAsciiEOL(ostr);
1330 }
1331
1332 bool wxRegKey::DoExport(wxOutputStream& ostr) const
1333 {
1334 // write out this key name
1335 if ( !WriteAsciiChar(ostr, '[') )
1336 return false;
1337
1338 if ( !WriteAsciiString(ostr, GetName(false /* no short prefix */)) )
1339 return false;
1340
1341 if ( !WriteAsciiChar(ostr, ']') || !WriteAsciiEOL(ostr) )
1342 return false;
1343
1344 // dump all our values
1345 long dummy;
1346 wxString name;
1347 wxRegKey& self = wx_const_cast(wxRegKey&, *this);
1348 bool cont = self.GetFirstValue(name, dummy);
1349 while ( cont )
1350 {
1351 if ( !DoExportValue(ostr, name) )
1352 return false;
1353
1354 cont = GetNextValue(name, dummy);
1355 }
1356
1357 // always terminate values by blank line, even if there were no values
1358 if ( !WriteAsciiEOL(ostr) )
1359 return false;
1360
1361 // recurse to subkeys
1362 cont = self.GetFirstKey(name, dummy);
1363 while ( cont )
1364 {
1365 wxRegKey subkey(*this, name);
1366 if ( !subkey.DoExport(ostr) )
1367 return false;
1368
1369 cont = GetNextKey(name, dummy);
1370 }
1371
1372 return true;
1373 }
1374
1375 #endif // wxUSE_STREAMS
1376
1377 // ============================================================================
1378 // implementation of global private functions
1379 // ============================================================================
1380
1381 bool KeyExists(WXHKEY hRootKey, const wxChar *szKey)
1382 {
1383 // don't close this key itself for the case of empty szKey!
1384 if ( wxIsEmpty(szKey) )
1385 return true;
1386
1387 HKEY hkeyDummy;
1388 if ( ::RegOpenKeyEx
1389 (
1390 (HKEY)hRootKey,
1391 szKey,
1392 RESERVED,
1393 KEY_READ, // we might not have enough rights for rw access
1394 &hkeyDummy
1395 ) == ERROR_SUCCESS )
1396 {
1397 ::RegCloseKey(hkeyDummy);
1398
1399 return true;
1400 }
1401
1402 return false;
1403 }
1404
1405 const wxChar *GetFullName(const wxRegKey *pKey, const wxChar *szValue)
1406 {
1407 static wxString s_str;
1408 s_str = pKey->GetName();
1409 if ( !wxIsEmpty(szValue) )
1410 s_str << wxT("\\") << szValue;
1411
1412 return s_str.c_str();
1413 }
1414
1415 void RemoveTrailingSeparator(wxString& str)
1416 {
1417 if ( !str.empty() && str.Last() == REG_SEPARATOR )
1418 str.Truncate(str.Len() - 1);
1419 }
1420
wxWidgets (Impactor)