]> git.saurik.com Git - wxWidgets.git/blob - src/msw/registry.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
removed Win16 code
[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 // for compilers that support precompilation, includes "wx.h".
16 #include "wx/wxprec.h"
17
18 #ifdef __BORLANDC__
19 #pragma hdrstop
20 #endif
21
22 // other wxWidgets headers
23 #include "wx/string.h"
24 #include "wx/intl.h"
25 #include "wx/log.h"
26 #include "wx/file.h"
27 #include "wx/wfstream.h"
28
29 // Windows headers
30 #include "wx/msw/wrapwin.h"
31
32 #ifdef __WXWINCE__
33 #include "wx/msw/private.h"
34 #include <winbase.h>
35 #include <winreg.h>
36 #endif
37
38 // other std headers
39 #include <stdlib.h> // for _MAX_PATH
40
41 #ifndef _MAX_PATH
42 #define _MAX_PATH 512
43 #endif
44
45 // our header
46 #define HKEY_DEFINED // already defined in windows.h
47 #include "wx/msw/registry.h"
48
49 // some registry functions don't like signed chars
50 typedef unsigned char *RegString;
51 typedef BYTE* RegBinary;
52
53 // ----------------------------------------------------------------------------
54 // constants
55 // ----------------------------------------------------------------------------
56
57 // the standard key names, short names and handles all bundled together for
58 // convenient access
59 static struct
60 {
61 HKEY hkey;
62 const wxChar *szName;
63 const wxChar *szShortName;
64 }
65 aStdKeys[] =
66 {
67 { HKEY_CLASSES_ROOT, wxT("HKEY_CLASSES_ROOT"), wxT("HKCR") },
68 { HKEY_CURRENT_USER, wxT("HKEY_CURRENT_USER"), wxT("HKCU") },
69 { HKEY_LOCAL_MACHINE, wxT("HKEY_LOCAL_MACHINE"), wxT("HKLM") },
70 { HKEY_USERS, wxT("HKEY_USERS"), wxT("HKU") }, // short name?
71 #ifndef __WXWINCE__
72 { HKEY_PERFORMANCE_DATA, wxT("HKEY_PERFORMANCE_DATA"), wxT("HKPD") },
73 #endif
74 #ifdef HKEY_CURRENT_CONFIG
75 { HKEY_CURRENT_CONFIG, wxT("HKEY_CURRENT_CONFIG"), wxT("HKCC") },
76 #endif
77 #ifdef HKEY_DYN_DATA
78 { HKEY_DYN_DATA, wxT("HKEY_DYN_DATA"), wxT("HKDD") }, // short name?
79 #endif
80 };
81
82 // the registry name separator (perhaps one day MS will change it to '/' ;-)
83 #define REG_SEPARATOR wxT('\\')
84
85 // useful for Windows programmers: makes somewhat more clear all these zeroes
86 // being passed to Windows APIs
87 #define RESERVED (0)
88
89 // ----------------------------------------------------------------------------
90 // macros
91 // ----------------------------------------------------------------------------
92
93 // const_cast<> is not yet supported by all compilers
94 #define CONST_CAST ((wxRegKey *)this)->
95
96 // and neither is mutable which m_dwLastError should be
97 #define m_dwLastError CONST_CAST m_dwLastError
98
99 // ----------------------------------------------------------------------------
100 // non member functions
101 // ----------------------------------------------------------------------------
102
103 // removes the trailing backslash from the string if it has one
104 static inline void RemoveTrailingSeparator(wxString& str);
105
106 // returns true if given registry key exists
107 static bool KeyExists(WXHKEY hRootKey, const wxChar *szKey);
108
109 // combines value and key name (uses static buffer!)
110 static const wxChar *GetFullName(const wxRegKey *pKey,
111 const wxChar *szValue = NULL);
112
113 // ============================================================================
114 // implementation of wxRegKey class
115 // ============================================================================
116
117 // ----------------------------------------------------------------------------
118 // static functions and variables
119 // ----------------------------------------------------------------------------
120
121 const size_t wxRegKey::nStdKeys = WXSIZEOF(aStdKeys);
122
123 // @@ should take a `StdKey key', but as it's often going to be used in loops
124 // it would require casts in user code.
125 const wxChar *wxRegKey::GetStdKeyName(size_t key)
126 {
127 // return empty string if key is invalid
128 wxCHECK_MSG( key < nStdKeys, wxEmptyString, wxT("invalid key in wxRegKey::GetStdKeyName") );
129
130 return aStdKeys[key].szName;
131 }
132
133 const wxChar *wxRegKey::GetStdKeyShortName(size_t key)
134 {
135 // return empty string if key is invalid
136 wxCHECK( key < nStdKeys, wxEmptyString );
137
138 return aStdKeys[key].szShortName;
139 }
140
141 wxRegKey::StdKey wxRegKey::ExtractKeyName(wxString& strKey)
142 {
143 wxString strRoot = strKey.BeforeFirst(REG_SEPARATOR);
144
145 HKEY hRootKey = 0;
146 size_t ui;
147 for ( ui = 0; ui < nStdKeys; ui++ ) {
148 if ( strRoot.CmpNoCase(aStdKeys[ui].szName) == 0 ||
149 strRoot.CmpNoCase(aStdKeys[ui].szShortName) == 0 ) {
150 hRootKey = aStdKeys[ui].hkey;
151 break;
152 }
153 }
154
155 if ( ui == nStdKeys ) {
156 wxFAIL_MSG(wxT("invalid key prefix in wxRegKey::ExtractKeyName."));
157
158 hRootKey = HKEY_CLASSES_ROOT;
159 }
160 else {
161 strKey = strKey.After(REG_SEPARATOR);
162 if ( !strKey.empty() && strKey.Last() == REG_SEPARATOR )
163 strKey.Truncate(strKey.Len() - 1);
164 }
165
166 return (wxRegKey::StdKey)(int)hRootKey;
167 }
168
169 wxRegKey::StdKey wxRegKey::GetStdKeyFromHkey(WXHKEY hkey)
170 {
171 for ( size_t ui = 0; ui < nStdKeys; ui++ ) {
172 if ( (int) aStdKeys[ui].hkey == (int) hkey )
173 return (StdKey)ui;
174 }
175
176 wxFAIL_MSG(wxT("non root hkey passed to wxRegKey::GetStdKeyFromHkey."));
177
178 return HKCR;
179 }
180
181 // ----------------------------------------------------------------------------
182 // ctors and dtor
183 // ----------------------------------------------------------------------------
184
185 wxRegKey::wxRegKey()
186 {
187 m_hRootKey = (WXHKEY) aStdKeys[HKCR].hkey;
188
189 Init();
190 }
191
192 wxRegKey::wxRegKey(const wxString& strKey) : m_strKey(strKey)
193 {
194 m_hRootKey = (WXHKEY) aStdKeys[ExtractKeyName(m_strKey)].hkey;
195
196 Init();
197 }
198
199 // parent is a predefined (and preopened) key
200 wxRegKey::wxRegKey(StdKey keyParent, const wxString& strKey) : m_strKey(strKey)
201 {
202 RemoveTrailingSeparator(m_strKey);
203 m_hRootKey = (WXHKEY) aStdKeys[keyParent].hkey;
204
205 Init();
206 }
207
208 // parent is a normal regkey
209 wxRegKey::wxRegKey(const wxRegKey& keyParent, const wxString& strKey)
210 : m_strKey(keyParent.m_strKey)
211 {
212 // combine our name with parent's to get the full name
213 if ( !m_strKey.empty() &&
214 (strKey.empty() || strKey[0] != REG_SEPARATOR) ) {
215 m_strKey += REG_SEPARATOR;
216 }
217
218 m_strKey += strKey;
219 RemoveTrailingSeparator(m_strKey);
220
221 m_hRootKey = keyParent.m_hRootKey;
222
223 Init();
224 }
225
226 // dtor closes the key releasing system resource
227 wxRegKey::~wxRegKey()
228 {
229 Close();
230 }
231
232 // ----------------------------------------------------------------------------
233 // change the key name/hkey
234 // ----------------------------------------------------------------------------
235
236 // set the full key name
237 void wxRegKey::SetName(const wxString& strKey)
238 {
239 Close();
240
241 m_strKey = strKey;
242 m_hRootKey = (WXHKEY) aStdKeys[ExtractKeyName(m_strKey)].hkey;
243 }
244
245 // the name is relative to the parent key
246 void wxRegKey::SetName(StdKey keyParent, const wxString& strKey)
247 {
248 Close();
249
250 m_strKey = strKey;
251 RemoveTrailingSeparator(m_strKey);
252 m_hRootKey = (WXHKEY) aStdKeys[keyParent].hkey;
253 }
254
255 // the name is relative to the parent key
256 void wxRegKey::SetName(const wxRegKey& keyParent, const wxString& strKey)
257 {
258 Close();
259
260 // combine our name with parent's to get the full name
261
262 // NB: this method is called by wxRegConfig::SetPath() which is a performance
263 // critical function and so it preallocates space for our m_strKey to
264 // gain some speed - this is why we only use += here and not = which
265 // would just free the prealloc'd buffer and would have to realloc it the
266 // next line!
267 m_strKey.clear();
268 m_strKey += keyParent.m_strKey;
269 if ( !strKey.empty() && strKey[0] != REG_SEPARATOR )
270 m_strKey += REG_SEPARATOR;
271 m_strKey += strKey;
272
273 RemoveTrailingSeparator(m_strKey);
274
275 m_hRootKey = keyParent.m_hRootKey;
276 }
277
278 // hKey should be opened and will be closed in wxRegKey dtor
279 void wxRegKey::SetHkey(WXHKEY hKey)
280 {
281 Close();
282
283 m_hKey = hKey;
284 }
285
286 // ----------------------------------------------------------------------------
287 // info about the key
288 // ----------------------------------------------------------------------------
289
290 // returns true if the key exists
291 bool wxRegKey::Exists() const
292 {
293 // opened key has to exist, try to open it if not done yet
294 return IsOpened() ? true : KeyExists(m_hRootKey, m_strKey);
295 }
296
297 // returns the full name of the key (prefix is abbreviated if bShortPrefix)
298 wxString wxRegKey::GetName(bool bShortPrefix) const
299 {
300 StdKey key = GetStdKeyFromHkey((WXHKEY) m_hRootKey);
301 wxString str = bShortPrefix ? aStdKeys[key].szShortName
302 : aStdKeys[key].szName;
303 if ( !m_strKey.empty() )
304 str << _T("\\") << m_strKey;
305
306 return str;
307 }
308
309 bool wxRegKey::GetKeyInfo(size_t *pnSubKeys,
310 size_t *pnMaxKeyLen,
311 size_t *pnValues,
312 size_t *pnMaxValueLen) const
313 {
314 // old gcc headers incorrectly prototype RegQueryInfoKey()
315 #if defined(__GNUWIN32_OLD__) && !defined(__CYGWIN10__)
316 #define REG_PARAM (size_t *)
317 #else
318 #define REG_PARAM (LPDWORD)
319 #endif
320
321 // it might be unexpected to some that this function doesn't open the key
322 wxASSERT_MSG( IsOpened(), _T("key should be opened in GetKeyInfo") );
323
324 m_dwLastError = ::RegQueryInfoKey
325 (
326 (HKEY) m_hKey,
327 NULL, // class name
328 NULL, // (ptr to) size of class name buffer
329 RESERVED,
330 REG_PARAM
331 pnSubKeys, // [out] number of subkeys
332 REG_PARAM
333 pnMaxKeyLen, // [out] max length of a subkey name
334 NULL, // longest subkey class name
335 REG_PARAM
336 pnValues, // [out] number of values
337 REG_PARAM
338 pnMaxValueLen, // [out] max length of a value name
339 NULL, // longest value data
340 NULL, // security descriptor
341 NULL // time of last modification
342 );
343
344 #undef REG_PARAM
345
346 if ( m_dwLastError != ERROR_SUCCESS ) {
347 wxLogSysError(m_dwLastError, _("Can't get info about registry key '%s'"),
348 GetName().c_str());
349 return false;
350 }
351
352 return true;
353 }
354
355 // ----------------------------------------------------------------------------
356 // operations
357 // ----------------------------------------------------------------------------
358
359 // opens key (it's not an error to call Open() on an already opened key)
360 bool wxRegKey::Open(AccessMode mode)
361 {
362 if ( IsOpened() )
363 {
364 if ( mode <= m_mode )
365 return true;
366
367 // we had been opened in read mode but now must be reopened in write
368 Close();
369 }
370
371 HKEY tmpKey;
372 m_dwLastError = ::RegOpenKeyEx
373 (
374 (HKEY) m_hRootKey,
375 m_strKey,
376 RESERVED,
377 mode == Read ? KEY_READ : KEY_ALL_ACCESS,
378 &tmpKey
379 );
380
381 if ( m_dwLastError != ERROR_SUCCESS )
382 {
383 wxLogSysError(m_dwLastError, _("Can't open registry key '%s'"),
384 GetName().c_str());
385 return false;
386 }
387
388 m_hKey = (WXHKEY) tmpKey;
389 m_mode = mode;
390
391 return true;
392 }
393
394 // creates key, failing if it exists and !bOkIfExists
395 bool wxRegKey::Create(bool bOkIfExists)
396 {
397 // check for existence only if asked (i.e. order is important!)
398 if ( !bOkIfExists && Exists() )
399 return false;
400
401 if ( IsOpened() )
402 return true;
403
404 HKEY tmpKey;
405 #ifdef __WXWINCE__
406 DWORD disposition;
407 m_dwLastError = RegCreateKeyEx((HKEY) m_hRootKey, m_strKey,
408 NULL, // reserved
409 NULL, // class string
410 0,
411 0,
412 NULL,
413 &tmpKey,
414 &disposition);
415 #else
416 m_dwLastError = RegCreateKey((HKEY) m_hRootKey, m_strKey, &tmpKey);
417 #endif
418 if ( m_dwLastError != ERROR_SUCCESS ) {
419 wxLogSysError(m_dwLastError, _("Can't create registry key '%s'"),
420 GetName().c_str());
421 return false;
422 }
423 else
424 {
425 m_hKey = (WXHKEY) tmpKey;
426 return true;
427 }
428 }
429
430 // close the key, it's not an error to call it when not opened
431 bool wxRegKey::Close()
432 {
433 if ( IsOpened() ) {
434 m_dwLastError = RegCloseKey((HKEY) m_hKey);
435 m_hKey = 0;
436
437 if ( m_dwLastError != ERROR_SUCCESS ) {
438 wxLogSysError(m_dwLastError, _("Can't close registry key '%s'"),
439 GetName().c_str());
440
441 return false;
442 }
443 }
444
445 return true;
446 }
447
448 bool wxRegKey::RenameValue(const wxChar *szValueOld, const wxChar *szValueNew)
449 {
450 bool ok = true;
451 if ( HasValue(szValueNew) ) {
452 wxLogError(_("Registry value '%s' already exists."), szValueNew);
453
454 ok = false;
455 }
456
457 if ( !ok ||
458 !CopyValue(szValueOld, *this, szValueNew) ||
459 !DeleteValue(szValueOld) ) {
460 wxLogError(_("Failed to rename registry value '%s' to '%s'."),
461 szValueOld, szValueNew);
462
463 return false;
464 }
465
466 return true;
467 }
468
469 bool wxRegKey::CopyValue(const wxChar *szValue,
470 wxRegKey& keyDst,
471 const wxChar *szValueNew)
472 {
473 if ( !szValueNew ) {
474 // by default, use the same name
475 szValueNew = szValue;
476 }
477
478 switch ( GetValueType(szValue) ) {
479 case Type_String:
480 {
481 wxString strVal;
482 return QueryValue(szValue, strVal) &&
483 keyDst.SetValue(szValueNew, strVal);
484 }
485
486 case Type_Dword:
487 /* case Type_Dword_little_endian: == Type_Dword */
488 {
489 long dwVal;
490 return QueryValue(szValue, &dwVal) &&
491 keyDst.SetValue(szValueNew, dwVal);
492 }
493
494 case Type_Binary:
495 {
496 wxMemoryBuffer buf;
497 return QueryValue(szValue,buf) &&
498 keyDst.SetValue(szValueNew,buf);
499 }
500
501 // these types are unsupported because I am not sure about how
502 // exactly they should be copied and because they shouldn't
503 // occur among the application keys (supposedly created with
504 // this class)
505 case Type_None:
506 case Type_Expand_String:
507 case Type_Dword_big_endian:
508 case Type_Link:
509 case Type_Multi_String:
510 case Type_Resource_list:
511 case Type_Full_resource_descriptor:
512 case Type_Resource_requirements_list:
513 default:
514 wxLogError(_("Can't copy values of unsupported type %d."),
515 GetValueType(szValue));
516 return false;
517 }
518 }
519
520 bool wxRegKey::Rename(const wxChar *szNewName)
521 {
522 wxCHECK_MSG( !m_strKey.empty(), false, _T("registry hives can't be renamed") );
523
524 if ( !Exists() ) {
525 wxLogError(_("Registry key '%s' does not exist, cannot rename it."),
526 GetFullName(this));
527
528 return false;
529 }
530
531 // do we stay in the same hive?
532 bool inSameHive = !wxStrchr(szNewName, REG_SEPARATOR);
533
534 // construct the full new name of the key
535 wxRegKey keyDst;
536
537 if ( inSameHive ) {
538 // rename the key to the new name under the same parent
539 wxString strKey = m_strKey.BeforeLast(REG_SEPARATOR);
540 if ( !strKey.empty() ) {
541 // don't add '\\' in the start if strFullNewName is empty
542 strKey += REG_SEPARATOR;
543 }
544
545 strKey += szNewName;
546
547 keyDst.SetName(GetStdKeyFromHkey(m_hRootKey), strKey);
548 }
549 else {
550 // this is the full name already
551 keyDst.SetName(szNewName);
552 }
553
554 bool ok = keyDst.Create(false /* fail if alredy exists */);
555 if ( !ok ) {
556 wxLogError(_("Registry key '%s' already exists."),
557 GetFullName(&keyDst));
558 }
559 else {
560 ok = Copy(keyDst) && DeleteSelf();
561 }
562
563 if ( !ok ) {
564 wxLogError(_("Failed to rename the registry key '%s' to '%s'."),
565 GetFullName(this), GetFullName(&keyDst));
566 }
567 else {
568 m_hRootKey = keyDst.m_hRootKey;
569 m_strKey = keyDst.m_strKey;
570 }
571
572 return ok;
573 }
574
575 bool wxRegKey::Copy(const wxChar *szNewName)
576 {
577 // create the new key first
578 wxRegKey keyDst(szNewName);
579 bool ok = keyDst.Create(false /* fail if alredy exists */);
580 if ( ok ) {
581 ok = Copy(keyDst);
582
583 // we created the dest key but copying to it failed - delete it
584 if ( !ok ) {
585 (void)keyDst.DeleteSelf();
586 }
587 }
588
589 return ok;
590 }
591
592 bool wxRegKey::Copy(wxRegKey& keyDst)
593 {
594 bool ok = true;
595
596 // copy all sub keys to the new location
597 wxString strKey;
598 long lIndex;
599 bool bCont = GetFirstKey(strKey, lIndex);
600 while ( ok && bCont ) {
601 wxRegKey key(*this, strKey);
602 wxString keyName;
603 keyName << GetFullName(&keyDst) << REG_SEPARATOR << strKey;
604 ok = key.Copy((const wxChar*) keyName);
605
606 if ( ok )
607 bCont = GetNextKey(strKey, lIndex);
608 else
609 wxLogError(_("Failed to copy the registry subkey '%s' to '%s'."),
610 GetFullName(&key), keyName.c_str());
611
612 }
613
614 // copy all values
615 wxString strVal;
616 bCont = GetFirstValue(strVal, lIndex);
617 while ( ok && bCont ) {
618 ok = CopyValue(strVal, keyDst);
619
620 if ( !ok ) {
621 wxLogSysError(m_dwLastError,
622 _("Failed to copy registry value '%s'"),
623 strVal.c_str());
624 }
625 else {
626 bCont = GetNextValue(strVal, lIndex);
627 }
628 }
629
630 if ( !ok ) {
631 wxLogError(_("Failed to copy the contents of registry key '%s' to '%s'."),
632 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.empty() ||
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."),
658 GetFullName(this));
659
660 return false;
661 }
662
663 // we can't delete keys while enumerating because it confuses GetNextKey, so
664 // we first save the key names and then delete them all
665 wxArrayString astrSubkeys;
666
667 wxString strKey;
668 long lIndex;
669 bool bCont = GetFirstKey(strKey, lIndex);
670 while ( bCont ) {
671 astrSubkeys.Add(strKey);
672
673 bCont = GetNextKey(strKey, lIndex);
674 }
675
676 size_t nKeyCount = astrSubkeys.Count();
677 for ( size_t nKey = 0; nKey < nKeyCount; nKey++ ) {
678 wxRegKey key(*this, astrSubkeys[nKey]);
679 if ( !key.DeleteSelf() )
680 return false;
681 }
682
683 // now delete this key itself
684 Close();
685
686 m_dwLastError = RegDeleteKey((HKEY) m_hRootKey, m_strKey);
687 // deleting a key which doesn't exist is not considered an error
688 if ( m_dwLastError != ERROR_SUCCESS &&
689 m_dwLastError != ERROR_FILE_NOT_FOUND ) {
690 wxLogSysError(m_dwLastError, _("Can't delete key '%s'"),
691 GetName().c_str());
692 return false;
693 }
694
695 return true;
696 }
697
698 bool wxRegKey::DeleteKey(const wxChar *szKey)
699 {
700 if ( !Open() )
701 return false;
702
703 wxRegKey key(*this, szKey);
704 return key.DeleteSelf();
705 }
706
707 bool wxRegKey::DeleteValue(const wxChar *szValue)
708 {
709 if ( !Open() )
710 return false;
711
712 m_dwLastError = RegDeleteValue((HKEY) m_hKey, WXSTRINGCAST szValue);
713
714 // deleting a value which doesn't exist is not considered an error
715 if ( (m_dwLastError != ERROR_SUCCESS) &&
716 (m_dwLastError != ERROR_FILE_NOT_FOUND) )
717 {
718 wxLogSysError(m_dwLastError, _("Can't delete value '%s' from key '%s'"),
719 szValue, GetName().c_str());
720 return false;
721 }
722
723 return true;
724 }
725
726 // ----------------------------------------------------------------------------
727 // access to values and subkeys
728 // ----------------------------------------------------------------------------
729
730 // return true if value exists
731 bool wxRegKey::HasValue(const wxChar *szValue) const
732 {
733 // this function should be silent, so suppress possible messages from Open()
734 wxLogNull nolog;
735
736 if ( !CONST_CAST Open(Read) )
737 return false;
738
739 LONG dwRet = ::RegQueryValueEx((HKEY) m_hKey,
740 WXSTRINGCAST szValue,
741 RESERVED,
742 NULL, NULL, NULL);
743 return dwRet == ERROR_SUCCESS;
744 }
745
746 // returns true if this key has any values
747 bool wxRegKey::HasValues() const
748 {
749 // suppress possible messages from GetFirstValue()
750 wxLogNull nolog;
751
752 // just call GetFirstValue with dummy parameters
753 wxString str;
754 long l;
755 return CONST_CAST GetFirstValue(str, l);
756 }
757
758 // returns true if this key has any subkeys
759 bool wxRegKey::HasSubkeys() const
760 {
761 // suppress possible messages from GetFirstKey()
762 wxLogNull nolog;
763
764 // just call GetFirstKey with dummy parameters
765 wxString str;
766 long l;
767 return CONST_CAST GetFirstKey(str, l);
768 }
769
770 // returns true if given subkey exists
771 bool wxRegKey::HasSubKey(const wxChar *szKey) const
772 {
773 // this function should be silent, so suppress possible messages from Open()
774 wxLogNull nolog;
775
776 if ( !CONST_CAST Open(Read) )
777 return false;
778
779 return KeyExists(m_hKey, szKey);
780 }
781
782 wxRegKey::ValueType wxRegKey::GetValueType(const wxChar *szValue) const
783 {
784 if ( ! CONST_CAST Open(Read) )
785 return Type_None;
786
787 DWORD dwType;
788 m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED,
789 &dwType, NULL, NULL);
790 if ( m_dwLastError != ERROR_SUCCESS ) {
791 wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"),
792 GetName().c_str());
793 return Type_None;
794 }
795
796 return (ValueType)dwType;
797 }
798
799 bool wxRegKey::SetValue(const wxChar *szValue, long lValue)
800 {
801 if ( CONST_CAST Open() ) {
802 m_dwLastError = RegSetValueEx((HKEY) m_hKey, szValue, (DWORD) RESERVED, REG_DWORD,
803 (RegString)&lValue, sizeof(lValue));
804 if ( m_dwLastError == ERROR_SUCCESS )
805 return true;
806 }
807
808 wxLogSysError(m_dwLastError, _("Can't set value of '%s'"),
809 GetFullName(this, szValue));
810 return false;
811 }
812
813 bool wxRegKey::QueryValue(const wxChar *szValue, long *plValue) const
814 {
815 if ( CONST_CAST Open(Read) ) {
816 DWORD dwType, dwSize = sizeof(DWORD);
817 RegString pBuf = (RegString)plValue;
818 m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED,
819 &dwType, pBuf, &dwSize);
820 if ( m_dwLastError != ERROR_SUCCESS ) {
821 wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"),
822 GetName().c_str());
823 return false;
824 }
825 else {
826 // check that we read the value of right type
827 wxASSERT_MSG( IsNumericValue(szValue),
828 wxT("Type mismatch in wxRegKey::QueryValue().") );
829
830 return true;
831 }
832 }
833 else
834 return false;
835 }
836
837 bool wxRegKey::SetValue(const wxChar *szValue,const wxMemoryBuffer& buffer)
838 {
839 #ifdef __TWIN32__
840 wxFAIL_MSG("RegSetValueEx not implemented by TWIN32");
841 return false;
842 #else
843 if ( CONST_CAST Open() ) {
844 m_dwLastError = RegSetValueEx((HKEY) m_hKey, szValue, (DWORD) RESERVED, REG_BINARY,
845 (RegBinary)buffer.GetData(),buffer.GetDataLen());
846 if ( m_dwLastError == ERROR_SUCCESS )
847 return true;
848 }
849
850 wxLogSysError(m_dwLastError, _("Can't set value of '%s'"),
851 GetFullName(this, szValue));
852 return false;
853 #endif
854 }
855
856 bool wxRegKey::QueryValue(const wxChar *szValue, wxMemoryBuffer& buffer) const
857 {
858 if ( CONST_CAST Open(Read) ) {
859 // first get the type and size of the data
860 DWORD dwType, dwSize;
861 m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED,
862 &dwType, NULL, &dwSize);
863
864 if ( m_dwLastError == ERROR_SUCCESS ) {
865 if ( dwSize ) {
866 const RegBinary pBuf = (RegBinary)buffer.GetWriteBuf(dwSize);
867 m_dwLastError = RegQueryValueEx((HKEY) m_hKey,
868 WXSTRINGCAST szValue,
869 RESERVED,
870 &dwType,
871 pBuf,
872 &dwSize);
873 buffer.UngetWriteBuf(dwSize);
874 } else {
875 buffer.SetDataLen(0);
876 }
877 }
878
879
880 if ( m_dwLastError != ERROR_SUCCESS ) {
881 wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"),
882 GetName().c_str());
883 return false;
884 }
885 return true;
886 }
887 return false;
888 }
889
890
891
892 bool wxRegKey::QueryValue(const wxChar *szValue,
893 wxString& strValue,
894 bool WXUNUSED_IN_WINCE(raw)) const
895 {
896 if ( CONST_CAST Open(Read) )
897 {
898
899 // first get the type and size of the data
900 DWORD dwType=REG_NONE, dwSize=0;
901 m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED,
902 &dwType, NULL, &dwSize);
903 if ( m_dwLastError == ERROR_SUCCESS )
904 {
905 if ( !dwSize )
906 {
907 // must treat this case specially as GetWriteBuf() doesn't like
908 // being called with 0 size
909 strValue.Empty();
910 }
911 else
912 {
913 m_dwLastError = RegQueryValueEx((HKEY) m_hKey,
914 WXSTRINGCAST szValue,
915 RESERVED,
916 &dwType,
917 (RegString)(wxChar*)wxStringBuffer(strValue, dwSize),
918 &dwSize);
919
920 // expand the var expansions in the string unless disabled
921 #ifndef __WXWINCE__
922 if ( (dwType == REG_EXPAND_SZ) && !raw )
923 {
924 DWORD dwExpSize = ::ExpandEnvironmentStrings(strValue, NULL, 0);
925 bool ok = dwExpSize != 0;
926 if ( ok )
927 {
928 wxString strExpValue;
929 ok = ::ExpandEnvironmentStrings(strValue,
930 wxStringBuffer(strExpValue, dwExpSize),
931 dwExpSize
932 ) != 0;
933 strValue = strExpValue;
934 }
935
936 if ( !ok )
937 {
938 wxLogLastError(_T("ExpandEnvironmentStrings"));
939 }
940 }
941 #endif
942 // __WXWINCE__
943 }
944
945 if ( m_dwLastError == ERROR_SUCCESS )
946 {
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 // exporting registry keys to file
1095 // ----------------------------------------------------------------------------
1096
1097 #if wxUSE_STREAMS
1098
1099 // helper functions for writing ASCII strings (even in Unicode build)
1100 static inline bool WriteAsciiChar(wxOutputStream& ostr, char ch)
1101 {
1102 ostr.PutC(ch);
1103 return ostr.IsOk();
1104 }
1105
1106 static inline bool WriteAsciiEOL(wxOutputStream& ostr)
1107 {
1108 // as we open the file in text mode, it is enough to write LF without CR
1109 return WriteAsciiChar(ostr, '\n');
1110 }
1111
1112 static inline bool WriteAsciiString(wxOutputStream& ostr, const char *p)
1113 {
1114 return ostr.Write(p, strlen(p)).IsOk();
1115 }
1116
1117 static inline bool WriteAsciiString(wxOutputStream& ostr, const wxString& s)
1118 {
1119 #if wxUSE_UNICODE
1120 wxCharBuffer name(s.mb_str());
1121 ostr.Write(name, strlen(name));
1122 #else
1123 ostr.Write(s, s.length());
1124 #endif
1125
1126 return ostr.IsOk();
1127 }
1128
1129 #endif // wxUSE_STREAMS
1130
1131 bool wxRegKey::Export(const wxString& filename) const
1132 {
1133 #if wxUSE_FFILE && wxUSE_STREAMS
1134 if ( wxFile::Exists(filename) )
1135 {
1136 wxLogError(_("Exporting registry key: file \"%s\" already exists and won't be overwritten."),
1137 filename.c_str());
1138 return false;
1139 }
1140
1141 wxFFileOutputStream ostr(filename, _T("w"));
1142
1143 return ostr.Ok() && Export(ostr);
1144 #else
1145 wxUnusedVar(filename);
1146 return false;
1147 #endif
1148 }
1149
1150 #if wxUSE_STREAMS
1151 bool wxRegKey::Export(wxOutputStream& ostr) const
1152 {
1153 // write out the header
1154 if ( !WriteAsciiString(ostr, "REGEDIT4\n\n") )
1155 return false;
1156
1157 return DoExport(ostr);
1158 }
1159 #endif // wxUSE_STREAMS
1160
1161 static
1162 wxString
1163 FormatAsHex(const void *data,
1164 size_t size,
1165 wxRegKey::ValueType type = wxRegKey::Type_Binary)
1166 {
1167 wxString value(_T("hex"));
1168
1169 // binary values use just "hex:" prefix while the other ones must indicate
1170 // the real type
1171 if ( type != wxRegKey::Type_Binary )
1172 value << _T('(') << type << _T(')');
1173 value << _T(':');
1174
1175 // write all the rest as comma-separated bytes
1176 value.reserve(3*size + 10);
1177 const char * const p = wx_static_cast(const char *, data);
1178 for ( size_t n = 0; n < size; n++ )
1179 {
1180 // TODO: line wrapping: although not required by regedit, this makes
1181 // the generated files easier to read and compare with the files
1182 // produced by regedit
1183 if ( n )
1184 value << _T(',');
1185
1186 value << wxString::Format(_T("%02x"), (unsigned char)p[n]);
1187 }
1188
1189 return value;
1190 }
1191
1192 static inline
1193 wxString FormatAsHex(const wxString& value, wxRegKey::ValueType type)
1194 {
1195 return FormatAsHex(value.c_str(), value.length() + 1, type);
1196 }
1197
1198 wxString wxRegKey::FormatValue(const wxString& name) const
1199 {
1200 wxString rhs;
1201 const ValueType type = GetValueType(name);
1202 switch ( type )
1203 {
1204 case Type_String:
1205 {
1206 wxString value;
1207 if ( !QueryValue(name, value) )
1208 break;
1209
1210 // quotes and backslashes must be quoted, linefeeds are not
1211 // allowed in string values
1212 rhs.reserve(value.length() + 2);
1213 rhs = _T('"');
1214
1215 // there can be no NULs here
1216 bool useHex = false;
1217 for ( const wxChar *p = value.c_str(); *p && !useHex; p++ )
1218 {
1219 switch ( *p )
1220 {
1221 case _T('\n'):
1222 // we can only represent this string in hex
1223 useHex = true;
1224 break;
1225
1226 case _T('"'):
1227 case _T('\\'):
1228 // escape special symbol
1229 rhs += _T('\\');
1230 // fall through
1231
1232 default:
1233 rhs += *p;
1234 }
1235 }
1236
1237 if ( useHex )
1238 rhs = FormatAsHex(value, Type_String);
1239 else
1240 rhs += _T('"');
1241 }
1242 break;
1243
1244 case Type_Dword:
1245 /* case Type_Dword_little_endian: == Type_Dword */
1246 {
1247 long value;
1248 if ( !QueryValue(name, &value) )
1249 break;
1250
1251 rhs.Printf(_T("dword:%08x"), (unsigned int)value);
1252 }
1253 break;
1254
1255 case Type_Expand_String:
1256 case Type_Multi_String:
1257 {
1258 wxString value;
1259 if ( !QueryRawValue(name, value) )
1260 break;
1261
1262 rhs = FormatAsHex(value, type);
1263 }
1264 break;
1265
1266 case Type_Binary:
1267 {
1268 wxMemoryBuffer buf;
1269 if ( !QueryValue(name, buf) )
1270 break;
1271
1272 rhs = FormatAsHex(buf.GetData(), buf.GetDataLen());
1273 }
1274 break;
1275
1276 // no idea how those appear in REGEDIT4 files
1277 case Type_None:
1278 case Type_Dword_big_endian:
1279 case Type_Link:
1280 case Type_Resource_list:
1281 case Type_Full_resource_descriptor:
1282 case Type_Resource_requirements_list:
1283 default:
1284 wxLogWarning(_("Can't export value of unsupported type %d."), type);
1285 }
1286
1287 return rhs;
1288 }
1289
1290 #if wxUSE_STREAMS
1291
1292 bool wxRegKey::DoExportValue(wxOutputStream& ostr, const wxString& name) const
1293 {
1294 // first examine the value type: if it's unsupported, simply skip it
1295 // instead of aborting the entire export process because we failed to
1296 // export a single value
1297 wxString value = FormatValue(name);
1298 if ( value.empty() )
1299 {
1300 wxLogWarning(_("Ignoring value \"%s\" of the key \"%s\"."),
1301 name.c_str(), GetName().c_str());
1302 return true;
1303 }
1304
1305 // we do have the text representation of the value, now write everything
1306 // out
1307
1308 // special case: unnamed/default value is represented as just "@"
1309 if ( name.empty() )
1310 {
1311 if ( !WriteAsciiChar(ostr, '@') )
1312 return false;
1313 }
1314 else // normal, named, value
1315 {
1316 if ( !WriteAsciiChar(ostr, '"') ||
1317 !WriteAsciiString(ostr, name) ||
1318 !WriteAsciiChar(ostr, '"') )
1319 return false;
1320 }
1321
1322 if ( !WriteAsciiChar(ostr, '=') )
1323 return false;
1324
1325 return WriteAsciiString(ostr, value) && WriteAsciiEOL(ostr);
1326 }
1327
1328 bool wxRegKey::DoExport(wxOutputStream& ostr) const
1329 {
1330 // write out this key name
1331 if ( !WriteAsciiChar(ostr, '[') )
1332 return false;
1333
1334 if ( !WriteAsciiString(ostr, GetName(false /* no short prefix */)) )
1335 return false;
1336
1337 if ( !WriteAsciiChar(ostr, ']') || !WriteAsciiEOL(ostr) )
1338 return false;
1339
1340 // dump all our values
1341 long dummy;
1342 wxString name;
1343 wxRegKey& self = wx_const_cast(wxRegKey&, *this);
1344 bool cont = self.GetFirstValue(name, dummy);
1345 while ( cont )
1346 {
1347 if ( !DoExportValue(ostr, name) )
1348 return false;
1349
1350 cont = GetNextValue(name, dummy);
1351 }
1352
1353 // always terminate values by blank line, even if there were no values
1354 if ( !WriteAsciiEOL(ostr) )
1355 return false;
1356
1357 // recurse to subkeys
1358 cont = self.GetFirstKey(name, dummy);
1359 while ( cont )
1360 {
1361 wxRegKey subkey(*this, name);
1362 if ( !subkey.DoExport(ostr) )
1363 return false;
1364
1365 cont = GetNextKey(name, dummy);
1366 }
1367
1368 return true;
1369 }
1370
1371 #endif // wxUSE_STREAMS
1372
1373 // ============================================================================
1374 // implementation of global private functions
1375 // ============================================================================
1376
1377 bool KeyExists(WXHKEY hRootKey, const wxChar *szKey)
1378 {
1379 // don't close this key itself for the case of empty szKey!
1380 if ( wxIsEmpty(szKey) )
1381 return true;
1382
1383 HKEY hkeyDummy;
1384 if ( ::RegOpenKeyEx
1385 (
1386 (HKEY)hRootKey,
1387 szKey,
1388 RESERVED,
1389 KEY_READ, // we might not have enough rights for rw access
1390 &hkeyDummy
1391 ) == ERROR_SUCCESS )
1392 {
1393 ::RegCloseKey(hkeyDummy);
1394
1395 return true;
1396 }
1397
1398 return false;
1399 }
1400
1401 const wxChar *GetFullName(const wxRegKey *pKey, const wxChar *szValue)
1402 {
1403 static wxString s_str;
1404 s_str = pKey->GetName();
1405 if ( !wxIsEmpty(szValue) )
1406 s_str << wxT("\\") << szValue;
1407
1408 return s_str.c_str();
1409 }
1410
1411 void RemoveTrailingSeparator(wxString& str)
1412 {
1413 if ( !str.empty() && str.Last() == REG_SEPARATOR )
1414 str.Truncate(str.Len() - 1);
1415 }
1416
wxWidgets (Impactor)