]>
Commit | Line | Data |
---|---|---|
2bda0e17 KB |
1 | /////////////////////////////////////////////////////////////////////////////// |
2 | // Name: msw/registry.cpp | |
3 | // Purpose: implementation of registry classes and functions | |
4 | // Author: Vadim Zeitlin | |
23f681ec | 5 | // Modified by: |
2bda0e17 KB |
6 | // Created: 03.04.98 |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr> | |
65571936 | 9 | // Licence: wxWindows licence |
2bda0e17 KB |
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 | ||
14f355c2 | 15 | #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) |
27529614 JS |
16 | #pragma implementation "registry.h" |
17 | #endif | |
18 | ||
2bda0e17 KB |
19 | // for compilers that support precompilation, includes "wx.h". |
20 | #include "wx/wxprec.h" | |
21 | ||
22 | #ifdef __BORLANDC__ | |
23 | #pragma hdrstop | |
24 | #endif | |
25 | ||
77ffb593 | 26 | // other wxWidgets headers |
2bda0e17 KB |
27 | #include "wx/string.h" |
28 | #include "wx/intl.h" | |
29 | #include "wx/log.h" | |
20d8c319 VZ |
30 | #include "wx/file.h" |
31 | #include "wx/wfstream.h" | |
41286812 | 32 | |
2bda0e17 | 33 | // Windows headers |
9ed0d735 | 34 | #include "wx/msw/wrapwin.h" |
2bda0e17 | 35 | |
4676948b JS |
36 | #ifdef __WXWINCE__ |
37 | #include "wx/msw/private.h" | |
38 | #include <winbase.h> | |
39 | #include <winreg.h> | |
40 | #endif | |
41 | ||
2bda0e17 KB |
42 | // other std headers |
43 | #include <stdlib.h> // for _MAX_PATH | |
44 | ||
45 | #ifndef _MAX_PATH | |
225fe9d6 | 46 | #define _MAX_PATH 512 |
2bda0e17 KB |
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; | |
9b386eca | 55 | typedef BYTE* RegBinary; |
2bda0e17 KB |
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; | |
837e5743 OK |
66 | const wxChar *szName; |
67 | const wxChar *szShortName; | |
2bda0e17 | 68 | } |
23f681ec VZ |
69 | aStdKeys[] = |
70 | { | |
223d09f6 | 71 | { HKEY_CLASSES_ROOT, wxT("HKEY_CLASSES_ROOT"), wxT("HKCR") }, |
223d09f6 KB |
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? | |
4676948b | 75 | #ifndef __WXWINCE__ |
223d09f6 | 76 | { HKEY_PERFORMANCE_DATA, wxT("HKEY_PERFORMANCE_DATA"), wxT("HKPD") }, |
4676948b | 77 | #endif |
6f94aa86 | 78 | #ifdef HKEY_CURRENT_CONFIG |
223d09f6 | 79 | { HKEY_CURRENT_CONFIG, wxT("HKEY_CURRENT_CONFIG"), wxT("HKCC") }, |
6f94aa86 VZ |
80 | #endif |
81 | #ifdef HKEY_DYN_DATA | |
223d09f6 | 82 | { HKEY_DYN_DATA, wxT("HKEY_DYN_DATA"), wxT("HKDD") }, // short name? |
6f94aa86 | 83 | #endif |
2bda0e17 KB |
84 | }; |
85 | ||
86 | // the registry name separator (perhaps one day MS will change it to '/' ;-) | |
223d09f6 | 87 | #define REG_SEPARATOR wxT('\\') |
2bda0e17 | 88 | |
c86f1403 VZ |
89 | // useful for Windows programmers: makes somewhat more clear all these zeroes |
90 | // being passed to Windows APIs | |
007007c5 | 91 | #define RESERVED (0) |
c86f1403 | 92 | |
2bda0e17 KB |
93 | // ---------------------------------------------------------------------------- |
94 | // macros | |
95 | // ---------------------------------------------------------------------------- | |
807a903e VZ |
96 | |
97 | // const_cast<> is not yet supported by all compilers | |
2bda0e17 KB |
98 | #define CONST_CAST ((wxRegKey *)this)-> |
99 | ||
807a903e VZ |
100 | // and neither is mutable which m_dwLastError should be |
101 | #define m_dwLastError CONST_CAST m_dwLastError | |
2bda0e17 KB |
102 | |
103 | // ---------------------------------------------------------------------------- | |
104 | // non member functions | |
105 | // ---------------------------------------------------------------------------- | |
106 | ||
0b1c5a6c VZ |
107 | // removes the trailing backslash from the string if it has one |
108 | static inline void RemoveTrailingSeparator(wxString& str); | |
109 | ||
4d08943e | 110 | // returns true if given registry key exists |
837e5743 | 111 | static bool KeyExists(WXHKEY hRootKey, const wxChar *szKey); |
2bda0e17 KB |
112 | |
113 | // combines value and key name (uses static buffer!) | |
23f681ec | 114 | static const wxChar *GetFullName(const wxRegKey *pKey, |
837e5743 | 115 | const wxChar *szValue = NULL); |
2bda0e17 KB |
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 | |
23f681ec | 128 | // it would require casts in user code. |
837e5743 | 129 | const wxChar *wxRegKey::GetStdKeyName(size_t key) |
2bda0e17 KB |
130 | { |
131 | // return empty string if key is invalid | |
fda7962d | 132 | wxCHECK_MSG( key < nStdKeys, wxEmptyString, wxT("invalid key in wxRegKey::GetStdKeyName") ); |
2bda0e17 KB |
133 | |
134 | return aStdKeys[key].szName; | |
135 | } | |
136 | ||
837e5743 | 137 | const wxChar *wxRegKey::GetStdKeyShortName(size_t key) |
2bda0e17 KB |
138 | { |
139 | // return empty string if key is invalid | |
fda7962d | 140 | wxCHECK( key < nStdKeys, wxEmptyString ); |
2bda0e17 KB |
141 | |
142 | return aStdKeys[key].szShortName; | |
143 | } | |
144 | ||
145 | wxRegKey::StdKey wxRegKey::ExtractKeyName(wxString& strKey) | |
146 | { | |
b32719cc | 147 | wxString strRoot = strKey.BeforeFirst(REG_SEPARATOR); |
2bda0e17 | 148 | |
fd3f686c | 149 | HKEY hRootKey = 0; |
c86f1403 | 150 | size_t ui; |
2bda0e17 | 151 | for ( ui = 0; ui < nStdKeys; ui++ ) { |
23f681ec | 152 | if ( strRoot.CmpNoCase(aStdKeys[ui].szName) == 0 || |
2bda0e17 KB |
153 | strRoot.CmpNoCase(aStdKeys[ui].szShortName) == 0 ) { |
154 | hRootKey = aStdKeys[ui].hkey; | |
155 | break; | |
156 | } | |
157 | } | |
158 | ||
159 | if ( ui == nStdKeys ) { | |
223d09f6 | 160 | wxFAIL_MSG(wxT("invalid key prefix in wxRegKey::ExtractKeyName.")); |
2bda0e17 KB |
161 | |
162 | hRootKey = HKEY_CLASSES_ROOT; | |
163 | } | |
164 | else { | |
165 | strKey = strKey.After(REG_SEPARATOR); | |
532d575b | 166 | if ( !strKey.empty() && strKey.Last() == REG_SEPARATOR ) |
2bda0e17 KB |
167 | strKey.Truncate(strKey.Len() - 1); |
168 | } | |
169 | ||
170 | return (wxRegKey::StdKey)(int)hRootKey; | |
171 | } | |
172 | ||
fd6c844b | 173 | wxRegKey::StdKey wxRegKey::GetStdKeyFromHkey(WXHKEY hkey) |
2bda0e17 | 174 | { |
c86f1403 | 175 | for ( size_t ui = 0; ui < nStdKeys; ui++ ) { |
fd6c844b | 176 | if ( (int) aStdKeys[ui].hkey == (int) hkey ) |
2bda0e17 KB |
177 | return (StdKey)ui; |
178 | } | |
23f681ec | 179 | |
223d09f6 | 180 | wxFAIL_MSG(wxT("non root hkey passed to wxRegKey::GetStdKeyFromHkey.")); |
2bda0e17 KB |
181 | |
182 | return HKCR; | |
183 | } | |
184 | ||
185 | // ---------------------------------------------------------------------------- | |
186 | // ctors and dtor | |
187 | // ---------------------------------------------------------------------------- | |
188 | ||
189 | wxRegKey::wxRegKey() | |
190 | { | |
fd6c844b | 191 | m_hRootKey = (WXHKEY) aStdKeys[HKCR].hkey; |
807a903e VZ |
192 | |
193 | Init(); | |
2bda0e17 KB |
194 | } |
195 | ||
196 | wxRegKey::wxRegKey(const wxString& strKey) : m_strKey(strKey) | |
197 | { | |
fd6c844b | 198 | m_hRootKey = (WXHKEY) aStdKeys[ExtractKeyName(m_strKey)].hkey; |
807a903e VZ |
199 | |
200 | Init(); | |
2bda0e17 KB |
201 | } |
202 | ||
203 | // parent is a predefined (and preopened) key | |
204 | wxRegKey::wxRegKey(StdKey keyParent, const wxString& strKey) : m_strKey(strKey) | |
205 | { | |
0b1c5a6c | 206 | RemoveTrailingSeparator(m_strKey); |
fd6c844b | 207 | m_hRootKey = (WXHKEY) aStdKeys[keyParent].hkey; |
807a903e VZ |
208 | |
209 | Init(); | |
2bda0e17 KB |
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 | |
532d575b WS |
217 | if ( !m_strKey.empty() && |
218 | (strKey.empty() || strKey[0] != REG_SEPARATOR) ) { | |
32c66ea2 VZ |
219 | m_strKey += REG_SEPARATOR; |
220 | } | |
2bda0e17 KB |
221 | |
222 | m_strKey += strKey; | |
0b1c5a6c | 223 | RemoveTrailingSeparator(m_strKey); |
2bda0e17 KB |
224 | |
225 | m_hRootKey = keyParent.m_hRootKey; | |
807a903e VZ |
226 | |
227 | Init(); | |
2bda0e17 KB |
228 | } |
229 | ||
230 | // dtor closes the key releasing system resource | |
231 | wxRegKey::~wxRegKey() | |
232 | { | |
233 | Close(); | |
234 | } | |
235 | ||
0b1c5a6c VZ |
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; | |
fd6c844b | 246 | m_hRootKey = (WXHKEY) aStdKeys[ExtractKeyName(m_strKey)].hkey; |
0b1c5a6c VZ |
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); | |
fd6c844b | 256 | m_hRootKey = (WXHKEY) aStdKeys[keyParent].hkey; |
0b1c5a6c VZ |
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 | |
807a903e VZ |
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; | |
532d575b | 273 | if ( !strKey.empty() && strKey[0] != REG_SEPARATOR ) |
0b1c5a6c | 274 | m_strKey += REG_SEPARATOR; |
02569ba8 | 275 | m_strKey += strKey; |
0b1c5a6c VZ |
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 | |
fd6c844b | 283 | void wxRegKey::SetHkey(WXHKEY hKey) |
0b1c5a6c VZ |
284 | { |
285 | Close(); | |
286 | ||
287 | m_hKey = hKey; | |
288 | } | |
289 | ||
2bda0e17 KB |
290 | // ---------------------------------------------------------------------------- |
291 | // info about the key | |
292 | // ---------------------------------------------------------------------------- | |
293 | ||
4d08943e | 294 | // returns true if the key exists |
2bda0e17 KB |
295 | bool wxRegKey::Exists() const |
296 | { | |
297 | // opened key has to exist, try to open it if not done yet | |
4d08943e | 298 | return IsOpened() ? true : KeyExists(m_hRootKey, m_strKey); |
2bda0e17 KB |
299 | } |
300 | ||
301 | // returns the full name of the key (prefix is abbreviated if bShortPrefix) | |
302 | wxString wxRegKey::GetName(bool bShortPrefix) const | |
303 | { | |
333b7dac | 304 | StdKey key = GetStdKeyFromHkey((WXHKEY) m_hRootKey); |
23f681ec | 305 | wxString str = bShortPrefix ? aStdKeys[key].szShortName |
2bda0e17 | 306 | : aStdKeys[key].szName; |
532d575b | 307 | if ( !m_strKey.empty() ) |
2b5f62a0 | 308 | str << _T("\\") << m_strKey; |
2bda0e17 KB |
309 | |
310 | return str; | |
311 | } | |
312 | ||
23f681ec VZ |
313 | bool wxRegKey::GetKeyInfo(size_t *pnSubKeys, |
314 | size_t *pnMaxKeyLen, | |
315 | size_t *pnValues, | |
316 | size_t *pnMaxValueLen) const | |
02569ba8 | 317 | { |
23f681ec | 318 | // old gcc headers incorrectly prototype RegQueryInfoKey() |
ae090fdb | 319 | #if defined(__GNUWIN32_OLD__) && !defined(__CYGWIN10__) |
23f681ec VZ |
320 | #define REG_PARAM (size_t *) |
321 | #else | |
322 | #define REG_PARAM (LPDWORD) | |
323 | #endif | |
324 | ||
6dfec4b8 VZ |
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 | ||
02569ba8 VZ |
328 | m_dwLastError = ::RegQueryInfoKey |
329 | ( | |
fd6c844b | 330 | (HKEY) m_hKey, |
02569ba8 VZ |
331 | NULL, // class name |
332 | NULL, // (ptr to) size of class name buffer | |
333 | RESERVED, | |
23f681ec | 334 | REG_PARAM |
02569ba8 | 335 | pnSubKeys, // [out] number of subkeys |
23f681ec | 336 | REG_PARAM |
02569ba8 VZ |
337 | pnMaxKeyLen, // [out] max length of a subkey name |
338 | NULL, // longest subkey class name | |
23f681ec | 339 | REG_PARAM |
02569ba8 | 340 | pnValues, // [out] number of values |
23f681ec | 341 | REG_PARAM |
02569ba8 VZ |
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 | ||
23f681ec VZ |
348 | #undef REG_PARAM |
349 | ||
02569ba8 | 350 | if ( m_dwLastError != ERROR_SUCCESS ) { |
23f681ec | 351 | wxLogSysError(m_dwLastError, _("Can't get info about registry key '%s'"), |
02569ba8 | 352 | GetName().c_str()); |
4d08943e | 353 | return false; |
02569ba8 | 354 | } |
6dfec4b8 | 355 | |
4d08943e | 356 | return true; |
02569ba8 VZ |
357 | } |
358 | ||
2bda0e17 KB |
359 | // ---------------------------------------------------------------------------- |
360 | // operations | |
361 | // ---------------------------------------------------------------------------- | |
362 | ||
363 | // opens key (it's not an error to call Open() on an already opened key) | |
bee96abf | 364 | bool wxRegKey::Open(AccessMode mode) |
2bda0e17 | 365 | { |
8a8c41dd | 366 | if ( IsOpened() ) |
fb5e0dcf VZ |
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 | } | |
8a8c41dd VZ |
374 | |
375 | HKEY tmpKey; | |
376 | m_dwLastError = ::RegOpenKeyEx | |
377 | ( | |
378 | (HKEY) m_hRootKey, | |
379 | m_strKey, | |
380 | RESERVED, | |
bee96abf | 381 | mode == Read ? KEY_READ : KEY_ALL_ACCESS, |
8a8c41dd VZ |
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()); | |
4d08943e | 389 | return false; |
8a8c41dd | 390 | } |
2bda0e17 | 391 | |
fd6c844b | 392 | m_hKey = (WXHKEY) tmpKey; |
fb5e0dcf VZ |
393 | m_mode = mode; |
394 | ||
4d08943e | 395 | return true; |
2bda0e17 KB |
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!) | |
8a8c41dd | 402 | if ( !bOkIfExists && Exists() ) |
4d08943e | 403 | return false; |
2bda0e17 KB |
404 | |
405 | if ( IsOpened() ) | |
4d08943e | 406 | return true; |
2bda0e17 | 407 | |
fd6c844b | 408 | HKEY tmpKey; |
4676948b JS |
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 | |
fd6c844b | 420 | m_dwLastError = RegCreateKey((HKEY) m_hRootKey, m_strKey, &tmpKey); |
4676948b | 421 | #endif |
2bda0e17 | 422 | if ( m_dwLastError != ERROR_SUCCESS ) { |
23f681ec | 423 | wxLogSysError(m_dwLastError, _("Can't create registry key '%s'"), |
2bda0e17 | 424 | GetName().c_str()); |
4d08943e | 425 | return false; |
2bda0e17 KB |
426 | } |
427 | else | |
fd6c844b JS |
428 | { |
429 | m_hKey = (WXHKEY) tmpKey; | |
4d08943e | 430 | return true; |
fd6c844b | 431 | } |
2bda0e17 KB |
432 | } |
433 | ||
0b1c5a6c VZ |
434 | // close the key, it's not an error to call it when not opened |
435 | bool wxRegKey::Close() | |
436 | { | |
437 | if ( IsOpened() ) { | |
fd6c844b | 438 | m_dwLastError = RegCloseKey((HKEY) m_hKey); |
807a903e VZ |
439 | m_hKey = 0; |
440 | ||
0b1c5a6c | 441 | if ( m_dwLastError != ERROR_SUCCESS ) { |
23f681ec | 442 | wxLogSysError(m_dwLastError, _("Can't close registry key '%s'"), |
0b1c5a6c VZ |
443 | GetName().c_str()); |
444 | ||
4d08943e | 445 | return false; |
0b1c5a6c | 446 | } |
0b1c5a6c VZ |
447 | } |
448 | ||
4d08943e | 449 | return true; |
0b1c5a6c VZ |
450 | } |
451 | ||
23f681ec VZ |
452 | bool wxRegKey::RenameValue(const wxChar *szValueOld, const wxChar *szValueNew) |
453 | { | |
4d08943e | 454 | bool ok = true; |
23f681ec VZ |
455 | if ( HasValue(szValueNew) ) { |
456 | wxLogError(_("Registry value '%s' already exists."), szValueNew); | |
457 | ||
4d08943e | 458 | ok = false; |
23f681ec VZ |
459 | } |
460 | ||
225fe9d6 VZ |
461 | if ( !ok || |
462 | !CopyValue(szValueOld, *this, szValueNew) || | |
463 | !DeleteValue(szValueOld) ) { | |
23f681ec VZ |
464 | wxLogError(_("Failed to rename registry value '%s' to '%s'."), |
465 | szValueOld, szValueNew); | |
466 | ||
4d08943e | 467 | return false; |
23f681ec VZ |
468 | } |
469 | ||
4d08943e | 470 | return true; |
23f681ec VZ |
471 | } |
472 | ||
473 | bool wxRegKey::CopyValue(const wxChar *szValue, | |
474 | wxRegKey& keyDst, | |
475 | const wxChar *szValueNew) | |
476 | { | |
5af3f0ef VZ |
477 | if ( !szValueNew ) { |
478 | // by default, use the same name | |
479 | szValueNew = szValue; | |
480 | } | |
481 | ||
23f681ec VZ |
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 | ||
9b386eca | 498 | case Type_Binary: |
4d08943e WS |
499 | { |
500 | wxMemoryBuffer buf; | |
501 | return QueryValue(szValue,buf) && | |
502 | keyDst.SetValue(szValueNew,buf); | |
503 | } | |
20d8c319 | 504 | |
23f681ec VZ |
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) | |
23f681ec VZ |
509 | case Type_None: |
510 | case Type_Expand_String: | |
23f681ec VZ |
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: | |
23f681ec VZ |
517 | default: |
518 | wxLogError(_("Can't copy values of unsupported type %d."), | |
519 | GetValueType(szValue)); | |
4d08943e | 520 | return false; |
23f681ec VZ |
521 | } |
522 | } | |
523 | ||
225fe9d6 VZ |
524 | bool wxRegKey::Rename(const wxChar *szNewName) |
525 | { | |
532d575b | 526 | wxCHECK_MSG( !m_strKey.empty(), false, _T("registry hives can't be renamed") ); |
225fe9d6 VZ |
527 | |
528 | if ( !Exists() ) { | |
529 | wxLogError(_("Registry key '%s' does not exist, cannot rename it."), | |
530 | GetFullName(this)); | |
531 | ||
4d08943e | 532 | return false; |
225fe9d6 VZ |
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); | |
532d575b | 544 | if ( !strKey.empty() ) { |
225fe9d6 VZ |
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 | ||
4d08943e | 558 | bool ok = keyDst.Create(false /* fail if alredy exists */); |
225fe9d6 VZ |
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) | |
23f681ec VZ |
580 | { |
581 | // create the new key first | |
225fe9d6 | 582 | wxRegKey keyDst(szNewName); |
4d08943e | 583 | bool ok = keyDst.Create(false /* fail if alredy exists */); |
23f681ec VZ |
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 | { | |
4d08943e | 598 | bool ok = true; |
23f681ec VZ |
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; | |
f6bcfd97 | 608 | ok = key.Copy((const wxChar*) keyName); |
23f681ec VZ |
609 | |
610 | if ( ok ) | |
611 | bCont = GetNextKey(strKey, lIndex); | |
4d08943e WS |
612 | else |
613 | wxLogError(_("Failed to copy the registry subkey '%s' to '%s'."), | |
835ab90d | 614 | GetFullName(&key), keyName.c_str()); |
4d08943e | 615 | |
23f681ec VZ |
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 ) { | |
835ab90d VZ |
635 | wxLogError(_("Failed to copy the contents of registry key '%s' to '%s'."), |
636 | GetFullName(this), GetFullName(&keyDst)); | |
23f681ec VZ |
637 | } |
638 | ||
639 | return ok; | |
640 | } | |
641 | ||
0b1c5a6c VZ |
642 | // ---------------------------------------------------------------------------- |
643 | // delete keys/values | |
644 | // ---------------------------------------------------------------------------- | |
2bda0e17 KB |
645 | bool wxRegKey::DeleteSelf() |
646 | { | |
0b1c5a6c VZ |
647 | { |
648 | wxLogNull nolog; | |
649 | if ( !Open() ) { | |
650 | // it already doesn't exist - ok! | |
4d08943e | 651 | return true; |
0b1c5a6c VZ |
652 | } |
653 | } | |
654 | ||
90186e52 VZ |
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) | |
532d575b | 658 | if ( m_strKey.empty() || |
3cc487d1 VZ |
659 | ((m_hRootKey != (WXHKEY) aStdKeys[HKCR].hkey) && |
660 | (m_strKey.Find(REG_SEPARATOR) == wxNOT_FOUND)) ) { | |
835ab90d VZ |
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)); | |
90186e52 | 663 | |
4d08943e | 664 | return false; |
90186e52 VZ |
665 | } |
666 | ||
0b1c5a6c VZ |
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; | |
2bda0e17 KB |
670 | |
671 | wxString strKey; | |
672 | long lIndex; | |
673 | bool bCont = GetFirstKey(strKey, lIndex); | |
674 | while ( bCont ) { | |
0b1c5a6c | 675 | astrSubkeys.Add(strKey); |
2bda0e17 KB |
676 | |
677 | bCont = GetNextKey(strKey, lIndex); | |
678 | } | |
679 | ||
c86f1403 VZ |
680 | size_t nKeyCount = astrSubkeys.Count(); |
681 | for ( size_t nKey = 0; nKey < nKeyCount; nKey++ ) { | |
0b1c5a6c VZ |
682 | wxRegKey key(*this, astrSubkeys[nKey]); |
683 | if ( !key.DeleteSelf() ) | |
4d08943e | 684 | return false; |
0b1c5a6c VZ |
685 | } |
686 | ||
687 | // now delete this key itself | |
2bda0e17 KB |
688 | Close(); |
689 | ||
fd6c844b | 690 | m_dwLastError = RegDeleteKey((HKEY) m_hRootKey, m_strKey); |
86a7257f VZ |
691 | // deleting a key which doesn't exist is not considered an error |
692 | if ( m_dwLastError != ERROR_SUCCESS && | |
863e83fa | 693 | m_dwLastError != ERROR_FILE_NOT_FOUND ) { |
23f681ec | 694 | wxLogSysError(m_dwLastError, _("Can't delete key '%s'"), |
02569ba8 | 695 | GetName().c_str()); |
4d08943e | 696 | return false; |
2bda0e17 KB |
697 | } |
698 | ||
4d08943e | 699 | return true; |
2bda0e17 KB |
700 | } |
701 | ||
837e5743 | 702 | bool wxRegKey::DeleteKey(const wxChar *szKey) |
2bda0e17 KB |
703 | { |
704 | if ( !Open() ) | |
4d08943e | 705 | return false; |
2bda0e17 KB |
706 | |
707 | wxRegKey key(*this, szKey); | |
708 | return key.DeleteSelf(); | |
709 | } | |
710 | ||
837e5743 | 711 | bool wxRegKey::DeleteValue(const wxChar *szValue) |
2bda0e17 KB |
712 | { |
713 | if ( !Open() ) | |
4d08943e | 714 | return false; |
2bda0e17 | 715 | |
837e5743 | 716 | m_dwLastError = RegDeleteValue((HKEY) m_hKey, WXSTRINGCAST szValue); |
886dd7d2 VZ |
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) ) { | |
23f681ec | 721 | wxLogSysError(m_dwLastError, _("Can't delete value '%s' from key '%s'"), |
2bda0e17 | 722 | szValue, GetName().c_str()); |
4d08943e | 723 | return false; |
2bda0e17 | 724 | } |
2bda0e17 | 725 | |
4d08943e | 726 | return true; |
2bda0e17 KB |
727 | } |
728 | ||
729 | // ---------------------------------------------------------------------------- | |
730 | // access to values and subkeys | |
731 | // ---------------------------------------------------------------------------- | |
732 | ||
4d08943e | 733 | // return true if value exists |
837e5743 | 734 | bool wxRegKey::HasValue(const wxChar *szValue) const |
0b1c5a6c | 735 | { |
32c66ea2 VZ |
736 | // this function should be silent, so suppress possible messages from Open() |
737 | wxLogNull nolog; | |
23f681ec | 738 | |
d305f9df | 739 | if ( !CONST_CAST Open(Read) ) |
4d08943e | 740 | return false; |
f6bcfd97 BP |
741 | |
742 | LONG dwRet = ::RegQueryValueEx((HKEY) m_hKey, | |
743 | WXSTRINGCAST szValue, | |
744 | RESERVED, | |
745 | NULL, NULL, NULL); | |
746 | return dwRet == ERROR_SUCCESS; | |
0b1c5a6c VZ |
747 | } |
748 | ||
4d08943e | 749 | // returns true if this key has any values |
92049cd4 VZ |
750 | bool wxRegKey::HasValues() const |
751 | { | |
752 | // suppress possible messages from GetFirstValue() | |
753 | wxLogNull nolog; | |
23f681ec | 754 | |
92049cd4 VZ |
755 | // just call GetFirstValue with dummy parameters |
756 | wxString str; | |
757 | long l; | |
758 | return CONST_CAST GetFirstValue(str, l); | |
759 | } | |
760 | ||
4d08943e | 761 | // returns true if this key has any subkeys |
2bda0e17 KB |
762 | bool wxRegKey::HasSubkeys() const |
763 | { | |
c19a8a9a VZ |
764 | // suppress possible messages from GetFirstKey() |
765 | wxLogNull nolog; | |
23f681ec | 766 | |
2bda0e17 KB |
767 | // just call GetFirstKey with dummy parameters |
768 | wxString str; | |
769 | long l; | |
770 | return CONST_CAST GetFirstKey(str, l); | |
771 | } | |
772 | ||
4d08943e | 773 | // returns true if given subkey exists |
837e5743 | 774 | bool wxRegKey::HasSubKey(const wxChar *szKey) const |
2bda0e17 | 775 | { |
c19a8a9a VZ |
776 | // this function should be silent, so suppress possible messages from Open() |
777 | wxLogNull nolog; | |
23f681ec | 778 | |
d305f9df | 779 | if ( !CONST_CAST Open(Read) ) |
4d08943e | 780 | return false; |
f6bcfd97 BP |
781 | |
782 | return KeyExists(m_hKey, szKey); | |
2bda0e17 KB |
783 | } |
784 | ||
837e5743 | 785 | wxRegKey::ValueType wxRegKey::GetValueType(const wxChar *szValue) const |
2bda0e17 | 786 | { |
d305f9df | 787 | if ( ! CONST_CAST Open(Read) ) |
2bda0e17 KB |
788 | return Type_None; |
789 | ||
790 | DWORD dwType; | |
837e5743 | 791 | m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED, |
2bda0e17 KB |
792 | &dwType, NULL, NULL); |
793 | if ( m_dwLastError != ERROR_SUCCESS ) { | |
23f681ec | 794 | wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"), |
2bda0e17 KB |
795 | GetName().c_str()); |
796 | return Type_None; | |
797 | } | |
798 | ||
799 | return (ValueType)dwType; | |
2bda0e17 KB |
800 | } |
801 | ||
837e5743 | 802 | bool wxRegKey::SetValue(const wxChar *szValue, long lValue) |
2bda0e17 KB |
803 | { |
804 | if ( CONST_CAST Open() ) { | |
6b037754 | 805 | m_dwLastError = RegSetValueEx((HKEY) m_hKey, szValue, (DWORD) RESERVED, REG_DWORD, |
2bda0e17 KB |
806 | (RegString)&lValue, sizeof(lValue)); |
807 | if ( m_dwLastError == ERROR_SUCCESS ) | |
4d08943e | 808 | return true; |
2bda0e17 KB |
809 | } |
810 | ||
23f681ec | 811 | wxLogSysError(m_dwLastError, _("Can't set value of '%s'"), |
2bda0e17 | 812 | GetFullName(this, szValue)); |
4d08943e | 813 | return false; |
2bda0e17 KB |
814 | } |
815 | ||
837e5743 | 816 | bool wxRegKey::QueryValue(const wxChar *szValue, long *plValue) const |
2bda0e17 | 817 | { |
d305f9df | 818 | if ( CONST_CAST Open(Read) ) { |
2bda0e17 KB |
819 | DWORD dwType, dwSize = sizeof(DWORD); |
820 | RegString pBuf = (RegString)plValue; | |
837e5743 | 821 | m_dwLastError = RegQueryValueEx((HKEY) m_hKey, WXSTRINGCAST szValue, RESERVED, |
2bda0e17 KB |
822 | &dwType, pBuf, &dwSize); |
823 | if ( m_dwLastError != ERROR_SUCCESS ) { | |
23f681ec | 824 | wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"), |
2bda0e17 | 825 | GetName().c_str()); |
4d08943e | 826 | return false; |
2bda0e17 KB |
827 | } |
828 | else { | |
829 | // check that we read the value of right type | |
23f681ec | 830 | wxASSERT_MSG( IsNumericValue(szValue), |
223d09f6 | 831 | wxT("Type mismatch in wxRegKey::QueryValue().") ); |
2bda0e17 | 832 | |
4d08943e | 833 | return true; |
2bda0e17 KB |
834 | } |
835 | } | |
836 | else | |
4d08943e | 837 | return false; |
2bda0e17 KB |
838 | } |
839 | ||
9b386eca RG |
840 | bool wxRegKey::SetValue(const wxChar *szValue,const wxMemoryBuffer& buffer) |
841 | { | |
842 | #ifdef __TWIN32__ | |
843 | wxFAIL_MSG("RegSetValueEx not implemented by TWIN32"); | |
4d08943e | 844 | return false; |
9b386eca RG |
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 ) | |
4d08943e | 850 | return true; |
9b386eca RG |
851 | } |
852 | ||
853 | wxLogSysError(m_dwLastError, _("Can't set value of '%s'"), | |
854 | GetFullName(this, szValue)); | |
4d08943e | 855 | return false; |
9b386eca RG |
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); | |
4d08943e | 866 | |
9b386eca RG |
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); | |
4d08943e WS |
877 | } else { |
878 | buffer.SetDataLen(0); | |
9b386eca RG |
879 | } |
880 | } | |
881 | ||
4d08943e | 882 | |
9b386eca RG |
883 | if ( m_dwLastError != ERROR_SUCCESS ) { |
884 | wxLogSysError(m_dwLastError, _("Can't read value of key '%s'"), | |
885 | GetName().c_str()); | |
4d08943e | 886 | return false; |
9b386eca | 887 | } |
4d08943e | 888 | return true; |
9b386eca | 889 | } |
4d08943e | 890 | return false; |
9b386eca RG |
891 | } |
892 | ||
893 | ||
894 | ||
6dfec4b8 VZ |
895 | bool wxRegKey::QueryValue(const wxChar *szValue, |
896 | wxString& strValue, | |
0c0d1521 | 897 | bool WXUNUSED_IN_WINCE(raw)) const |
2bda0e17 | 898 | { |
0c0d1521 WS |
899 | if ( CONST_CAST Open(Read) ) |
900 | { | |
6dfec4b8 | 901 | |
0c0d1521 WS |
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 ) | |
6dfec4b8 | 909 | { |
0c0d1521 WS |
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 ) | |
6dfec4b8 | 926 | { |
0c0d1521 WS |
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 | } | |
6dfec4b8 | 943 | } |
4676948b | 944 | #endif |
0c0d1521 WS |
945 | // __WXWINCE__ |
946 | } | |
23f681ec | 947 | |
0c0d1521 WS |
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().") ); | |
2bda0e17 | 953 | |
0c0d1521 WS |
954 | return true; |
955 | } | |
2bda0e17 | 956 | } |
0c0d1521 | 957 | } |
2bda0e17 | 958 | |
0c0d1521 WS |
959 | wxLogSysError(m_dwLastError, _("Can't read value of '%s'"), |
960 | GetFullName(this, szValue)); | |
961 | return false; | |
2bda0e17 KB |
962 | } |
963 | ||
837e5743 | 964 | bool wxRegKey::SetValue(const wxChar *szValue, const wxString& strValue) |
2bda0e17 KB |
965 | { |
966 | if ( CONST_CAST Open() ) { | |
6b037754 | 967 | m_dwLastError = RegSetValueEx((HKEY) m_hKey, szValue, (DWORD) RESERVED, REG_SZ, |
23f681ec | 968 | (RegString)strValue.c_str(), |
f6bcfd97 | 969 | (strValue.Len() + 1)*sizeof(wxChar)); |
2bda0e17 | 970 | if ( m_dwLastError == ERROR_SUCCESS ) |
4d08943e | 971 | return true; |
2bda0e17 KB |
972 | } |
973 | ||
23f681ec | 974 | wxLogSysError(m_dwLastError, _("Can't set value of '%s'"), |
2bda0e17 | 975 | GetFullName(this, szValue)); |
4d08943e | 976 | return false; |
2bda0e17 KB |
977 | } |
978 | ||
50e42404 | 979 | wxString wxRegKey::QueryDefaultValue() const |
2bda0e17 KB |
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 | ||
2bda0e17 KB |
992 | bool wxRegKey::GetFirstValue(wxString& strValueName, long& lIndex) |
993 | { | |
d305f9df | 994 | if ( !Open(Read) ) |
4d08943e | 995 | return false; |
2bda0e17 KB |
996 | |
997 | lIndex = 0; | |
0b1c5a6c | 998 | return GetNextValue(strValueName, lIndex); |
2bda0e17 KB |
999 | } |
1000 | ||
1001 | bool wxRegKey::GetNextValue(wxString& strValueName, long& lIndex) const | |
1002 | { | |
1003 | wxASSERT( IsOpened() ); | |
2bda0e17 | 1004 | |
0b1c5a6c VZ |
1005 | // are we already at the end of enumeration? |
1006 | if ( lIndex == -1 ) | |
4d08943e | 1007 | return false; |
2bda0e17 | 1008 | |
837e5743 | 1009 | wxChar szValueName[1024]; // @@ use RegQueryInfoKey... |
0b1c5a6c | 1010 | DWORD dwValueLen = WXSIZEOF(szValueName); |
2bda0e17 | 1011 | |
92049cd4 | 1012 | m_dwLastError = RegEnumValue((HKEY) m_hKey, lIndex++, |
0b1c5a6c | 1013 | szValueName, &dwValueLen, |
23f681ec VZ |
1014 | RESERVED, |
1015 | NULL, // [out] type | |
0b1c5a6c VZ |
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 { | |
23f681ec | 1025 | wxLogSysError(m_dwLastError, _("Can't enumerate values of key '%s'"), |
0b1c5a6c VZ |
1026 | GetName().c_str()); |
1027 | } | |
1028 | ||
4d08943e | 1029 | return false; |
2bda0e17 KB |
1030 | } |
1031 | ||
0b1c5a6c | 1032 | strValueName = szValueName; |
0b1c5a6c | 1033 | |
4d08943e | 1034 | return true; |
2bda0e17 | 1035 | } |
2bda0e17 KB |
1036 | |
1037 | bool wxRegKey::GetFirstKey(wxString& strKeyName, long& lIndex) | |
1038 | { | |
d305f9df | 1039 | if ( !Open(Read) ) |
4d08943e | 1040 | return false; |
2bda0e17 | 1041 | |
2bda0e17 | 1042 | lIndex = 0; |
0b1c5a6c | 1043 | return GetNextKey(strKeyName, lIndex); |
2bda0e17 KB |
1044 | } |
1045 | ||
1046 | bool wxRegKey::GetNextKey(wxString& strKeyName, long& lIndex) const | |
1047 | { | |
1048 | wxASSERT( IsOpened() ); | |
0b1c5a6c VZ |
1049 | |
1050 | // are we already at the end of enumeration? | |
1051 | if ( lIndex == -1 ) | |
4d08943e | 1052 | return false; |
2bda0e17 | 1053 | |
837e5743 | 1054 | wxChar szKeyName[_MAX_PATH + 1]; |
4676948b JS |
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 | |
fd6c844b | 1061 | m_dwLastError = RegEnumKey((HKEY) m_hKey, lIndex++, szKeyName, WXSIZEOF(szKeyName)); |
4676948b | 1062 | #endif |
2bda0e17 KB |
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 { | |
23f681ec | 1070 | wxLogSysError(m_dwLastError, _("Can't enumerate subkeys of key '%s'"), |
2bda0e17 KB |
1071 | GetName().c_str()); |
1072 | } | |
1073 | ||
4d08943e | 1074 | return false; |
2bda0e17 KB |
1075 | } |
1076 | ||
1077 | strKeyName = szKeyName; | |
4d08943e | 1078 | return true; |
2bda0e17 KB |
1079 | } |
1080 | ||
4d08943e | 1081 | // returns true if the value contains a number (else it's some string) |
837e5743 | 1082 | bool wxRegKey::IsNumericValue(const wxChar *szValue) const |
4d08943e WS |
1083 | { |
1084 | ValueType type = GetValueType(szValue); | |
1085 | switch ( type ) { | |
03ab016d | 1086 | case Type_Dword: |
23f681ec | 1087 | /* case Type_Dword_little_endian: == Type_Dword */ |
03ab016d | 1088 | case Type_Dword_big_endian: |
4d08943e | 1089 | return true; |
03ab016d JS |
1090 | |
1091 | default: | |
4d08943e WS |
1092 | return false; |
1093 | } | |
1094 | } | |
03ab016d | 1095 | |
20d8c319 VZ |
1096 | // ---------------------------------------------------------------------------- |
1097 | // exporting registry keys to file | |
1098 | // ---------------------------------------------------------------------------- | |
1099 | ||
532d575b WS |
1100 | #if wxUSE_STREAMS |
1101 | ||
20d8c319 VZ |
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 | ||
532d575b WS |
1132 | #endif // wxUSE_STREAMS |
1133 | ||
20d8c319 VZ |
1134 | bool wxRegKey::Export(const wxString& filename) const |
1135 | { | |
532d575b | 1136 | #if wxUSE_FFILE && wxUSE_STREAMS |
20d8c319 VZ |
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); | |
532d575b WS |
1147 | #else |
1148 | wxUnusedVar(filename); | |
1149 | return false; | |
1150 | #endif | |
20d8c319 VZ |
1151 | } |
1152 | ||
532d575b | 1153 | #if wxUSE_STREAMS |
20d8c319 VZ |
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 | } | |
532d575b | 1162 | #endif // wxUSE_STREAMS |
20d8c319 VZ |
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 | ||
f1a9125b | 1189 | value << wxString::Format(_T("%02x"), (unsigned char)p[n]); |
20d8c319 VZ |
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 | ||
04a18b0d | 1254 | rhs.Printf(_T("dword:%08x"), (unsigned int)value); |
20d8c319 VZ |
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 | ||
532d575b WS |
1293 | #if wxUSE_STREAMS |
1294 | ||
20d8c319 VZ |
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 | ||
532d575b WS |
1374 | #endif // wxUSE_STREAMS |
1375 | ||
2bda0e17 | 1376 | // ============================================================================ |
1880e452 | 1377 | // implementation of global private functions |
2bda0e17 | 1378 | // ============================================================================ |
f6bcfd97 | 1379 | |
837e5743 | 1380 | bool KeyExists(WXHKEY hRootKey, const wxChar *szKey) |
2bda0e17 | 1381 | { |
8a8c41dd VZ |
1382 | // don't close this key itself for the case of empty szKey! |
1383 | if ( wxIsEmpty(szKey) ) | |
4d08943e | 1384 | return true; |
8a8c41dd VZ |
1385 | |
1386 | HKEY hkeyDummy; | |
1387 | if ( ::RegOpenKeyEx | |
1388 | ( | |
1389 | (HKEY)hRootKey, | |
1390 | szKey, | |
1391 | RESERVED, | |
bee96abf | 1392 | KEY_READ, // we might not have enough rights for rw access |
8a8c41dd VZ |
1393 | &hkeyDummy |
1394 | ) == ERROR_SUCCESS ) | |
1395 | { | |
1396 | ::RegCloseKey(hkeyDummy); | |
1397 | ||
4d08943e | 1398 | return true; |
8a8c41dd | 1399 | } |
f6bcfd97 | 1400 | |
4d08943e | 1401 | return false; |
2bda0e17 KB |
1402 | } |
1403 | ||
837e5743 | 1404 | const wxChar *GetFullName(const wxRegKey *pKey, const wxChar *szValue) |
2bda0e17 KB |
1405 | { |
1406 | static wxString s_str; | |
1407 | s_str = pKey->GetName(); | |
837e5743 | 1408 | if ( !wxIsEmpty(szValue) ) |
223d09f6 | 1409 | s_str << wxT("\\") << szValue; |
2bda0e17 KB |
1410 | |
1411 | return s_str.c_str(); | |
0b1c5a6c VZ |
1412 | } |
1413 | ||
1414 | void RemoveTrailingSeparator(wxString& str) | |
1415 | { | |
532d575b | 1416 | if ( !str.empty() && str.Last() == REG_SEPARATOR ) |
0b1c5a6c VZ |
1417 | str.Truncate(str.Len() - 1); |
1418 | } | |
3d05544e | 1419 |