]> git.saurik.com Git - wxWidgets.git/blob - src/common/fileconf.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
a tad bit more padding
[wxWidgets.git] / src / common / fileconf.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/fileconf.cpp
3 // Purpose: implementation of wxFileConfig derivation of wxConfig
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 07.04.98 (adapted from appconf.cpp)
7 // RCS-ID: $Id$
8 // Copyright: (c) 1997 Karsten Ballüder & Vadim Zeitlin
9 // Ballueder@usa.net <zeitlin@dptmaths.ens-cachan.fr>
10 // Licence: wxWindows licence
11 ///////////////////////////////////////////////////////////////////////////////
12
13 // ----------------------------------------------------------------------------
14 // headers
15 // ----------------------------------------------------------------------------
16
17 // For compilers that support precompilation, includes "wx.h".
18 #include "wx/wxprec.h"
19
20 #ifdef __BORLANDC__
21 #pragma hdrstop
22 #endif //__BORLANDC__
23
24 #if wxUSE_CONFIG && wxUSE_FILECONFIG
25
26 #ifndef WX_PRECOMP
27 #include "wx/dynarray.h"
28 #include "wx/string.h"
29 #include "wx/intl.h"
30 #include "wx/log.h"
31 #include "wx/app.h"
32 #include "wx/utils.h" // for wxGetHomeDir
33 #if wxUSE_STREAMS
34 #include "wx/stream.h"
35 #endif // wxUSE_STREAMS
36 #endif //WX_PRECOMP
37
38 #include "wx/file.h"
39 #include "wx/textfile.h"
40 #include "wx/memtext.h"
41 #include "wx/config.h"
42 #include "wx/fileconf.h"
43 #include "wx/filefn.h"
44
45 #if defined(__WXMAC__)
46 #include "wx/mac/private.h" // includes mac headers
47 #include "wx/filename.h" // for MacSetTypeAndCreator
48 #endif
49
50 #if defined(__WXMSW__)
51 #include "wx/msw/private.h"
52 #endif //windows.h
53 #if defined(__WXPM__)
54 #define INCL_DOS
55 #include <os2.h>
56 #endif
57
58 #include <stdlib.h>
59 #include <ctype.h>
60
61 // ----------------------------------------------------------------------------
62 // macros
63 // ----------------------------------------------------------------------------
64 #define CONST_CAST ((wxFileConfig *)this)->
65
66 // ----------------------------------------------------------------------------
67 // constants
68 // ----------------------------------------------------------------------------
69
70 #ifndef MAX_PATH
71 #define MAX_PATH 512
72 #endif
73
74 #define FILECONF_TRACE_MASK _T("fileconf")
75
76 // ----------------------------------------------------------------------------
77 // global functions declarations
78 // ----------------------------------------------------------------------------
79
80 // compare functions for sorting the arrays
81 static int LINKAGEMODE CompareEntries(wxFileConfigEntry *p1, wxFileConfigEntry *p2);
82 static int LINKAGEMODE CompareGroups(wxFileConfigGroup *p1, wxFileConfigGroup *p2);
83
84 // filter strings
85 static wxString FilterInValue(const wxString& str);
86 static wxString FilterOutValue(const wxString& str);
87
88 static wxString FilterInEntryName(const wxString& str);
89 static wxString FilterOutEntryName(const wxString& str);
90
91 // get the name to use in wxFileConfig ctor
92 static wxString GetAppName(const wxString& appname);
93
94 // ============================================================================
95 // private classes
96 // ============================================================================
97
98 // ----------------------------------------------------------------------------
99 // "template" array types
100 // ----------------------------------------------------------------------------
101
102 #ifdef WXMAKINGDLL_BASE
103 WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(wxFileConfigEntry *, ArrayEntries,
104 WXDLLIMPEXP_BASE);
105 WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(wxFileConfigGroup *, ArrayGroups,
106 WXDLLIMPEXP_BASE);
107 #else
108 WX_DEFINE_SORTED_ARRAY(wxFileConfigEntry *, ArrayEntries);
109 WX_DEFINE_SORTED_ARRAY(wxFileConfigGroup *, ArrayGroups);
110 #endif
111
112 // ----------------------------------------------------------------------------
113 // wxFileConfigLineList
114 // ----------------------------------------------------------------------------
115
116 // we store all lines of the local config file as a linked list in memory
117 class wxFileConfigLineList
118 {
119 public:
120 void SetNext(wxFileConfigLineList *pNext) { m_pNext = pNext; }
121 void SetPrev(wxFileConfigLineList *pPrev) { m_pPrev = pPrev; }
122
123 // ctor
124 wxFileConfigLineList(const wxString& str,
125 wxFileConfigLineList *pNext = NULL) : m_strLine(str)
126 { SetNext(pNext); SetPrev(NULL); }
127
128 // next/prev nodes in the linked list
129 wxFileConfigLineList *Next() const { return m_pNext; }
130 wxFileConfigLineList *Prev() const { return m_pPrev; }
131
132 // get/change lines text
133 void SetText(const wxString& str) { m_strLine = str; }
134 const wxString& Text() const { return m_strLine; }
135
136 private:
137 wxString m_strLine; // line contents
138 wxFileConfigLineList *m_pNext, // next node
139 *m_pPrev; // previous one
140
141 DECLARE_NO_COPY_CLASS(wxFileConfigLineList)
142 };
143
144 // ----------------------------------------------------------------------------
145 // wxFileConfigEntry: a name/value pair
146 // ----------------------------------------------------------------------------
147
148 class wxFileConfigEntry
149 {
150 private:
151 wxFileConfigGroup *m_pParent; // group that contains us
152
153 wxString m_strName, // entry name
154 m_strValue; // value
155 bool m_bImmutable:1, // can be overriden locally?
156 m_bHasValue:1; // set after first call to SetValue()
157
158 int m_nLine; // used if m_pLine == NULL only
159
160 // pointer to our line in the linked list or NULL if it was found in global
161 // file (which we don't modify)
162 wxFileConfigLineList *m_pLine;
163
164 public:
165 wxFileConfigEntry(wxFileConfigGroup *pParent,
166 const wxString& strName, int nLine);
167
168 // simple accessors
169 const wxString& Name() const { return m_strName; }
170 const wxString& Value() const { return m_strValue; }
171 wxFileConfigGroup *Group() const { return m_pParent; }
172 bool IsImmutable() const { return m_bImmutable; }
173 bool IsLocal() const { return m_pLine != 0; }
174 int Line() const { return m_nLine; }
175 wxFileConfigLineList *
176 GetLine() const { return m_pLine; }
177
178 // modify entry attributes
179 void SetValue(const wxString& strValue, bool bUser = true);
180 void SetLine(wxFileConfigLineList *pLine);
181
182 DECLARE_NO_COPY_CLASS(wxFileConfigEntry)
183 };
184
185 // ----------------------------------------------------------------------------
186 // wxFileConfigGroup: container of entries and other groups
187 // ----------------------------------------------------------------------------
188
189 class wxFileConfigGroup
190 {
191 private:
192 wxFileConfig *m_pConfig; // config object we belong to
193 wxFileConfigGroup *m_pParent; // parent group (NULL for root group)
194 ArrayEntries m_aEntries; // entries in this group
195 ArrayGroups m_aSubgroups; // subgroups
196 wxString m_strName; // group's name
197 wxFileConfigLineList *m_pLine; // pointer to our line in the linked list
198 wxFileConfigEntry *m_pLastEntry; // last entry/subgroup of this group in the
199 wxFileConfigGroup *m_pLastGroup; // local file (we insert new ones after it)
200
201 // DeleteSubgroupByName helper
202 bool DeleteSubgroup(wxFileConfigGroup *pGroup);
203
204 // used by Rename()
205 void UpdateGroupAndSubgroupsLines();
206
207 public:
208 // ctor
209 wxFileConfigGroup(wxFileConfigGroup *pParent, const wxString& strName, wxFileConfig *);
210
211 // dtor deletes all entries and subgroups also
212 ~wxFileConfigGroup();
213
214 // simple accessors
215 const wxString& Name() const { return m_strName; }
216 wxFileConfigGroup *Parent() const { return m_pParent; }
217 wxFileConfig *Config() const { return m_pConfig; }
218
219 const ArrayEntries& Entries() const { return m_aEntries; }
220 const ArrayGroups& Groups() const { return m_aSubgroups; }
221 bool IsEmpty() const { return Entries().IsEmpty() && Groups().IsEmpty(); }
222
223 // find entry/subgroup (NULL if not found)
224 wxFileConfigGroup *FindSubgroup(const wxChar *szName) const;
225 wxFileConfigEntry *FindEntry (const wxChar *szName) const;
226
227 // delete entry/subgroup, return false if doesn't exist
228 bool DeleteSubgroupByName(const wxChar *szName);
229 bool DeleteEntry(const wxChar *szName);
230
231 // create new entry/subgroup returning pointer to newly created element
232 wxFileConfigGroup *AddSubgroup(const wxString& strName);
233 wxFileConfigEntry *AddEntry (const wxString& strName, int nLine = wxNOT_FOUND);
234
235 void SetLine(wxFileConfigLineList *pLine);
236
237 // rename: no checks are done to ensure that the name is unique!
238 void Rename(const wxString& newName);
239
240 //
241 wxString GetFullName() const;
242
243 // get the last line belonging to an entry/subgroup of this group
244 wxFileConfigLineList *GetGroupLine(); // line which contains [group]
245 wxFileConfigLineList *GetLastEntryLine(); // after which our subgroups start
246 wxFileConfigLineList *GetLastGroupLine(); // after which the next group starts
247
248 // called by entries/subgroups when they're created/deleted
249 void SetLastEntry(wxFileConfigEntry *pEntry);
250 void SetLastGroup(wxFileConfigGroup *pGroup)
251 { m_pLastGroup = pGroup; }
252
253 DECLARE_NO_COPY_CLASS(wxFileConfigGroup)
254 };
255
256 // ============================================================================
257 // implementation
258 // ============================================================================
259
260 // ----------------------------------------------------------------------------
261 // static functions
262 // ----------------------------------------------------------------------------
263 wxString wxFileConfig::GetGlobalDir()
264 {
265 wxString strDir;
266
267 #ifdef __VMS__ // Note if __VMS is defined __UNIX is also defined
268 strDir = wxT("sys$manager:");
269 #elif defined(__WXMAC__)
270 strDir = wxMacFindFolder( (short) kOnSystemDisk, kPreferencesFolderType, kDontCreateFolder ) ;
271 #elif defined( __UNIX__ )
272 strDir = wxT("/etc/");
273 #elif defined(__OS2__)
274 ULONG aulSysInfo[QSV_MAX] = {0};
275 UINT drive;
276 APIRET rc;
277
278 rc = DosQuerySysInfo( 1L, QSV_MAX, (PVOID)aulSysInfo, sizeof(ULONG)*QSV_MAX);
279 if (rc == 0)
280 {
281 drive = aulSysInfo[QSV_BOOT_DRIVE - 1];
282 strDir.Printf(wxT("%c:\\OS2\\"), 'A'+drive-1);
283 }
284 #elif defined(__WXSTUBS__)
285 wxFAIL_MSG( wxT("TODO") );
286 #elif defined(__DOS__)
287 // There's no such thing as global cfg dir in MS-DOS, let's return
288 // current directory (FIXME_MGL?)
289 strDir = wxT(".\\");
290 #elif defined(__WXWINCE__)
291 strDir = wxT("\\Windows\\");
292 #else // Windows
293
294 wxChar szWinDir[MAX_PATH];
295 ::GetWindowsDirectory(szWinDir, MAX_PATH);
296
297 strDir = szWinDir;
298 strDir << wxT('\\');
299 #endif // Unix/Windows
300
301 return strDir;
302 }
303
304 wxString wxFileConfig::GetLocalDir()
305 {
306 wxString strDir;
307
308 #if defined(__WXMAC__) || defined(__DOS__)
309 // no local dir concept on Mac OS 9 or MS-DOS
310 strDir << GetGlobalDir() ;
311 #else
312 wxGetHomeDir(&strDir);
313
314 #ifdef __UNIX__
315 if (
316 (strDir.Last() != wxT('/'))
317 #ifdef __VMS
318 && (strDir.Last() != wxT(']'))
319 #endif
320 )
321 strDir << wxT('/');
322 #else
323 if (strDir.Last() != wxT('\\'))
324 strDir << wxT('\\');
325 #endif
326 #endif
327
328 return strDir;
329 }
330
331 wxString wxFileConfig::GetGlobalFileName(const wxChar *szFile)
332 {
333 wxString str = GetGlobalDir();
334 str << szFile;
335
336 if ( wxStrchr(szFile, wxT('.')) == NULL )
337 #if defined( __WXMAC__ )
338 str << wxT(" Preferences") ;
339 #elif defined( __UNIX__ )
340 str << wxT(".conf");
341 #else // Windows
342 str << wxT(".ini");
343 #endif // UNIX/Win
344
345 return str;
346 }
347
348 wxString wxFileConfig::GetLocalFileName(const wxChar *szFile)
349 {
350 #ifdef __VMS__
351 // On VMS I saw the problem that the home directory was appended
352 // twice for the configuration file. Does that also happen for
353 // other platforms?
354 wxString str = wxT( '.' );
355 #else
356 wxString str = GetLocalDir();
357 #endif
358
359 #if defined( __UNIX__ ) && !defined( __VMS ) && !defined( __WXMAC__ )
360 str << wxT('.');
361 #endif
362
363 str << szFile;
364
365 #if defined(__WINDOWS__) || defined(__DOS__)
366 if ( wxStrchr(szFile, wxT('.')) == NULL )
367 str << wxT(".ini");
368 #endif
369
370 #ifdef __WXMAC__
371 str << wxT(" Preferences") ;
372 #endif
373
374 return str;
375 }
376
377 // ----------------------------------------------------------------------------
378 // ctor
379 // ----------------------------------------------------------------------------
380
381 void wxFileConfig::Init()
382 {
383 m_pCurrentGroup =
384 m_pRootGroup = new wxFileConfigGroup(NULL, wxEmptyString, this);
385
386 m_linesHead =
387 m_linesTail = NULL;
388
389 // It's not an error if (one of the) file(s) doesn't exist.
390
391 // parse the global file
392 if ( !m_strGlobalFile.empty() && wxFile::Exists(m_strGlobalFile) )
393 {
394 wxTextFile fileGlobal(m_strGlobalFile);
395
396 if ( fileGlobal.Open(*m_conv/*ignored in ANSI build*/) )
397 {
398 Parse(fileGlobal, false /* global */);
399 SetRootPath();
400 }
401 else
402 {
403 wxLogWarning(_("can't open global configuration file '%s'."), m_strGlobalFile.c_str());
404 }
405 }
406
407 // parse the local file
408 if ( !m_strLocalFile.empty() && wxFile::Exists(m_strLocalFile) )
409 {
410 wxTextFile fileLocal(m_strLocalFile);
411 if ( fileLocal.Open(*m_conv/*ignored in ANSI build*/) )
412 {
413 Parse(fileLocal, true /* local */);
414 SetRootPath();
415 }
416 else
417 {
418 wxLogWarning(_("can't open user configuration file '%s'."), m_strLocalFile.c_str() );
419 }
420 }
421
422 m_isDirty = false;
423 }
424
425 // constructor supports creation of wxFileConfig objects of any type
426 wxFileConfig::wxFileConfig(const wxString& appName, const wxString& vendorName,
427 const wxString& strLocal, const wxString& strGlobal,
428 long style,
429 const wxMBConv& conv)
430 : wxConfigBase(::GetAppName(appName), vendorName,
431 strLocal, strGlobal,
432 style),
433 m_strLocalFile(strLocal), m_strGlobalFile(strGlobal),
434 m_conv(conv.Clone())
435 {
436 // Make up names for files if empty
437 if ( m_strLocalFile.empty() && (style & wxCONFIG_USE_LOCAL_FILE) )
438 m_strLocalFile = GetLocalFileName(GetAppName());
439
440 if ( m_strGlobalFile.empty() && (style & wxCONFIG_USE_GLOBAL_FILE) )
441 m_strGlobalFile = GetGlobalFileName(GetAppName());
442
443 // Check if styles are not supplied, but filenames are, in which case
444 // add the correct styles.
445 if ( !m_strLocalFile.empty() )
446 SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE);
447
448 if ( !m_strGlobalFile.empty() )
449 SetStyle(GetStyle() | wxCONFIG_USE_GLOBAL_FILE);
450
451 // if the path is not absolute, prepend the standard directory to it
452 // UNLESS wxCONFIG_USE_RELATIVE_PATH style is set
453 if ( !(style & wxCONFIG_USE_RELATIVE_PATH) )
454 {
455 if ( !m_strLocalFile.empty() && !wxIsAbsolutePath(m_strLocalFile) )
456 {
457 const wxString strLocalOrig = m_strLocalFile;
458 m_strLocalFile = GetLocalDir();
459 m_strLocalFile << strLocalOrig;
460 }
461
462 if ( !m_strGlobalFile.empty() && !wxIsAbsolutePath(m_strGlobalFile) )
463 {
464 const wxString strGlobalOrig = m_strGlobalFile;
465 m_strGlobalFile = GetGlobalDir();
466 m_strGlobalFile << strGlobalOrig;
467 }
468 }
469
470 SetUmask(-1);
471
472 Init();
473 }
474
475 #if wxUSE_STREAMS
476
477 wxFileConfig::wxFileConfig(wxInputStream &inStream, const wxMBConv& conv)
478 : m_conv(conv.Clone())
479 {
480 // always local_file when this constructor is called (?)
481 SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE);
482
483 m_pCurrentGroup =
484 m_pRootGroup = new wxFileConfigGroup(NULL, wxEmptyString, this);
485
486 m_linesHead =
487 m_linesTail = NULL;
488
489 // translate everything to the current (platform-dependent) line
490 // termination character
491 wxString strTrans;
492 {
493 wxString strTmp;
494
495 char buf[1024];
496 do
497 {
498 inStream.Read(buf, WXSIZEOF(buf)-1); // leave room for the NULL
499
500 const wxStreamError err = inStream.GetLastError();
501
502 if ( err != wxSTREAM_NO_ERROR && err != wxSTREAM_EOF )
503 {
504 wxLogError(_("Error reading config options."));
505 break;
506 }
507
508 // FIXME: this is broken because if we have part of multibyte
509 // character in the buffer (and another part hasn't been
510 // read yet) we're going to lose data because of conversion
511 // errors
512 buf[inStream.LastRead()] = '\0';
513 strTmp += conv.cMB2WX(buf);
514 }
515 while ( !inStream.Eof() );
516
517 strTrans = wxTextBuffer::Translate(strTmp);
518 }
519
520 wxMemoryText memText;
521
522 // Now we can add the text to the memory text. To do this we extract line
523 // by line from the translated string, until we've reached the end.
524 //
525 // VZ: all this is horribly inefficient, we should do the translation on
526 // the fly in one pass saving both memory and time (TODO)
527
528 const wxChar *pEOL = wxTextBuffer::GetEOL(wxTextBuffer::typeDefault);
529 const size_t EOLLen = wxStrlen(pEOL);
530
531 int posLineStart = strTrans.Find(pEOL);
532 while ( posLineStart != -1 )
533 {
534 wxString line(strTrans.Left(posLineStart));
535
536 memText.AddLine(line);
537
538 strTrans = strTrans.Mid(posLineStart + EOLLen);
539
540 posLineStart = strTrans.Find(pEOL);
541 }
542
543 // also add whatever we have left in the translated string.
544 if ( !strTrans.empty() )
545 memText.AddLine(strTrans);
546
547 // Finally we can parse it all.
548 Parse(memText, true /* local */);
549
550 SetRootPath();
551 ResetDirty();
552 }
553
554 #endif // wxUSE_STREAMS
555
556 void wxFileConfig::CleanUp()
557 {
558 delete m_pRootGroup;
559
560 wxFileConfigLineList *pCur = m_linesHead;
561 while ( pCur != NULL ) {
562 wxFileConfigLineList *pNext = pCur->Next();
563 delete pCur;
564 pCur = pNext;
565 }
566 }
567
568 wxFileConfig::~wxFileConfig()
569 {
570 Flush();
571
572 CleanUp();
573
574 delete m_conv;
575 }
576
577 // ----------------------------------------------------------------------------
578 // parse a config file
579 // ----------------------------------------------------------------------------
580
581 void wxFileConfig::Parse(const wxTextBuffer& buffer, bool bLocal)
582 {
583 const wxChar *pStart;
584 const wxChar *pEnd;
585 wxString strLine;
586
587 size_t nLineCount = buffer.GetLineCount();
588
589 for ( size_t n = 0; n < nLineCount; n++ )
590 {
591 strLine = buffer[n];
592
593 // add the line to linked list
594 if ( bLocal )
595 {
596 LineListAppend(strLine);
597
598 // let the root group have its start line as well
599 if ( !n )
600 {
601 m_pCurrentGroup->SetLine(m_linesTail);
602 }
603 }
604
605
606 // skip leading spaces
607 for ( pStart = strLine; wxIsspace(*pStart); pStart++ )
608 ;
609
610 // skip blank/comment lines
611 if ( *pStart == wxT('\0')|| *pStart == wxT(';') || *pStart == wxT('#') )
612 continue;
613
614 if ( *pStart == wxT('[') ) { // a new group
615 pEnd = pStart;
616
617 while ( *++pEnd != wxT(']') ) {
618 if ( *pEnd == wxT('\\') ) {
619 // the next char is escaped, so skip it even if it is ']'
620 pEnd++;
621 }
622
623 if ( *pEnd == wxT('\n') || *pEnd == wxT('\0') ) {
624 // we reached the end of line, break out of the loop
625 break;
626 }
627 }
628
629 if ( *pEnd != wxT(']') ) {
630 wxLogError(_("file '%s': unexpected character %c at line %d."),
631 buffer.GetName(), *pEnd, n + 1);
632 continue; // skip this line
633 }
634
635 // group name here is always considered as abs path
636 wxString strGroup;
637 pStart++;
638 strGroup << wxCONFIG_PATH_SEPARATOR
639 << FilterInEntryName(wxString(pStart, pEnd - pStart));
640
641 // will create it if doesn't yet exist
642 SetPath(strGroup);
643
644 if ( bLocal )
645 {
646 if ( m_pCurrentGroup->Parent() )
647 m_pCurrentGroup->Parent()->SetLastGroup(m_pCurrentGroup);
648 m_pCurrentGroup->SetLine(m_linesTail);
649 }
650
651 // check that there is nothing except comments left on this line
652 bool bCont = true;
653 while ( *++pEnd != wxT('\0') && bCont ) {
654 switch ( *pEnd ) {
655 case wxT('#'):
656 case wxT(';'):
657 bCont = false;
658 break;
659
660 case wxT(' '):
661 case wxT('\t'):
662 // ignore whitespace ('\n' impossible here)
663 break;
664
665 default:
666 wxLogWarning(_("file '%s', line %d: '%s' ignored after group header."),
667 buffer.GetName(), n + 1, pEnd);
668 bCont = false;
669 }
670 }
671 }
672 else { // a key
673 pEnd = pStart;
674 while ( *pEnd && *pEnd != wxT('=') /* && !wxIsspace(*pEnd)*/ ) {
675 if ( *pEnd == wxT('\\') ) {
676 // next character may be space or not - still take it because it's
677 // quoted (unless there is nothing)
678 pEnd++;
679 if ( !*pEnd ) {
680 // the error message will be given below anyhow
681 break;
682 }
683 }
684
685 pEnd++;
686 }
687
688 wxString strKey(FilterInEntryName(wxString(pStart, pEnd).Trim()));
689
690 // skip whitespace
691 while ( wxIsspace(*pEnd) )
692 pEnd++;
693
694 if ( *pEnd++ != wxT('=') ) {
695 wxLogError(_("file '%s', line %d: '=' expected."),
696 buffer.GetName(), n + 1);
697 }
698 else {
699 wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strKey);
700
701 if ( pEntry == NULL ) {
702 // new entry
703 pEntry = m_pCurrentGroup->AddEntry(strKey, n);
704 }
705 else {
706 if ( bLocal && pEntry->IsImmutable() ) {
707 // immutable keys can't be changed by user
708 wxLogWarning(_("file '%s', line %d: value for immutable key '%s' ignored."),
709 buffer.GetName(), n + 1, strKey.c_str());
710 continue;
711 }
712 // the condition below catches the cases (a) and (b) but not (c):
713 // (a) global key found second time in global file
714 // (b) key found second (or more) time in local file
715 // (c) key from global file now found in local one
716 // which is exactly what we want.
717 else if ( !bLocal || pEntry->IsLocal() ) {
718 wxLogWarning(_("file '%s', line %d: key '%s' was first found at line %d."),
719 buffer.GetName(), n + 1, strKey.c_str(), pEntry->Line());
720
721 }
722 }
723
724 if ( bLocal )
725 pEntry->SetLine(m_linesTail);
726
727 // skip whitespace
728 while ( wxIsspace(*pEnd) )
729 pEnd++;
730
731 wxString value = pEnd;
732 if ( !(GetStyle() & wxCONFIG_USE_NO_ESCAPE_CHARACTERS) )
733 value = FilterInValue(value);
734
735 pEntry->SetValue(value, false);
736 }
737 }
738 }
739 }
740
741 // ----------------------------------------------------------------------------
742 // set/retrieve path
743 // ----------------------------------------------------------------------------
744
745 void wxFileConfig::SetRootPath()
746 {
747 m_strPath.Empty();
748 m_pCurrentGroup = m_pRootGroup;
749 }
750
751 bool
752 wxFileConfig::DoSetPath(const wxString& strPath, bool createMissingComponents)
753 {
754 wxArrayString aParts;
755
756 if ( strPath.empty() ) {
757 SetRootPath();
758 return true;
759 }
760
761 if ( strPath[0] == wxCONFIG_PATH_SEPARATOR ) {
762 // absolute path
763 wxSplitPath(aParts, strPath);
764 }
765 else {
766 // relative path, combine with current one
767 wxString strFullPath = m_strPath;
768 strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
769 wxSplitPath(aParts, strFullPath);
770 }
771
772 // change current group
773 size_t n;
774 m_pCurrentGroup = m_pRootGroup;
775 for ( n = 0; n < aParts.Count(); n++ ) {
776 wxFileConfigGroup *pNextGroup = m_pCurrentGroup->FindSubgroup(aParts[n]);
777 if ( pNextGroup == NULL )
778 {
779 if ( !createMissingComponents )
780 return false;
781
782 pNextGroup = m_pCurrentGroup->AddSubgroup(aParts[n]);
783 }
784
785 m_pCurrentGroup = pNextGroup;
786 }
787
788 // recombine path parts in one variable
789 m_strPath.Empty();
790 for ( n = 0; n < aParts.Count(); n++ ) {
791 m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n];
792 }
793
794 return true;
795 }
796
797 void wxFileConfig::SetPath(const wxString& strPath)
798 {
799 DoSetPath(strPath, true /* create missing path components */);
800 }
801
802 // ----------------------------------------------------------------------------
803 // enumeration
804 // ----------------------------------------------------------------------------
805
806 bool wxFileConfig::GetFirstGroup(wxString& str, long& lIndex) const
807 {
808 lIndex = 0;
809 return GetNextGroup(str, lIndex);
810 }
811
812 bool wxFileConfig::GetNextGroup (wxString& str, long& lIndex) const
813 {
814 if ( size_t(lIndex) < m_pCurrentGroup->Groups().Count() ) {
815 str = m_pCurrentGroup->Groups()[(size_t)lIndex++]->Name();
816 return true;
817 }
818 else
819 return false;
820 }
821
822 bool wxFileConfig::GetFirstEntry(wxString& str, long& lIndex) const
823 {
824 lIndex = 0;
825 return GetNextEntry(str, lIndex);
826 }
827
828 bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) const
829 {
830 if ( size_t(lIndex) < m_pCurrentGroup->Entries().Count() ) {
831 str = m_pCurrentGroup->Entries()[(size_t)lIndex++]->Name();
832 return true;
833 }
834 else
835 return false;
836 }
837
838 size_t wxFileConfig::GetNumberOfEntries(bool bRecursive) const
839 {
840 size_t n = m_pCurrentGroup->Entries().Count();
841 if ( bRecursive ) {
842 wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
843 size_t nSubgroups = m_pCurrentGroup->Groups().Count();
844 for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
845 CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
846 n += GetNumberOfEntries(true);
847 CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
848 }
849 }
850
851 return n;
852 }
853
854 size_t wxFileConfig::GetNumberOfGroups(bool bRecursive) const
855 {
856 size_t n = m_pCurrentGroup->Groups().Count();
857 if ( bRecursive ) {
858 wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
859 size_t nSubgroups = m_pCurrentGroup->Groups().Count();
860 for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
861 CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
862 n += GetNumberOfGroups(true);
863 CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
864 }
865 }
866
867 return n;
868 }
869
870 // ----------------------------------------------------------------------------
871 // tests for existence
872 // ----------------------------------------------------------------------------
873
874 bool wxFileConfig::HasGroup(const wxString& strName) const
875 {
876 // special case: DoSetPath("") does work as it's equivalent to DoSetPath("/")
877 // but there is no group with empty name so treat this separately
878 if ( strName.empty() )
879 return false;
880
881 const wxString pathOld = GetPath();
882
883 wxFileConfig *self = wx_const_cast(wxFileConfig *, this);
884 const bool
885 rc = self->DoSetPath(strName, false /* don't create missing components */);
886
887 self->SetPath(pathOld);
888
889 return rc;
890 }
891
892 bool wxFileConfig::HasEntry(const wxString& entry) const
893 {
894 // path is the part before the last "/"
895 wxString path = entry.BeforeLast(wxCONFIG_PATH_SEPARATOR);
896
897 // except in the special case of "/keyname" when there is nothing before "/"
898 if ( path.empty() && *entry.c_str() == wxCONFIG_PATH_SEPARATOR )
899 {
900 path = wxCONFIG_PATH_SEPARATOR;
901 }
902
903 // change to the path of the entry if necessary and remember the old path
904 // to restore it later
905 wxString pathOld;
906 wxFileConfig * const self = wx_const_cast(wxFileConfig *, this);
907 if ( !path.empty() )
908 {
909 pathOld = GetPath();
910 if ( pathOld.empty() )
911 pathOld = wxCONFIG_PATH_SEPARATOR;
912
913 if ( !self->DoSetPath(path, false /* don't create if doesn't exist */) )
914 {
915 return false;
916 }
917 }
918
919 // check if the entry exists in this group
920 const bool exists = m_pCurrentGroup->FindEntry(
921 entry.AfterLast(wxCONFIG_PATH_SEPARATOR)) != NULL;
922
923 // restore the old path if we changed it above
924 if ( !pathOld.empty() )
925 {
926 self->SetPath(pathOld);
927 }
928
929 return exists;
930 }
931
932 // ----------------------------------------------------------------------------
933 // read/write values
934 // ----------------------------------------------------------------------------
935
936 bool wxFileConfig::DoReadString(const wxString& key, wxString* pStr) const
937 {
938 wxConfigPathChanger path(this, key);
939
940 wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
941 if (pEntry == NULL) {
942 return false;
943 }
944
945 *pStr = pEntry->Value();
946
947 return true;
948 }
949
950 bool wxFileConfig::DoReadLong(const wxString& key, long *pl) const
951 {
952 wxString str;
953 if ( !Read(key, &str) )
954 return false;
955
956 // extra spaces shouldn't prevent us from reading numeric values
957 str.Trim();
958
959 return str.ToLong(pl);
960 }
961
962 bool wxFileConfig::DoWriteString(const wxString& key, const wxString& szValue)
963 {
964 wxConfigPathChanger path(this, key);
965 wxString strName = path.Name();
966
967 wxLogTrace( FILECONF_TRACE_MASK,
968 _T(" Writing String '%s' = '%s' to Group '%s'"),
969 strName.c_str(),
970 szValue.c_str(),
971 GetPath().c_str() );
972
973 if ( strName.empty() )
974 {
975 // setting the value of a group is an error
976
977 wxASSERT_MSG( szValue.empty(), wxT("can't set value of a group!") );
978
979 // ... except if it's empty in which case it's a way to force it's creation
980
981 wxLogTrace( FILECONF_TRACE_MASK,
982 _T(" Creating group %s"),
983 m_pCurrentGroup->Name().c_str() );
984
985 SetDirty();
986
987 // this will add a line for this group if it didn't have it before
988
989 (void)m_pCurrentGroup->GetGroupLine();
990 }
991 else
992 {
993 // writing an entry check that the name is reasonable
994 if ( strName[0u] == wxCONFIG_IMMUTABLE_PREFIX )
995 {
996 wxLogError( _("Config entry name cannot start with '%c'."),
997 wxCONFIG_IMMUTABLE_PREFIX);
998 return false;
999 }
1000
1001 wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strName);
1002
1003 if ( pEntry == 0 )
1004 {
1005 wxLogTrace( FILECONF_TRACE_MASK,
1006 _T(" Adding Entry %s"),
1007 strName.c_str() );
1008 pEntry = m_pCurrentGroup->AddEntry(strName);
1009 }
1010
1011 wxLogTrace( FILECONF_TRACE_MASK,
1012 _T(" Setting value %s"),
1013 szValue.c_str() );
1014 pEntry->SetValue(szValue);
1015
1016 SetDirty();
1017 }
1018
1019 return true;
1020 }
1021
1022 bool wxFileConfig::DoWriteLong(const wxString& key, long lValue)
1023 {
1024 return Write(key, wxString::Format(_T("%ld"), lValue));
1025 }
1026
1027 bool wxFileConfig::Flush(bool /* bCurrentOnly */)
1028 {
1029 if ( !IsDirty() || !m_strLocalFile )
1030 return true;
1031
1032 // set the umask if needed
1033 wxCHANGE_UMASK(m_umask);
1034
1035 wxTempFile file(m_strLocalFile);
1036
1037 if ( !file.IsOpened() )
1038 {
1039 wxLogError(_("can't open user configuration file."));
1040 return false;
1041 }
1042
1043 // write all strings to file
1044 for ( wxFileConfigLineList *p = m_linesHead; p != NULL; p = p->Next() )
1045 {
1046 wxString line = p->Text();
1047 line += wxTextFile::GetEOL();
1048 if ( !file.Write(line, *m_conv) )
1049 {
1050 wxLogError(_("can't write user configuration file."));
1051 return false;
1052 }
1053 }
1054
1055 if ( !file.Commit() )
1056 {
1057 wxLogError(_("Failed to update user configuration file."));
1058
1059 return false;
1060 }
1061
1062 ResetDirty();
1063
1064 #if defined(__WXMAC__)
1065 wxFileName(m_strLocalFile).MacSetTypeAndCreator('TEXT', 'ttxt');
1066 #endif // __WXMAC__
1067
1068 return true;
1069 }
1070
1071 #if wxUSE_STREAMS
1072
1073 bool wxFileConfig::Save(wxOutputStream& os, const wxMBConv& conv)
1074 {
1075 // save unconditionally, even if not dirty
1076 for ( wxFileConfigLineList *p = m_linesHead; p != NULL; p = p->Next() )
1077 {
1078 wxString line = p->Text();
1079 line += wxTextFile::GetEOL();
1080
1081 wxCharBuffer buf(line.mb_str(conv));
1082 if ( !os.Write(buf, strlen(buf)) )
1083 {
1084 wxLogError(_("Error saving user configuration data."));
1085
1086 return false;
1087 }
1088 }
1089
1090 ResetDirty();
1091
1092 return true;
1093 }
1094
1095 #endif // wxUSE_STREAMS
1096
1097 // ----------------------------------------------------------------------------
1098 // renaming groups/entries
1099 // ----------------------------------------------------------------------------
1100
1101 bool wxFileConfig::RenameEntry(const wxString& oldName,
1102 const wxString& newName)
1103 {
1104 wxASSERT_MSG( !wxStrchr(oldName, wxCONFIG_PATH_SEPARATOR),
1105 _T("RenameEntry(): paths are not supported") );
1106
1107 // check that the entry exists
1108 wxFileConfigEntry *oldEntry = m_pCurrentGroup->FindEntry(oldName);
1109 if ( !oldEntry )
1110 return false;
1111
1112 // check that the new entry doesn't already exist
1113 if ( m_pCurrentGroup->FindEntry(newName) )
1114 return false;
1115
1116 // delete the old entry, create the new one
1117 wxString value = oldEntry->Value();
1118 if ( !m_pCurrentGroup->DeleteEntry(oldName) )
1119 return false;
1120
1121 SetDirty();
1122
1123 wxFileConfigEntry *newEntry = m_pCurrentGroup->AddEntry(newName);
1124 newEntry->SetValue(value);
1125
1126 return true;
1127 }
1128
1129 bool wxFileConfig::RenameGroup(const wxString& oldName,
1130 const wxString& newName)
1131 {
1132 // check that the group exists
1133 wxFileConfigGroup *group = m_pCurrentGroup->FindSubgroup(oldName);
1134 if ( !group )
1135 return false;
1136
1137 // check that the new group doesn't already exist
1138 if ( m_pCurrentGroup->FindSubgroup(newName) )
1139 return false;
1140
1141 group->Rename(newName);
1142
1143 SetDirty();
1144
1145 return true;
1146 }
1147
1148 // ----------------------------------------------------------------------------
1149 // delete groups/entries
1150 // ----------------------------------------------------------------------------
1151
1152 bool wxFileConfig::DeleteEntry(const wxString& key, bool bGroupIfEmptyAlso)
1153 {
1154 wxConfigPathChanger path(this, key);
1155
1156 if ( !m_pCurrentGroup->DeleteEntry(path.Name()) )
1157 return false;
1158
1159 SetDirty();
1160
1161 if ( bGroupIfEmptyAlso && m_pCurrentGroup->IsEmpty() ) {
1162 if ( m_pCurrentGroup != m_pRootGroup ) {
1163 wxFileConfigGroup *pGroup = m_pCurrentGroup;
1164 SetPath(wxT("..")); // changes m_pCurrentGroup!
1165 m_pCurrentGroup->DeleteSubgroupByName(pGroup->Name());
1166 }
1167 //else: never delete the root group
1168 }
1169
1170 return true;
1171 }
1172
1173 bool wxFileConfig::DeleteGroup(const wxString& key)
1174 {
1175 wxConfigPathChanger path(this, key);
1176
1177 if ( !m_pCurrentGroup->DeleteSubgroupByName(path.Name()) )
1178 return false;
1179
1180 path.UpdateIfDeleted();
1181
1182 SetDirty();
1183
1184 return true;
1185 }
1186
1187 bool wxFileConfig::DeleteAll()
1188 {
1189 CleanUp();
1190
1191 if ( !m_strLocalFile.empty() )
1192 {
1193 if ( wxFile::Exists(m_strLocalFile) && wxRemove(m_strLocalFile) == -1 )
1194 {
1195 wxLogSysError(_("can't delete user configuration file '%s'"),
1196 m_strLocalFile.c_str());
1197 return false;
1198 }
1199 }
1200
1201 Init();
1202
1203 return true;
1204 }
1205
1206 // ----------------------------------------------------------------------------
1207 // linked list functions
1208 // ----------------------------------------------------------------------------
1209
1210 // append a new line to the end of the list
1211
1212 wxFileConfigLineList *wxFileConfig::LineListAppend(const wxString& str)
1213 {
1214 wxLogTrace( FILECONF_TRACE_MASK,
1215 _T(" ** Adding Line '%s'"),
1216 str.c_str() );
1217 wxLogTrace( FILECONF_TRACE_MASK,
1218 _T(" head: %s"),
1219 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1220 wxLogTrace( FILECONF_TRACE_MASK,
1221 _T(" tail: %s"),
1222 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1223
1224 wxFileConfigLineList *pLine = new wxFileConfigLineList(str);
1225
1226 if ( m_linesTail == NULL )
1227 {
1228 // list is empty
1229 m_linesHead = pLine;
1230 }
1231 else
1232 {
1233 // adjust pointers
1234 m_linesTail->SetNext(pLine);
1235 pLine->SetPrev(m_linesTail);
1236 }
1237
1238 m_linesTail = pLine;
1239
1240 wxLogTrace( FILECONF_TRACE_MASK,
1241 _T(" head: %s"),
1242 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1243 wxLogTrace( FILECONF_TRACE_MASK,
1244 _T(" tail: %s"),
1245 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1246
1247 return m_linesTail;
1248 }
1249
1250 // insert a new line after the given one or in the very beginning if !pLine
1251 wxFileConfigLineList *wxFileConfig::LineListInsert(const wxString& str,
1252 wxFileConfigLineList *pLine)
1253 {
1254 wxLogTrace( FILECONF_TRACE_MASK,
1255 _T(" ** Inserting Line '%s' after '%s'"),
1256 str.c_str(),
1257 ((pLine) ? pLine->Text().c_str() : wxEmptyString) );
1258 wxLogTrace( FILECONF_TRACE_MASK,
1259 _T(" head: %s"),
1260 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1261 wxLogTrace( FILECONF_TRACE_MASK,
1262 _T(" tail: %s"),
1263 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1264
1265 if ( pLine == m_linesTail )
1266 return LineListAppend(str);
1267
1268 wxFileConfigLineList *pNewLine = new wxFileConfigLineList(str);
1269 if ( pLine == NULL )
1270 {
1271 // prepend to the list
1272 pNewLine->SetNext(m_linesHead);
1273 m_linesHead->SetPrev(pNewLine);
1274 m_linesHead = pNewLine;
1275 }
1276 else
1277 {
1278 // insert before pLine
1279 wxFileConfigLineList *pNext = pLine->Next();
1280 pNewLine->SetNext(pNext);
1281 pNewLine->SetPrev(pLine);
1282 pNext->SetPrev(pNewLine);
1283 pLine->SetNext(pNewLine);
1284 }
1285
1286 wxLogTrace( FILECONF_TRACE_MASK,
1287 _T(" head: %s"),
1288 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1289 wxLogTrace( FILECONF_TRACE_MASK,
1290 _T(" tail: %s"),
1291 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1292
1293 return pNewLine;
1294 }
1295
1296 void wxFileConfig::LineListRemove(wxFileConfigLineList *pLine)
1297 {
1298 wxLogTrace( FILECONF_TRACE_MASK,
1299 _T(" ** Removing Line '%s'"),
1300 pLine->Text().c_str() );
1301 wxLogTrace( FILECONF_TRACE_MASK,
1302 _T(" head: %s"),
1303 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1304 wxLogTrace( FILECONF_TRACE_MASK,
1305 _T(" tail: %s"),
1306 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1307
1308 wxFileConfigLineList *pPrev = pLine->Prev(),
1309 *pNext = pLine->Next();
1310
1311 // first entry?
1312
1313 if ( pPrev == NULL )
1314 m_linesHead = pNext;
1315 else
1316 pPrev->SetNext(pNext);
1317
1318 // last entry?
1319
1320 if ( pNext == NULL )
1321 m_linesTail = pPrev;
1322 else
1323 pNext->SetPrev(pPrev);
1324
1325 if ( m_pRootGroup->GetGroupLine() == pLine )
1326 m_pRootGroup->SetLine(m_linesHead);
1327
1328 wxLogTrace( FILECONF_TRACE_MASK,
1329 _T(" head: %s"),
1330 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1331 wxLogTrace( FILECONF_TRACE_MASK,
1332 _T(" tail: %s"),
1333 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1334
1335 delete pLine;
1336 }
1337
1338 bool wxFileConfig::LineListIsEmpty()
1339 {
1340 return m_linesHead == NULL;
1341 }
1342
1343 // ============================================================================
1344 // wxFileConfig::wxFileConfigGroup
1345 // ============================================================================
1346
1347 // ----------------------------------------------------------------------------
1348 // ctor/dtor
1349 // ----------------------------------------------------------------------------
1350
1351 // ctor
1352 wxFileConfigGroup::wxFileConfigGroup(wxFileConfigGroup *pParent,
1353 const wxString& strName,
1354 wxFileConfig *pConfig)
1355 : m_aEntries(CompareEntries),
1356 m_aSubgroups(CompareGroups),
1357 m_strName(strName)
1358 {
1359 m_pConfig = pConfig;
1360 m_pParent = pParent;
1361 m_pLine = NULL;
1362
1363 m_pLastEntry = NULL;
1364 m_pLastGroup = NULL;
1365 }
1366
1367 // dtor deletes all children
1368 wxFileConfigGroup::~wxFileConfigGroup()
1369 {
1370 // entries
1371 size_t n, nCount = m_aEntries.Count();
1372 for ( n = 0; n < nCount; n++ )
1373 delete m_aEntries[n];
1374
1375 // subgroups
1376 nCount = m_aSubgroups.Count();
1377 for ( n = 0; n < nCount; n++ )
1378 delete m_aSubgroups[n];
1379 }
1380
1381 // ----------------------------------------------------------------------------
1382 // line
1383 // ----------------------------------------------------------------------------
1384
1385 void wxFileConfigGroup::SetLine(wxFileConfigLineList *pLine)
1386 {
1387 // for a normal (i.e. not root) group this method shouldn't be called twice
1388 // unless we are resetting the line
1389 wxASSERT_MSG( !m_pParent || !m_pLine || !pLine,
1390 _T("changing line for a non-root group?") );
1391
1392 m_pLine = pLine;
1393 }
1394
1395 /*
1396 This is a bit complicated, so let me explain it in details. All lines that
1397 were read from the local file (the only one we will ever modify) are stored
1398 in a (doubly) linked list. Our problem is to know at which position in this
1399 list should we insert the new entries/subgroups. To solve it we keep three
1400 variables for each group: m_pLine, m_pLastEntry and m_pLastGroup.
1401
1402 m_pLine points to the line containing "[group_name]"
1403 m_pLastEntry points to the last entry of this group in the local file.
1404 m_pLastGroup subgroup
1405
1406 Initially, they're NULL all three. When the group (an entry/subgroup) is read
1407 from the local file, the corresponding variable is set. However, if the group
1408 was read from the global file and then modified or created by the application
1409 these variables are still NULL and we need to create the corresponding lines.
1410 See the following functions (and comments preceding them) for the details of
1411 how we do it.
1412
1413 Also, when our last entry/group are deleted we need to find the new last
1414 element - the code in DeleteEntry/Subgroup does this by backtracking the list
1415 of lines until it either founds an entry/subgroup (and this is the new last
1416 element) or the m_pLine of the group, in which case there are no more entries
1417 (or subgroups) left and m_pLast<element> becomes NULL.
1418
1419 NB: This last problem could be avoided for entries if we added new entries
1420 immediately after m_pLine, but in this case the entries would appear
1421 backwards in the config file (OTOH, it's not that important) and as we
1422 would still need to do it for the subgroups the code wouldn't have been
1423 significantly less complicated.
1424 */
1425
1426 // Return the line which contains "[our name]". If we're still not in the list,
1427 // add our line to it immediately after the last line of our parent group if we
1428 // have it or in the very beginning if we're the root group.
1429 wxFileConfigLineList *wxFileConfigGroup::GetGroupLine()
1430 {
1431 wxLogTrace( FILECONF_TRACE_MASK,
1432 _T(" GetGroupLine() for Group '%s'"),
1433 Name().c_str() );
1434
1435 if ( !m_pLine )
1436 {
1437 wxLogTrace( FILECONF_TRACE_MASK,
1438 _T(" Getting Line item pointer") );
1439
1440 wxFileConfigGroup *pParent = Parent();
1441
1442 // this group wasn't present in local config file, add it now
1443 if ( pParent )
1444 {
1445 wxLogTrace( FILECONF_TRACE_MASK,
1446 _T(" checking parent '%s'"),
1447 pParent->Name().c_str() );
1448
1449 wxString strFullName;
1450
1451 // add 1 to the name because we don't want to start with '/'
1452 strFullName << wxT("[")
1453 << FilterOutEntryName(GetFullName().c_str() + 1)
1454 << wxT("]");
1455 m_pLine = m_pConfig->LineListInsert(strFullName,
1456 pParent->GetLastGroupLine());
1457 pParent->SetLastGroup(this); // we're surely after all the others
1458 }
1459 //else: this is the root group and so we return NULL because we don't
1460 // have any group line
1461 }
1462
1463 return m_pLine;
1464 }
1465
1466 // Return the last line belonging to the subgroups of this group (after which
1467 // we can add a new subgroup), if we don't have any subgroups or entries our
1468 // last line is the group line (m_pLine) itself.
1469 wxFileConfigLineList *wxFileConfigGroup::GetLastGroupLine()
1470 {
1471 // if we have any subgroups, our last line is the last line of the last
1472 // subgroup
1473 if ( m_pLastGroup )
1474 {
1475 wxFileConfigLineList *pLine = m_pLastGroup->GetLastGroupLine();
1476
1477 wxASSERT_MSG( pLine, _T("last group must have !NULL associated line") );
1478
1479 return pLine;
1480 }
1481
1482 // no subgroups, so the last line is the line of thelast entry (if any)
1483 return GetLastEntryLine();
1484 }
1485
1486 // return the last line belonging to the entries of this group (after which
1487 // we can add a new entry), if we don't have any entries we will add the new
1488 // one immediately after the group line itself.
1489 wxFileConfigLineList *wxFileConfigGroup::GetLastEntryLine()
1490 {
1491 wxLogTrace( FILECONF_TRACE_MASK,
1492 _T(" GetLastEntryLine() for Group '%s'"),
1493 Name().c_str() );
1494
1495 if ( m_pLastEntry )
1496 {
1497 wxFileConfigLineList *pLine = m_pLastEntry->GetLine();
1498
1499 wxASSERT_MSG( pLine, _T("last entry must have !NULL associated line") );
1500
1501 return pLine;
1502 }
1503
1504 // no entries: insert after the group header, if any
1505 return GetGroupLine();
1506 }
1507
1508 void wxFileConfigGroup::SetLastEntry(wxFileConfigEntry *pEntry)
1509 {
1510 m_pLastEntry = pEntry;
1511
1512 if ( !m_pLine )
1513 {
1514 // the only situation in which a group without its own line can have
1515 // an entry is when the first entry is added to the initially empty
1516 // root pseudo-group
1517 wxASSERT_MSG( !m_pParent, _T("unexpected for non root group") );
1518
1519 // let the group know that it does have a line in the file now
1520 m_pLine = pEntry->GetLine();
1521 }
1522 }
1523
1524 // ----------------------------------------------------------------------------
1525 // group name
1526 // ----------------------------------------------------------------------------
1527
1528 void wxFileConfigGroup::UpdateGroupAndSubgroupsLines()
1529 {
1530 // update the line of this group
1531 wxFileConfigLineList *line = GetGroupLine();
1532 wxCHECK_RET( line, _T("a non root group must have a corresponding line!") );
1533
1534 // +1: skip the leading '/'
1535 line->SetText(wxString::Format(_T("[%s]"), GetFullName().c_str() + 1));
1536
1537
1538 // also update all subgroups as they have this groups name in their lines
1539 const size_t nCount = m_aSubgroups.Count();
1540 for ( size_t n = 0; n < nCount; n++ )
1541 {
1542 m_aSubgroups[n]->UpdateGroupAndSubgroupsLines();
1543 }
1544 }
1545
1546 void wxFileConfigGroup::Rename(const wxString& newName)
1547 {
1548 wxCHECK_RET( m_pParent, _T("the root group can't be renamed") );
1549
1550 m_strName = newName;
1551
1552 // update the group lines recursively
1553 UpdateGroupAndSubgroupsLines();
1554 }
1555
1556 wxString wxFileConfigGroup::GetFullName() const
1557 {
1558 wxString fullname;
1559 if ( Parent() )
1560 fullname = Parent()->GetFullName() + wxCONFIG_PATH_SEPARATOR + Name();
1561
1562 return fullname;
1563 }
1564
1565 // ----------------------------------------------------------------------------
1566 // find an item
1567 // ----------------------------------------------------------------------------
1568
1569 // use binary search because the array is sorted
1570 wxFileConfigEntry *
1571 wxFileConfigGroup::FindEntry(const wxChar *szName) const
1572 {
1573 size_t i,
1574 lo = 0,
1575 hi = m_aEntries.Count();
1576 int res;
1577 wxFileConfigEntry *pEntry;
1578
1579 while ( lo < hi ) {
1580 i = (lo + hi)/2;
1581 pEntry = m_aEntries[i];
1582
1583 #if wxCONFIG_CASE_SENSITIVE
1584 res = wxStrcmp(pEntry->Name(), szName);
1585 #else
1586 res = wxStricmp(pEntry->Name(), szName);
1587 #endif
1588
1589 if ( res > 0 )
1590 hi = i;
1591 else if ( res < 0 )
1592 lo = i + 1;
1593 else
1594 return pEntry;
1595 }
1596
1597 return NULL;
1598 }
1599
1600 wxFileConfigGroup *
1601 wxFileConfigGroup::FindSubgroup(const wxChar *szName) const
1602 {
1603 size_t i,
1604 lo = 0,
1605 hi = m_aSubgroups.Count();
1606 int res;
1607 wxFileConfigGroup *pGroup;
1608
1609 while ( lo < hi ) {
1610 i = (lo + hi)/2;
1611 pGroup = m_aSubgroups[i];
1612
1613 #if wxCONFIG_CASE_SENSITIVE
1614 res = wxStrcmp(pGroup->Name(), szName);
1615 #else
1616 res = wxStricmp(pGroup->Name(), szName);
1617 #endif
1618
1619 if ( res > 0 )
1620 hi = i;
1621 else if ( res < 0 )
1622 lo = i + 1;
1623 else
1624 return pGroup;
1625 }
1626
1627 return NULL;
1628 }
1629
1630 // ----------------------------------------------------------------------------
1631 // create a new item
1632 // ----------------------------------------------------------------------------
1633
1634 // create a new entry and add it to the current group
1635 wxFileConfigEntry *wxFileConfigGroup::AddEntry(const wxString& strName, int nLine)
1636 {
1637 wxASSERT( FindEntry(strName) == 0 );
1638
1639 wxFileConfigEntry *pEntry = new wxFileConfigEntry(this, strName, nLine);
1640
1641 m_aEntries.Add(pEntry);
1642 return pEntry;
1643 }
1644
1645 // create a new group and add it to the current group
1646 wxFileConfigGroup *wxFileConfigGroup::AddSubgroup(const wxString& strName)
1647 {
1648 wxASSERT( FindSubgroup(strName) == 0 );
1649
1650 wxFileConfigGroup *pGroup = new wxFileConfigGroup(this, strName, m_pConfig);
1651
1652 m_aSubgroups.Add(pGroup);
1653 return pGroup;
1654 }
1655
1656 // ----------------------------------------------------------------------------
1657 // delete an item
1658 // ----------------------------------------------------------------------------
1659
1660 /*
1661 The delete operations are _very_ slow if we delete the last item of this
1662 group (see comments before GetXXXLineXXX functions for more details),
1663 so it's much better to start with the first entry/group if we want to
1664 delete several of them.
1665 */
1666
1667 bool wxFileConfigGroup::DeleteSubgroupByName(const wxChar *szName)
1668 {
1669 wxFileConfigGroup * const pGroup = FindSubgroup(szName);
1670
1671 return pGroup ? DeleteSubgroup(pGroup) : false;
1672 }
1673
1674 // Delete the subgroup and remove all references to it from
1675 // other data structures.
1676 bool wxFileConfigGroup::DeleteSubgroup(wxFileConfigGroup *pGroup)
1677 {
1678 wxCHECK_MSG( pGroup, false, _T("deleting non existing group?") );
1679
1680 wxLogTrace( FILECONF_TRACE_MASK,
1681 _T("Deleting group '%s' from '%s'"),
1682 pGroup->Name().c_str(),
1683 Name().c_str() );
1684
1685 wxLogTrace( FILECONF_TRACE_MASK,
1686 _T(" (m_pLine) = prev: %p, this %p, next %p"),
1687 m_pLine ? wx_static_cast(void*, m_pLine->Prev()) : 0,
1688 wx_static_cast(void*, m_pLine),
1689 m_pLine ? wx_static_cast(void*, m_pLine->Next()) : 0 );
1690 wxLogTrace( FILECONF_TRACE_MASK,
1691 _T(" text: '%s'"),
1692 m_pLine ? m_pLine->Text().c_str() : wxEmptyString );
1693
1694 // delete all entries...
1695 size_t nCount = pGroup->m_aEntries.Count();
1696
1697 wxLogTrace(FILECONF_TRACE_MASK,
1698 _T("Removing %lu entries"), (unsigned long)nCount );
1699
1700 for ( size_t nEntry = 0; nEntry < nCount; nEntry++ )
1701 {
1702 wxFileConfigLineList *pLine = pGroup->m_aEntries[nEntry]->GetLine();
1703
1704 if ( pLine )
1705 {
1706 wxLogTrace( FILECONF_TRACE_MASK,
1707 _T(" '%s'"),
1708 pLine->Text().c_str() );
1709 m_pConfig->LineListRemove(pLine);
1710 }
1711 }
1712
1713 // ...and subgroups of this subgroup
1714 nCount = pGroup->m_aSubgroups.Count();
1715
1716 wxLogTrace( FILECONF_TRACE_MASK,
1717 _T("Removing %lu subgroups"), (unsigned long)nCount );
1718
1719 for ( size_t nGroup = 0; nGroup < nCount; nGroup++ )
1720 {
1721 pGroup->DeleteSubgroup(pGroup->m_aSubgroups[0]);
1722 }
1723
1724 // and then finally the group itself
1725 wxFileConfigLineList *pLine = pGroup->m_pLine;
1726 if ( pLine )
1727 {
1728 wxLogTrace( FILECONF_TRACE_MASK,
1729 _T(" Removing line for group '%s' : '%s'"),
1730 pGroup->Name().c_str(),
1731 pLine->Text().c_str() );
1732 wxLogTrace( FILECONF_TRACE_MASK,
1733 _T(" Removing from group '%s' : '%s'"),
1734 Name().c_str(),
1735 ((m_pLine) ? m_pLine->Text().c_str() : wxEmptyString) );
1736
1737 // notice that we may do this test inside the previous "if"
1738 // because the last entry's line is surely !NULL
1739 if ( pGroup == m_pLastGroup )
1740 {
1741 wxLogTrace( FILECONF_TRACE_MASK,
1742 _T(" Removing last group") );
1743
1744 // our last entry is being deleted, so find the last one which
1745 // stays by going back until we find a subgroup or reach the
1746 // group line
1747 const size_t nSubgroups = m_aSubgroups.Count();
1748
1749 m_pLastGroup = NULL;
1750 for ( wxFileConfigLineList *pl = pLine->Prev();
1751 pl && pl != m_pLine && !m_pLastGroup;
1752 pl = pl->Prev() )
1753 {
1754 // does this line belong to our subgroup?
1755 for ( size_t n = 0; n < nSubgroups; n++ )
1756 {
1757 // do _not_ call GetGroupLine! we don't want to add it to
1758 // the local file if it's not already there
1759 if ( m_aSubgroups[n]->m_pLine == pl )
1760 {
1761 m_pLastGroup = m_aSubgroups[n];
1762 break;
1763 }
1764 }
1765 }
1766 }
1767
1768 m_pConfig->LineListRemove(pLine);
1769 }
1770 else
1771 {
1772 wxLogTrace( FILECONF_TRACE_MASK,
1773 _T(" No line entry for Group '%s'?"),
1774 pGroup->Name().c_str() );
1775 }
1776
1777 m_aSubgroups.Remove(pGroup);
1778 delete pGroup;
1779
1780 return true;
1781 }
1782
1783 bool wxFileConfigGroup::DeleteEntry(const wxChar *szName)
1784 {
1785 wxFileConfigEntry *pEntry = FindEntry(szName);
1786 if ( !pEntry )
1787 {
1788 // entry doesn't exist, nothing to do
1789 return false;
1790 }
1791
1792 wxFileConfigLineList *pLine = pEntry->GetLine();
1793 if ( pLine != NULL ) {
1794 // notice that we may do this test inside the previous "if" because the
1795 // last entry's line is surely !NULL
1796 if ( pEntry == m_pLastEntry ) {
1797 // our last entry is being deleted - find the last one which stays
1798 wxASSERT( m_pLine != NULL ); // if we have an entry with !NULL pLine...
1799
1800 // go back until we find another entry or reach the group's line
1801 wxFileConfigEntry *pNewLast = NULL;
1802 size_t n, nEntries = m_aEntries.Count();
1803 wxFileConfigLineList *pl;
1804 for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) {
1805 // is it our subgroup?
1806 for ( n = 0; (pNewLast == NULL) && (n < nEntries); n++ ) {
1807 if ( m_aEntries[n]->GetLine() == m_pLine )
1808 pNewLast = m_aEntries[n];
1809 }
1810
1811 if ( pNewLast != NULL ) // found?
1812 break;
1813 }
1814
1815 if ( pl == m_pLine ) {
1816 wxASSERT( !pNewLast ); // how comes it has the same line as we?
1817
1818 // we've reached the group line without finding any subgroups
1819 m_pLastEntry = NULL;
1820 }
1821 else
1822 m_pLastEntry = pNewLast;
1823 }
1824
1825 m_pConfig->LineListRemove(pLine);
1826 }
1827
1828 m_aEntries.Remove(pEntry);
1829 delete pEntry;
1830
1831 return true;
1832 }
1833
1834 // ============================================================================
1835 // wxFileConfig::wxFileConfigEntry
1836 // ============================================================================
1837
1838 // ----------------------------------------------------------------------------
1839 // ctor
1840 // ----------------------------------------------------------------------------
1841 wxFileConfigEntry::wxFileConfigEntry(wxFileConfigGroup *pParent,
1842 const wxString& strName,
1843 int nLine)
1844 : m_strName(strName)
1845 {
1846 wxASSERT( !strName.empty() );
1847
1848 m_pParent = pParent;
1849 m_nLine = nLine;
1850 m_pLine = NULL;
1851
1852 m_bHasValue = false;
1853
1854 m_bImmutable = strName[0] == wxCONFIG_IMMUTABLE_PREFIX;
1855 if ( m_bImmutable )
1856 m_strName.erase(0, 1); // remove first character
1857 }
1858
1859 // ----------------------------------------------------------------------------
1860 // set value
1861 // ----------------------------------------------------------------------------
1862
1863 void wxFileConfigEntry::SetLine(wxFileConfigLineList *pLine)
1864 {
1865 if ( m_pLine != NULL ) {
1866 wxLogWarning(_("entry '%s' appears more than once in group '%s'"),
1867 Name().c_str(), m_pParent->GetFullName().c_str());
1868 }
1869
1870 m_pLine = pLine;
1871 Group()->SetLastEntry(this);
1872 }
1873
1874 // second parameter is false if we read the value from file and prevents the
1875 // entry from being marked as 'dirty'
1876 void wxFileConfigEntry::SetValue(const wxString& strValue, bool bUser)
1877 {
1878 if ( bUser && IsImmutable() )
1879 {
1880 wxLogWarning( _("attempt to change immutable key '%s' ignored."),
1881 Name().c_str());
1882 return;
1883 }
1884
1885 // do nothing if it's the same value: but don't test for it if m_bHasValue
1886 // hadn't been set yet or we'd never write empty values to the file
1887 if ( m_bHasValue && strValue == m_strValue )
1888 return;
1889
1890 m_bHasValue = true;
1891 m_strValue = strValue;
1892
1893 if ( bUser )
1894 {
1895 wxString strValFiltered;
1896
1897 if ( Group()->Config()->GetStyle() & wxCONFIG_USE_NO_ESCAPE_CHARACTERS )
1898 {
1899 strValFiltered = strValue;
1900 }
1901 else {
1902 strValFiltered = FilterOutValue(strValue);
1903 }
1904
1905 wxString strLine;
1906 strLine << FilterOutEntryName(m_strName) << wxT('=') << strValFiltered;
1907
1908 if ( m_pLine )
1909 {
1910 // entry was read from the local config file, just modify the line
1911 m_pLine->SetText(strLine);
1912 }
1913 else // this entry didn't exist in the local file
1914 {
1915 // add a new line to the file: note that line returned by
1916 // GetLastEntryLine() may be NULL if we're in the root group and it
1917 // doesn't have any entries yet, but this is ok as passing NULL
1918 // line to LineListInsert() means to prepend new line to the list
1919 wxFileConfigLineList *line = Group()->GetLastEntryLine();
1920 m_pLine = Group()->Config()->LineListInsert(strLine, line);
1921
1922 Group()->SetLastEntry(this);
1923 }
1924 }
1925 }
1926
1927 // ============================================================================
1928 // global functions
1929 // ============================================================================
1930
1931 // ----------------------------------------------------------------------------
1932 // compare functions for array sorting
1933 // ----------------------------------------------------------------------------
1934
1935 int CompareEntries(wxFileConfigEntry *p1, wxFileConfigEntry *p2)
1936 {
1937 #if wxCONFIG_CASE_SENSITIVE
1938 return wxStrcmp(p1->Name(), p2->Name());
1939 #else
1940 return wxStricmp(p1->Name(), p2->Name());
1941 #endif
1942 }
1943
1944 int CompareGroups(wxFileConfigGroup *p1, wxFileConfigGroup *p2)
1945 {
1946 #if wxCONFIG_CASE_SENSITIVE
1947 return wxStrcmp(p1->Name(), p2->Name());
1948 #else
1949 return wxStricmp(p1->Name(), p2->Name());
1950 #endif
1951 }
1952
1953 // ----------------------------------------------------------------------------
1954 // filter functions
1955 // ----------------------------------------------------------------------------
1956
1957 // undo FilterOutValue
1958 static wxString FilterInValue(const wxString& str)
1959 {
1960 wxString strResult;
1961 strResult.Alloc(str.Len());
1962
1963 bool bQuoted = !str.empty() && str[0] == '"';
1964
1965 for ( size_t n = bQuoted ? 1 : 0; n < str.Len(); n++ ) {
1966 if ( str[n] == wxT('\\') ) {
1967 switch ( str[++n] ) {
1968 case wxT('n'):
1969 strResult += wxT('\n');
1970 break;
1971
1972 case wxT('r'):
1973 strResult += wxT('\r');
1974 break;
1975
1976 case wxT('t'):
1977 strResult += wxT('\t');
1978 break;
1979
1980 case wxT('\\'):
1981 strResult += wxT('\\');
1982 break;
1983
1984 case wxT('"'):
1985 strResult += wxT('"');
1986 break;
1987 }
1988 }
1989 else {
1990 if ( str[n] != wxT('"') || !bQuoted )
1991 strResult += str[n];
1992 else if ( n != str.Len() - 1 ) {
1993 wxLogWarning(_("unexpected \" at position %d in '%s'."),
1994 n, str.c_str());
1995 }
1996 //else: it's the last quote of a quoted string, ok
1997 }
1998 }
1999
2000 return strResult;
2001 }
2002
2003 // quote the string before writing it to file
2004 static wxString FilterOutValue(const wxString& str)
2005 {
2006 if ( !str )
2007 return str;
2008
2009 wxString strResult;
2010 strResult.Alloc(str.Len());
2011
2012 // quoting is necessary to preserve spaces in the beginning of the string
2013 bool bQuote = wxIsspace(str[0]) || str[0] == wxT('"');
2014
2015 if ( bQuote )
2016 strResult += wxT('"');
2017
2018 wxChar c;
2019 for ( size_t n = 0; n < str.Len(); n++ ) {
2020 switch ( str[n] ) {
2021 case wxT('\n'):
2022 c = wxT('n');
2023 break;
2024
2025 case wxT('\r'):
2026 c = wxT('r');
2027 break;
2028
2029 case wxT('\t'):
2030 c = wxT('t');
2031 break;
2032
2033 case wxT('\\'):
2034 c = wxT('\\');
2035 break;
2036
2037 case wxT('"'):
2038 if ( bQuote ) {
2039 c = wxT('"');
2040 break;
2041 }
2042 //else: fall through
2043
2044 default:
2045 strResult += str[n];
2046 continue; // nothing special to do
2047 }
2048
2049 // we get here only for special characters
2050 strResult << wxT('\\') << c;
2051 }
2052
2053 if ( bQuote )
2054 strResult += wxT('"');
2055
2056 return strResult;
2057 }
2058
2059 // undo FilterOutEntryName
2060 static wxString FilterInEntryName(const wxString& str)
2061 {
2062 wxString strResult;
2063 strResult.Alloc(str.Len());
2064
2065 for ( const wxChar *pc = str.c_str(); *pc != '\0'; pc++ ) {
2066 if ( *pc == wxT('\\') ) {
2067 // we need to test it here or we'd skip past the NUL in the loop line
2068 if ( *++pc == _T('\0') )
2069 break;
2070 }
2071
2072 strResult += *pc;
2073 }
2074
2075 return strResult;
2076 }
2077
2078 // sanitize entry or group name: insert '\\' before any special characters
2079 static wxString FilterOutEntryName(const wxString& str)
2080 {
2081 wxString strResult;
2082 strResult.Alloc(str.Len());
2083
2084 for ( const wxChar *pc = str.c_str(); *pc != wxT('\0'); pc++ ) {
2085 const wxChar c = *pc;
2086
2087 // we explicitly allow some of "safe" chars and 8bit ASCII characters
2088 // which will probably never have special meaning and with which we can't
2089 // use isalnum() anyhow (in ASCII built, in Unicode it's just fine)
2090 //
2091 // NB: note that wxCONFIG_IMMUTABLE_PREFIX and wxCONFIG_PATH_SEPARATOR
2092 // should *not* be quoted
2093 if (
2094 #if !wxUSE_UNICODE
2095 ((unsigned char)c < 127) &&
2096 #endif // ANSI
2097 !wxIsalnum(c) && !wxStrchr(wxT("@_/-!.*%"), c) )
2098 {
2099 strResult += wxT('\\');
2100 }
2101
2102 strResult += c;
2103 }
2104
2105 return strResult;
2106 }
2107
2108 // we can't put ?: in the ctor initializer list because it confuses some
2109 // broken compilers (Borland C++)
2110 static wxString GetAppName(const wxString& appName)
2111 {
2112 if ( !appName && wxTheApp )
2113 return wxTheApp->GetAppName();
2114 else
2115 return appName;
2116 }
2117
2118 #endif // wxUSE_CONFIG
wxWidgets (Impactor)