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