projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Allow MSW Base be usable in other ports than wxMSW (ie. wxTVision in windows console...
[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 wxLogSysError(m_dwLastError, _("Can't delete value '%s' from key '%s'"),
722 szValue, GetName().c_str());
723 return false;
724 }
725
726 return true;
727 }
728
729 // ----------------------------------------------------------------------------
730 // access to values and subkeys
731 // ----------------------------------------------------------------------------
732
733 // return true if value exists
734 bool wxRegKey::HasValue(const wxChar *szValue) const
735 {
736 // this function should be silent, so suppress possible messages from Open()
737 wxLogNull nolog;
738
739 if ( !CONST_CAST Open(Read) )
740 return false;
741
742 LONG dwRet = ::RegQueryValueEx((HKEY) m_hKey,
743 WXSTRINGCAST szValue,
744 RESERVED,
745 NULL, NULL, NULL);
746 return dwRet == ERROR_SUCCESS;
747 }
748
749 // returns true if this key has any values
750 bool wxRegKey::HasValues() const
751 {
752 // suppress possible messages from GetFirstValue()
753 wxLogNull nolog;
754
755 // just call GetFirstValue with dummy parameters
756 wxString str;
757 long l;
758 return CONST_CAST GetFirstValue(str, l);
759 }
760
761 // returns true if this key has any subkeys
762 bool wxRegKey::HasSubkeys() const
763 {
764 // suppress possible messages from GetFirstKey()
765 wxLogNull nolog;
766
767 // just call GetFirstKey with dummy parameters
768 wxString str;
769 long l;
770 return CONST_CAST GetFirstKey(str, l);
771 }
772
773 // returns true if given subkey exists
774 bool wxRegKey::HasSubKey(const wxChar *szKey) const
775 {
776 // this function should be silent, so suppress possible messages from Open()
777 wxLogNull nolog;
778
779 if ( !CONST_CAST Open(Read) )
780 return false;
781
782 return KeyExists(m_hKey, szKey);
783 }
784
785 wxRegKey::ValueType wxRegKey::GetValueType(const wxChar *szValue) const
786 {
787 if ( ! CONST_CAST Open(Read) )
788 return Type_None;
789
790 DWORD dwType;
791 m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED,
792 &dwType, NULL, NULL);
793 if ( m_dwLastError != ERROR_SUCCESS ) {
794 wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"),
795 GetName().c_str());
796 return Type_None;
797 }
798
799 return (ValueType)dwType;
800 }
801
802 bool wxRegKey::SetValue(const wxChar *szValue, long lValue)
803 {
804 if ( CONST_CAST Open() ) {
805 m_dwLastError = RegSetValueEx((HKEY) m_hKey, szValue, (DWORD) RESERVED, REG_DWORD,
806 (RegString)&lValue, sizeof(lValue));
807 if ( m_dwLastError == ERROR_SUCCESS )
808 return true;
809 }
810
811 wxLogSysError(m_dwLastError, _("Can't set value of '%s'"),
812 GetFullName(this, szValue));
813 return false;
814 }
815
816 bool wxRegKey::QueryValue(const wxChar *szValue, long *plValue) const
817 {
818 if ( CONST_CAST Open(Read) ) {
819 DWORD dwType, dwSize = sizeof(DWORD);
820 RegString pBuf = (RegString)plValue;
821 m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED,
822 &dwType, pBuf, &dwSize);
823 if ( m_dwLastError != ERROR_SUCCESS ) {
824 wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"),
825 GetName().c_str());
826 return false;
827 }
828 else {
829 // check that we read the value of right type
830 wxASSERT_MSG( IsNumericValue(szValue),
831 wxT("Type mismatch in wxRegKey::QueryValue().") );
832
833 return true;
834 }
835 }
836 else
837 return false;
838 }
839
840 bool wxRegKey::SetValue(const wxChar *szValue,const wxMemoryBuffer& buffer)
841 {
842 #ifdef __TWIN32__
843 wxFAIL_MSG("RegSetValueEx not implemented by TWIN32");
844 return false;
845 #else
846 if ( CONST_CAST Open() ) {
847 m_dwLastError = RegSetValueEx((HKEY) m_hKey, szValue, (DWORD) RESERVED, REG_BINARY,
848 (RegBinary)buffer.GetData(),buffer.GetDataLen());
849 if ( m_dwLastError == ERROR_SUCCESS )
850 return true;
851 }
852
853 wxLogSysError(m_dwLastError, _("Can't set value of '%s'"),
854 GetFullName(this, szValue));
855 return false;
856 #endif
857 }
858
859 bool wxRegKey::QueryValue(const wxChar *szValue, wxMemoryBuffer& buffer) const
860 {
861 if ( CONST_CAST Open() ) {
862 // first get the type and size of the data
863 DWORD dwType, dwSize;
864 m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED,
865 &dwType, NULL, &dwSize);
866
867 if ( m_dwLastError == ERROR_SUCCESS ) {
868 if ( dwSize ) {
869 const RegBinary pBuf = (RegBinary)buffer.GetWriteBuf(dwSize);
870 m_dwLastError = RegQueryValueEx((HKEY) m_hKey,
871 WXSTRINGCAST szValue,
872 RESERVED,
873 &dwType,
874 pBuf,
875 &dwSize);
876 buffer.UngetWriteBuf(dwSize);
877 } else {
878 buffer.SetDataLen(0);
879 }
880 }
881
882
883 if ( m_dwLastError != ERROR_SUCCESS ) {
884 wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"),
885 GetName().c_str());
886 return false;
887 }
888 return true;
889 }
890 return false;
891 }
892
893
894
895 bool wxRegKey::QueryValue(const wxChar *szValue,
896 wxString& strValue,
897 bool raw) const
898 {
899 if ( CONST_CAST Open(Read) ) {
900
901 // first get the type and size of the data
902 DWORD dwType, dwSize;
903 m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED,
904 &dwType, NULL, &dwSize);
905 if ( m_dwLastError == ERROR_SUCCESS ) {
906 if ( !dwSize ) {
907 // must treat this case specially as GetWriteBuf() doesn't like
908 // being called with 0 size
909 strValue.Empty();
910 }
911 else {
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
929 (
930 strValue,
931 wxStringBuffer(strExpValue, dwExpSize),
932 dwExpSize
933 ) != 0;
934 strValue = strExpValue;
935 }
936
937 if ( !ok )
938 {
939 wxLogLastError(_T("ExpandEnvironmentStrings"));
940 }
941 }
942 #else
943 wxUnusedVar(raw);
944 #endif
945 // __WXWINCE__
946 }
947
948 if ( m_dwLastError == ERROR_SUCCESS ) {
949 // check that it was the right type
950 wxASSERT_MSG( !IsNumericValue(szValue),
951 wxT("Type mismatch in wxRegKey::QueryValue().") );
952
953 return true;
954 }
955 }
956 }
957
958 wxLogSysError(m_dwLastError, _("Can't read value of '%s'"),
959 GetFullName(this, szValue));
960 return false;
961 }
962
963 bool wxRegKey::SetValue(const wxChar *szValue, const wxString& strValue)
964 {
965 if ( CONST_CAST Open() ) {
966 m_dwLastError = RegSetValueEx((HKEY) m_hKey, szValue, (DWORD) RESERVED, REG_SZ,
967 (RegString)strValue.c_str(),
968 (strValue.Len() + 1)*sizeof(wxChar));
969 if ( m_dwLastError == ERROR_SUCCESS )
970 return true;
971 }
972
973 wxLogSysError(m_dwLastError, _("Can't set value of '%s'"),
974 GetFullName(this, szValue));
975 return false;
976 }
977
978 wxString wxRegKey::QueryDefaultValue() const
979 {
980 wxString str;
981 QueryValue(NULL, str);
982 return str;
983 }
984
985 // ----------------------------------------------------------------------------
986 // enumeration
987 // NB: all these functions require an index variable which allows to have
988 // several concurrently running indexations on the same key
989 // ----------------------------------------------------------------------------
990
991 bool wxRegKey::GetFirstValue(wxString& strValueName, long& lIndex)
992 {
993 if ( !Open(Read) )
994 return false;
995
996 lIndex = 0;
997 return GetNextValue(strValueName, lIndex);
998 }
999
1000 bool wxRegKey::GetNextValue(wxString& strValueName, long& lIndex) const
1001 {
1002 wxASSERT( IsOpened() );
1003
1004 // are we already at the end of enumeration?
1005 if ( lIndex == -1 )
1006 return false;
1007
1008 wxChar szValueName[1024]; // @@ use RegQueryInfoKey...
1009 DWORD dwValueLen = WXSIZEOF(szValueName);
1010
1011 m_dwLastError = RegEnumValue((HKEY) m_hKey, lIndex++,
1012 szValueName, &dwValueLen,
1013 RESERVED,
1014 NULL, // [out] type
1015 NULL, // [out] buffer for value
1016 NULL); // [i/o] it's length
1017
1018 if ( m_dwLastError != ERROR_SUCCESS ) {
1019 if ( m_dwLastError == ERROR_NO_MORE_ITEMS ) {
1020 m_dwLastError = ERROR_SUCCESS;
1021 lIndex = -1;
1022 }
1023 else {
1024 wxLogSysError(m_dwLastError, _("Can't enumerate values of key '%s'"),
1025 GetName().c_str());
1026 }
1027
1028 return false;
1029 }
1030
1031 strValueName = szValueName;
1032
1033 return true;
1034 }
1035
1036 bool wxRegKey::GetFirstKey(wxString& strKeyName, long& lIndex)
1037 {
1038 if ( !Open(Read) )
1039 return false;
1040
1041 lIndex = 0;
1042 return GetNextKey(strKeyName, lIndex);
1043 }
1044
1045 bool wxRegKey::GetNextKey(wxString& strKeyName, long& lIndex) const
1046 {
1047 wxASSERT( IsOpened() );
1048
1049 // are we already at the end of enumeration?
1050 if ( lIndex == -1 )
1051 return false;
1052
1053 wxChar szKeyName[_MAX_PATH + 1];
1054
1055 #ifdef __WXWINCE__
1056 DWORD sizeName = WXSIZEOF(szKeyName);
1057 m_dwLastError = RegEnumKeyEx((HKEY) m_hKey, lIndex++, szKeyName, & sizeName,
1058 0, NULL, NULL, NULL);
1059 #else
1060 m_dwLastError = RegEnumKey((HKEY) m_hKey, lIndex++, szKeyName, WXSIZEOF(szKeyName));
1061 #endif
1062
1063 if ( m_dwLastError != ERROR_SUCCESS ) {
1064 if ( m_dwLastError == ERROR_NO_MORE_ITEMS ) {
1065 m_dwLastError = ERROR_SUCCESS;
1066 lIndex = -1;
1067 }
1068 else {
1069 wxLogSysError(m_dwLastError, _("Can't enumerate subkeys of key '%s'"),
1070 GetName().c_str());
1071 }
1072
1073 return false;
1074 }
1075
1076 strKeyName = szKeyName;
1077 return true;
1078 }
1079
1080 // returns true if the value contains a number (else it's some string)
1081 bool wxRegKey::IsNumericValue(const wxChar *szValue) const
1082 {
1083 ValueType type = GetValueType(szValue);
1084 switch ( type ) {
1085 case Type_Dword:
1086 /* case Type_Dword_little_endian: == Type_Dword */
1087 case Type_Dword_big_endian:
1088 return true;
1089
1090 default:
1091 return false;
1092 }
1093 }
1094
1095 // ----------------------------------------------------------------------------
1096 // exporting registry keys to file
1097 // ----------------------------------------------------------------------------
1098
1099 #if wxUSE_STREAMS
1100
1101 // helper functions for writing ASCII strings (even in Unicode build)
1102 static inline bool WriteAsciiChar(wxOutputStream& ostr, char ch)
1103 {
1104 ostr.PutC(ch);
1105 return ostr.IsOk();
1106 }
1107
1108 static inline bool WriteAsciiEOL(wxOutputStream& ostr)
1109 {
1110 // as we open the file in text mode, it is enough to write LF without CR
1111 return WriteAsciiChar(ostr, '\n');
1112 }
1113
1114 static inline bool WriteAsciiString(wxOutputStream& ostr, const char *p)
1115 {
1116 return ostr.Write(p, strlen(p)).IsOk();
1117 }
1118
1119 static inline bool WriteAsciiString(wxOutputStream& ostr, const wxString& s)
1120 {
1121 #if wxUSE_UNICODE
1122 wxCharBuffer name(s.mb_str());
1123 ostr.Write(name, strlen(name));
1124 #else
1125 ostr.Write(s, s.length());
1126 #endif
1127
1128 return ostr.IsOk();
1129 }
1130
1131 #endif // wxUSE_STREAMS
1132
1133 bool wxRegKey::Export(const wxString& filename) const
1134 {
1135 #if wxUSE_FFILE && wxUSE_STREAMS
1136 if ( wxFile::Exists(filename) )
1137 {
1138 wxLogError(_("Exporting registry key: file \"%s\" already exists and won't be overwritten."),
1139 filename.c_str());
1140 return false;
1141 }
1142
1143 wxFFileOutputStream ostr(filename, _T("w"));
1144
1145 return ostr.Ok() && Export(ostr);
1146 #else
1147 wxUnusedVar(filename);
1148 return false;
1149 #endif
1150 }
1151
1152 #if wxUSE_STREAMS
1153 bool wxRegKey::Export(wxOutputStream& ostr) const
1154 {
1155 // write out the header
1156 if ( !WriteAsciiString(ostr, "REGEDIT4\n\n") )
1157 return false;
1158
1159 return DoExport(ostr);
1160 }
1161 #endif // wxUSE_STREAMS
1162
1163 static
1164 wxString
1165 FormatAsHex(const void *data,
1166 size_t size,
1167 wxRegKey::ValueType type = wxRegKey::Type_Binary)
1168 {
1169 wxString value(_T("hex"));
1170
1171 // binary values use just "hex:" prefix while the other ones must indicate
1172 // the real type
1173 if ( type != wxRegKey::Type_Binary )
1174 value << _T('(') << type << _T(')');
1175 value << _T(':');
1176
1177 // write all the rest as comma-separated bytes
1178 value.reserve(3*size + 10);
1179 const char * const p = wx_static_cast(const char *, data);
1180 for ( size_t n = 0; n < size; n++ )
1181 {
1182 // TODO: line wrapping: although not required by regedit, this makes
1183 // the generated files easier to read and compare with the files
1184 // produced by regedit
1185 if ( n )
1186 value << _T(',');
1187
1188 value << wxString::Format(_T("%02x"), (unsigned char)p[n]);
1189 }
1190
1191 return value;
1192 }
1193
1194 static inline
1195 wxString FormatAsHex(const wxString& value, wxRegKey::ValueType type)
1196 {
1197 return FormatAsHex(value.c_str(), value.length() + 1, type);
1198 }
1199
1200 wxString wxRegKey::FormatValue(const wxString& name) const
1201 {
1202 wxString rhs;
1203 const ValueType type = GetValueType(name);
1204 switch ( type )
1205 {
1206 case Type_String:
1207 {
1208 wxString value;
1209 if ( !QueryValue(name, value) )
1210 break;
1211
1212 // quotes and backslashes must be quoted, linefeeds are not
1213 // allowed in string values
1214 rhs.reserve(value.length() + 2);
1215 rhs = _T('"');
1216
1217 // there can be no NULs here
1218 bool useHex = false;
1219 for ( const wxChar *p = value.c_str(); *p && !useHex; p++ )
1220 {
1221 switch ( *p )
1222 {
1223 case _T('\n'):
1224 // we can only represent this string in hex
1225 useHex = true;
1226 break;
1227
1228 case _T('"'):
1229 case _T('\\'):
1230 // escape special symbol
1231 rhs += _T('\\');
1232 // fall through
1233
1234 default:
1235 rhs += *p;
1236 }
1237 }
1238
1239 if ( useHex )
1240 rhs = FormatAsHex(value, Type_String);
1241 else
1242 rhs += _T('"');
1243 }
1244 break;
1245
1246 case Type_Dword:
1247 /* case Type_Dword_little_endian: == Type_Dword */
1248 {
1249 long value;
1250 if ( !QueryValue(name, &value) )
1251 break;
1252
1253 rhs.Printf(_T("dword:%08x"), (unsigned int)value);
1254 }
1255 break;
1256
1257 case Type_Expand_String:
1258 case Type_Multi_String:
1259 {
1260 wxString value;
1261 if ( !QueryRawValue(name, value) )
1262 break;
1263
1264 rhs = FormatAsHex(value, type);
1265 }
1266 break;
1267
1268 case Type_Binary:
1269 {
1270 wxMemoryBuffer buf;
1271 if ( !QueryValue(name, buf) )
1272 break;
1273
1274 rhs = FormatAsHex(buf.GetData(), buf.GetDataLen());
1275 }
1276 break;
1277
1278 // no idea how those appear in REGEDIT4 files
1279 case Type_None:
1280 case Type_Dword_big_endian:
1281 case Type_Link:
1282 case Type_Resource_list:
1283 case Type_Full_resource_descriptor:
1284 case Type_Resource_requirements_list:
1285 default:
1286 wxLogWarning(_("Can't export value of unsupported type %d."), type);
1287 }
1288
1289 return rhs;
1290 }
1291
1292 #if wxUSE_STREAMS
1293
1294 bool wxRegKey::DoExportValue(wxOutputStream& ostr, const wxString& name) const
1295 {
1296 // first examine the value type: if it's unsupported, simply skip it
1297 // instead of aborting the entire export process because we failed to
1298 // export a single value
1299 wxString value = FormatValue(name);
1300 if ( value.empty() )
1301 {
1302 wxLogWarning(_("Ignoring value \"%s\" of the key \"%s\"."),
1303 name.c_str(), GetName().c_str());
1304 return true;
1305 }
1306
1307 // we do have the text representation of the value, now write everything
1308 // out
1309
1310 // special case: unnamed/default value is represented as just "@"
1311 if ( name.empty() )
1312 {
1313 if ( !WriteAsciiChar(ostr, '@') )
1314 return false;
1315 }
1316 else // normal, named, value
1317 {
1318 if ( !WriteAsciiChar(ostr, '"') ||
1319 !WriteAsciiString(ostr, name) ||
1320 !WriteAsciiChar(ostr, '"') )
1321 return false;
1322 }
1323
1324 if ( !WriteAsciiChar(ostr, '=') )
1325 return false;
1326
1327 return WriteAsciiString(ostr, value) && WriteAsciiEOL(ostr);
1328 }
1329
1330 bool wxRegKey::DoExport(wxOutputStream& ostr) const
1331 {
1332 // write out this key name
1333 if ( !WriteAsciiChar(ostr, '[') )
1334 return false;
1335
1336 if ( !WriteAsciiString(ostr, GetName(false /* no short prefix */)) )
1337 return false;
1338
1339 if ( !WriteAsciiChar(ostr, ']') || !WriteAsciiEOL(ostr) )
1340 return false;
1341
1342 // dump all our values
1343 long dummy;
1344 wxString name;
1345 wxRegKey& self = wx_const_cast(wxRegKey&, *this);
1346 bool cont = self.GetFirstValue(name, dummy);
1347 while ( cont )
1348 {
1349 if ( !DoExportValue(ostr, name) )
1350 return false;
1351
1352 cont = GetNextValue(name, dummy);
1353 }
1354
1355 // always terminate values by blank line, even if there were no values
1356 if ( !WriteAsciiEOL(ostr) )
1357 return false;
1358
1359 // recurse to subkeys
1360 cont = self.GetFirstKey(name, dummy);
1361 while ( cont )
1362 {
1363 wxRegKey subkey(*this, name);
1364 if ( !subkey.DoExport(ostr) )
1365 return false;
1366
1367 cont = GetNextKey(name, dummy);
1368 }
1369
1370 return true;
1371 }
1372
1373 #endif // wxUSE_STREAMS
1374
1375 // ============================================================================
1376 // implementation of global private functions
1377 // ============================================================================
1378
1379 bool KeyExists(WXHKEY hRootKey, const wxChar *szKey)
1380 {
1381 // don't close this key itself for the case of empty szKey!
1382 if ( wxIsEmpty(szKey) )
1383 return true;
1384
1385 HKEY hkeyDummy;
1386 if ( ::RegOpenKeyEx
1387 (
1388 (HKEY)hRootKey,
1389 szKey,
1390 RESERVED,
1391 KEY_READ, // we might not have enough rights for rw access
1392 &hkeyDummy
1393 ) == ERROR_SUCCESS )
1394 {
1395 ::RegCloseKey(hkeyDummy);
1396
1397 return true;
1398 }
1399
1400 return false;
1401 }
1402
1403 const wxChar *GetFullName(const wxRegKey *pKey, const wxChar *szValue)
1404 {
1405 static wxString s_str;
1406 s_str = pKey->GetName();
1407 if ( !wxIsEmpty(szValue) )
1408 s_str << wxT("\\") << szValue;
1409
1410 return s_str.c_str();
1411 }
1412
1413 void RemoveTrailingSeparator(wxString& str)
1414 {
1415 if ( !str.empty() && str.Last() == REG_SEPARATOR )
1416 str.Truncate(str.Len() - 1);
1417 }
1418
wxWidgets (Impactor)