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