]>
git.saurik.com Git - wxWidgets.git/blob - src/msw/regconf.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: msw/regconf.cpp
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows license
10 ///////////////////////////////////////////////////////////////////////////////
13 #pragma implementation "regconf.h"
16 // For compilers that support precompilation, includes "wx.h".
17 #include "wx/wxprec.h"
24 #include "wx/string.h"
33 #include "wx/config.h"
37 #include "wx/msw/registry.h"
38 #include "wx/msw/regconf.h"
40 // ----------------------------------------------------------------------------
42 // ----------------------------------------------------------------------------
44 // we put our data in HKLM\SOFTWARE_KEY\appname
45 #define SOFTWARE_KEY wxString("Software\\")
47 // ----------------------------------------------------------------------------
49 // ----------------------------------------------------------------------------
51 // get the value if the key is opened and it exists
52 bool TryGetValue(const wxRegKey
& key
, const wxString
& str
, wxString
& strVal
)
54 return key
.IsOpened() && key
.HasValue(str
) && key
.QueryValue(str
, strVal
);
57 bool TryGetValue(const wxRegKey
& key
, const wxString
& str
, long *plVal
)
59 return key
.IsOpened() && key
.HasValue(str
) && key
.QueryValue(str
, plVal
);
62 // ============================================================================
64 // ============================================================================
66 // ----------------------------------------------------------------------------
68 // ----------------------------------------------------------------------------
70 // create the config object which stores its data under HKCU\vendor\app and, if
71 // style & wxCONFIG_USE_GLOBAL_FILE, under HKLM\vendor\app
72 wxRegConfig::wxRegConfig(const wxString
& appName
, const wxString
& vendorName
,
73 const wxString
& strLocal
, const wxString
& strGlobal
,
75 : wxConfigBase(appName
, vendorName
, strLocal
, strGlobal
, style
)
79 bool bDoUseGlobal
= (style
& wxCONFIG_USE_GLOBAL_FILE
) != 0;
81 // the convention is to put the programs keys under <vendor>\<appname>
82 // (but it can be overriden by specifying the pathes explicitly in strLocal
84 if ( strLocal
.IsEmpty() || (strGlobal
.IsEmpty() && bDoUseGlobal
) )
86 if ( vendorName
.IsEmpty() )
89 strRoot
= wxTheApp
->GetVendorName();
96 // no '\\' needed if no vendor name
97 if ( !strRoot
.IsEmpty() )
102 if ( appName
.IsEmpty() )
104 wxCHECK_RET( wxTheApp
, wxT("No application name in wxRegConfig ctor!") );
105 strRoot
<< wxTheApp
->GetAppName();
112 //else: we don't need to do all the complicated stuff above
114 wxString str
= strLocal
.IsEmpty() ? strRoot
: strLocal
;
115 m_keyLocalRoot
.SetName(wxRegKey::HKCU
, SOFTWARE_KEY
+ str
);
116 m_keyLocal
.SetName(m_keyLocalRoot
, "");
120 str
= strGlobal
.IsEmpty() ? strRoot
: strGlobal
;
121 m_keyGlobalRoot
.SetName(wxRegKey::HKLM
, SOFTWARE_KEY
+ str
);
122 m_keyGlobal
.SetName(m_keyGlobalRoot
, "");
125 // Create() will Open() if key already exists
126 m_keyLocalRoot
.Create();
128 // as it's the same key, Open() shouldn't fail (i.e. no need for Create())
131 // OTOH, this key may perfectly not exist, so suppress error messages the call
132 // to Open() might generate
136 m_keyGlobalRoot
.Open();
140 wxRegConfig::~wxRegConfig()
142 // nothing to do - key will be closed in their dtors
145 // ----------------------------------------------------------------------------
147 // ----------------------------------------------------------------------------
148 void wxRegConfig::SetPath(const wxString
& strPath
)
150 wxArrayString aParts
;
152 // because GetPath() returns "" when we're at root, we must understand
153 // empty string as "/"
154 if ( strPath
.IsEmpty() || (strPath
[0] == wxCONFIG_PATH_SEPARATOR
) ) {
156 wxSplitPath(aParts
, strPath
);
159 // relative path, combine with current one
160 wxString strFullPath
= GetPath();
161 strFullPath
<< wxCONFIG_PATH_SEPARATOR
<< strPath
;
162 wxSplitPath(aParts
, strFullPath
);
165 // recombine path parts in one variable
166 wxString strOldPath
= m_strPath
, strRegPath
;
168 for ( size_t n
= 0; n
< aParts
.Count(); n
++ ) {
169 strRegPath
<< '\\' << aParts
[n
];
170 m_strPath
<< wxCONFIG_PATH_SEPARATOR
<< aParts
[n
];
173 if ( m_strPath
== strOldPath
)
176 // as we create the registry key when SetPath(key) is done, we can be left
177 // with plenty of empty keys if this was only done to try to read some value
178 // which, in fact, doesn't exist - to prevent this from happening we
179 // automatically delete the old key if it was empty
180 if ( m_keyLocal
.IsEmpty() )
182 m_keyLocal
.DeleteSelf();
185 // change current key(s)
186 m_keyLocal
.SetName(m_keyLocalRoot
, strRegPath
);
187 m_keyGlobal
.SetName(m_keyGlobalRoot
, strRegPath
);
194 // ----------------------------------------------------------------------------
195 // enumeration (works only with current group)
196 // ----------------------------------------------------------------------------
199 We want to enumerate all local keys/values after the global ones, but, of
200 course, we don't want to repeat a key which appears locally as well as
203 We use the 15th bit of lIndex for distinction between global and local.
206 #define LOCAL_MASK 0x8000
207 #define IS_LOCAL_INDEX(l) (((l) & LOCAL_MASK) != 0)
209 bool wxRegConfig::GetFirstGroup(wxString
& str
, long& lIndex
) const
212 return GetNextGroup(str
, lIndex
);
215 bool wxRegConfig::GetNextGroup(wxString
& str
, long& lIndex
) const
217 // are we already enumerating local entries?
218 if ( m_keyGlobal
.IsOpened() && !IS_LOCAL_INDEX(lIndex
) ) {
219 // try to find a global entry which doesn't appear locally
220 while ( m_keyGlobal
.GetNextKey(str
, lIndex
) ) {
221 if ( !m_keyLocal
.HasSubKey(str
) ) {
222 // ok, found one - return it
227 // no more global entries
228 lIndex
|= LOCAL_MASK
;
231 // much easier with local entries: get the next one we find
232 // (don't forget to clear our flag bit and set it again later)
233 lIndex
&= ~LOCAL_MASK
;
234 bool bOk
= m_keyLocal
.GetNextKey(str
, lIndex
);
235 lIndex
|= LOCAL_MASK
;
240 bool wxRegConfig::GetFirstEntry(wxString
& str
, long& lIndex
) const
243 return GetNextEntry(str
, lIndex
);
246 bool wxRegConfig::GetNextEntry(wxString
& str
, long& lIndex
) const
248 // are we already enumerating local entries?
249 if ( m_keyGlobal
.IsOpened() && !IS_LOCAL_INDEX(lIndex
) ) {
250 // try to find a global entry which doesn't appear locally
251 while ( m_keyGlobal
.GetNextValue(str
, lIndex
) ) {
252 if ( !m_keyLocal
.HasValue(str
) ) {
253 // ok, found one - return it
258 // no more global entries
259 lIndex
|= LOCAL_MASK
;
262 // much easier with local entries: get the next one we find
263 // (don't forget to clear our flag bit and set it again later)
264 lIndex
&= ~LOCAL_MASK
;
265 bool bOk
= m_keyLocal
.GetNextValue(str
, lIndex
);
266 lIndex
|= LOCAL_MASK
;
271 size_t wxRegConfig::GetNumberOfEntries(bool bRecursive
) const
278 bool bCont
= ((wxRegConfig
*)this)->GetFirstEntry(str
, l
);
282 bCont
= ((wxRegConfig
*)this)->GetNextEntry(str
, l
);
288 size_t wxRegConfig::GetNumberOfGroups(bool bRecursive
) const
295 bool bCont
= ((wxRegConfig
*)this)->GetFirstGroup(str
, l
);
299 bCont
= ((wxRegConfig
*)this)->GetNextGroup(str
, l
);
305 // ----------------------------------------------------------------------------
306 // tests for existence
307 // ----------------------------------------------------------------------------
309 bool wxRegConfig::HasGroup(const wxString
& key
) const
311 wxConfigPathChanger
path(this, key
);
313 wxString
strName(path
.Name());
315 return m_keyLocal
.HasSubKey(strName
) || m_keyGlobal
.HasSubKey(strName
);
318 bool wxRegConfig::HasEntry(const wxString
& key
) const
320 wxConfigPathChanger
path(this, key
);
322 wxString
strName(path
.Name());
324 return m_keyLocal
.HasValue(strName
) || m_keyGlobal
.HasValue(strName
);
327 wxConfigBase::EntryType
wxRegConfig::GetEntryType(const wxString
& key
) const
329 wxConfigPathChanger
path(this, key
);
331 wxString
strName(path
.Name());
334 if ( m_keyLocal
.HasValue(strName
) )
335 isNumeric
= m_keyLocal
.IsNumericValue(strName
);
336 else if ( m_keyGlobal
.HasValue(strName
) )
337 isNumeric
= m_keyGlobal
.IsNumericValue(strName
);
339 return wxConfigBase::Type_Unknown
;
341 return isNumeric
? wxConfigBase::Type_Integer
: wxConfigBase::Type_String
;
344 // ----------------------------------------------------------------------------
346 // ----------------------------------------------------------------------------
348 bool wxRegConfig::Read(const wxString
& key
, wxString
*pStr
) const
350 wxConfigPathChanger
path(this, key
);
352 bool bQueryGlobal
= TRUE
;
354 // if immutable key exists in global key we must check that it's not
355 // overriden by the local key with the same name
356 if ( IsImmutable(path
.Name()) ) {
357 if ( TryGetValue(m_keyGlobal
, path
.Name(), *pStr
) ) {
358 if ( m_keyLocal
.HasValue(path
.Name()) ) {
359 wxLogWarning(wxT("User value for immutable key '%s' ignored."),
360 path
.Name().c_str());
362 *pStr
= wxConfigBase::ExpandEnvVars(*pStr
);
366 // don't waste time - it's not there anyhow
367 bQueryGlobal
= FALSE
;
371 // first try local key
372 if ( TryGetValue(m_keyLocal
, path
.Name(), *pStr
) ||
373 (bQueryGlobal
&& TryGetValue(m_keyGlobal
, path
.Name(), *pStr
)) ) {
376 *pStr
= wxConfigBase::ExpandEnvVars(*pStr
);
383 bool wxRegConfig::Read(const wxString
& key
, wxString
*pStr
,
384 const wxString
& szDefault
) const
386 wxConfigPathChanger
path(this, key
);
388 bool bQueryGlobal
= TRUE
;
390 // if immutable key exists in global key we must check that it's not
391 // overriden by the local key with the same name
392 if ( IsImmutable(path
.Name()) ) {
393 if ( TryGetValue(m_keyGlobal
, path
.Name(), *pStr
) ) {
394 if ( m_keyLocal
.HasValue(path
.Name()) ) {
395 wxLogWarning(wxT("User value for immutable key '%s' ignored."),
396 path
.Name().c_str());
402 // don't waste time - it's not there anyhow
403 bQueryGlobal
= FALSE
;
407 // first try local key
408 if ( TryGetValue(m_keyLocal
, path
.Name(), *pStr
) ||
409 (bQueryGlobal
&& TryGetValue(m_keyGlobal
, path
.Name(), *pStr
)) ) {
410 *pStr
= wxConfigBase::ExpandEnvVars(*pStr
);
414 if ( IsRecordingDefaults() ) {
415 ((wxRegConfig
*)this)->Write(key
, szDefault
);
422 *pStr
= wxConfigBase::ExpandEnvVars(*pStr
);
427 bool wxRegConfig::Read(const wxString
& key
, long *plResult
) const
429 wxConfigPathChanger
path(this, key
);
431 bool bQueryGlobal
= TRUE
;
433 // if immutable key exists in global key we must check that it's not
434 // overriden by the local key with the same name
435 if ( IsImmutable(path
.Name()) ) {
436 if ( TryGetValue(m_keyGlobal
, path
.Name(), plResult
) ) {
437 if ( m_keyLocal
.HasValue(path
.Name()) ) {
438 wxLogWarning(wxT("User value for immutable key '%s' ignored."),
439 path
.Name().c_str());
445 // don't waste time - it's not there anyhow
446 bQueryGlobal
= FALSE
;
450 // first try local key
451 if ( TryGetValue(m_keyLocal
, path
.Name(), plResult
) ||
452 (bQueryGlobal
&& TryGetValue(m_keyGlobal
, path
.Name(), plResult
)) ) {
458 bool wxRegConfig::Write(const wxString
& key
, const wxString
& szValue
)
460 wxConfigPathChanger
path(this, key
);
462 if ( IsImmutable(path
.Name()) ) {
463 wxLogError(wxT("Can't change immutable entry '%s'."), path
.Name().c_str());
467 return m_keyLocal
.SetValue(path
.Name(), szValue
);
470 bool wxRegConfig::Write(const wxString
& key
, long lValue
)
472 wxConfigPathChanger
path(this, key
);
474 if ( IsImmutable(path
.Name()) ) {
475 wxLogError(wxT("Can't change immutable entry '%s'."), path
.Name().c_str());
479 return m_keyLocal
.SetValue(path
.Name(), lValue
);
482 // ----------------------------------------------------------------------------
484 // ----------------------------------------------------------------------------
486 bool wxRegConfig::RenameEntry(const wxString
& oldName
, const wxString
& newName
)
488 // check that the old entry exists...
489 if ( !HasEntry(oldName
) )
492 // and that the new one doesn't
493 if ( HasEntry(newName
) )
496 // delete the old entry and create the new one - but do in the reverse
497 // order to not lose the data if Create() fails
500 if ( m_keyLocal
.IsNumericValue(oldName
) )
503 ok
= m_keyLocal
.QueryValue(oldName
, &val
) &&
504 m_keyLocal
.SetValue(newName
, val
);
509 ok
= m_keyLocal
.QueryValue(oldName
, val
) &&
510 m_keyLocal
.SetValue(newName
, val
);
516 if ( !m_keyLocal
.DeleteValue(oldName
) )
518 m_keyLocal
.DeleteValue(newName
);
526 bool wxRegConfig::RenameGroup(const wxString
& oldName
, const wxString
& newName
)
528 // check that the old group exists...
529 if ( !HasGroup(oldName
) )
532 // and that the new one doesn't
533 if ( HasGroup(newName
) )
536 // TODO there is no way to rename a registry key - we must do a deep copy
538 wxFAIL_MSG(wxT("Registry key renaming not implemented"));
543 // ----------------------------------------------------------------------------
545 // ----------------------------------------------------------------------------
546 bool wxRegConfig::DeleteEntry(const wxString
& value
, bool bGroupIfEmptyAlso
)
548 wxConfigPathChanger
path(this, value
);
550 if ( !m_keyLocal
.DeleteValue(path
.Name()) )
553 if ( m_keyLocal
.IsEmpty() ) {
554 wxString strKey
= GetPath().AfterLast(wxCONFIG_PATH_SEPARATOR
);
555 SetPath(".."); // changes m_keyLocal
556 return m_keyLocal
.DeleteKey(strKey
);
562 bool wxRegConfig::DeleteGroup(const wxString
& key
)
564 wxConfigPathChanger
path(this, key
);
566 return m_keyLocal
.DeleteKey(path
.Name());
569 bool wxRegConfig::DeleteAll()
574 bool bOk
= m_keyLocalRoot
.DeleteSelf();
576 // make sure that we opened m_keyGlobalRoot and so it has a reasonable name:
577 // otherwise we will delete HKEY_CLASSES_ROOT recursively
578 if ( bOk
&& m_keyGlobalRoot
.IsOpened() )
579 bOk
= m_keyGlobalRoot
.DeleteSelf();