#pragma implementation "fileconf.h"
#endif
-// ============================================================================
-// declarations
-// ============================================================================
-
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
+
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif //__BORLANDC__
+#if wxUSE_CONFIG
+
#ifndef WX_PRECOMP
#include "wx/string.h"
#include "wx/intl.h"
// global functions declarations
// ----------------------------------------------------------------------------
-// is 'c' a valid character in group name?
-// NB: wxCONFIG_IMMUTABLE_PREFIX and wxCONFIG_PATH_SEPARATOR must be valid chars,
-// but _not_ ']' (group name delimiter)
-inline bool IsValid(char c) { return isalnum(c) || strchr("@_/-!.*%", c); }
-
// compare functions for sorting the arrays
-static int CompareEntries(wxFileConfig::ConfigEntry *p1,
- wxFileConfig::ConfigEntry *p2);
-static int CompareGroups(wxFileConfig::ConfigGroup *p1,
- wxFileConfig::ConfigGroup *p2);
+static int CompareEntries(ConfigEntry *p1, ConfigEntry *p2);
+static int CompareGroups(ConfigGroup *p1, ConfigGroup *p2);
// filter strings
-static wxString FilterIn(const wxString& str);
-static wxString FilterOut(const wxString& str);
+static wxString FilterInValue(const wxString& str);
+static wxString FilterOutValue(const wxString& str);
+
+static wxString FilterInEntryName(const wxString& str);
+static wxString FilterOutEntryName(const wxString& str);
+
+// get the name to use in wxFileConfig ctor
+static wxString GetAppName(const wxString& appname);
// ============================================================================
// implementation
wxString strDir;
#ifdef __UNIX__
- strDir = "/etc/";
+ strDir = _T("/etc/");
#elif defined(__WXSTUBS__)
- wxASSERT_MSG( FALSE, "TODO" ) ;
+ wxASSERT_MSG( FALSE, _T("TODO") ) ;
+ #elif defined(__WXMAC__)
+ wxASSERT_MSG( FALSE, _T("TODO") ) ;
#else // Windows
- char szWinDir[MAX_PATH];
+ wxChar szWinDir[MAX_PATH];
::GetWindowsDirectory(szWinDir, MAX_PATH);
strDir = szWinDir;
- strDir << '\\';
+ strDir << _T('\\');
#endif // Unix/Windows
return strDir;
wxString wxFileConfig::GetLocalDir()
{
wxString strDir;
-
+
wxGetHomeDir(&strDir);
+#ifdef __UNIX__
+ if (strDir.Last() != _T('/')) strDir << _T('/');
+#else
+ if (strDir.Last() != _T('\\')) strDir << _T('\\');
+#endif
+
return strDir;
}
-wxString wxFileConfig::GetGlobalFileName(const char *szFile)
+wxString wxFileConfig::GetGlobalFileName(const wxChar *szFile)
{
wxString str = GetGlobalDir();
str << szFile;
- if ( strchr(szFile, '.') == NULL )
+ if ( wxStrchr(szFile, _T('.')) == NULL )
#ifdef __UNIX__
- str << ".conf";
+ str << _T(".conf");
#else // Windows
- str << ".ini";
+ str << _T(".ini");
#endif // UNIX/Win
return str;
}
-wxString wxFileConfig::GetLocalFileName(const char *szFile)
+wxString wxFileConfig::GetLocalFileName(const wxChar *szFile)
{
wxString str = GetLocalDir();
#ifdef __UNIX__
- str << '.';
+ str << _T('.');
#endif
str << szFile;
#ifdef __WXMSW__
- if ( strchr(szFile, '.') == NULL )
- str << ".ini";
+ if ( wxStrchr(szFile, _T('.')) == NULL )
+ str << _T(".ini");
#endif
return str;
wxFileConfig::wxFileConfig(const wxString& appName, const wxString& vendorName,
const wxString& strLocal, const wxString& strGlobal,
long style)
- : wxConfigBase(appName, vendorName, strLocal, strGlobal, style),
+ : wxConfigBase(::GetAppName(appName), vendorName,
+ strLocal, strGlobal,
+ style),
m_strLocalFile(strLocal), m_strGlobalFile(strGlobal)
{
- // Make up an application name if not supplied
- if (appName.IsEmpty() && wxTheApp)
- {
- SetAppName(wxTheApp->GetAppName());
- }
-
// Make up names for files if empty
if ( m_strLocalFile.IsEmpty() && (style & wxCONFIG_USE_LOCAL_FILE) )
{
SetStyle(GetStyle() | wxCONFIG_USE_GLOBAL_FILE);
// if the path is not absolute, prepend the standard directory to it
- if ( !m_strLocalFile.IsEmpty() && !wxIsAbsolutePath(m_strLocalFile) )
- {
- wxString strLocal = m_strLocalFile;
- m_strLocalFile = GetLocalDir();
- m_strLocalFile << strLocal;
- }
-
- if ( !m_strGlobalFile.IsEmpty() && !wxIsAbsolutePath(m_strGlobalFile) )
- {
- wxString strGlobal = m_strGlobalFile;
- m_strGlobalFile = GetGlobalDir();
- m_strGlobalFile << strGlobal;
+ // UNLESS wxCONFIG_USE_RELATIVE_PATH style is set
+ if ( !(style & wxCONFIG_USE_RELATIVE_PATH) ){
+ if ( !m_strLocalFile.IsEmpty() && !wxIsAbsolutePath(m_strLocalFile) )
+ {
+ wxString strLocal = m_strLocalFile;
+ m_strLocalFile = GetLocalDir();
+ m_strLocalFile << strLocal;
+ }
+
+ if ( !m_strGlobalFile.IsEmpty() && !wxIsAbsolutePath(m_strGlobalFile) )
+ {
+ wxString strGlobal = m_strGlobalFile;
+ m_strGlobalFile = GetGlobalDir();
+ m_strGlobalFile << strGlobal;
+ }
}
Init();
void wxFileConfig::Parse(wxTextFile& file, bool bLocal)
{
- const char *pStart;
- const char *pEnd;
+ const wxChar *pStart;
+ const wxChar *pEnd;
wxString strLine;
size_t nLineCount = file.GetLineCount();
LineListAppend(strLine);
// skip leading spaces
- for ( pStart = strLine; isspace(*pStart); pStart++ )
+ for ( pStart = strLine; wxIsspace(*pStart); pStart++ )
;
// skip blank/comment lines
- if ( *pStart == '\0'|| *pStart == ';' || *pStart == '#' )
+ if ( *pStart == _T('\0')|| *pStart == _T(';') || *pStart == _T('#') )
continue;
- if ( *pStart == '[' ) { // a new group
+ if ( *pStart == _T('[') ) { // a new group
pEnd = pStart;
- while ( *++pEnd != ']' ) {
- if ( !IsValid(*pEnd) && *pEnd != ' ' ) // allow spaces in group names
- break;
+ while ( *++pEnd != _T(']') ) {
+ if ( *pEnd == _T('\n') || *pEnd == _T('\0') )
+ break;
}
- if ( *pEnd != ']' ) {
+ if ( *pEnd != _T(']') ) {
wxLogError(_("file '%s': unexpected character %c at line %d."),
file.GetName(), *pEnd, n + 1);
continue; // skip this line
// group name here is always considered as abs path
wxString strGroup;
pStart++;
- strGroup << wxCONFIG_PATH_SEPARATOR << wxString(pStart, pEnd - pStart);
+ strGroup << wxCONFIG_PATH_SEPARATOR
+ << FilterInEntryName(wxString(pStart, pEnd - pStart));
// will create it if doesn't yet exist
SetPath(strGroup);
// check that there is nothing except comments left on this line
bool bCont = TRUE;
- while ( *++pEnd != '\0' && bCont ) {
+ while ( *++pEnd != _T('\0') && bCont ) {
switch ( *pEnd ) {
- case '#':
- case ';':
+ case _T('#'):
+ case _T(';'):
bCont = FALSE;
break;
- case ' ':
- case '\t':
+ case _T(' '):
+ case _T('\t'):
// ignore whitespace ('\n' impossible here)
break;
}
}
else { // a key
- const char *pEnd = pStart;
- while ( IsValid(*pEnd) )
+ const wxChar *pEnd = pStart;
+ while ( *pEnd != _T('=') && !wxIsspace(*pEnd) ) {
+ if ( *pEnd == _T('\\') ) {
+ // next character may be space or not - still take it because it's
+ // quoted
+ pEnd++;
+ }
+
pEnd++;
+ }
- wxString strKey(pStart, pEnd);
+ wxString strKey(FilterInEntryName(wxString(pStart, pEnd)));
// skip whitespace
while ( isspace(*pEnd) )
pEnd++;
- if ( *pEnd++ != '=' ) {
+ if ( *pEnd++ != _T('=') ) {
wxLogError(_("file '%s', line %d: '=' expected."),
file.GetName(), n + 1);
}
}
// skip whitespace
- while ( isspace(*pEnd) )
+ while ( wxIsspace(*pEnd) )
pEnd++;
- pEntry->SetValue(FilterIn(pEnd), FALSE /* read from file */);
+ pEntry->SetValue(FilterInValue(pEnd), FALSE /* read from file */);
}
}
}
{
wxString str;
if ( Read(key, & str) ) {
- *pl = atol(str);
+ *pl = wxAtol(str);
return TRUE;
}
else {
wxString strName = path.Name();
if ( strName.IsEmpty() ) {
// setting the value of a group is an error
- wxASSERT_MSG( IsEmpty(szValue), _("can't set value of a group!") );
+ wxASSERT_MSG( wxIsEmpty(szValue), _T("can't set value of a group!") );
// ... except if it's empty in which case it's a way to force it's creation
m_pCurrentGroup->SetDirty();
// check that the name is reasonable
if ( strName[0u] == wxCONFIG_IMMUTABLE_PREFIX ) {
- wxLogError(_("Entry name can't start with '%c'."),
+ wxLogError(_("Config entry name cannot start with '%c'."),
wxCONFIG_IMMUTABLE_PREFIX);
return FALSE;
}
- for ( const char *pc = strName; *pc != '\0'; pc++ ) {
- if ( !IsValid(*pc) ) {
- wxLogError(_("Character '%c' is invalid in a config entry name."),
- *pc);
- return FALSE;
- }
- }
-
ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strName);
if ( pEntry == NULL )
pEntry = m_pCurrentGroup->AddEntry(strName);
bool wxFileConfig::Write(const wxString& key, long lValue)
{
// ltoa() is not ANSI :-(
- char szBuf[40]; // should be good for sizeof(long) <= 16 (128 bits)
- sprintf(szBuf, "%ld", lValue);
- return Write(key, szBuf);
+ wxString buf;
+ buf.Printf(_T("%ld"), lValue);
+ return Write(key, buf);
}
bool wxFileConfig::Flush(bool /* bCurrentOnly */)
return file.Commit();
}
+// ----------------------------------------------------------------------------
+// renaming groups/entries
+// ----------------------------------------------------------------------------
+
+bool wxFileConfig::RenameEntry(const wxString& oldName,
+ const wxString& newName)
+{
+ // check that the entry exists
+ ConfigEntry *oldEntry = m_pCurrentGroup->FindEntry(oldName);
+ if ( !oldEntry )
+ return FALSE;
+
+ // check that the new entry doesn't already exist
+ if ( m_pCurrentGroup->FindEntry(newName) )
+ return FALSE;
+
+ // delete the old entry, create the new one
+ wxString value = oldEntry->Value();
+ if ( !m_pCurrentGroup->DeleteEntry(oldName) )
+ return FALSE;
+
+ ConfigEntry *newEntry = m_pCurrentGroup->AddEntry(newName);
+ newEntry->SetValue(value);
+
+ return TRUE;
+}
+
+bool wxFileConfig::RenameGroup(const wxString& oldName,
+ const wxString& newName)
+{
+ // check that the group exists
+ ConfigGroup *group = m_pCurrentGroup->FindSubgroup(oldName);
+ if ( !group )
+ return FALSE;
+
+ // check that the new group doesn't already exist
+ if ( m_pCurrentGroup->FindSubgroup(newName) )
+ return FALSE;
+
+ group->Rename(newName);
+
+ return TRUE;
+}
+
// ----------------------------------------------------------------------------
// delete groups/entries
// ----------------------------------------------------------------------------
if ( bGroupIfEmptyAlso && m_pCurrentGroup->IsEmpty() ) {
if ( m_pCurrentGroup != m_pRootGroup ) {
ConfigGroup *pGroup = m_pCurrentGroup;
- SetPath(".."); // changes m_pCurrentGroup!
+ SetPath(_T("..")); // changes m_pCurrentGroup!
m_pCurrentGroup->DeleteSubgroupByName(pGroup->Name());
}
//else: never delete the root group
{
CleanUp();
- const char *szFile = m_strLocalFile;
-
- if ( remove(szFile) == -1 )
- wxLogSysError(_("can't delete user configuration file '%s'"), szFile);
+ if ( remove(m_strLocalFile.fn_str()) == -1 )
+ wxLogSysError(_("can't delete user configuration file '%s'"), m_strLocalFile.c_str());
- m_strLocalFile = m_strGlobalFile = "";
+ m_strLocalFile = m_strGlobalFile = _T("");
Init();
return TRUE;
// ----------------------------------------------------------------------------
// append a new line to the end of the list
-wxFileConfig::LineList *wxFileConfig::LineListAppend(const wxString& str)
+LineList *wxFileConfig::LineListAppend(const wxString& str)
{
LineList *pLine = new LineList(str);
}
// insert a new line after the given one or in the very beginning if !pLine
-wxFileConfig::LineList *wxFileConfig::LineListInsert(const wxString& str,
+LineList *wxFileConfig::LineListInsert(const wxString& str,
LineList *pLine)
{
if ( pLine == m_linesTail )
// last entry?
if ( pNext == NULL )
m_linesTail = pPrev;
- else
+ else
pNext->SetPrev(pPrev);
delete pLine;
// ----------------------------------------------------------------------------
// ctor
-wxFileConfig::ConfigGroup::ConfigGroup(wxFileConfig::ConfigGroup *pParent,
+ConfigGroup::ConfigGroup(ConfigGroup *pParent,
const wxString& strName,
wxFileConfig *pConfig)
: m_aEntries(CompareEntries),
}
// dtor deletes all children
-wxFileConfig::ConfigGroup::~ConfigGroup()
+ConfigGroup::~ConfigGroup()
{
// entries
size_t n, nCount = m_aEntries.Count();
// line
// ----------------------------------------------------------------------------
-void wxFileConfig::ConfigGroup::SetLine(LineList *pLine)
+void ConfigGroup::SetLine(LineList *pLine)
{
wxASSERT( m_pLine == NULL ); // shouldn't be called twice
backwards in the config file (OTOH, it's not that important) and as we
would still need to do it for the subgroups the code wouldn't have been
significantly less complicated.
- */
+*/
// Return the line which contains "[our name]". If we're still not in the list,
// add our line to it immediately after the last line of our parent group if we
// have it or in the very beginning if we're the root group.
-wxFileConfig::LineList *wxFileConfig::ConfigGroup::GetGroupLine()
+LineList *ConfigGroup::GetGroupLine()
{
if ( m_pLine == NULL ) {
ConfigGroup *pParent = Parent();
// this group wasn't present in local config file, add it now
if ( pParent != NULL ) {
wxString strFullName;
- strFullName << "[" << (GetFullName().c_str() + 1) << "]"; // +1: no '/'
+ strFullName << _T("[")
+ // +1: no '/'
+ << FilterOutEntryName(GetFullName().c_str() + 1)
+ << _T("]");
m_pLine = m_pConfig->LineListInsert(strFullName,
pParent->GetLastGroupLine());
pParent->SetLastGroup(this); // we're surely after all the others
// Return the last line belonging to the subgroups of this group (after which
// we can add a new subgroup), if we don't have any subgroups or entries our
// last line is the group line (m_pLine) itself.
-wxFileConfig::LineList *wxFileConfig::ConfigGroup::GetLastGroupLine()
+LineList *ConfigGroup::GetLastGroupLine()
{
// if we have any subgroups, our last line is the last line of the last
// subgroup
if ( m_pLastGroup != NULL ) {
- wxFileConfig::LineList *pLine = m_pLastGroup->GetLastGroupLine();
+ LineList *pLine = m_pLastGroup->GetLastGroupLine();
wxASSERT( pLine != NULL ); // last group must have !NULL associated line
return pLine;
// return the last line belonging to the entries of this group (after which
// we can add a new entry), if we don't have any entries we will add the new
// one immediately after the group line itself.
-wxFileConfig::LineList *wxFileConfig::ConfigGroup::GetLastEntryLine()
+LineList *ConfigGroup::GetLastEntryLine()
{
if ( m_pLastEntry != NULL ) {
- wxFileConfig::LineList *pLine = m_pLastEntry->GetLine();
+ LineList *pLine = m_pLastEntry->GetLine();
wxASSERT( pLine != NULL ); // last entry must have !NULL associated line
return pLine;
// group name
// ----------------------------------------------------------------------------
-wxString wxFileConfig::ConfigGroup::GetFullName() const
+void ConfigGroup::Rename(const wxString& newName)
+{
+ m_strName = newName;
+
+ LineList *line = GetGroupLine();
+ wxString strFullName;
+ strFullName << _T("[") << (GetFullName().c_str() + 1) << _T("]"); // +1: no '/'
+ line->SetText(strFullName);
+
+ SetDirty();
+}
+
+wxString ConfigGroup::GetFullName() const
{
if ( Parent() )
return Parent()->GetFullName() + wxCONFIG_PATH_SEPARATOR + Name();
else
- return "";
+ return _T("");
}
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// use binary search because the array is sorted
-wxFileConfig::ConfigEntry *
-wxFileConfig::ConfigGroup::FindEntry(const char *szName) const
+ConfigEntry *
+ConfigGroup::FindEntry(const wxChar *szName) const
{
size_t i,
lo = 0,
hi = m_aEntries.Count();
int res;
- wxFileConfig::ConfigEntry *pEntry;
+ ConfigEntry *pEntry;
while ( lo < hi ) {
i = (lo + hi)/2;
pEntry = m_aEntries[i];
#if wxCONFIG_CASE_SENSITIVE
- res = strcmp(pEntry->Name(), szName);
+ res = wxStrcmp(pEntry->Name(), szName);
#else
- res = Stricmp(pEntry->Name(), szName);
+ res = wxStricmp(pEntry->Name(), szName);
#endif
if ( res > 0 )
return NULL;
}
-wxFileConfig::ConfigGroup *
-wxFileConfig::ConfigGroup::FindSubgroup(const char *szName) const
+ConfigGroup *
+ConfigGroup::FindSubgroup(const wxChar *szName) const
{
size_t i,
lo = 0,
hi = m_aSubgroups.Count();
int res;
- wxFileConfig::ConfigGroup *pGroup;
+ ConfigGroup *pGroup;
while ( lo < hi ) {
i = (lo + hi)/2;
pGroup = m_aSubgroups[i];
#if wxCONFIG_CASE_SENSITIVE
- res = strcmp(pGroup->Name(), szName);
+ res = wxStrcmp(pGroup->Name(), szName);
#else
- res = Stricmp(pGroup->Name(), szName);
+ res = wxStricmp(pGroup->Name(), szName);
#endif
if ( res > 0 )
// ----------------------------------------------------------------------------
// create a new entry and add it to the current group
-wxFileConfig::ConfigEntry *
-wxFileConfig::ConfigGroup::AddEntry(const wxString& strName, int nLine)
+ConfigEntry *
+ConfigGroup::AddEntry(const wxString& strName, int nLine)
{
wxASSERT( FindEntry(strName) == NULL );
}
// create a new group and add it to the current group
-wxFileConfig::ConfigGroup *
-wxFileConfig::ConfigGroup::AddSubgroup(const wxString& strName)
+ConfigGroup *
+ConfigGroup::AddSubgroup(const wxString& strName)
{
wxASSERT( FindSubgroup(strName) == NULL );
delete several of them.
*/
-bool wxFileConfig::ConfigGroup::DeleteSubgroupByName(const char *szName)
+bool ConfigGroup::DeleteSubgroupByName(const wxChar *szName)
{
return DeleteSubgroup(FindSubgroup(szName));
}
// doesn't delete the subgroup itself, but does remove references to it from
// all other data structures (and normally the returned pointer should be
// deleted a.s.a.p. because there is nothing much to be done with it anyhow)
-bool wxFileConfig::ConfigGroup::DeleteSubgroup(ConfigGroup *pGroup)
+bool ConfigGroup::DeleteSubgroup(ConfigGroup *pGroup)
{
wxCHECK( pGroup != NULL, FALSE ); // deleting non existing group?
// and subgroups of this sungroup
nCount = pGroup->m_aSubgroups.Count();
for ( size_t nGroup = 0; nGroup < nCount; nGroup++ ) {
- pGroup->DeleteSubgroup(pGroup->m_aSubgroups[nGroup]);
+ pGroup->DeleteSubgroup(pGroup->m_aSubgroups[0]);
}
LineList *pLine = pGroup->m_pLine;
return TRUE;
}
-bool wxFileConfig::ConfigGroup::DeleteEntry(const char *szName)
+bool ConfigGroup::DeleteEntry(const wxChar *szName)
{
ConfigEntry *pEntry = FindEntry(szName);
wxCHECK( pEntry != NULL, FALSE ); // deleting non existing item?
// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
-void wxFileConfig::ConfigGroup::SetDirty()
+void ConfigGroup::SetDirty()
{
m_bDirty = TRUE;
if ( Parent() != NULL ) // propagate upwards
// ----------------------------------------------------------------------------
// ctor
// ----------------------------------------------------------------------------
-wxFileConfig::ConfigEntry::ConfigEntry(wxFileConfig::ConfigGroup *pParent,
+ConfigEntry::ConfigEntry(ConfigGroup *pParent,
const wxString& strName,
int nLine)
: m_strName(strName)
// set value
// ----------------------------------------------------------------------------
-void wxFileConfig::ConfigEntry::SetLine(LineList *pLine)
+void ConfigEntry::SetLine(LineList *pLine)
{
if ( m_pLine != NULL ) {
wxLogWarning(_("entry '%s' appears more than once in group '%s'"),
// second parameter is FALSE if we read the value from file and prevents the
// entry from being marked as 'dirty'
-void wxFileConfig::ConfigEntry::SetValue(const wxString& strValue, bool bUser)
+void ConfigEntry::SetValue(const wxString& strValue, bool bUser)
{
if ( bUser && IsImmutable() ) {
wxLogWarning(_("attempt to change immutable key '%s' ignored."),
m_strValue = strValue;
if ( bUser ) {
- wxString strVal = FilterOut(strValue);
+ wxString strVal = FilterOutValue(strValue);
wxString strLine;
- strLine << m_strName << " = " << strVal;
+ strLine << FilterOutEntryName(m_strName) << _T('=') << strVal;
if ( m_pLine != NULL ) {
// entry was read from the local config file, just modify the line
}
else {
// add a new line to the file
- wxASSERT( m_nLine == NOT_FOUND ); // consistency check
+ wxASSERT( m_nLine == wxNOT_FOUND ); // consistency check
m_pLine = Group()->Config()->LineListInsert(strLine,
Group()->GetLastEntryLine());
}
}
-void wxFileConfig::ConfigEntry::SetDirty()
+void ConfigEntry::SetDirty()
{
m_bDirty = TRUE;
Group()->SetDirty();
// compare functions for array sorting
// ----------------------------------------------------------------------------
-int CompareEntries(wxFileConfig::ConfigEntry *p1,
- wxFileConfig::ConfigEntry *p2)
+int CompareEntries(ConfigEntry *p1,
+ ConfigEntry *p2)
{
#if wxCONFIG_CASE_SENSITIVE
- return strcmp(p1->Name(), p2->Name());
+ return wxStrcmp(p1->Name(), p2->Name());
#else
- return Stricmp(p1->Name(), p2->Name());
+ return wxStricmp(p1->Name(), p2->Name());
#endif
}
-int CompareGroups(wxFileConfig::ConfigGroup *p1,
- wxFileConfig::ConfigGroup *p2)
+int CompareGroups(ConfigGroup *p1,
+ ConfigGroup *p2)
{
#if wxCONFIG_CASE_SENSITIVE
- return strcmp(p1->Name(), p2->Name());
+ return wxStrcmp(p1->Name(), p2->Name());
#else
- return Stricmp(p1->Name(), p2->Name());
+ return wxStricmp(p1->Name(), p2->Name());
#endif
}
// filter functions
// ----------------------------------------------------------------------------
-// undo FilterOut
-wxString FilterIn(const wxString& str)
+// undo FilterOutValue
+static wxString FilterInValue(const wxString& str)
{
wxString strResult;
strResult.Alloc(str.Len());
bool bQuoted = !str.IsEmpty() && str[0] == '"';
for ( size_t n = bQuoted ? 1 : 0; n < str.Len(); n++ ) {
- if ( str[n] == '\\' ) {
+ if ( str[n] == _T('\\') ) {
switch ( str[++n] ) {
- case 'n':
- strResult += '\n';
+ case _T('n'):
+ strResult += _T('\n');
break;
- case 'r':
- strResult += '\r';
+ case _T('r'):
+ strResult += _T('\r');
break;
- case 't':
- strResult += '\t';
+ case _T('t'):
+ strResult += _T('\t');
break;
- case '\\':
- strResult += '\\';
+ case _T('\\'):
+ strResult += _T('\\');
break;
- case '"':
- strResult += '"';
+ case _T('"'):
+ strResult += _T('"');
break;
}
}
else {
- if ( str[n] != '"' || !bQuoted )
+ if ( str[n] != _T('"') || !bQuoted )
strResult += str[n];
else if ( n != str.Len() - 1 ) {
wxLogWarning(_("unexpected \" at position %d in '%s'."),
}
// quote the string before writing it to file
-wxString FilterOut(const wxString& str)
+static wxString FilterOutValue(const wxString& str)
{
- if(str.IsEmpty())
+ if ( !str )
return str;
-
+
wxString strResult;
strResult.Alloc(str.Len());
// quoting is necessary to preserve spaces in the beginning of the string
- bool bQuote = isspace(str[0]) || str[0] == '"';
+ bool bQuote = wxIsspace(str[0]) || str[0] == _T('"');
if ( bQuote )
- strResult += '"';
+ strResult += _T('"');
- char c;
+ wxChar c;
for ( size_t n = 0; n < str.Len(); n++ ) {
switch ( str[n] ) {
- case '\n':
- c = 'n';
+ case _T('\n'):
+ c = _T('n');
break;
- case '\r':
- c = 'r';
+ case _T('\r'):
+ c = _T('r');
break;
- case '\t':
- c = 't';
+ case _T('\t'):
+ c = _T('t');
break;
- case '\\':
- c = '\\';
+ case _T('\\'):
+ c = _T('\\');
break;
- case '"':
+ case _T('"'):
if ( bQuote ) {
- c = '"';
+ c = _T('"');
break;
}
//else: fall through
}
// we get here only for special characters
- strResult << '\\' << c;
+ strResult << _T('\\') << c;
}
if ( bQuote )
- strResult += '"';
+ strResult += _T('"');
+
+ return strResult;
+}
+
+// undo FilterOutEntryName
+static wxString FilterInEntryName(const wxString& str)
+{
+ wxString strResult;
+ strResult.Alloc(str.Len());
+
+ for ( const wxChar *pc = str.c_str(); *pc != '\0'; pc++ ) {
+ if ( *pc == _T('\\') )
+ pc++;
+
+ strResult += *pc;
+ }
+
+ return strResult;
+}
+
+// sanitize entry or group name: insert '\\' before any special characters
+static wxString FilterOutEntryName(const wxString& str)
+{
+ wxString strResult;
+ strResult.Alloc(str.Len());
+
+ for ( const wxChar *pc = str.c_str(); *pc != _T('\0'); pc++ ) {
+ wxChar c = *pc;
+
+ // we explicitly allow some of "safe" chars and 8bit ASCII characters
+ // which will probably never have special meaning
+ // NB: note that wxCONFIG_IMMUTABLE_PREFIX and wxCONFIG_PATH_SEPARATOR
+ // should *not* be quoted
+ if ( !wxIsalnum(c) && !wxStrchr(_T("@_/-!.*%"), c) && ((c & 0x80) == 0) )
+ strResult += _T('\\');
+
+ strResult += c;
+ }
return strResult;
}
+
+// we can't put ?: in the ctor initializer list because it confuses some
+// broken compilers (Borland C++)
+static wxString GetAppName(const wxString& appName)
+{
+ if ( !appName && wxTheApp )
+ return wxTheApp->GetAppName();
+ else
+ return appName;
+}
+
+#endif // wxUSE_CONFIG
+
projects / wxWidgets.git / blobdiff