X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/876419ce60c535a06fde52023f7360d2d29ee82a..d1427b705318677afe28b1291867f6930c8823a7:/src/common/fileconf.cpp diff --git a/src/common/fileconf.cpp b/src/common/fileconf.cpp index f2e2c35e03..24d10b9833 100644 --- a/src/common/fileconf.cpp +++ b/src/common/fileconf.cpp @@ -40,23 +40,34 @@ #include // _WINDOWS_ is defined when windows.h is included, -// __WINDOWS__ is defined for MS Windows compilation -#if defined(__WINDOWS__) && !defined(_WINDOWS_) +// __WXMSW__ is defined for MS Windows compilation +#if defined(__WXMSW__) && !defined(_WINDOWS_) #include #endif //windows.h #include #include +// ---------------------------------------------------------------------------- +// macros +// ---------------------------------------------------------------------------- +#define CONST_CAST ((wxFileConfig *)this)-> + // ---------------------------------------------------------------------------- // global functions declarations // ---------------------------------------------------------------------------- // is 'c' a valid character in group name? -// NB: APPCONF_IMMUTABLE_PREFIX and APPCONF_PATH_SEPARATOR must be valid chars, +// 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); + // filter strings static wxString FilterIn(const wxString& str); static wxString FilterOut(const wxString& str); @@ -68,60 +79,88 @@ static wxString FilterOut(const wxString& str); // ---------------------------------------------------------------------------- // static functions // ---------------------------------------------------------------------------- -wxString wxFileConfig::GetGlobalFileName(const char *szFile) +wxString wxFileConfig::GetGlobalDir() { - wxString str; - - bool bNoExt = strchr(szFile, '.') == NULL; + wxString strDir; - #ifdef __UNIX__ - str << "/etc/" << szFile; - if ( bNoExt ) - str << ".conf"; - #else // Windows + #ifdef __UNIX__ + strDir = "/etc/"; + #else // Windows #ifndef _MAX_PATH #define _MAX_PATH 512 #endif char szWinDir[_MAX_PATH]; ::GetWindowsDirectory(szWinDir, _MAX_PATH); - str << szWinDir << "\\" << szFile; - if ( bNoExt ) - str << ".ini"; - #endif // UNIX/Win - return str; + strDir = szWinDir; + strDir << '\\'; + #endif // Unix/Windows + + return strDir; } -wxString wxFileConfig::GetLocalFileName(const char *szFile) +wxString wxFileConfig::GetLocalDir() { - wxString str; + wxString strDir; - #ifdef __UNIX__ + #ifdef __UNIX__ const char *szHome = getenv("HOME"); if ( szHome == NULL ) { // we're homeless... - wxLogWarning("can't find user's HOME, using current directory."); - szHome = "."; + wxLogWarning(_("can't find user's HOME, using current directory.")); + strDir = "."; } - str << szHome << "/." << szFile; + 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 ) - str << szHome; + strDir << szHome; szHome = getenv("HOMEPATH"); if ( szHome != NULL ) - str << szHome; - str << szFile; - if ( strchr(szFile, '.') == NULL ) - str << ".ini"; + strDir << szHome; #else // Win16 // Win16 has no idea about home, so use the current directory instead - str << ".\\" << szFile; + strDir = ".\\"; #endif // WIN16/32 #endif // UNIX/Win + return strDir; +} + +wxString wxFileConfig::GetGlobalFileName(const char *szFile) +{ + wxString str = GetGlobalDir(); + str << szFile; + + if ( strchr(szFile, '.') == NULL ) + #ifdef __UNIX__ + str << ".conf"; + #else // Windows + str << ".ini"; + #endif // UNIX/Win + + return str; +} + +wxString wxFileConfig::GetLocalFileName(const char *szFile) +{ + wxString str = GetLocalDir(); + + #ifdef __UNIX__ + str << '.'; + #endif + + str << szFile; + + #ifdef __WXMSW__ + if ( strchr(szFile, '.') == NULL ) + str << ".ini"; + #endif + return str; } @@ -137,50 +176,82 @@ void wxFileConfig::Init() m_linesHead = m_linesTail = NULL; - m_bExpandEnvVars = TRUE; - - m_strPath.Empty(); -} - -wxFileConfig::wxFileConfig(const wxString& strLocal, const wxString& strGlobal) - : m_strLocalFile(strLocal), m_strGlobalFile(strGlobal) -{ - Init(); - // it's not an error if (one of the) file(s) doesn't exist // parse the global file - if ( !strGlobal.IsEmpty() ) { - if ( wxFile::Exists(strGlobal) ) { - wxTextFile fileGlobal(strGlobal); + if ( !m_strGlobalFile.IsEmpty() && wxFile::Exists(m_strGlobalFile) ) { + wxTextFile fileGlobal(m_strGlobalFile); - if ( fileGlobal.Open() ) { - Parse(fileGlobal, FALSE /* global */); - SetRootPath(); - } - else - wxLogWarning("Can't open global configuration file '%s'.", - strGlobal.c_str()); + if ( fileGlobal.Open() ) { + Parse(fileGlobal, FALSE /* global */); + SetRootPath(); } + else + wxLogWarning(_("can't open global configuration file '%s'."), + m_strGlobalFile.c_str()); } // parse the local file - if ( wxFile::Exists(strLocal) ) { - wxTextFile fileLocal(strLocal); + if ( !m_strLocalFile.IsEmpty() && wxFile::Exists(m_strLocalFile) ) { + wxTextFile fileLocal(m_strLocalFile); if ( fileLocal.Open() ) { Parse(fileLocal, TRUE /* local */); SetRootPath(); } else - wxLogWarning("Can't open user configuration file '%s'.", - strLocal.c_str()); + wxLogWarning(_("can't open user configuration file '%s'."), + m_strLocalFile.c_str()); + } +} + +wxFileConfig::wxFileConfig(const char *szAppName, bool bLocalOnly) +{ + wxASSERT( !IsEmpty(szAppName) ); // invent a name for your application! + + 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 + + Init(); +} + +wxFileConfig::wxFileConfig(const wxString& strLocal, const wxString& strGlobal) + : m_strLocalFile(strLocal), m_strGlobalFile(strGlobal) +{ + // if the path is not absolute, prepend the standard directory to it + if ( !strLocal.IsEmpty() && !wxIsAbsolutePath(strLocal) ) + { + m_strLocalFile = GetLocalDir(); + m_strLocalFile << strLocal; + } + + if ( !strGlobal.IsEmpty() && !wxIsAbsolutePath(strGlobal) ) + { + m_strGlobalFile = GetGlobalDir(); + m_strGlobalFile << strGlobal; + } + + Init(); +} + +void wxFileConfig::CleanUp() +{ + delete m_pRootGroup; + + LineList *pCur = m_linesHead; + while ( pCur != NULL ) { + LineList *pNext = pCur->Next(); + delete pCur; + pCur = pNext; } } wxFileConfig::~wxFileConfig() { Flush(); - delete m_pRootGroup; + + CleanUp(); } // ---------------------------------------------------------------------------- @@ -191,14 +262,18 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal) { const char *pStart; const char *pEnd; + wxString strLine; + + uint nLineCount = file.GetLineCount(); + for ( uint n = 0; n < nLineCount; n++ ) { + strLine = file[n]; - for ( uint n = 0; n < file.GetLineCount(); n++ ) { // add the line to linked list if ( bLocal ) - LineListAppend(file[n]); + LineListAppend(strLine); // skip leading spaces - for ( pStart = file[n]; isspace(*pStart); pStart++ ) + for ( pStart = strLine; isspace(*pStart); pStart++ ) ; // skip blank/comment lines @@ -214,15 +289,15 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal) } if ( *pEnd != ']' ) { - wxLogError("file '%s': unexpected character at line %d (missing ']'?)", - file.GetName(), n + 1); + 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 << APPCONF_PATH_SEPARATOR << wxString(pStart, pEnd - pStart); + strGroup << wxCONFIG_PATH_SEPARATOR << wxString(pStart, pEnd - pStart); // will create it if doesn't yet exist SetPath(strGroup); @@ -245,7 +320,8 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal) break; default: - wxLogWarning("file '%s', line %d: '%s' ignored after group header.", + wxLogWarning(_("file '%s', line %d: '%s' " + "ignored after group header."), file.GetName(), n + 1, pEnd); bCont = FALSE; } @@ -263,7 +339,8 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal) pEnd++; if ( *pEnd++ != '=' ) { - wxLogError("file '%s', line %d: '=' expected.", file.GetName(), n + 1); + wxLogError(_("file '%s', line %d: '=' expected."), + file.GetName(), n + 1); } else { ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strKey); @@ -278,7 +355,8 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal) else { if ( bLocal && pEntry->IsImmutable() ) { // immutable keys can't be changed by user - wxLogWarning("file '%s', line %d: value for immutable key '%s' ignored.", + wxLogWarning(_("file '%s', line %d: value for " + "immutable key '%s' ignored."), file.GetName(), n + 1, strKey.c_str()); continue; } @@ -288,7 +366,8 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal) // (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.", + wxLogWarning(_("file '%s', line %d: key '%s' was first " + "found at line %d."), file.GetName(), n + 1, strKey.c_str(), pEntry->Line()); if ( bLocal ) @@ -300,12 +379,7 @@ void wxFileConfig::Parse(wxTextFile& file, bool bLocal) while ( isspace(*pEnd) ) pEnd++; - wxString strValue; - if (m_bExpandEnvVars) - strValue = ExpandEnvVars(FilterIn(pEnd)); - else - strValue = FilterIn(pEnd); - pEntry->SetValue(strValue, FALSE); + pEntry->SetValue(FilterIn(pEnd), FALSE /* read from file */); } } } @@ -330,15 +404,15 @@ void wxFileConfig::SetPath(const wxString& strPath) return; } - if ( strPath[0] == APPCONF_PATH_SEPARATOR ) { + if ( strPath[0] == wxCONFIG_PATH_SEPARATOR ) { // absolute path - SplitPath(aParts, strPath); + wxSplitPath(aParts, strPath); } else { // relative path, combine with current one wxString strFullPath = m_strPath; - strFullPath << APPCONF_PATH_SEPARATOR << strPath; - SplitPath(aParts, strFullPath); + strFullPath << wxCONFIG_PATH_SEPARATOR << strPath; + wxSplitPath(aParts, strFullPath); } // change current group @@ -354,7 +428,7 @@ void wxFileConfig::SetPath(const wxString& strPath) // recombine path parts in one variable m_strPath.Empty(); for ( n = 0; n < aParts.Count(); n++ ) { - m_strPath << APPCONF_PATH_SEPARATOR << aParts[n]; + m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n]; } } @@ -362,13 +436,13 @@ void wxFileConfig::SetPath(const wxString& strPath) // enumeration // ---------------------------------------------------------------------------- -bool wxFileConfig::GetFirstGroup(wxString& str, long& lIndex) +bool wxFileConfig::GetFirstGroup(wxString& str, long& lIndex) const { lIndex = 0; return GetNextGroup(str, lIndex); } -bool wxFileConfig::GetNextGroup (wxString& str, long& lIndex) +bool wxFileConfig::GetNextGroup (wxString& str, long& lIndex) const { if ( uint(lIndex) < m_pCurrentGroup->Groups().Count() ) { str = m_pCurrentGroup->Groups()[lIndex++]->Name(); @@ -378,13 +452,13 @@ bool wxFileConfig::GetNextGroup (wxString& str, long& lIndex) return FALSE; } -bool wxFileConfig::GetFirstEntry(wxString& str, long& lIndex) +bool wxFileConfig::GetFirstEntry(wxString& str, long& lIndex) const { lIndex = 0; return GetNextEntry(str, lIndex); } -bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) +bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) const { if ( uint(lIndex) < m_pCurrentGroup->Entries().Count() ) { str = m_pCurrentGroup->Entries()[lIndex++]->Name(); @@ -394,6 +468,38 @@ bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) return FALSE; } +uint wxFileConfig::GetNumberOfEntries(bool bRecursive) const +{ + uint n = m_pCurrentGroup->Entries().Count(); + if ( bRecursive ) { + ConfigGroup *pOldCurrentGroup = m_pCurrentGroup; + uint nSubgroups = m_pCurrentGroup->Groups().Count(); + for ( uint 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 +{ + uint n = m_pCurrentGroup->Groups().Count(); + if ( bRecursive ) { + ConfigGroup *pOldCurrentGroup = m_pCurrentGroup; + uint nSubgroups = m_pCurrentGroup->Groups().Count(); + for ( uint nGroup = 0; nGroup < nSubgroups; nGroup++ ) { + CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup]; + n += GetNumberOfGroups(TRUE); + CONST_CAST m_pCurrentGroup = pOldCurrentGroup; + } + } + + return n; +} + // ---------------------------------------------------------------------------- // tests for existence // ---------------------------------------------------------------------------- @@ -418,15 +524,6 @@ bool wxFileConfig::HasEntry(const wxString& strName) const // read/write values // ---------------------------------------------------------------------------- -const char *wxFileConfig::Read(const char *szKey, - const char *szDefault) const -{ - PathChanger path(this, szKey); - - ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name()); - return pEntry == NULL ? szDefault : pEntry->Value().c_str(); -} - bool wxFileConfig::Read(wxString *pstr, const char *szKey, const char *szDefault) const @@ -435,15 +532,26 @@ bool wxFileConfig::Read(wxString *pstr, ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name()); if (pEntry == NULL) { - *pstr = szDefault; + if( IsRecordingDefaults() ) + ((wxFileConfig *)this)->Write(szKey,szDefault); + *pstr = ExpandEnvVars(szDefault); return FALSE; } else { - *pstr = pEntry->Value(); + *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); + + return s_str.c_str(); +} + bool wxFileConfig::Read(long *pl, const char *szKey, long lDefault) const { wxString str; @@ -461,10 +569,41 @@ bool wxFileConfig::Write(const char *szKey, const char *szValue) { PathChanger path(this, szKey); - ConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name()); - if ( pEntry == NULL ) - pEntry = m_pCurrentGroup->AddEntry(path.Name()); - pEntry->SetValue(szValue); + 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!") ); + + // ... except if it's empty in which case it's a way to force it's creation + m_pCurrentGroup->SetDirty(); + + // this will add a line for this group if it didn't have it before + (void)m_pCurrentGroup->GetGroupLine(); + } + else { + // writing an entry + + // check that the name is reasonable + if ( strName[0u] == wxCONFIG_IMMUTABLE_PREFIX ) { + wxLogError(_("Entry name can't 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); + + pEntry->SetValue(szValue); + } return TRUE; } @@ -485,14 +624,14 @@ bool wxFileConfig::Flush(bool /* bCurrentOnly */) wxTempFile file(m_strLocalFile); if ( !file.IsOpened() ) { - wxLogError("Can't open user configuration file."); + wxLogError(_("can't open user configuration file.")); return FALSE; } // write all strings to file for ( LineList *p = m_linesHead; p != NULL; p = p->Next() ) { if ( !file.Write(p->Text() + wxTextFile::GetEOL()) ) { - wxLogError("Can't write user configuration file."); + wxLogError(_("can't write user configuration file.")); return FALSE; } } @@ -515,7 +654,7 @@ bool wxFileConfig::DeleteEntry(const char *szKey, bool bGroupIfEmptyAlso) if ( m_pCurrentGroup != m_pRootGroup ) { ConfigGroup *pGroup = m_pCurrentGroup; SetPath(".."); // changes m_pCurrentGroup! - m_pCurrentGroup->DeleteSubgroup(pGroup->Name()); + m_pCurrentGroup->DeleteSubgroupByName(pGroup->Name()); } //else: never delete the root group } @@ -527,21 +666,20 @@ bool wxFileConfig::DeleteGroup(const char *szKey) { PathChanger path(this, szKey); - return m_pCurrentGroup->DeleteSubgroup(path.Name()); + return m_pCurrentGroup->DeleteSubgroupByName(path.Name()); } bool wxFileConfig::DeleteAll() { + CleanUp(); + const char *szFile = m_strLocalFile; - delete m_pRootGroup; - Init(); if ( remove(szFile) == -1 ) - wxLogSysError("Can't delete user configuration file '%s'", szFile); + wxLogSysError(_("can't delete user configuration file '%s'"), szFile); - szFile = m_strGlobalFile; - if ( remove(szFile) ) - wxLogSysError("Can't delete system configuration file '%s'", szFile); + m_strLocalFile = m_strGlobalFile = ""; + Init(); return TRUE; } @@ -599,16 +737,18 @@ void wxFileConfig::LineListRemove(LineList *pLine) { LineList *pPrev = pLine->Prev(), *pNext = pLine->Next(); - if ( pPrev == NULL ) { - // deleting the first entry + + // first entry? + if ( pPrev == NULL ) m_linesHead = pNext; - } - else { - // not the first entry + else pPrev->SetNext(pNext); - } - pNext->SetPrev(pPrev); + // last entry? + if ( pNext == NULL ) + m_linesTail = pPrev; + else + pNext->SetPrev(pPrev); delete pLine; } @@ -630,12 +770,15 @@ bool wxFileConfig::LineListIsEmpty() wxFileConfig::ConfigGroup::ConfigGroup(wxFileConfig::ConfigGroup *pParent, const wxString& strName, wxFileConfig *pConfig) - : m_strName(strName) + : m_aEntries(CompareEntries), + m_aSubgroups(CompareGroups), + m_strName(strName) { m_pConfig = pConfig; m_pParent = pParent; - m_pLine = NULL; m_bDirty = FALSE; + m_pLine = NULL; + m_pLastEntry = NULL; m_pLastGroup = NULL; } @@ -665,17 +808,52 @@ void wxFileConfig::ConfigGroup::SetLine(LineList *pLine) m_pLine = pLine; } -// return the line which contains "[our name]" +/* + This is a bit complicated, so let me explain it in details. All lines that + were read from the local file (the only one we will ever modify) are stored + in a (doubly) linked list. Our problem is to know at which position in this + list should we insert the new entries/subgroups. To solve it we keep three + variables for each group: m_pLine, m_pLastEntry and m_pLastGroup. + + m_pLine points to the line containing "[group_name]" + m_pLastEntry points to the last entry of this group in the local file. + m_pLastGroup subgroup + + Initially, they're NULL all three. When the group (an entry/subgroup) is read + from the local file, the corresponding variable is set. However, if the group + was read from the global file and then modified or created by the application + these variables are still NULL and we need to create the corresponding lines. + See the following functions (and comments preceding them) for the details of + how we do it. + + Also, when our last entry/group are deleted we need to find the new last + element - the code in DeleteEntry/Subgroup does this by backtracking the list + of lines until it either founds an entry/subgroup (and this is the new last + element) or the m_pLine of the group, in which case there are no more entries + (or subgroups) left and m_pLast becomes NULL. + + NB: This last problem could be avoided for entries if we added new entries + immediately after m_pLine, but in this case the entries would appear + 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() { if ( m_pLine == NULL ) { + ConfigGroup *pParent = Parent(); + // this group wasn't present in local config file, add it now - if ( Parent() != NULL ) { + if ( pParent != NULL ) { wxString strFullName; strFullName << "[" << GetFullName().c_str() + 1 << "]"; // +1: no '/' m_pLine = m_pConfig->LineListInsert(strFullName, - Parent()->GetLastGroupLine()); - Parent()->SetLastGroup(this); + pParent->GetLastGroupLine()); + pParent->SetLastGroup(this); // we're surely after all the others } else { // we return NULL, so that LineListInsert() will insert us in the @@ -686,25 +864,27 @@ wxFileConfig::LineList *wxFileConfig::ConfigGroup::GetGroupLine() return m_pLine; } -// return the last line belonging to the subgroups of this group -// (after which we can add a new subgroup) +// 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() { // if we have any subgroups, our last line is the last line of the last // subgroup - if ( m_pLastGroup != NULL ) - return m_pLastGroup->GetLastGroupLine(); + if ( m_pLastGroup != NULL ) { + wxFileConfig::LineList *pLine = m_pLastGroup->GetLastGroupLine(); - // if we have any entries, our last line is the last entry - if ( m_pLastEntry != NULL ) - return m_pLastEntry->GetLine(); + wxASSERT( pLine != NULL ); // last group must have !NULL associated line + return pLine; + } - // nothing at all: last line is the first one - return GetGroupLine(); + // no subgroups, so the last line is the line of thelast entry (if any) + return GetLastEntryLine(); } -// return the last line belonging to the entries of this group -// (after which we can add a new entry) +// 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() { if ( m_pLastEntry != NULL ) { @@ -714,7 +894,7 @@ wxFileConfig::LineList *wxFileConfig::ConfigGroup::GetLastEntryLine() return pLine; } - // no entrues: insert after the group header + // no entries: insert after the group header return GetGroupLine(); } @@ -725,7 +905,7 @@ wxFileConfig::LineList *wxFileConfig::ConfigGroup::GetLastEntryLine() wxString wxFileConfig::ConfigGroup::GetFullName() const { if ( Parent() ) - return Parent()->GetFullName() + APPCONF_PATH_SEPARATOR + Name(); + return Parent()->GetFullName() + wxCONFIG_PATH_SEPARATOR + Name(); else return ""; } @@ -734,13 +914,32 @@ wxString wxFileConfig::ConfigGroup::GetFullName() const // find an item // ---------------------------------------------------------------------------- +// use binary search because the array is sorted wxFileConfig::ConfigEntry * wxFileConfig::ConfigGroup::FindEntry(const char *szName) const { - uint nCount = m_aEntries.Count(); - for ( uint n = 0; n < nCount; n++ ) { - if ( m_aEntries[n]->Name().IsSameAs(szName, APPCONF_CASE_SENSITIVE) ) - return m_aEntries[n]; + uint i, + lo = 0, + hi = m_aEntries.Count(); + int res; + wxFileConfig::ConfigEntry *pEntry; + + while ( lo < hi ) { + i = (lo + hi)/2; + pEntry = m_aEntries[i]; + + #if wxCONFIG_CASE_SENSITIVE + res = strcmp(pEntry->Name(), szName); + #else + res = Stricmp(pEntry->Name(), szName); + #endif + + if ( res > 0 ) + hi = i; + else if ( res < 0 ) + lo = i + 1; + else + return pEntry; } return NULL; @@ -749,10 +948,28 @@ wxFileConfig::ConfigGroup::FindEntry(const char *szName) const wxFileConfig::ConfigGroup * wxFileConfig::ConfigGroup::FindSubgroup(const char *szName) const { - uint nCount = m_aSubgroups.Count(); - for ( uint n = 0; n < nCount; n++ ) { - if ( m_aSubgroups[n]->Name().IsSameAs(szName, APPCONF_CASE_SENSITIVE) ) - return m_aSubgroups[n]; + uint i, + lo = 0, + hi = m_aSubgroups.Count(); + int res; + wxFileConfig::ConfigGroup *pGroup; + + while ( lo < hi ) { + i = (lo + hi)/2; + pGroup = m_aSubgroups[i]; + + #if wxCONFIG_CASE_SENSITIVE + res = strcmp(pGroup->Name(), szName); + #else + res = Stricmp(pGroup->Name(), szName); + #endif + + if ( res > 0 ) + hi = i; + else if ( res < 0 ) + lo = i + 1; + else + return pGroup; } return NULL; @@ -790,56 +1007,132 @@ wxFileConfig::ConfigGroup::AddSubgroup(const wxString& strName) // delete an item // ---------------------------------------------------------------------------- -bool wxFileConfig::ConfigGroup::DeleteSubgroup(const char *szName) +/* + The delete operations are _very_ slow if we delete the last item of this + group (see comments before GetXXXLineXXX functions for more details), + so it's much better to start with the first entry/group if we want to + delete several of them. + */ + +bool wxFileConfig::ConfigGroup::DeleteSubgroupByName(const char *szName) { - uint n, nCount = m_aSubgroups.Count(); - for ( n = 0; n < nCount; n++ ) { - if ( m_aSubgroups[n]->Name().IsSameAs(szName, APPCONF_CASE_SENSITIVE) ) - break; - } + return DeleteSubgroup(FindSubgroup(szName)); +} - if ( n == nCount ) - return FALSE; +// 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) +{ + wxCHECK( pGroup != NULL, FALSE ); // deleting non existing group? - nCount = m_aEntries.Count(); - for ( n = 0; n < nCount; n++ ) { - LineList *pLine = m_aEntries[n]->GetLine(); + // delete all entries + uint nCount = pGroup->m_aEntries.Count(); + for ( uint nEntry = 0; nEntry < nCount; nEntry++ ) { + LineList *pLine = pGroup->m_aEntries[nEntry]->GetLine(); if ( pLine != NULL ) m_pConfig->LineListRemove(pLine); } - ConfigGroup *pGroup = m_aSubgroups[n]; + // and subgroups of this sungroup + nCount = pGroup->m_aSubgroups.Count(); + for ( uint nGroup = 0; nGroup < nCount; nGroup++ ) { + pGroup->DeleteSubgroup(pGroup->m_aSubgroups[nGroup]); + } + LineList *pLine = pGroup->m_pLine; - if ( pLine != NULL ) + if ( pLine != NULL ) { + // notice that we may do this test inside the previous "if" because the + // last entry's line is surely !NULL + if ( pGroup == m_pLastGroup ) { + // our last entry is being deleted - find the last one which stays + 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; + for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) { + // is it our subgroup? + for ( n = 0; (pNewLast == NULL) && (n < nSubgroups); n++ ) { + // do _not_ call GetGroupLine! we don't want to add it to the local + // file if it's not already there + if ( m_aSubgroups[n]->m_pLine == m_pLine ) + pNewLast = m_aSubgroups[n]; + } + + if ( pNewLast != NULL ) // found? + break; + } + + if ( pl == m_pLine ) { + wxASSERT( !pNewLast ); // how comes it has the same line as we? + + // we've reached the group line without finding any subgroups + m_pLastGroup = NULL; + } + else + m_pLastGroup = pNewLast; + } + m_pConfig->LineListRemove(pLine); - delete pGroup; + } SetDirty(); - m_aSubgroups.Remove(n); + m_aSubgroups.Remove(pGroup); + delete pGroup; + return TRUE; } bool wxFileConfig::ConfigGroup::DeleteEntry(const char *szName) { - uint n, nCount = m_aEntries.Count(); - for ( n = 0; n < nCount; n++ ) { - if ( m_aEntries[n]->Name().IsSameAs(szName, APPCONF_CASE_SENSITIVE) ) - break; - } + ConfigEntry *pEntry = FindEntry(szName); + wxCHECK( pEntry != NULL, FALSE ); // deleting non existing item? - if ( n == nCount ) - return FALSE; - - ConfigEntry *pEntry = m_aEntries[n]; LineList *pLine = pEntry->GetLine(); - if ( pLine != NULL ) + if ( pLine != NULL ) { + // notice that we may do this test inside the previous "if" because the + // last entry's line is surely !NULL + if ( pEntry == m_pLastEntry ) { + // our last entry is being deleted - find the last one which stays + 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; + for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) { + // is it our subgroup? + for ( n = 0; (pNewLast == NULL) && (n < nEntries); n++ ) { + if ( m_aEntries[n]->GetLine() == m_pLine ) + pNewLast = m_aEntries[n]; + } + + if ( pNewLast != NULL ) // found? + break; + } + + if ( pl == m_pLine ) { + wxASSERT( !pNewLast ); // how comes it has the same line as we? + + // we've reached the group line without finding any subgroups + m_pLastEntry = NULL; + } + else + m_pLastEntry = pNewLast; + } + m_pConfig->LineListRemove(pLine); - delete pEntry; + } + // we must be written back for the changes to be saved SetDirty(); - m_aEntries.Remove(n); + m_aEntries.Remove(pEntry); + delete pEntry; + return TRUE; } @@ -865,13 +1158,15 @@ wxFileConfig::ConfigEntry::ConfigEntry(wxFileConfig::ConfigGroup *pParent, int nLine) : m_strName(strName) { + wxASSERT( !strName.IsEmpty() ); + m_pParent = pParent; m_nLine = nLine; m_pLine = NULL; m_bDirty = FALSE; - m_bImmutable = strName[0] == APPCONF_IMMUTABLE_PREFIX; + m_bImmutable = strName[0] == wxCONFIG_IMMUTABLE_PREFIX; if ( m_bImmutable ) m_strName.erase(0, 1); // remove first character } @@ -883,7 +1178,7 @@ wxFileConfig::ConfigEntry::ConfigEntry(wxFileConfig::ConfigGroup *pParent, void wxFileConfig::ConfigEntry::SetLine(LineList *pLine) { if ( m_pLine != NULL ) { - wxLogWarning("Entry '%s' appears more than once in group '%s'", + wxLogWarning(_("entry '%s' appears more than once in group '%s'"), Name().c_str(), m_pParent->GetFullName().c_str()); } @@ -896,7 +1191,7 @@ void wxFileConfig::ConfigEntry::SetLine(LineList *pLine) void wxFileConfig::ConfigEntry::SetValue(const wxString& strValue, bool bUser) { if ( bUser && IsImmutable() ) { - wxLogWarning("Attempt to change immutable key '%s' ignored.", + wxLogWarning(_("attempt to change immutable key '%s' ignored."), Name().c_str()); return; } @@ -939,10 +1234,39 @@ void wxFileConfig::ConfigEntry::SetDirty() // global functions // ============================================================================ +// ---------------------------------------------------------------------------- +// compare functions for array sorting +// ---------------------------------------------------------------------------- + +int CompareEntries(wxFileConfig::ConfigEntry *p1, + wxFileConfig::ConfigEntry *p2) +{ + #if wxCONFIG_CASE_SENSITIVE + return strcmp(p1->Name(), p2->Name()); + #else + return Stricmp(p1->Name(), p2->Name()); + #endif +} + +int CompareGroups(wxFileConfig::ConfigGroup *p1, + wxFileConfig::ConfigGroup *p2) +{ + #if wxCONFIG_CASE_SENSITIVE + return strcmp(p1->Name(), p2->Name()); + #else + return Stricmp(p1->Name(), p2->Name()); + #endif +} + +// ---------------------------------------------------------------------------- +// filter functions +// ---------------------------------------------------------------------------- + // undo FilterOut wxString FilterIn(const wxString& str) { wxString strResult; + strResult.Alloc(str.Len()); bool bQuoted = !str.IsEmpty() && str[0] == '"'; @@ -953,6 +1277,10 @@ wxString FilterIn(const wxString& str) strResult += '\n'; break; + case 'r': + strResult += '\r'; + break; + case 't': strResult += '\t'; break; @@ -969,8 +1297,10 @@ wxString FilterIn(const wxString& str) else { if ( str[n] != '"' || !bQuoted ) strResult += str[n]; - else if ( n != str.Len() - 1 ) - wxLogWarning("unexpected \" at position %d in '%s'.", n, str.c_str()); + else if ( n != str.Len() - 1 ) { + wxLogWarning(_("unexpected \" at position %d in '%s'."), + n, str.c_str()); + } //else: it's the last quote of a quoted string, ok } } @@ -982,6 +1312,7 @@ wxString FilterIn(const wxString& str) wxString FilterOut(const wxString& 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] == '"'; @@ -996,6 +1327,10 @@ wxString FilterOut(const wxString& str) c = 'n'; break; + case '\r': + c = 'r'; + break; + case '\t': c = 't'; break; @@ -1005,8 +1340,10 @@ wxString FilterOut(const wxString& str) break; case '"': - if ( bQuote ) + if ( bQuote ) { c = '"'; + break; + } //else: fall through default: