]> git.saurik.com Git - wxWidgets.git/blob - src/msw/registry.cpp
WinCE fixes.
[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
31 // Windows headers
32 /*
33 #define STRICT
34 #define WIN32_LEAN_AND_MEAN
35 */
36
37 #include "wx/msw/wrapwin.h"
38
39 #ifdef __WXWINCE__
40 #include "wx/msw/private.h"
41 #include <winbase.h>
42 #include <winreg.h>
43 #endif
44
45 // other std headers
46 #include <stdlib.h> // for _MAX_PATH
47
48 #ifndef _MAX_PATH
49 #define _MAX_PATH 512
50 #endif
51
52 // our header
53 #define HKEY_DEFINED // already defined in windows.h
54 #include "wx/msw/registry.h"
55
56 // some registry functions don't like signed chars
57 typedef unsigned char *RegString;
58 typedef BYTE* RegBinary;
59
60 // ----------------------------------------------------------------------------
61 // constants
62 // ----------------------------------------------------------------------------
63
64 // the standard key names, short names and handles all bundled together for
65 // convenient access
66 static struct
67 {
68 HKEY hkey;
69 const wxChar *szName;
70 const wxChar *szShortName;
71 }
72 aStdKeys[] =
73 {
74 { HKEY_CLASSES_ROOT, wxT("HKEY_CLASSES_ROOT"), wxT("HKCR") },
75 #ifdef __WIN32__
76 { HKEY_CURRENT_USER, wxT("HKEY_CURRENT_USER"), wxT("HKCU") },
77 { HKEY_LOCAL_MACHINE, wxT("HKEY_LOCAL_MACHINE"), wxT("HKLM") },
78 { HKEY_USERS, wxT("HKEY_USERS"), wxT("HKU") }, // short name?
79 #ifndef __WXWINCE__
80 { HKEY_PERFORMANCE_DATA, wxT("HKEY_PERFORMANCE_DATA"), wxT("HKPD") },
81 #endif
82 #if WINVER >= 0x0400 && !defined(__WXWINCE__)
83 { HKEY_CURRENT_CONFIG, wxT("HKEY_CURRENT_CONFIG"), wxT("HKCC") },
84 #if !defined(__GNUWIN32__) && !defined(__WXWINCE__)
85 { HKEY_DYN_DATA, wxT("HKEY_DYN_DATA"), wxT("HKDD") }, // short name?
86 #endif //GNUWIN32
87 #endif //WINVER >= 4.0
88 #endif //WIN32
89 };
90
91 // the registry name separator (perhaps one day MS will change it to '/' ;-)
92 #define REG_SEPARATOR wxT('\\')
93
94 // useful for Windows programmers: makes somewhat more clear all these zeroes
95 // being passed to Windows APIs
96 #define RESERVED (0)
97
98 // ----------------------------------------------------------------------------
99 // macros
100 // ----------------------------------------------------------------------------
101
102 // const_cast<> is not yet supported by all compilers
103 #define CONST_CAST ((wxRegKey *)this)->
104
105 // and neither is mutable which m_dwLastError should be
106 #define m_dwLastError CONST_CAST m_dwLastError
107
108 // ----------------------------------------------------------------------------
109 // non member functions
110 // ----------------------------------------------------------------------------
111
112 // removes the trailing backslash from the string if it has one
113 static inline void RemoveTrailingSeparator(wxString& str);
114
115 // returns TRUE if given registry key exists
116 static bool KeyExists(WXHKEY hRootKey, const wxChar *szKey);
117
118 // combines value and key name (uses static buffer!)
119 static const wxChar *GetFullName(const wxRegKey *pKey,
120 const wxChar *szValue = NULL);
121
122 // ============================================================================
123 // implementation of wxRegKey class
124 // ============================================================================
125
126 // ----------------------------------------------------------------------------
127 // static functions and variables
128 // ----------------------------------------------------------------------------
129
130 const size_t wxRegKey::nStdKeys = WXSIZEOF(aStdKeys);
131
132 // @@ should take a `StdKey key', but as it's often going to be used in loops
133 // it would require casts in user code.
134 const wxChar *wxRegKey::GetStdKeyName(size_t key)
135 {
136 // return empty string if key is invalid
137 wxCHECK_MSG( key < nStdKeys, wxEmptyString, wxT("invalid key in wxRegKey::GetStdKeyName") );
138
139 return aStdKeys[key].szName;
140 }
141
142 const wxChar *wxRegKey::GetStdKeyShortName(size_t key)
143 {
144 // return empty string if key is invalid
145 wxCHECK( key < nStdKeys, wxEmptyString );
146
147 return aStdKeys[key].szShortName;
148 }
149
150 wxRegKey::StdKey wxRegKey::ExtractKeyName(wxString& strKey)
151 {
152 wxString strRoot = strKey.BeforeFirst(REG_SEPARATOR);
153
154 HKEY hRootKey = 0;
155 size_t ui;
156 for ( ui = 0; ui < nStdKeys; ui++ ) {
157 if ( strRoot.CmpNoCase(aStdKeys[ui].szName) == 0 ||
158 strRoot.CmpNoCase(aStdKeys[ui].szShortName) == 0 ) {
159 hRootKey = aStdKeys[ui].hkey;
160 break;
161 }
162 }
163
164 if ( ui == nStdKeys ) {
165 wxFAIL_MSG(wxT("invalid key prefix in wxRegKey::ExtractKeyName."));
166
167 hRootKey = HKEY_CLASSES_ROOT;
168 }
169 else {
170 strKey = strKey.After(REG_SEPARATOR);
171 if ( !strKey.IsEmpty() && strKey.Last() == REG_SEPARATOR )
172 strKey.Truncate(strKey.Len() - 1);
173 }
174
175 return (wxRegKey::StdKey)(int)hRootKey;
176 }
177
178 wxRegKey::StdKey wxRegKey::GetStdKeyFromHkey(WXHKEY hkey)
179 {
180 for ( size_t ui = 0; ui < nStdKeys; ui++ ) {
181 if ( (int) aStdKeys[ui].hkey == (int) hkey )
182 return (StdKey)ui;
183 }
184
185 wxFAIL_MSG(wxT("non root hkey passed to wxRegKey::GetStdKeyFromHkey."));
186
187 return HKCR;
188 }
189
190 // ----------------------------------------------------------------------------
191 // ctors and dtor
192 // ----------------------------------------------------------------------------
193
194 wxRegKey::wxRegKey()
195 {
196 m_hRootKey = (WXHKEY) aStdKeys[HKCR].hkey;
197
198 Init();
199 }
200
201 wxRegKey::wxRegKey(const wxString& strKey) : m_strKey(strKey)
202 {
203 m_hRootKey = (WXHKEY) aStdKeys[ExtractKeyName(m_strKey)].hkey;
204
205 Init();
206 }
207
208 // parent is a predefined (and preopened) key
209 wxRegKey::wxRegKey(StdKey keyParent, const wxString& strKey) : m_strKey(strKey)
210 {
211 RemoveTrailingSeparator(m_strKey);
212 m_hRootKey = (WXHKEY) aStdKeys[keyParent].hkey;
213
214 Init();
215 }
216
217 // parent is a normal regkey
218 wxRegKey::wxRegKey(const wxRegKey& keyParent, const wxString& strKey)
219 : m_strKey(keyParent.m_strKey)
220 {
221 // combine our name with parent's to get the full name
222 if ( !m_strKey.IsEmpty() &&
223 (strKey.IsEmpty() || strKey[0] != REG_SEPARATOR) ) {
224 m_strKey += REG_SEPARATOR;
225 }
226
227 m_strKey += strKey;
228 RemoveTrailingSeparator(m_strKey);
229
230 m_hRootKey = keyParent.m_hRootKey;
231
232 Init();
233 }
234
235 // dtor closes the key releasing system resource
236 wxRegKey::~wxRegKey()
237 {
238 Close();
239 }
240
241 // ----------------------------------------------------------------------------
242 // change the key name/hkey
243 // ----------------------------------------------------------------------------
244
245 // set the full key name
246 void wxRegKey::SetName(const wxString& strKey)
247 {
248 Close();
249
250 m_strKey = strKey;
251 m_hRootKey = (WXHKEY) aStdKeys[ExtractKeyName(m_strKey)].hkey;
252 }
253
254 // the name is relative to the parent key
255 void wxRegKey::SetName(StdKey keyParent, const wxString& strKey)
256 {
257 Close();
258
259 m_strKey = strKey;
260 RemoveTrailingSeparator(m_strKey);
261 m_hRootKey = (WXHKEY) aStdKeys[keyParent].hkey;
262 }
263
264 // the name is relative to the parent key
265 void wxRegKey::SetName(const wxRegKey& keyParent, const wxString& strKey)
266 {
267 Close();
268
269 // combine our name with parent's to get the full name
270
271 // NB: this method is called by wxRegConfig::SetPath() which is a performance
272 // critical function and so it preallocates space for our m_strKey to
273 // gain some speed - this is why we only use += here and not = which
274 // would just free the prealloc'd buffer and would have to realloc it the
275 // next line!
276 m_strKey.clear();
277 m_strKey += keyParent.m_strKey;
278 if ( !strKey.IsEmpty() && strKey[0] != REG_SEPARATOR )
279 m_strKey += REG_SEPARATOR;
280 m_strKey += strKey;
281
282 RemoveTrailingSeparator(m_strKey);
283
284 m_hRootKey = keyParent.m_hRootKey;
285 }
286
287 // hKey should be opened and will be closed in wxRegKey dtor
288 void wxRegKey::SetHkey(WXHKEY hKey)
289 {
290 Close();
291
292 m_hKey = hKey;
293 }
294
295 // ----------------------------------------------------------------------------
296 // info about the key
297 // ----------------------------------------------------------------------------
298
299 // returns TRUE if the key exists
300 bool wxRegKey::Exists() const
301 {
302 // opened key has to exist, try to open it if not done yet
303 return IsOpened() ? TRUE : KeyExists(m_hRootKey, m_strKey);
304 }
305
306 // returns the full name of the key (prefix is abbreviated if bShortPrefix)
307 wxString wxRegKey::GetName(bool bShortPrefix) const
308 {
309 StdKey key = GetStdKeyFromHkey((WXHKEY) m_hRootKey);
310 wxString str = bShortPrefix ? aStdKeys[key].szShortName
311 : aStdKeys[key].szName;
312 if ( !m_strKey.IsEmpty() )
313 str << _T("\\") << m_strKey;
314
315 return str;
316 }
317
318 bool wxRegKey::GetKeyInfo(size_t *pnSubKeys,
319 size_t *pnMaxKeyLen,
320 size_t *pnValues,
321 size_t *pnMaxValueLen) const
322 {
323 // old gcc headers incorrectly prototype RegQueryInfoKey()
324 #if defined(__GNUWIN32_OLD__) && !defined(__CYGWIN10__)
325 #define REG_PARAM (size_t *)
326 #else
327 #define REG_PARAM (LPDWORD)
328 #endif
329
330 // it might be unexpected to some that this function doesn't open the key
331 wxASSERT_MSG( IsOpened(), _T("key should be opened in GetKeyInfo") );
332
333 m_dwLastError = ::RegQueryInfoKey
334 (
335 (HKEY) m_hKey,
336 NULL, // class name
337 NULL, // (ptr to) size of class name buffer
338 RESERVED,
339 REG_PARAM
340 pnSubKeys, // [out] number of subkeys
341 REG_PARAM
342 pnMaxKeyLen, // [out] max length of a subkey name
343 NULL, // longest subkey class name
344 REG_PARAM
345 pnValues, // [out] number of values
346 REG_PARAM
347 pnMaxValueLen, // [out] max length of a value name
348 NULL, // longest value data
349 NULL, // security descriptor
350 NULL // time of last modification
351 );
352
353 #undef REG_PARAM
354
355 if ( m_dwLastError != ERROR_SUCCESS ) {
356 wxLogSysError(m_dwLastError, _("Can't get info about registry key '%s'"),
357 GetName().c_str());
358 return FALSE;
359 }
360
361 return TRUE;
362 }
363
364 // ----------------------------------------------------------------------------
365 // operations
366 // ----------------------------------------------------------------------------
367
368 // opens key (it's not an error to call Open() on an already opened key)
369 bool wxRegKey::Open(AccessMode mode)
370 {
371 if ( IsOpened() )
372 return TRUE;
373
374 HKEY tmpKey;
375 m_dwLastError = ::RegOpenKeyEx
376 (
377 (HKEY) m_hRootKey,
378 m_strKey,
379 RESERVED,
380 mode == Read ? KEY_READ : KEY_ALL_ACCESS,
381 &tmpKey
382 );
383
384 if ( m_dwLastError != ERROR_SUCCESS )
385 {
386 wxLogSysError(m_dwLastError, _("Can't open registry key '%s'"),
387 GetName().c_str());
388 return FALSE;
389 }
390
391 m_hKey = (WXHKEY) tmpKey;
392 return TRUE;
393 }
394
395 // creates key, failing if it exists and !bOkIfExists
396 bool wxRegKey::Create(bool bOkIfExists)
397 {
398 // check for existence only if asked (i.e. order is important!)
399 if ( !bOkIfExists && Exists() )
400 return FALSE;
401
402 if ( IsOpened() )
403 return TRUE;
404
405 HKEY tmpKey;
406 #ifdef __WXWINCE__
407 DWORD disposition;
408 m_dwLastError = RegCreateKeyEx((HKEY) m_hRootKey, m_strKey,
409 NULL, // reserved
410 NULL, // class string
411 0,
412 0,
413 NULL,
414 &tmpKey,
415 &disposition);
416 #else
417 m_dwLastError = RegCreateKey((HKEY) m_hRootKey, m_strKey, &tmpKey);
418 #endif
419 if ( m_dwLastError != ERROR_SUCCESS ) {
420 wxLogSysError(m_dwLastError, _("Can't create registry key '%s'"),
421 GetName().c_str());
422 return FALSE;
423 }
424 else
425 {
426 m_hKey = (WXHKEY) tmpKey;
427 return TRUE;
428 }
429 }
430
431 // close the key, it's not an error to call it when not opened
432 bool wxRegKey::Close()
433 {
434 if ( IsOpened() ) {
435 m_dwLastError = RegCloseKey((HKEY) m_hKey);
436 m_hKey = 0;
437
438 if ( m_dwLastError != ERROR_SUCCESS ) {
439 wxLogSysError(m_dwLastError, _("Can't close registry key '%s'"),
440 GetName().c_str());
441
442 return FALSE;
443 }
444 }
445
446 return TRUE;
447 }
448
449 bool wxRegKey::RenameValue(const wxChar *szValueOld, const wxChar *szValueNew)
450 {
451 bool ok = TRUE;
452 if ( HasValue(szValueNew) ) {
453 wxLogError(_("Registry value '%s' already exists."), szValueNew);
454
455 ok = FALSE;
456 }
457
458 if ( !ok ||
459 !CopyValue(szValueOld, *this, szValueNew) ||
460 !DeleteValue(szValueOld) ) {
461 wxLogError(_("Failed to rename registry value '%s' to '%s'."),
462 szValueOld, szValueNew);
463
464 return FALSE;
465 }
466
467 return TRUE;
468 }
469
470 bool wxRegKey::CopyValue(const wxChar *szValue,
471 wxRegKey& keyDst,
472 const wxChar *szValueNew)
473 {
474 if ( !szValueNew ) {
475 // by default, use the same name
476 szValueNew = szValue;
477 }
478
479 switch ( GetValueType(szValue) ) {
480 case Type_String:
481 {
482 wxString strVal;
483 return QueryValue(szValue, strVal) &&
484 keyDst.SetValue(szValueNew, strVal);
485 }
486
487 case Type_Dword:
488 /* case Type_Dword_little_endian: == Type_Dword */
489 {
490 long dwVal;
491 return QueryValue(szValue, &dwVal) &&
492 keyDst.SetValue(szValueNew, dwVal);
493 }
494
495 #ifdef __WIN32__
496 case Type_Binary:
497 {
498 wxMemoryBuffer buf;
499 return QueryValue(szValue,buf) &&
500 keyDst.SetValue(szValueNew,buf);
501 }
502 // these types are unsupported because I am not sure about how
503 // exactly they should be copied and because they shouldn't
504 // occur among the application keys (supposedly created with
505 // this class)
506 case Type_None:
507 case Type_Expand_String:
508 case Type_Dword_big_endian:
509 case Type_Link:
510 case Type_Multi_String:
511 case Type_Resource_list:
512 case Type_Full_resource_descriptor:
513 case Type_Resource_requirements_list:
514 #endif // Win32
515 default:
516 wxLogError(_("Can't copy values of unsupported type %d."),
517 GetValueType(szValue));
518 return FALSE;
519 }
520 }
521
522 bool wxRegKey::Rename(const wxChar *szNewName)
523 {
524 wxCHECK_MSG( !!m_strKey, FALSE, _T("registry hives can't be renamed") );
525
526 if ( !Exists() ) {
527 wxLogError(_("Registry key '%s' does not exist, cannot rename it."),
528 GetFullName(this));
529
530 return FALSE;
531 }
532
533 // do we stay in the same hive?
534 bool inSameHive = !wxStrchr(szNewName, REG_SEPARATOR);
535
536 // construct the full new name of the key
537 wxRegKey keyDst;
538
539 if ( inSameHive ) {
540 // rename the key to the new name under the same parent
541 wxString strKey = m_strKey.BeforeLast(REG_SEPARATOR);
542 if ( !!strKey ) {
543 // don't add '\\' in the start if strFullNewName is empty
544 strKey += REG_SEPARATOR;
545 }
546
547 strKey += szNewName;
548
549 keyDst.SetName(GetStdKeyFromHkey(m_hRootKey), strKey);
550 }
551 else {
552 // this is the full name already
553 keyDst.SetName(szNewName);
554 }
555
556 bool ok = keyDst.Create(FALSE /* fail if alredy exists */);
557 if ( !ok ) {
558 wxLogError(_("Registry key '%s' already exists."),
559 GetFullName(&keyDst));
560 }
561 else {
562 ok = Copy(keyDst) && DeleteSelf();
563 }
564
565 if ( !ok ) {
566 wxLogError(_("Failed to rename the registry key '%s' to '%s'."),
567 GetFullName(this), GetFullName(&keyDst));
568 }
569 else {
570 m_hRootKey = keyDst.m_hRootKey;
571 m_strKey = keyDst.m_strKey;
572 }
573
574 return ok;
575 }
576
577 bool wxRegKey::Copy(const wxChar *szNewName)
578 {
579 // create the new key first
580 wxRegKey keyDst(szNewName);
581 bool ok = keyDst.Create(FALSE /* fail if alredy exists */);
582 if ( ok ) {
583 ok = Copy(keyDst);
584
585 // we created the dest key but copying to it failed - delete it
586 if ( !ok ) {
587 (void)keyDst.DeleteSelf();
588 }
589 }
590
591 return ok;
592 }
593
594 bool wxRegKey::Copy(wxRegKey& keyDst)
595 {
596 bool ok = TRUE;
597
598 // copy all sub keys to the new location
599 wxString strKey;
600 long lIndex;
601 bool bCont = GetFirstKey(strKey, lIndex);
602 while ( ok && bCont ) {
603 wxRegKey key(*this, strKey);
604 wxString keyName;
605 keyName << GetFullName(&keyDst) << REG_SEPARATOR << strKey;
606 ok = key.Copy((const wxChar*) keyName);
607
608 if ( ok )
609 bCont = GetNextKey(strKey, lIndex);
610 else
611 wxLogError(_("Failed to copy the registry subkey '%s' to '%s'."), GetFullName(&key), keyName.mb_str());
612
613 }
614
615 // copy all values
616 wxString strVal;
617 bCont = GetFirstValue(strVal, lIndex);
618 while ( ok && bCont ) {
619 ok = CopyValue(strVal, keyDst);
620
621 if ( !ok ) {
622 wxLogSysError(m_dwLastError,
623 _("Failed to copy registry value '%s'"),
624 strVal.c_str());
625 }
626 else {
627 bCont = GetNextValue(strVal, lIndex);
628 }
629 }
630
631 if ( !ok ) {
632 wxLogError(_("Failed to copy the contents of registry key '%s' to '%s'."), GetFullName(this), GetFullName(&keyDst));
633 }
634
635 return ok;
636 }
637
638 // ----------------------------------------------------------------------------
639 // delete keys/values
640 // ----------------------------------------------------------------------------
641 bool wxRegKey::DeleteSelf()
642 {
643 {
644 wxLogNull nolog;
645 if ( !Open() ) {
646 // it already doesn't exist - ok!
647 return TRUE;
648 }
649 }
650
651 // prevent a buggy program from erasing one of the root registry keys or an
652 // immediate subkey (i.e. one which doesn't have '\\' inside) of any other
653 // key except HKCR (HKCR has some "deleteable" subkeys)
654 if ( m_strKey.IsEmpty() ||
655 ((m_hRootKey != (WXHKEY) aStdKeys[HKCR].hkey) &&
656 (m_strKey.Find(REG_SEPARATOR) == wxNOT_FOUND)) ) {
657 wxLogError(_("Registry key '%s' is needed for normal system operation,\ndeleting it will leave your system in unusable state:\noperation aborted."), 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 wxLogSysError(m_dwLastError, _("Can't delete value '%s' from key '%s'"),
717 szValue, GetName().c_str());
718 return FALSE;
719 }
720
721 return TRUE;
722 }
723
724 // ----------------------------------------------------------------------------
725 // access to values and subkeys
726 // ----------------------------------------------------------------------------
727
728 // return TRUE if value exists
729 bool wxRegKey::HasValue(const wxChar *szValue) const
730 {
731 // this function should be silent, so suppress possible messages from Open()
732 wxLogNull nolog;
733
734 if ( !CONST_CAST Open(Read) )
735 return FALSE;
736
737 LONG dwRet = ::RegQueryValueEx((HKEY) m_hKey,
738 WXSTRINGCAST szValue,
739 RESERVED,
740 NULL, NULL, NULL);
741 return dwRet == ERROR_SUCCESS;
742 }
743
744 // returns TRUE if this key has any values
745 bool wxRegKey::HasValues() const
746 {
747 // suppress possible messages from GetFirstValue()
748 wxLogNull nolog;
749
750 // just call GetFirstValue with dummy parameters
751 wxString str;
752 long l;
753 return CONST_CAST GetFirstValue(str, l);
754 }
755
756 // returns TRUE if this key has any subkeys
757 bool wxRegKey::HasSubkeys() const
758 {
759 // suppress possible messages from GetFirstKey()
760 wxLogNull nolog;
761
762 // just call GetFirstKey with dummy parameters
763 wxString str;
764 long l;
765 return CONST_CAST GetFirstKey(str, l);
766 }
767
768 // returns TRUE if given subkey exists
769 bool wxRegKey::HasSubKey(const wxChar *szKey) const
770 {
771 // this function should be silent, so suppress possible messages from Open()
772 wxLogNull nolog;
773
774 if ( !CONST_CAST Open(Read) )
775 return FALSE;
776
777 return KeyExists(m_hKey, szKey);
778 }
779
780 wxRegKey::ValueType wxRegKey::GetValueType(const wxChar *szValue) const
781 {
782 if ( ! CONST_CAST Open(Read) )
783 return Type_None;
784
785 DWORD dwType;
786 m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED,
787 &dwType, NULL, NULL);
788 if ( m_dwLastError != ERROR_SUCCESS ) {
789 wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"),
790 GetName().c_str());
791 return Type_None;
792 }
793
794 return (ValueType)dwType;
795 }
796
797 #ifdef __WIN32__
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() ) {
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 #endif //Win32
892
893 bool wxRegKey::QueryValue(const wxChar *szValue,
894 wxString& strValue,
895 bool raw) const
896 {
897 if ( CONST_CAST Open(Read) ) {
898
899 // first get the type and size of the data
900 DWORD dwType, dwSize;
901 m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED,
902 &dwType, NULL, &dwSize);
903 if ( m_dwLastError == ERROR_SUCCESS ) {
904 if ( !dwSize ) {
905 // must treat this case specially as GetWriteBuf() doesn't like
906 // being called with 0 size
907 strValue.Empty();
908 }
909 else {
910 m_dwLastError = RegQueryValueEx((HKEY) m_hKey,
911 WXSTRINGCAST szValue,
912 RESERVED,
913 &dwType,
914 (RegString)(wxChar*)wxStringBuffer(strValue, dwSize),
915 &dwSize);
916
917 // expand the var expansions in the string unless disabled
918 #ifndef __WXWINCE__
919 if ( (dwType == REG_EXPAND_SZ) && !raw )
920 {
921 DWORD dwExpSize = ::ExpandEnvironmentStrings(strValue, NULL, 0);
922 bool ok = dwExpSize != 0;
923 if ( ok )
924 {
925 wxString strExpValue;
926 ok = ::ExpandEnvironmentStrings
927 (
928 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 #else
941 wxUnusedVar(raw);
942 #endif
943 // __WXWINCE__
944 }
945
946 if ( m_dwLastError == ERROR_SUCCESS ) {
947 // check that it was the right type
948 wxASSERT_MSG( !IsNumericValue(szValue),
949 wxT("Type mismatch in wxRegKey::QueryValue().") );
950
951 return TRUE;
952 }
953 }
954 }
955
956 wxLogSysError(m_dwLastError, _("Can't read value of '%s'"),
957 GetFullName(this, szValue));
958 return FALSE;
959 }
960
961 bool wxRegKey::SetValue(const wxChar *szValue, const wxString& strValue)
962 {
963 if ( CONST_CAST Open() ) {
964 m_dwLastError = RegSetValueEx((HKEY) m_hKey, szValue, (DWORD) RESERVED, REG_SZ,
965 (RegString)strValue.c_str(),
966 (strValue.Len() + 1)*sizeof(wxChar));
967 if ( m_dwLastError == ERROR_SUCCESS )
968 return TRUE;
969 }
970
971 wxLogSysError(m_dwLastError, _("Can't set value of '%s'"),
972 GetFullName(this, szValue));
973 return FALSE;
974 }
975
976 wxString wxRegKey::QueryDefaultValue() const
977 {
978 wxString str;
979 QueryValue(NULL, str);
980 return str;
981 }
982
983 // ----------------------------------------------------------------------------
984 // enumeration
985 // NB: all these functions require an index variable which allows to have
986 // several concurrently running indexations on the same key
987 // ----------------------------------------------------------------------------
988
989 bool wxRegKey::GetFirstValue(wxString& strValueName, long& lIndex)
990 {
991 if ( !Open(Read) )
992 return FALSE;
993
994 lIndex = 0;
995 return GetNextValue(strValueName, lIndex);
996 }
997
998 bool wxRegKey::GetNextValue(wxString& strValueName, long& lIndex) const
999 {
1000 wxASSERT( IsOpened() );
1001
1002 // are we already at the end of enumeration?
1003 if ( lIndex == -1 )
1004 return FALSE;
1005
1006 wxChar szValueName[1024]; // @@ use RegQueryInfoKey...
1007 DWORD dwValueLen = WXSIZEOF(szValueName);
1008
1009 m_dwLastError = RegEnumValue((HKEY) m_hKey, lIndex++,
1010 szValueName, &dwValueLen,
1011 RESERVED,
1012 NULL, // [out] type
1013 NULL, // [out] buffer for value
1014 NULL); // [i/o] it's length
1015
1016 if ( m_dwLastError != ERROR_SUCCESS ) {
1017 if ( m_dwLastError == ERROR_NO_MORE_ITEMS ) {
1018 m_dwLastError = ERROR_SUCCESS;
1019 lIndex = -1;
1020 }
1021 else {
1022 wxLogSysError(m_dwLastError, _("Can't enumerate values of key '%s'"),
1023 GetName().c_str());
1024 }
1025
1026 return FALSE;
1027 }
1028
1029 strValueName = szValueName;
1030
1031 return TRUE;
1032 }
1033
1034 bool wxRegKey::GetFirstKey(wxString& strKeyName, long& lIndex)
1035 {
1036 if ( !Open(Read) )
1037 return FALSE;
1038
1039 lIndex = 0;
1040 return GetNextKey(strKeyName, lIndex);
1041 }
1042
1043 bool wxRegKey::GetNextKey(wxString& strKeyName, long& lIndex) const
1044 {
1045 wxASSERT( IsOpened() );
1046
1047 // are we already at the end of enumeration?
1048 if ( lIndex == -1 )
1049 return FALSE;
1050
1051 wxChar szKeyName[_MAX_PATH + 1];
1052
1053 #ifdef __WXWINCE__
1054 DWORD sizeName = WXSIZEOF(szKeyName);
1055 m_dwLastError = RegEnumKeyEx((HKEY) m_hKey, lIndex++, szKeyName, & sizeName,
1056 0, NULL, NULL, NULL);
1057 #else
1058 m_dwLastError = RegEnumKey((HKEY) m_hKey, lIndex++, szKeyName, WXSIZEOF(szKeyName));
1059 #endif
1060
1061 if ( m_dwLastError != ERROR_SUCCESS ) {
1062 if ( m_dwLastError == ERROR_NO_MORE_ITEMS ) {
1063 m_dwLastError = ERROR_SUCCESS;
1064 lIndex = -1;
1065 }
1066 else {
1067 wxLogSysError(m_dwLastError, _("Can't enumerate subkeys of key '%s'"),
1068 GetName().c_str());
1069 }
1070
1071 return FALSE;
1072 }
1073
1074 strKeyName = szKeyName;
1075 return TRUE;
1076 }
1077
1078 // returns TRUE if the value contains a number (else it's some string)
1079 bool wxRegKey::IsNumericValue(const wxChar *szValue) const
1080 {
1081 ValueType type = GetValueType(szValue);
1082 switch ( type ) {
1083 case Type_Dword:
1084 /* case Type_Dword_little_endian: == Type_Dword */
1085 case Type_Dword_big_endian:
1086 return TRUE;
1087
1088 default:
1089 return FALSE;
1090 }
1091 }
1092
1093 // ============================================================================
1094 // implementation of global private functions
1095 // ============================================================================
1096
1097 bool KeyExists(WXHKEY hRootKey, const wxChar *szKey)
1098 {
1099 // don't close this key itself for the case of empty szKey!
1100 if ( wxIsEmpty(szKey) )
1101 return TRUE;
1102
1103 HKEY hkeyDummy;
1104 if ( ::RegOpenKeyEx
1105 (
1106 (HKEY)hRootKey,
1107 szKey,
1108 RESERVED,
1109 KEY_READ, // we might not have enough rights for rw access
1110 &hkeyDummy
1111 ) == ERROR_SUCCESS )
1112 {
1113 ::RegCloseKey(hkeyDummy);
1114
1115 return TRUE;
1116 }
1117
1118 return FALSE;
1119 }
1120
1121 const wxChar *GetFullName(const wxRegKey *pKey, const wxChar *szValue)
1122 {
1123 static wxString s_str;
1124 s_str = pKey->GetName();
1125 if ( !wxIsEmpty(szValue) )
1126 s_str << wxT("\\") << szValue;
1127
1128 return s_str.c_str();
1129 }
1130
1131 void RemoveTrailingSeparator(wxString& str)
1132 {
1133 if ( !str.IsEmpty() && str.Last() == REG_SEPARATOR )
1134 str.Truncate(str.Len() - 1);
1135 }
1136