#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>
+ #include "wx/string.h"
+ #include "wx/intl.h"
#endif //WX_PRECOMP
-#include <wx/dynarray.h>
-#include <wx/file.h>
-#include <wx/log.h>
-#include <wx/textfile.h>
-#include <wx/config.h>
-#include <wx/fileconf.h>
-
-// _WINDOWS_ is defined when windows.h is included,
-// __WXMSW__ is defined for MS Windows compilation
-#if defined(__WXMSW__) && !defined(_WINDOWS_)
- #include <windows.h>
+#include "wx/app.h"
+#include "wx/dynarray.h"
+#include "wx/file.h"
+#include "wx/log.h"
+#include "wx/textfile.h"
+#include "wx/memtext.h"
+#include "wx/config.h"
+#include "wx/fileconf.h"
+
+#if wxUSE_STREAMS
+ #include "wx/stream.h"
+#endif // wxUSE_STREAMS
+
+#include "wx/utils.h" // for wxGetHomeDir
+
+#if defined(__WXMAC__)
+ #include "wx/mac/private.h" // includes mac headers
+#endif
+
+#if defined(__WXMSW__)
+ #include "wx/msw/private.h"
#endif //windows.h
+#if defined(__WXPM__)
+ #define INCL_DOS
+ #include <os2.h>
+#endif
#include <stdlib.h>
#include <ctype.h>
+// headers needed for umask()
+#ifdef __UNIX__
+ #include <sys/types.h>
+ #include <sys/stat.h>
+#endif // __UNIX__
+
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------
#define CONST_CAST ((wxFileConfig *)this)->
// ----------------------------------------------------------------------------
-// global functions declarations
+// constants
// ----------------------------------------------------------------------------
-// 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); }
+#ifndef MAX_PATH
+ #define MAX_PATH 512
+#endif
+
+// ----------------------------------------------------------------------------
+// global functions declarations
+// ----------------------------------------------------------------------------
// 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 LINKAGEMODE CompareEntries(wxFileConfigEntry *p1, wxFileConfigEntry *p2);
+static int LINKAGEMODE CompareGroups(wxFileConfigGroup *p1, wxFileConfigGroup *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);
+
+// ============================================================================
+// private classes
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// "template" array types
+// ----------------------------------------------------------------------------
+
+WX_DEFINE_SORTED_EXPORTED_ARRAY(wxFileConfigEntry *, ArrayEntries);
+WX_DEFINE_SORTED_EXPORTED_ARRAY(wxFileConfigGroup *, ArrayGroups);
+
+// ----------------------------------------------------------------------------
+// wxFileConfigLineList
+// ----------------------------------------------------------------------------
+
+// we store all lines of the local config file as a linked list in memory
+class wxFileConfigLineList
+{
+public:
+ void SetNext(wxFileConfigLineList *pNext) { m_pNext = pNext; }
+ void SetPrev(wxFileConfigLineList *pPrev) { m_pPrev = pPrev; }
+
+ // ctor
+ wxFileConfigLineList(const wxString& str,
+ wxFileConfigLineList *pNext = NULL) : m_strLine(str)
+ { SetNext(pNext); SetPrev(NULL); }
+
+ // next/prev nodes in the linked list
+ wxFileConfigLineList *Next() const { return m_pNext; }
+ wxFileConfigLineList *Prev() const { return m_pPrev; }
+
+ // get/change lines text
+ void SetText(const wxString& str) { m_strLine = str; }
+ const wxString& Text() const { return m_strLine; }
+
+private:
+ wxString m_strLine; // line contents
+ wxFileConfigLineList *m_pNext, // next node
+ *m_pPrev; // previous one
+};
+
+// ----------------------------------------------------------------------------
+// wxFileConfigEntry: a name/value pair
+// ----------------------------------------------------------------------------
+
+class wxFileConfigEntry
+{
+private:
+ wxFileConfigGroup *m_pParent; // group that contains us
+
+ wxString m_strName, // entry name
+ m_strValue; // value
+ bool m_bDirty:1, // changed since last read?
+ m_bImmutable:1, // can be overriden locally?
+ m_bHasValue:1; // set after first call to SetValue()
+
+ int m_nLine; // used if m_pLine == NULL only
+
+ // pointer to our line in the linked list or NULL if it was found in global
+ // file (which we don't modify)
+ wxFileConfigLineList *m_pLine;
+
+public:
+ wxFileConfigEntry(wxFileConfigGroup *pParent,
+ const wxString& strName, int nLine);
+
+ // simple accessors
+ const wxString& Name() const { return m_strName; }
+ const wxString& Value() const { return m_strValue; }
+ wxFileConfigGroup *Group() const { return m_pParent; }
+ bool IsDirty() const { return m_bDirty; }
+ bool IsImmutable() const { return m_bImmutable; }
+ bool IsLocal() const { return m_pLine != 0; }
+ int Line() const { return m_nLine; }
+ wxFileConfigLineList *
+ GetLine() const { return m_pLine; }
+
+ // modify entry attributes
+ void SetValue(const wxString& strValue, bool bUser = TRUE);
+ void SetDirty();
+ void SetLine(wxFileConfigLineList *pLine);
+};
+
+// ----------------------------------------------------------------------------
+// wxFileConfigGroup: container of entries and other groups
+// ----------------------------------------------------------------------------
+
+class wxFileConfigGroup
+{
+private:
+ wxFileConfig *m_pConfig; // config object we belong to
+ wxFileConfigGroup *m_pParent; // parent group (NULL for root group)
+ ArrayEntries m_aEntries; // entries in this group
+ ArrayGroups m_aSubgroups; // subgroups
+ wxString m_strName; // group's name
+ bool m_bDirty; // if FALSE => all subgroups are not dirty
+ wxFileConfigLineList *m_pLine; // pointer to our line in the linked list
+ wxFileConfigEntry *m_pLastEntry; // last entry/subgroup of this group in the
+ wxFileConfigGroup *m_pLastGroup; // local file (we insert new ones after it)
+
+ // DeleteSubgroupByName helper
+ bool DeleteSubgroup(wxFileConfigGroup *pGroup);
+
+public:
+ // ctor
+ wxFileConfigGroup(wxFileConfigGroup *pParent, const wxString& strName, wxFileConfig *);
+
+ // dtor deletes all entries and subgroups also
+ ~wxFileConfigGroup();
+
+ // simple accessors
+ const wxString& Name() const { return m_strName; }
+ wxFileConfigGroup *Parent() const { return m_pParent; }
+ wxFileConfig *Config() const { return m_pConfig; }
+ bool IsDirty() const { return m_bDirty; }
+
+ const ArrayEntries& Entries() const { return m_aEntries; }
+ const ArrayGroups& Groups() const { return m_aSubgroups; }
+ bool IsEmpty() const { return Entries().IsEmpty() && Groups().IsEmpty(); }
+
+ // find entry/subgroup (NULL if not found)
+ wxFileConfigGroup *FindSubgroup(const wxChar *szName) const;
+ wxFileConfigEntry *FindEntry (const wxChar *szName) const;
+
+ // delete entry/subgroup, return FALSE if doesn't exist
+ bool DeleteSubgroupByName(const wxChar *szName);
+ bool DeleteEntry(const wxChar *szName);
+
+ // create new entry/subgroup returning pointer to newly created element
+ wxFileConfigGroup *AddSubgroup(const wxString& strName);
+ wxFileConfigEntry *AddEntry (const wxString& strName, int nLine = wxNOT_FOUND);
+
+ // will also recursively set parent's dirty flag
+ void SetDirty();
+ void SetLine(wxFileConfigLineList *pLine);
+
+ // rename: no checks are done to ensure that the name is unique!
+ void Rename(const wxString& newName);
+
+ //
+ wxString GetFullName() const;
+
+ // get the last line belonging to an entry/subgroup of this group
+ wxFileConfigLineList *GetGroupLine(); // line which contains [group]
+ wxFileConfigLineList *GetLastEntryLine(); // after which our subgroups start
+ wxFileConfigLineList *GetLastGroupLine(); // after which the next group starts
+
+ // called by entries/subgroups when they're created/deleted
+ void SetLastEntry(wxFileConfigEntry *pEntry) { m_pLastEntry = pEntry; }
+ void SetLastGroup(wxFileConfigGroup *pGroup) { m_pLastGroup = pGroup; }
+};
// ============================================================================
// implementation
{
wxString strDir;
- #ifdef __UNIX__
- strDir = "/etc/";
+ #ifdef __VMS__ // Note if __VMS is defined __UNIX is also defined
+ strDir = wxT("sys$manager:");
+ #elif defined(__WXMAC__)
+ strDir = wxMacFindFolder( (short) kOnSystemDisk, kPreferencesFolderType, kDontCreateFolder ) ;
+ #elif defined( __UNIX__ )
+ strDir = wxT("/etc/");
+ #elif defined(__WXPM__)
+ ULONG aulSysInfo[QSV_MAX] = {0};
+ UINT drive;
+ APIRET rc;
+
+ rc = DosQuerySysInfo( 1L, QSV_MAX, (PVOID)aulSysInfo, sizeof(ULONG)*QSV_MAX);
+ if (rc == 0)
+ {
+ drive = aulSysInfo[QSV_BOOT_DRIVE - 1];
+ strDir.Printf(wxT("%c:\\OS2\\"), 'A'+drive-1);
+ }
+ #elif defined(__WXSTUBS__)
+ wxASSERT_MSG( FALSE, wxT("TODO") ) ;
+ #elif defined(__DOS__)
+ // There's no such thing as global cfg dir in MS-DOS, let's return
+ // current directory (FIXME_MGL?)
+ return wxT(".\\");
#else // Windows
- #ifndef _MAX_PATH
- #define _MAX_PATH 512
- #endif
-
- char szWinDir[_MAX_PATH];
- ::GetWindowsDirectory(szWinDir, _MAX_PATH);
+ wxChar szWinDir[MAX_PATH];
+ ::GetWindowsDirectory(szWinDir, MAX_PATH);
strDir = szWinDir;
- strDir << '\\';
+ strDir << wxT('\\');
#endif // Unix/Windows
return strDir;
{
wxString strDir;
- #ifdef __UNIX__
- const char *szHome = getenv("HOME");
- if ( szHome == NULL ) {
- // we're homeless...
- wxLogWarning(_("can't find user's HOME, using current directory."));
- strDir = ".";
- }
- else
- strDir = szHome;
- strDir << '/'; // a double slash is no problem, a missin one yes
- #else // Windows
- #ifdef __WIN32__
- const char *szHome = getenv("HOMEDRIVE");
- if ( szHome != NULL )
- strDir << szHome;
- szHome = getenv("HOMEPATH");
- if ( szHome != NULL )
- strDir << szHome;
- #else // Win16
- // Win16 has no idea about home, so use the current directory instead
- strDir = ".\\";
- #endif // WIN16/32
- #endif // UNIX/Win
+#if defined(__WXMAC__) || defined(__DOS__)
+ // no local dir concept on Mac OS 9 or MS-DOS
+ return GetGlobalDir() ;
+#else
+ wxGetHomeDir(&strDir);
+
+# ifdef __UNIX__
+# ifdef __VMS
+ if (strDir.Last() != wxT(']'))
+# endif
+ if (strDir.Last() != wxT('/')) strDir << wxT('/');
+# else
+ if (strDir.Last() != wxT('\\')) strDir << wxT('\\');
+# endif
+#endif
return strDir;
}
-wxString wxFileConfig::GetGlobalFileName(const char *szFile)
+wxString wxFileConfig::GetGlobalFileName(const wxChar *szFile)
{
wxString str = GetGlobalDir();
str << szFile;
- if ( strchr(szFile, '.') == NULL )
- #ifdef __UNIX__
- str << ".conf";
+ if ( wxStrchr(szFile, wxT('.')) == NULL )
+ #if defined( __WXMAC__ )
+ str << " Preferences";
+ #elif defined( __UNIX__ )
+ str << wxT(".conf");
#else // Windows
- str << ".ini";
+ str << wxT(".ini");
#endif // UNIX/Win
return str;
}
-wxString wxFileConfig::GetLocalFileName(const char *szFile)
+wxString wxFileConfig::GetLocalFileName(const wxChar *szFile)
{
- wxString str = GetLocalDir();
-
- #ifdef __UNIX__
- str << '.';
+#ifdef __VMS__ // On VMS I saw the problem that the home directory was appended
+ // twice for the configuration file. Does that also happen for other
+ // platforms?
+ wxString str = wxT( '.' );
+#else
+ wxString str = GetLocalDir();
+#endif
+
+ #if defined( __UNIX__ ) && !defined( __VMS ) && !defined( __WXMAC__ )
+ str << wxT('.');
#endif
str << szFile;
- #ifdef __WXMSW__
- if ( strchr(szFile, '.') == NULL )
- str << ".ini";
+ #if defined(__WINDOWS__) || defined(__DOS__)
+ if ( wxStrchr(szFile, wxT('.')) == NULL )
+ str << wxT(".ini");
#endif
+ #ifdef __WXMAC__
+ str << " Preferences";
+ #endif
return str;
}
void wxFileConfig::Init()
{
m_pCurrentGroup =
- m_pRootGroup = new ConfigGroup(NULL, "", this);
+ m_pRootGroup = new wxFileConfigGroup(NULL, "", this);
m_linesHead =
m_linesTail = NULL;
}
}
-wxFileConfig::wxFileConfig(const char *szAppName, bool bLocalOnly)
+// constructor supports creation of wxFileConfig objects of any type
+wxFileConfig::wxFileConfig(const wxString& appName, const wxString& vendorName,
+ const wxString& strLocal, const wxString& strGlobal,
+ long style)
+ : wxConfigBase(::GetAppName(appName), vendorName,
+ strLocal, strGlobal,
+ style),
+ m_strLocalFile(strLocal), m_strGlobalFile(strGlobal)
{
- wxASSERT( !IsEmpty(szAppName) ); // invent a name for your application!
+ // Make up names for files if empty
+ if ( m_strLocalFile.IsEmpty() && (style & wxCONFIG_USE_LOCAL_FILE) )
+ {
+ m_strLocalFile = GetLocalFileName(GetAppName());
+ }
- m_strLocalFile = GetLocalFileName(szAppName);
- if ( !bLocalOnly )
- m_strGlobalFile = GetGlobalFileName(szAppName);
- //else: it's going to be empty and we won't use the global file
+ if ( m_strGlobalFile.IsEmpty() && (style & wxCONFIG_USE_GLOBAL_FILE) )
+ {
+ m_strGlobalFile = GetGlobalFileName(GetAppName());
+ }
+
+ // Check if styles are not supplied, but filenames are, in which case
+ // add the correct styles.
+ if ( !m_strLocalFile.IsEmpty() )
+ SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE);
+
+ if ( !m_strGlobalFile.IsEmpty() )
+ SetStyle(GetStyle() | wxCONFIG_USE_GLOBAL_FILE);
+
+ // if the path is not absolute, prepend the standard directory to it
+ // 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;
+ }
+ }
+
+ SetUmask(-1);
Init();
}
-wxFileConfig::wxFileConfig(const wxString& strLocal, const wxString& strGlobal)
- : m_strLocalFile(strLocal), m_strGlobalFile(strGlobal)
+#if wxUSE_STREAMS
+
+wxFileConfig::wxFileConfig(wxInputStream &inStream)
{
- // if the path is not absolute, prepend the standard directory to it
+ // always local_file when this constructor is called (?)
+ SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE);
- if ( !strLocal.IsEmpty() && !wxIsPathSeparator(strLocal[0u]) )
- m_strLocalFile = GetLocalDir();
- m_strLocalFile << strLocal;
+ m_pCurrentGroup =
+ m_pRootGroup = new wxFileConfigGroup(NULL, "", this);
- if ( !strGlobal.IsEmpty() && !wxIsPathSeparator(strGlobal[0u]) )
- m_strGlobalFile = GetGlobalDir();
- m_strGlobalFile << strGlobal;
+ m_linesHead =
+ m_linesTail = NULL;
- Init();
+ // translate everything to the current (platform-dependent) line
+ // termination character
+ wxString strTrans;
+ {
+ wxString strTmp;
+
+ char buf[1024];
+ while ( !inStream.Read(buf, WXSIZEOF(buf)).Eof() )
+ strTmp.append(wxConvertMB2WX(buf), inStream.LastRead());
+
+ strTmp.append(wxConvertMB2WX(buf), inStream.LastRead());
+
+ strTrans = wxTextBuffer::Translate(strTmp);
+ }
+
+ wxMemoryText memText;
+
+ // Now we can add the text to the memory text. To do this we extract line
+ // by line from the translated string, until we've reached the end.
+ //
+ // VZ: all this is horribly inefficient, we should do the translation on
+ // the fly in one pass saving both memory and time (TODO)
+
+ const wxChar *pEOL = wxTextBuffer::GetEOL(wxTextBuffer::typeDefault);
+ const size_t EOLLen = wxStrlen(pEOL);
+
+ int posLineStart = strTrans.Find(pEOL);
+ while ( posLineStart != -1 )
+ {
+ wxString line(strTrans.Left(posLineStart));
+
+ memText.AddLine(line);
+
+ strTrans = strTrans.Mid(posLineStart + EOLLen);
+
+ posLineStart = strTrans.Find(pEOL);
+ }
+
+ // also add whatever we have left in the translated string.
+ memText.AddLine(strTrans);
+
+ // Finally we can parse it all.
+ Parse(memText, TRUE /* local */);
+
+ SetRootPath();
}
+#endif // wxUSE_STREAMS
+
void wxFileConfig::CleanUp()
{
delete m_pRootGroup;
- LineList *pCur = m_linesHead;
+ wxFileConfigLineList *pCur = m_linesHead;
while ( pCur != NULL ) {
- LineList *pNext = pCur->Next();
+ wxFileConfigLineList *pNext = pCur->Next();
delete pCur;
pCur = pNext;
}
// parse a config file
// ----------------------------------------------------------------------------
-void wxFileConfig::Parse(wxTextFile& file, bool bLocal)
+void wxFileConfig::Parse(wxTextBuffer& buffer, bool bLocal)
{
- const char *pStart;
- const char *pEnd;
+ const wxChar *pStart;
+ const wxChar *pEnd;
wxString strLine;
- uint nLineCount = file.GetLineCount();
- for ( uint n = 0; n < nLineCount; n++ ) {
- strLine = file[n];
+ size_t nLineCount = buffer.GetLineCount();
+ for ( size_t n = 0; n < nLineCount; n++ ) {
+ strLine = buffer[n];
// add the line to linked list
if ( bLocal )
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 == wxT('\0')|| *pStart == wxT(';') || *pStart == wxT('#') )
continue;
- if ( *pStart == '[' ) { // a new group
+ if ( *pStart == wxT('[') ) { // a new group
pEnd = pStart;
- while ( *++pEnd != ']' ) {
- if ( !IsValid(*pEnd) && *pEnd != ' ' ) // allow spaces in group names
- break;
+ while ( *++pEnd != wxT(']') ) {
+ if ( *pEnd == wxT('\\') ) {
+ // the next char is escaped, so skip it even if it is ']'
+ pEnd++;
+ }
+
+ if ( *pEnd == wxT('\n') || *pEnd == wxT('\0') ) {
+ // we reached the end of line, break out of the loop
+ break;
+ }
}
- if ( *pEnd != ']' ) {
+ if ( *pEnd != wxT(']') ) {
wxLogError(_("file '%s': unexpected character %c at line %d."),
- file.GetName(), *pEnd, n + 1);
+ buffer.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 != wxT('\0') && bCont ) {
switch ( *pEnd ) {
- case '#':
- case ';':
+ case wxT('#'):
+ case wxT(';'):
bCont = FALSE;
break;
- case ' ':
- case '\t':
+ case wxT(' '):
+ case wxT('\t'):
// ignore whitespace ('\n' impossible here)
break;
default:
- wxLogWarning(_("file '%s', line %d: '%s' "
- "ignored after group header."),
- file.GetName(), n + 1, pEnd);
+ wxLogWarning(_("file '%s', line %d: '%s' ignored after group header."),
+ buffer.GetName(), n + 1, pEnd);
bCont = FALSE;
}
}
}
else { // a key
- const char *pEnd = pStart;
- while ( IsValid(*pEnd) )
+ const wxChar *pEnd = pStart;
+ while ( *pEnd && *pEnd != wxT('=') && !wxIsspace(*pEnd) ) {
+ if ( *pEnd == wxT('\\') ) {
+ // next character may be space or not - still take it because it's
+ // quoted (unless there is nothing)
+ pEnd++;
+ if ( !*pEnd ) {
+ // the error message will be given below anyhow
+ break;
+ }
+ }
+
pEnd++;
+ }
- wxString strKey(pStart, pEnd);
+ wxString strKey(FilterInEntryName(wxString(pStart, pEnd)));
// skip whitespace
- while ( isspace(*pEnd) )
+ while ( wxIsspace(*pEnd) )
pEnd++;
- if ( *pEnd++ != '=' ) {
+ if ( *pEnd++ != wxT('=') ) {
wxLogError(_("file '%s', line %d: '=' expected."),
- file.GetName(), n + 1);
+ buffer.GetName(), n + 1);
}
else {
- ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strKey);
+ wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strKey);
if ( pEntry == NULL ) {
// new entry
else {
if ( bLocal && pEntry->IsImmutable() ) {
// immutable keys can't be changed by user
- wxLogWarning(_("file '%s', line %d: value for "
- "immutable key '%s' ignored."),
- file.GetName(), n + 1, strKey.c_str());
+ wxLogWarning(_("file '%s', line %d: value for immutable key '%s' ignored."),
+ buffer.GetName(), n + 1, strKey.c_str());
continue;
}
// the condition below catches the cases (a) and (b) but not (c):
// (c) key from global file now found in local one
// which is exactly what we want.
else if ( !bLocal || pEntry->IsLocal() ) {
- wxLogWarning(_("file '%s', line %d: key '%s' was first "
- "found at line %d."),
- file.GetName(), n + 1, strKey.c_str(), pEntry->Line());
+ wxLogWarning(_("file '%s', line %d: key '%s' was first found at line %d."),
+ buffer.GetName(), n + 1, strKey.c_str(), pEntry->Line());
if ( bLocal )
pEntry->SetLine(m_linesTail);
}
// 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 */);
}
}
}
}
// change current group
- uint n;
+ size_t n;
m_pCurrentGroup = m_pRootGroup;
for ( n = 0; n < aParts.Count(); n++ ) {
- ConfigGroup *pNextGroup = m_pCurrentGroup->FindSubgroup(aParts[n]);
+ wxFileConfigGroup *pNextGroup = m_pCurrentGroup->FindSubgroup(aParts[n]);
if ( pNextGroup == NULL )
pNextGroup = m_pCurrentGroup->AddSubgroup(aParts[n]);
m_pCurrentGroup = pNextGroup;
bool wxFileConfig::GetNextGroup (wxString& str, long& lIndex) const
{
- if ( uint(lIndex) < m_pCurrentGroup->Groups().Count() ) {
- str = m_pCurrentGroup->Groups()[lIndex++]->Name();
+ if ( size_t(lIndex) < m_pCurrentGroup->Groups().Count() ) {
+ str = m_pCurrentGroup->Groups()[(size_t)lIndex++]->Name();
return TRUE;
}
else
bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) const
{
- if ( uint(lIndex) < m_pCurrentGroup->Entries().Count() ) {
- str = m_pCurrentGroup->Entries()[lIndex++]->Name();
+ if ( size_t(lIndex) < m_pCurrentGroup->Entries().Count() ) {
+ str = m_pCurrentGroup->Entries()[(size_t)lIndex++]->Name();
return TRUE;
}
else
return FALSE;
}
-uint wxFileConfig::GetNumberOfEntries(bool bRecursive) const
+size_t wxFileConfig::GetNumberOfEntries(bool bRecursive) const
{
- uint n = m_pCurrentGroup->Entries().Count();
+ size_t n = m_pCurrentGroup->Entries().Count();
if ( bRecursive ) {
- ConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
- uint nSubgroups = m_pCurrentGroup->Groups().Count();
- for ( uint nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
+ wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
+ size_t nSubgroups = m_pCurrentGroup->Groups().Count();
+ for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
n += GetNumberOfEntries(TRUE);
CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
return n;
}
-uint wxFileConfig::GetNumberOfGroups(bool bRecursive) const
+size_t wxFileConfig::GetNumberOfGroups(bool bRecursive) const
{
- uint n = m_pCurrentGroup->Groups().Count();
+ size_t n = m_pCurrentGroup->Groups().Count();
if ( bRecursive ) {
- ConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
- uint nSubgroups = m_pCurrentGroup->Groups().Count();
- for ( uint nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
+ wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
+ size_t nSubgroups = m_pCurrentGroup->Groups().Count();
+ for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
n += GetNumberOfGroups(TRUE);
CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
bool wxFileConfig::HasGroup(const wxString& strName) const
{
- PathChanger path(this, strName);
+ wxConfigPathChanger path(this, strName);
- ConfigGroup *pGroup = m_pCurrentGroup->FindSubgroup(path.Name());
+ wxFileConfigGroup *pGroup = m_pCurrentGroup->FindSubgroup(path.Name());
return pGroup != NULL;
}
bool wxFileConfig::HasEntry(const wxString& strName) const
{
- PathChanger path(this, strName);
+ wxConfigPathChanger path(this, strName);
- ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
+ wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
return pEntry != NULL;
}
// read/write values
// ----------------------------------------------------------------------------
-bool wxFileConfig::Read(wxString *pstr,
- const char *szKey,
- const char *szDefault) const
+bool wxFileConfig::DoReadString(const wxString& key, wxString* pStr) const
{
- PathChanger path(this, szKey);
+ wxConfigPathChanger path(this, key);
- ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
+ wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
if (pEntry == NULL) {
- *pstr = ExpandEnvVars(szDefault);
return FALSE;
}
- else {
- *pstr = ExpandEnvVars(pEntry->Value());
- return TRUE;
- }
-}
-const char *wxFileConfig::Read(const char *szKey,
- const char *szDefault) const
-{
- static wxString s_str;
- Read(&s_str, szKey, szDefault);
+ *pStr = pEntry->Value();
- return s_str.c_str();
+ return TRUE;
}
-bool wxFileConfig::Read(long *pl, const char *szKey, long lDefault) const
+bool wxFileConfig::DoReadLong(const wxString& key, long *pl) const
{
wxString str;
- if ( Read(&str, szKey) ) {
- *pl = atol(str);
- return TRUE;
- }
- else {
- *pl = lDefault;
+ if ( !Read(key, & str) )
+ {
return FALSE;
}
+ return str.ToLong(pl) ;
}
-bool wxFileConfig::Write(const char *szKey, const char *szValue)
+bool wxFileConfig::DoWriteString(const wxString& key, const wxString& szValue)
{
- PathChanger path(this, szKey);
+ wxConfigPathChanger path(this, key);
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), wxT("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);
+ wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strName);
if ( pEntry == NULL )
pEntry = m_pCurrentGroup->AddEntry(strName);
return TRUE;
}
-bool wxFileConfig::Write(const char *szKey, long lValue)
+bool wxFileConfig::DoWriteLong(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(szKey, szBuf);
+ return Write(key, wxString::Format(_T("%ld"), lValue));
}
bool wxFileConfig::Flush(bool /* bCurrentOnly */)
{
- if ( LineListIsEmpty() || !m_pRootGroup->IsDirty() )
+ if ( LineListIsEmpty() || !m_pRootGroup->IsDirty() || !m_strLocalFile )
return TRUE;
+#ifdef __UNIX__
+ // set the umask if needed
+ mode_t umaskOld = 0;
+ if ( m_umask != -1 )
+ {
+ umaskOld = umask((mode_t)m_umask);
+ }
+#endif // __UNIX__
+
wxTempFile file(m_strLocalFile);
if ( !file.IsOpened() ) {
}
// write all strings to file
- for ( LineList *p = m_linesHead; p != NULL; p = p->Next() ) {
+ for ( wxFileConfigLineList *p = m_linesHead; p != NULL; p = p->Next() ) {
if ( !file.Write(p->Text() + wxTextFile::GetEOL()) ) {
wxLogError(_("can't write user configuration file."));
return FALSE;
}
}
- return file.Commit();
+ bool ret = file.Commit();
+
+#if defined(__WXMAC__)
+ if ( ret )
+ {
+ FSSpec spec ;
+
+ wxMacFilename2FSSpec( m_strLocalFile , &spec ) ;
+ FInfo finfo ;
+ if ( FSpGetFInfo( &spec , &finfo ) == noErr )
+ {
+ finfo.fdType = 'TEXT' ;
+ finfo.fdCreator = 'ttxt' ;
+ FSpSetFInfo( &spec , &finfo ) ;
+ }
+ }
+#endif // __WXMAC__
+
+#ifdef __UNIX__
+ // restore the old umask if we changed it
+ if ( m_umask != -1 )
+ {
+ (void)umask(umaskOld);
+ }
+#endif // __UNIX__
+
+ return ret;
+}
+
+// ----------------------------------------------------------------------------
+// renaming groups/entries
+// ----------------------------------------------------------------------------
+
+bool wxFileConfig::RenameEntry(const wxString& oldName,
+ const wxString& newName)
+{
+ // check that the entry exists
+ wxFileConfigEntry *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;
+
+ wxFileConfigEntry *newEntry = m_pCurrentGroup->AddEntry(newName);
+ newEntry->SetValue(value);
+
+ return TRUE;
+}
+
+bool wxFileConfig::RenameGroup(const wxString& oldName,
+ const wxString& newName)
+{
+ // check that the group exists
+ wxFileConfigGroup *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
// ----------------------------------------------------------------------------
-bool wxFileConfig::DeleteEntry(const char *szKey, bool bGroupIfEmptyAlso)
+bool wxFileConfig::DeleteEntry(const wxString& key, bool bGroupIfEmptyAlso)
{
- PathChanger path(this, szKey);
+ wxConfigPathChanger path(this, key);
if ( !m_pCurrentGroup->DeleteEntry(path.Name()) )
return FALSE;
if ( bGroupIfEmptyAlso && m_pCurrentGroup->IsEmpty() ) {
if ( m_pCurrentGroup != m_pRootGroup ) {
- ConfigGroup *pGroup = m_pCurrentGroup;
- SetPath(".."); // changes m_pCurrentGroup!
+ wxFileConfigGroup *pGroup = m_pCurrentGroup;
+ SetPath(wxT("..")); // changes m_pCurrentGroup!
m_pCurrentGroup->DeleteSubgroupByName(pGroup->Name());
}
//else: never delete the root group
return TRUE;
}
-bool wxFileConfig::DeleteGroup(const char *szKey)
+bool wxFileConfig::DeleteGroup(const wxString& key)
{
- PathChanger path(this, szKey);
+ wxConfigPathChanger path(this, key);
return m_pCurrentGroup->DeleteSubgroupByName(path.Name());
}
{
CleanUp();
- const char *szFile = m_strLocalFile;
-
- if ( remove(szFile) == -1 )
- wxLogSysError(_("can't delete user configuration file '%s'"), szFile);
-
- szFile = m_strGlobalFile;
- if ( remove(szFile) )
- wxLogSysError(_("can't delete system configuration file '%s'"), szFile);
+ if ( wxRemove(m_strLocalFile) == -1 )
+ wxLogSysError(_("can't delete user configuration file '%s'"), m_strLocalFile.c_str());
- m_strLocalFile = m_strGlobalFile = "";
+ m_strLocalFile = m_strGlobalFile = wxT("");
Init();
return TRUE;
// ----------------------------------------------------------------------------
// append a new line to the end of the list
-wxFileConfig::LineList *wxFileConfig::LineListAppend(const wxString& str)
+wxFileConfigLineList *wxFileConfig::LineListAppend(const wxString& str)
{
- LineList *pLine = new LineList(str);
+ wxFileConfigLineList *pLine = new wxFileConfigLineList(str);
if ( m_linesTail == NULL ) {
// list is empty
}
// insert a new line after the given one or in the very beginning if !pLine
-wxFileConfig::LineList *wxFileConfig::LineListInsert(const wxString& str,
- LineList *pLine)
+wxFileConfigLineList *wxFileConfig::LineListInsert(const wxString& str,
+ wxFileConfigLineList *pLine)
{
if ( pLine == m_linesTail )
return LineListAppend(str);
- LineList *pNewLine = new LineList(str);
+ wxFileConfigLineList *pNewLine = new wxFileConfigLineList(str);
if ( pLine == NULL ) {
// prepend to the list
pNewLine->SetNext(m_linesHead);
}
else {
// insert before pLine
- LineList *pNext = pLine->Next();
+ wxFileConfigLineList *pNext = pLine->Next();
pNewLine->SetNext(pNext);
pNewLine->SetPrev(pLine);
pNext->SetPrev(pNewLine);
return pNewLine;
}
-void wxFileConfig::LineListRemove(LineList *pLine)
+void wxFileConfig::LineListRemove(wxFileConfigLineList *pLine)
{
- LineList *pPrev = pLine->Prev(),
+ wxFileConfigLineList *pPrev = pLine->Prev(),
*pNext = pLine->Next();
// first entry?
// last entry?
if ( pNext == NULL )
m_linesTail = pPrev;
- else
+ else
pNext->SetPrev(pPrev);
delete pLine;
}
// ============================================================================
-// wxFileConfig::ConfigGroup
+// wxFileConfig::wxFileConfigGroup
// ============================================================================
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// ctor
-wxFileConfig::ConfigGroup::ConfigGroup(wxFileConfig::ConfigGroup *pParent,
+wxFileConfigGroup::wxFileConfigGroup(wxFileConfigGroup *pParent,
const wxString& strName,
wxFileConfig *pConfig)
: m_aEntries(CompareEntries),
}
// dtor deletes all children
-wxFileConfig::ConfigGroup::~ConfigGroup()
+wxFileConfigGroup::~wxFileConfigGroup()
{
// entries
- uint n, nCount = m_aEntries.Count();
+ size_t n, nCount = m_aEntries.Count();
for ( n = 0; n < nCount; n++ )
delete m_aEntries[n];
// line
// ----------------------------------------------------------------------------
-void wxFileConfig::ConfigGroup::SetLine(LineList *pLine)
+void wxFileConfigGroup::SetLine(wxFileConfigLineList *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()
+wxFileConfigLineList *wxFileConfigGroup::GetGroupLine()
{
if ( m_pLine == NULL ) {
- ConfigGroup *pParent = Parent();
+ wxFileConfigGroup *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 << wxT("[")
+ // +1: no '/'
+ << FilterOutEntryName(GetFullName().c_str() + 1)
+ << wxT("]");
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()
+wxFileConfigLineList *wxFileConfigGroup::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();
+ wxFileConfigLineList *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()
+wxFileConfigLineList *wxFileConfigGroup::GetLastEntryLine()
{
if ( m_pLastEntry != NULL ) {
- wxFileConfig::LineList *pLine = m_pLastEntry->GetLine();
+ wxFileConfigLineList *pLine = m_pLastEntry->GetLine();
wxASSERT( pLine != NULL ); // last entry must have !NULL associated line
return pLine;
// group name
// ----------------------------------------------------------------------------
-wxString wxFileConfig::ConfigGroup::GetFullName() const
+void wxFileConfigGroup::Rename(const wxString& newName)
+{
+ m_strName = newName;
+
+ wxFileConfigLineList *line = GetGroupLine();
+ wxString strFullName;
+ strFullName << wxT("[") << (GetFullName().c_str() + 1) << wxT("]"); // +1: no '/'
+ line->SetText(strFullName);
+
+ SetDirty();
+}
+
+wxString wxFileConfigGroup::GetFullName() const
{
if ( Parent() )
return Parent()->GetFullName() + wxCONFIG_PATH_SEPARATOR + Name();
else
- return "";
+ return wxT("");
}
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// use binary search because the array is sorted
-wxFileConfig::ConfigEntry *
-wxFileConfig::ConfigGroup::FindEntry(const char *szName) const
+wxFileConfigEntry *
+wxFileConfigGroup::FindEntry(const wxChar *szName) const
{
- uint i,
+ size_t i,
lo = 0,
hi = m_aEntries.Count();
int res;
- wxFileConfig::ConfigEntry *pEntry;
+ wxFileConfigEntry *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
+wxFileConfigGroup *
+wxFileConfigGroup::FindSubgroup(const wxChar *szName) const
{
- uint i,
+ size_t i,
lo = 0,
hi = m_aSubgroups.Count();
int res;
- wxFileConfig::ConfigGroup *pGroup;
+ wxFileConfigGroup *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)
+wxFileConfigEntry *
+wxFileConfigGroup::AddEntry(const wxString& strName, int nLine)
{
wxASSERT( FindEntry(strName) == NULL );
- ConfigEntry *pEntry = new ConfigEntry(this, strName, nLine);
+ wxFileConfigEntry *pEntry = new wxFileConfigEntry(this, strName, nLine);
m_aEntries.Add(pEntry);
return pEntry;
}
// create a new group and add it to the current group
-wxFileConfig::ConfigGroup *
-wxFileConfig::ConfigGroup::AddSubgroup(const wxString& strName)
+wxFileConfigGroup *
+wxFileConfigGroup::AddSubgroup(const wxString& strName)
{
wxASSERT( FindSubgroup(strName) == NULL );
- ConfigGroup *pGroup = new ConfigGroup(this, strName, m_pConfig);
+ wxFileConfigGroup *pGroup = new wxFileConfigGroup(this, strName, m_pConfig);
m_aSubgroups.Add(pGroup);
return pGroup;
delete several of them.
*/
-bool wxFileConfig::ConfigGroup::DeleteSubgroupByName(const char *szName)
+bool wxFileConfigGroup::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 wxFileConfigGroup::DeleteSubgroup(wxFileConfigGroup *pGroup)
{
wxCHECK( pGroup != NULL, FALSE ); // deleting non existing group?
// delete all entries
- uint nCount = pGroup->m_aEntries.Count();
- for ( uint nEntry = 0; nEntry < nCount; nEntry++ ) {
- LineList *pLine = pGroup->m_aEntries[nEntry]->GetLine();
+ size_t nCount = pGroup->m_aEntries.Count();
+ for ( size_t nEntry = 0; nEntry < nCount; nEntry++ ) {
+ wxFileConfigLineList *pLine = pGroup->m_aEntries[nEntry]->GetLine();
if ( pLine != NULL )
m_pConfig->LineListRemove(pLine);
}
// and subgroups of this sungroup
nCount = pGroup->m_aSubgroups.Count();
- for ( uint nGroup = 0; nGroup < nCount; nGroup++ ) {
- pGroup->DeleteSubgroup(pGroup->m_aSubgroups[nGroup]);
+ for ( size_t nGroup = 0; nGroup < nCount; nGroup++ ) {
+ pGroup->DeleteSubgroup(pGroup->m_aSubgroups[0]);
}
- LineList *pLine = pGroup->m_pLine;
+ wxFileConfigLineList *pLine = pGroup->m_pLine;
if ( pLine != NULL ) {
// notice that we may do this test inside the previous "if" because the
// last entry's line is surely !NULL
wxASSERT( m_pLine != NULL ); // we have a subgroup with !NULL pLine...
// go back until we find a subgroup or reach the group's line
- ConfigGroup *pNewLast = NULL;
- uint n, nSubgroups = m_aSubgroups.Count();
- LineList *pl;
+ wxFileConfigGroup *pNewLast = NULL;
+ size_t n, nSubgroups = m_aSubgroups.Count();
+ wxFileConfigLineList *pl;
for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) {
// is it our subgroup?
for ( n = 0; (pNewLast == NULL) && (n < nSubgroups); n++ ) {
return TRUE;
}
-bool wxFileConfig::ConfigGroup::DeleteEntry(const char *szName)
+bool wxFileConfigGroup::DeleteEntry(const wxChar *szName)
{
- ConfigEntry *pEntry = FindEntry(szName);
+ wxFileConfigEntry *pEntry = FindEntry(szName);
wxCHECK( pEntry != NULL, FALSE ); // deleting non existing item?
- LineList *pLine = pEntry->GetLine();
+ wxFileConfigLineList *pLine = pEntry->GetLine();
if ( pLine != NULL ) {
// notice that we may do this test inside the previous "if" because the
// last entry's line is surely !NULL
wxASSERT( m_pLine != NULL ); // if we have an entry with !NULL pLine...
// go back until we find another entry or reach the group's line
- ConfigEntry *pNewLast = NULL;
- uint n, nEntries = m_aEntries.Count();
- LineList *pl;
+ wxFileConfigEntry *pNewLast = NULL;
+ size_t n, nEntries = m_aEntries.Count();
+ wxFileConfigLineList *pl;
for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) {
// is it our subgroup?
for ( n = 0; (pNewLast == NULL) && (n < nEntries); n++ ) {
// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
-void wxFileConfig::ConfigGroup::SetDirty()
+void wxFileConfigGroup::SetDirty()
{
m_bDirty = TRUE;
if ( Parent() != NULL ) // propagate upwards
}
// ============================================================================
-// wxFileConfig::ConfigEntry
+// wxFileConfig::wxFileConfigEntry
// ============================================================================
// ----------------------------------------------------------------------------
// ctor
// ----------------------------------------------------------------------------
-wxFileConfig::ConfigEntry::ConfigEntry(wxFileConfig::ConfigGroup *pParent,
+wxFileConfigEntry::wxFileConfigEntry(wxFileConfigGroup *pParent,
const wxString& strName,
int nLine)
: m_strName(strName)
m_nLine = nLine;
m_pLine = NULL;
- m_bDirty = FALSE;
+ m_bDirty =
+ m_bHasValue = FALSE;
m_bImmutable = strName[0] == wxCONFIG_IMMUTABLE_PREFIX;
if ( m_bImmutable )
// set value
// ----------------------------------------------------------------------------
-void wxFileConfig::ConfigEntry::SetLine(LineList *pLine)
+void wxFileConfigEntry::SetLine(wxFileConfigLineList *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 wxFileConfigEntry::SetValue(const wxString& strValue, bool bUser)
{
if ( bUser && IsImmutable() ) {
wxLogWarning(_("attempt to change immutable key '%s' ignored."),
return;
}
- // do nothing if it's the same value
- if ( strValue == m_strValue )
+ // do nothing if it's the same value: but don't test for it if m_bHasValue
+ // hadn't been set yet or we'd never write empty values to the file
+ if ( m_bHasValue && strValue == m_strValue )
return;
+ m_bHasValue = TRUE;
m_strValue = strValue;
if ( bUser ) {
- wxString strVal = FilterOut(strValue);
+ wxString strVal = FilterOutValue(strValue);
wxString strLine;
- strLine << m_strName << " = " << strVal;
+ strLine << FilterOutEntryName(m_strName) << wxT('=') << 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 wxFileConfigEntry::SetDirty()
{
m_bDirty = TRUE;
Group()->SetDirty();
// compare functions for array sorting
// ----------------------------------------------------------------------------
-int CompareEntries(wxFileConfig::ConfigEntry *p1,
- wxFileConfig::ConfigEntry *p2)
+int CompareEntries(wxFileConfigEntry *p1, wxFileConfigEntry *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(wxFileConfigGroup *p1, wxFileConfigGroup *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 ( uint n = bQuoted ? 1 : 0; n < str.Len(); n++ ) {
- if ( str[n] == '\\' ) {
+ for ( size_t n = bQuoted ? 1 : 0; n < str.Len(); n++ ) {
+ if ( str[n] == wxT('\\') ) {
switch ( str[++n] ) {
- case 'n':
- strResult += '\n';
+ case wxT('n'):
+ strResult += wxT('\n');
break;
- case 'r':
- strResult += '\r';
+ case wxT('r'):
+ strResult += wxT('\r');
break;
- case 't':
- strResult += '\t';
+ case wxT('t'):
+ strResult += wxT('\t');
break;
- case '\\':
- strResult += '\\';
+ case wxT('\\'):
+ strResult += wxT('\\');
break;
- case '"':
- strResult += '"';
+ case wxT('"'):
+ strResult += wxT('"');
break;
}
}
else {
- if ( str[n] != '"' || !bQuoted )
+ if ( str[n] != wxT('"') || !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 )
+ 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] == wxT('"');
if ( bQuote )
- strResult += '"';
+ strResult += wxT('"');
- char c;
- for ( uint n = 0; n < str.Len(); n++ ) {
+ wxChar c;
+ for ( size_t n = 0; n < str.Len(); n++ ) {
switch ( str[n] ) {
- case '\n':
- c = 'n';
+ case wxT('\n'):
+ c = wxT('n');
break;
- case '\r':
- c = 'r';
+ case wxT('\r'):
+ c = wxT('r');
break;
- case '\t':
- c = 't';
+ case wxT('\t'):
+ c = wxT('t');
break;
- case '\\':
- c = '\\';
+ case wxT('\\'):
+ c = wxT('\\');
break;
- case '"':
- if ( bQuote )
- c = '"';
+ case wxT('"'):
+ if ( bQuote ) {
+ c = wxT('"');
+ break;
+ }
//else: fall through
default:
}
// we get here only for special characters
- strResult << '\\' << c;
+ strResult << wxT('\\') << c;
}
if ( bQuote )
- strResult += '"';
+ strResult += wxT('"');
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 == wxT('\\') )
+ 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 != wxT('\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(wxT("@_/-!.*%"), c) && ((c & 0x80) == 0) )
+ strResult += wxT('\\');
+
+ 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