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