projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
missing or wrong DLLEXPORTs for DLL build
[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 #ifdef __GNUG__
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 WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(wxFileConfigEntry *, ArrayEntries,
110 WXDLLIMPEXP_BASE);
111 WX_DEFINE_SORTED_USER_EXPORTED_ARRAY(wxFileConfigGroup *, ArrayGroups,
112 WXDLLIMPEXP_BASE);
113
114 // ----------------------------------------------------------------------------
115 // wxFileConfigLineList
116 // ----------------------------------------------------------------------------
117
118 // we store all lines of the local config file as a linked list in memory
119 class wxFileConfigLineList
120 {
121 public:
122 void SetNext(wxFileConfigLineList *pNext) { m_pNext = pNext; }
123 void SetPrev(wxFileConfigLineList *pPrev) { m_pPrev = pPrev; }
124
125 // ctor
126 wxFileConfigLineList(const wxString& str,
127 wxFileConfigLineList *pNext = NULL) : m_strLine(str)
128 { SetNext(pNext); SetPrev(NULL); }
129
130 // next/prev nodes in the linked list
131 wxFileConfigLineList *Next() const { return m_pNext; }
132 wxFileConfigLineList *Prev() const { return m_pPrev; }
133
134 // get/change lines text
135 void SetText(const wxString& str) { m_strLine = str; }
136 const wxString& Text() const { return m_strLine; }
137
138 private:
139 wxString m_strLine; // line contents
140 wxFileConfigLineList *m_pNext, // next node
141 *m_pPrev; // previous one
142
143 DECLARE_NO_COPY_CLASS(wxFileConfigLineList)
144 };
145
146 // ----------------------------------------------------------------------------
147 // wxFileConfigEntry: a name/value pair
148 // ----------------------------------------------------------------------------
149
150 class wxFileConfigEntry
151 {
152 private:
153 wxFileConfigGroup *m_pParent; // group that contains us
154
155 wxString m_strName, // entry name
156 m_strValue; // value
157 bool m_bDirty:1, // changed since last read?
158 m_bImmutable:1, // can be overriden locally?
159 m_bHasValue:1; // set after first call to SetValue()
160
161 int m_nLine; // used if m_pLine == NULL only
162
163 // pointer to our line in the linked list or NULL if it was found in global
164 // file (which we don't modify)
165 wxFileConfigLineList *m_pLine;
166
167 public:
168 wxFileConfigEntry(wxFileConfigGroup *pParent,
169 const wxString& strName, int nLine);
170
171 // simple accessors
172 const wxString& Name() const { return m_strName; }
173 const wxString& Value() const { return m_strValue; }
174 wxFileConfigGroup *Group() const { return m_pParent; }
175 bool IsDirty() const { return m_bDirty; }
176 bool IsImmutable() const { return m_bImmutable; }
177 bool IsLocal() const { return m_pLine != 0; }
178 int Line() const { return m_nLine; }
179 wxFileConfigLineList *
180 GetLine() const { return m_pLine; }
181
182 // modify entry attributes
183 void SetValue(const wxString& strValue, bool bUser = TRUE);
184 void SetDirty();
185 void SetLine(wxFileConfigLineList *pLine);
186
187 DECLARE_NO_COPY_CLASS(wxFileConfigEntry)
188 };
189
190 // ----------------------------------------------------------------------------
191 // wxFileConfigGroup: container of entries and other groups
192 // ----------------------------------------------------------------------------
193
194 class wxFileConfigGroup
195 {
196 private:
197 wxFileConfig *m_pConfig; // config object we belong to
198 wxFileConfigGroup *m_pParent; // parent group (NULL for root group)
199 ArrayEntries m_aEntries; // entries in this group
200 ArrayGroups m_aSubgroups; // subgroups
201 wxString m_strName; // group's name
202 bool m_bDirty; // if FALSE => all subgroups are not dirty
203 wxFileConfigLineList *m_pLine; // pointer to our line in the linked list
204 wxFileConfigEntry *m_pLastEntry; // last entry/subgroup of this group in the
205 wxFileConfigGroup *m_pLastGroup; // local file (we insert new ones after it)
206
207 // DeleteSubgroupByName helper
208 bool DeleteSubgroup(wxFileConfigGroup *pGroup);
209
210 public:
211 // ctor
212 wxFileConfigGroup(wxFileConfigGroup *pParent, const wxString& strName, wxFileConfig *);
213
214 // dtor deletes all entries and subgroups also
215 ~wxFileConfigGroup();
216
217 // simple accessors
218 const wxString& Name() const { return m_strName; }
219 wxFileConfigGroup *Parent() const { return m_pParent; }
220 wxFileConfig *Config() const { return m_pConfig; }
221 bool IsDirty() const { return m_bDirty; }
222
223 const ArrayEntries& Entries() const { return m_aEntries; }
224 const ArrayGroups& Groups() const { return m_aSubgroups; }
225 bool IsEmpty() const { return Entries().IsEmpty() && Groups().IsEmpty(); }
226
227 // find entry/subgroup (NULL if not found)
228 wxFileConfigGroup *FindSubgroup(const wxChar *szName) const;
229 wxFileConfigEntry *FindEntry (const wxChar *szName) const;
230
231 // delete entry/subgroup, return FALSE if doesn't exist
232 bool DeleteSubgroupByName(const wxChar *szName);
233 bool DeleteEntry(const wxChar *szName);
234
235 // create new entry/subgroup returning pointer to newly created element
236 wxFileConfigGroup *AddSubgroup(const wxString& strName);
237 wxFileConfigEntry *AddEntry (const wxString& strName, int nLine = wxNOT_FOUND);
238
239 // will also recursively set parent's dirty flag
240 void SetDirty();
241 void SetLine(wxFileConfigLineList *pLine);
242
243 // rename: no checks are done to ensure that the name is unique!
244 void Rename(const wxString& newName);
245
246 //
247 wxString GetFullName() const;
248
249 // get the last line belonging to an entry/subgroup of this group
250 wxFileConfigLineList *GetGroupLine(); // line which contains [group]
251 wxFileConfigLineList *GetLastEntryLine(); // after which our subgroups start
252 wxFileConfigLineList *GetLastGroupLine(); // after which the next group starts
253
254 // called by entries/subgroups when they're created/deleted
255 void SetLastEntry(wxFileConfigEntry *pEntry);
256 void SetLastGroup(wxFileConfigGroup *pGroup)
257 { m_pLastGroup = pGroup; }
258
259 DECLARE_NO_COPY_CLASS(wxFileConfigGroup)
260 };
261
262 // ============================================================================
263 // implementation
264 // ============================================================================
265
266 // ----------------------------------------------------------------------------
267 // static functions
268 // ----------------------------------------------------------------------------
269 wxString wxFileConfig::GetGlobalDir()
270 {
271 wxString strDir;
272
273 #ifdef __VMS__ // Note if __VMS is defined __UNIX is also defined
274 strDir = wxT("sys$manager:");
275 #elif defined(__WXMAC__)
276 strDir = wxMacFindFolder( (short) kOnSystemDisk, kPreferencesFolderType, kDontCreateFolder ) ;
277 #elif defined( __UNIX__ )
278 strDir = wxT("/etc/");
279 #elif defined(__WXPM__)
280 ULONG aulSysInfo[QSV_MAX] = {0};
281 UINT drive;
282 APIRET rc;
283
284 rc = DosQuerySysInfo( 1L, QSV_MAX, (PVOID)aulSysInfo, sizeof(ULONG)*QSV_MAX);
285 if (rc == 0)
286 {
287 drive = aulSysInfo[QSV_BOOT_DRIVE - 1];
288 strDir.Printf(wxT("%c:\\OS2\\"), 'A'+drive-1);
289 }
290 #elif defined(__WXSTUBS__)
291 wxASSERT_MSG( FALSE, wxT("TODO") ) ;
292 #elif defined(__DOS__)
293 // There's no such thing as global cfg dir in MS-DOS, let's return
294 // current directory (FIXME_MGL?)
295 return wxT(".\\");
296 #else // Windows
297 wxChar szWinDir[MAX_PATH];
298 ::GetWindowsDirectory(szWinDir, MAX_PATH);
299
300 strDir = szWinDir;
301 strDir << wxT('\\');
302 #endif // Unix/Windows
303
304 return strDir;
305 }
306
307 wxString wxFileConfig::GetLocalDir()
308 {
309 wxString strDir;
310
311 #if defined(__WXMAC__) || defined(__DOS__)
312 // no local dir concept on Mac OS 9 or MS-DOS
313 return GetGlobalDir() ;
314 #else
315 wxGetHomeDir(&strDir);
316
317 #ifdef __UNIX__
318 #ifdef __VMS
319 if (strDir.Last() != wxT(']'))
320 #endif
321 if (strDir.Last() != wxT('/')) strDir << wxT('/');
322 #else
323 if (strDir.Last() != wxT('\\')) strDir << wxT('\\');
324 #endif
325 #endif
326
327 return strDir;
328 }
329
330 wxString wxFileConfig::GetGlobalFileName(const wxChar *szFile)
331 {
332 wxString str = GetGlobalDir();
333 str << szFile;
334
335 if ( wxStrchr(szFile, wxT('.')) == NULL )
336 #if defined( __WXMAC__ )
337 str << wxT(" Preferences") ;
338 #elif defined( __UNIX__ )
339 str << wxT(".conf");
340 #else // Windows
341 str << wxT(".ini");
342 #endif // UNIX/Win
343
344 return str;
345 }
346
347 wxString wxFileConfig::GetLocalFileName(const wxChar *szFile)
348 {
349 #ifdef __VMS__
350 // On VMS I saw the problem that the home directory was appended
351 // twice for the configuration file. Does that also happen for
352 // other platforms?
353 wxString str = wxT( '.' );
354 #else
355 wxString str = GetLocalDir();
356 #endif
357
358 #if defined( __UNIX__ ) && !defined( __VMS ) && !defined( __WXMAC__ )
359 str << wxT('.');
360 #endif
361
362 str << szFile;
363
364 #if defined(__WINDOWS__) || defined(__DOS__)
365 if ( wxStrchr(szFile, wxT('.')) == NULL )
366 str << wxT(".ini");
367 #endif
368
369 #ifdef __WXMAC__
370 str << wxT(" Preferences") ;
371 #endif
372
373 return str;
374 }
375
376 // ----------------------------------------------------------------------------
377 // ctor
378 // ----------------------------------------------------------------------------
379
380 void wxFileConfig::Init()
381 {
382 m_pCurrentGroup =
383 m_pRootGroup = new wxFileConfigGroup(NULL, wxT(""), this);
384
385 m_linesHead =
386 m_linesTail = NULL;
387
388 // It's not an error if (one of the) file(s) doesn't exist.
389
390 // parse the global file
391 if ( !m_strGlobalFile.IsEmpty() && wxFile::Exists(m_strGlobalFile) )
392 {
393 wxTextFile fileGlobal(m_strGlobalFile);
394
395 if ( fileGlobal.Open(m_conv/*ignored in ANSI build*/) )
396 {
397 Parse(fileGlobal, FALSE /* global */);
398 SetRootPath();
399 }
400 else
401 {
402 wxLogWarning(_("can't open global configuration file '%s'."), m_strGlobalFile.c_str());
403 }
404 }
405
406 // parse the local file
407 if ( !m_strLocalFile.IsEmpty() && wxFile::Exists(m_strLocalFile) )
408 {
409 wxTextFile fileLocal(m_strLocalFile);
410 if ( fileLocal.Open(m_conv/*ignored in ANSI build*/) )
411 {
412 Parse(fileLocal, TRUE /* local */);
413 SetRootPath();
414 }
415 else
416 {
417 wxLogWarning(_("can't open user configuration file '%s'."), m_strLocalFile.c_str() );
418 }
419 }
420 }
421
422 // constructor supports creation of wxFileConfig objects of any type
423 wxFileConfig::wxFileConfig(const wxString& appName, const wxString& vendorName,
424 const wxString& strLocal, const wxString& strGlobal,
425 long style, wxMBConv& conv)
426 : wxConfigBase(::GetAppName(appName), vendorName,
427 strLocal, strGlobal,
428 style),
429 m_strLocalFile(strLocal), m_strGlobalFile(strGlobal),
430 m_conv(conv)
431 {
432 // Make up names for files if empty
433 if ( m_strLocalFile.IsEmpty() && (style & wxCONFIG_USE_LOCAL_FILE) )
434 m_strLocalFile = GetLocalFileName(GetAppName());
435
436 if ( m_strGlobalFile.IsEmpty() && (style & wxCONFIG_USE_GLOBAL_FILE) )
437 m_strGlobalFile = GetGlobalFileName(GetAppName());
438
439 // Check if styles are not supplied, but filenames are, in which case
440 // add the correct styles.
441 if ( !m_strLocalFile.IsEmpty() )
442 SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE);
443
444 if ( !m_strGlobalFile.IsEmpty() )
445 SetStyle(GetStyle() | wxCONFIG_USE_GLOBAL_FILE);
446
447 // if the path is not absolute, prepend the standard directory to it
448 // UNLESS wxCONFIG_USE_RELATIVE_PATH style is set
449 if ( !(style & wxCONFIG_USE_RELATIVE_PATH) )
450 {
451 if ( !m_strLocalFile.IsEmpty() && !wxIsAbsolutePath(m_strLocalFile) )
452 {
453 wxString strLocal = m_strLocalFile;
454 m_strLocalFile = GetLocalDir();
455 m_strLocalFile << strLocal;
456 }
457
458 if ( !m_strGlobalFile.IsEmpty() && !wxIsAbsolutePath(m_strGlobalFile) )
459 {
460 wxString strGlobal = m_strGlobalFile;
461 m_strGlobalFile = GetGlobalDir();
462 m_strGlobalFile << strGlobal;
463 }
464 }
465
466 SetUmask(-1);
467
468 Init();
469 }
470
471 #if wxUSE_STREAMS
472
473 wxFileConfig::wxFileConfig(wxInputStream &inStream, wxMBConv& conv)
474 : m_conv(conv)
475 {
476 // always local_file when this constructor is called (?)
477 SetStyle(GetStyle() | wxCONFIG_USE_LOCAL_FILE);
478
479 m_pCurrentGroup =
480 m_pRootGroup = new wxFileConfigGroup(NULL, wxT(""), this);
481
482 m_linesHead =
483 m_linesTail = NULL;
484
485 // translate everything to the current (platform-dependent) line
486 // termination character
487 wxString strTrans;
488 {
489 wxString strTmp;
490
491 char buf[1024];
492 while ( !inStream.Read(buf, WXSIZEOF(buf)).Eof() )
493 strTmp.append(wxConvertMB2WX(buf), inStream.LastRead());
494
495 strTmp.append(wxConvertMB2WX(buf), inStream.LastRead());
496
497 strTrans = wxTextBuffer::Translate(strTmp);
498 }
499
500 wxMemoryText memText;
501
502 // Now we can add the text to the memory text. To do this we extract line
503 // by line from the translated string, until we've reached the end.
504 //
505 // VZ: all this is horribly inefficient, we should do the translation on
506 // the fly in one pass saving both memory and time (TODO)
507
508 const wxChar *pEOL = wxTextBuffer::GetEOL(wxTextBuffer::typeDefault);
509 const size_t EOLLen = wxStrlen(pEOL);
510
511 int posLineStart = strTrans.Find(pEOL);
512 while ( posLineStart != -1 )
513 {
514 wxString line(strTrans.Left(posLineStart));
515
516 memText.AddLine(line);
517
518 strTrans = strTrans.Mid(posLineStart + EOLLen);
519
520 posLineStart = strTrans.Find(pEOL);
521 }
522
523 // also add whatever we have left in the translated string.
524 memText.AddLine(strTrans);
525
526 // Finally we can parse it all.
527 Parse(memText, TRUE /* local */);
528
529 SetRootPath();
530 }
531
532 #endif // wxUSE_STREAMS
533
534 void wxFileConfig::CleanUp()
535 {
536 delete m_pRootGroup;
537
538 wxFileConfigLineList *pCur = m_linesHead;
539 while ( pCur != NULL ) {
540 wxFileConfigLineList *pNext = pCur->Next();
541 delete pCur;
542 pCur = pNext;
543 }
544 }
545
546 wxFileConfig::~wxFileConfig()
547 {
548 Flush();
549
550 CleanUp();
551 }
552
553 // ----------------------------------------------------------------------------
554 // parse a config file
555 // ----------------------------------------------------------------------------
556
557 void wxFileConfig::Parse(wxTextBuffer& buffer, bool bLocal)
558 {
559 const wxChar *pStart;
560 const wxChar *pEnd;
561 wxString strLine;
562
563 size_t nLineCount = buffer.GetLineCount();
564
565 for ( size_t n = 0; n < nLineCount; n++ )
566 {
567 strLine = buffer[n];
568
569 // add the line to linked list
570 if ( bLocal )
571 {
572 LineListAppend(strLine);
573
574 // let the root group have it start line as well
575 if ( !n )
576 {
577 m_pCurrentGroup->SetLine(m_linesTail);
578 }
579 }
580
581
582 // skip leading spaces
583 for ( pStart = strLine; wxIsspace(*pStart); pStart++ )
584 ;
585
586 // skip blank/comment lines
587 if ( *pStart == wxT('\0')|| *pStart == wxT(';') || *pStart == wxT('#') )
588 continue;
589
590 if ( *pStart == wxT('[') ) { // a new group
591 pEnd = pStart;
592
593 while ( *++pEnd != wxT(']') ) {
594 if ( *pEnd == wxT('\\') ) {
595 // the next char is escaped, so skip it even if it is ']'
596 pEnd++;
597 }
598
599 if ( *pEnd == wxT('\n') || *pEnd == wxT('\0') ) {
600 // we reached the end of line, break out of the loop
601 break;
602 }
603 }
604
605 if ( *pEnd != wxT(']') ) {
606 wxLogError(_("file '%s': unexpected character %c at line %d."),
607 buffer.GetName(), *pEnd, n + 1);
608 continue; // skip this line
609 }
610
611 // group name here is always considered as abs path
612 wxString strGroup;
613 pStart++;
614 strGroup << wxCONFIG_PATH_SEPARATOR
615 << FilterInEntryName(wxString(pStart, pEnd - pStart));
616
617 // will create it if doesn't yet exist
618 SetPath(strGroup);
619
620 if ( bLocal )
621 m_pCurrentGroup->SetLine(m_linesTail);
622
623 // check that there is nothing except comments left on this line
624 bool bCont = TRUE;
625 while ( *++pEnd != wxT('\0') && bCont ) {
626 switch ( *pEnd ) {
627 case wxT('#'):
628 case wxT(';'):
629 bCont = FALSE;
630 break;
631
632 case wxT(' '):
633 case wxT('\t'):
634 // ignore whitespace ('\n' impossible here)
635 break;
636
637 default:
638 wxLogWarning(_("file '%s', line %d: '%s' ignored after group header."),
639 buffer.GetName(), n + 1, pEnd);
640 bCont = FALSE;
641 }
642 }
643 }
644 else { // a key
645 const wxChar *pEnd = pStart;
646 while ( *pEnd && *pEnd != wxT('=') && !wxIsspace(*pEnd) ) {
647 if ( *pEnd == wxT('\\') ) {
648 // next character may be space or not - still take it because it's
649 // quoted (unless there is nothing)
650 pEnd++;
651 if ( !*pEnd ) {
652 // the error message will be given below anyhow
653 break;
654 }
655 }
656
657 pEnd++;
658 }
659
660 wxString strKey(FilterInEntryName(wxString(pStart, pEnd)));
661
662 // skip whitespace
663 while ( wxIsspace(*pEnd) )
664 pEnd++;
665
666 if ( *pEnd++ != wxT('=') ) {
667 wxLogError(_("file '%s', line %d: '=' expected."),
668 buffer.GetName(), n + 1);
669 }
670 else {
671 wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strKey);
672
673 if ( pEntry == NULL ) {
674 // new entry
675 pEntry = m_pCurrentGroup->AddEntry(strKey, n);
676
677 // <JACS>
678 // Take the opportunity to set some pointers now
679 // that we know there are items in this group.
680 // Otherwise, items added to a newly read file
681 // can be put in the wrong place.
682 m_pCurrentGroup->SetLastEntry(pEntry);
683 if (m_pCurrentGroup->Parent())
684 m_pCurrentGroup->Parent()->SetLastGroup(m_pCurrentGroup);
685 // </JACS>
686
687 if ( bLocal )
688 pEntry->SetLine(m_linesTail);
689 }
690 else {
691 if ( bLocal && pEntry->IsImmutable() ) {
692 // immutable keys can't be changed by user
693 wxLogWarning(_("file '%s', line %d: value for immutable key '%s' ignored."),
694 buffer.GetName(), n + 1, strKey.c_str());
695 continue;
696 }
697 // the condition below catches the cases (a) and (b) but not (c):
698 // (a) global key found second time in global file
699 // (b) key found second (or more) time in local file
700 // (c) key from global file now found in local one
701 // which is exactly what we want.
702 else if ( !bLocal || pEntry->IsLocal() ) {
703 wxLogWarning(_("file '%s', line %d: key '%s' was first found at line %d."),
704 buffer.GetName(), n + 1, strKey.c_str(), pEntry->Line());
705
706 if ( bLocal )
707 pEntry->SetLine(m_linesTail);
708 }
709 }
710
711 // skip whitespace
712 while ( wxIsspace(*pEnd) )
713 pEnd++;
714
715 wxString value = pEnd;
716 if ( !(GetStyle() & wxCONFIG_USE_NO_ESCAPE_CHARACTERS) )
717 value = FilterInValue(value);
718
719 pEntry->SetValue(value, FALSE);
720 }
721 }
722 }
723 }
724
725 // ----------------------------------------------------------------------------
726 // set/retrieve path
727 // ----------------------------------------------------------------------------
728
729 void wxFileConfig::SetRootPath()
730 {
731 m_strPath.Empty();
732 m_pCurrentGroup = m_pRootGroup;
733 }
734
735 void wxFileConfig::SetPath(const wxString& strPath)
736 {
737 wxArrayString aParts;
738
739 if ( strPath.IsEmpty() ) {
740 SetRootPath();
741 return;
742 }
743
744 if ( strPath[0] == wxCONFIG_PATH_SEPARATOR ) {
745 // absolute path
746 wxSplitPath(aParts, strPath);
747 }
748 else {
749 // relative path, combine with current one
750 wxString strFullPath = m_strPath;
751 strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
752 wxSplitPath(aParts, strFullPath);
753 }
754
755 // change current group
756 size_t n;
757 m_pCurrentGroup = m_pRootGroup;
758 for ( n = 0; n < aParts.Count(); n++ ) {
759 wxFileConfigGroup *pNextGroup = m_pCurrentGroup->FindSubgroup(aParts[n]);
760 if ( pNextGroup == NULL )
761 pNextGroup = m_pCurrentGroup->AddSubgroup(aParts[n]);
762 m_pCurrentGroup = pNextGroup;
763 }
764
765 // recombine path parts in one variable
766 m_strPath.Empty();
767 for ( n = 0; n < aParts.Count(); n++ ) {
768 m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n];
769 }
770 }
771
772 // ----------------------------------------------------------------------------
773 // enumeration
774 // ----------------------------------------------------------------------------
775
776 bool wxFileConfig::GetFirstGroup(wxString& str, long& lIndex) const
777 {
778 lIndex = 0;
779 return GetNextGroup(str, lIndex);
780 }
781
782 bool wxFileConfig::GetNextGroup (wxString& str, long& lIndex) const
783 {
784 if ( size_t(lIndex) < m_pCurrentGroup->Groups().Count() ) {
785 str = m_pCurrentGroup->Groups()[(size_t)lIndex++]->Name();
786 return TRUE;
787 }
788 else
789 return FALSE;
790 }
791
792 bool wxFileConfig::GetFirstEntry(wxString& str, long& lIndex) const
793 {
794 lIndex = 0;
795 return GetNextEntry(str, lIndex);
796 }
797
798 bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) const
799 {
800 if ( size_t(lIndex) < m_pCurrentGroup->Entries().Count() ) {
801 str = m_pCurrentGroup->Entries()[(size_t)lIndex++]->Name();
802 return TRUE;
803 }
804 else
805 return FALSE;
806 }
807
808 size_t wxFileConfig::GetNumberOfEntries(bool bRecursive) const
809 {
810 size_t n = m_pCurrentGroup->Entries().Count();
811 if ( bRecursive ) {
812 wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
813 size_t nSubgroups = m_pCurrentGroup->Groups().Count();
814 for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
815 CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
816 n += GetNumberOfEntries(TRUE);
817 CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
818 }
819 }
820
821 return n;
822 }
823
824 size_t wxFileConfig::GetNumberOfGroups(bool bRecursive) const
825 {
826 size_t n = m_pCurrentGroup->Groups().Count();
827 if ( bRecursive ) {
828 wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
829 size_t nSubgroups = m_pCurrentGroup->Groups().Count();
830 for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
831 CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
832 n += GetNumberOfGroups(TRUE);
833 CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
834 }
835 }
836
837 return n;
838 }
839
840 // ----------------------------------------------------------------------------
841 // tests for existence
842 // ----------------------------------------------------------------------------
843
844 bool wxFileConfig::HasGroup(const wxString& strName) const
845 {
846 wxConfigPathChanger path(this, strName);
847
848 wxFileConfigGroup *pGroup = m_pCurrentGroup->FindSubgroup(path.Name());
849 return pGroup != NULL;
850 }
851
852 bool wxFileConfig::HasEntry(const wxString& strName) const
853 {
854 wxConfigPathChanger path(this, strName);
855
856 wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
857 return pEntry != NULL;
858 }
859
860 // ----------------------------------------------------------------------------
861 // read/write values
862 // ----------------------------------------------------------------------------
863
864 bool wxFileConfig::DoReadString(const wxString& key, wxString* pStr) const
865 {
866 wxConfigPathChanger path(this, key);
867
868 wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
869 if (pEntry == NULL) {
870 return FALSE;
871 }
872
873 *pStr = pEntry->Value();
874
875 return TRUE;
876 }
877
878 bool wxFileConfig::DoReadLong(const wxString& key, long *pl) const
879 {
880 wxString str;
881 if ( !Read(key, &str) )
882 return FALSE;
883
884 // extra spaces shouldn't prevent us from reading numeric values
885 str.Trim();
886
887 return str.ToLong(pl);
888 }
889
890 bool wxFileConfig::DoWriteString(const wxString& key, const wxString& szValue)
891 {
892 wxConfigPathChanger path(this, key);
893 wxString strName = path.Name();
894
895 wxLogTrace( _T("wxFileConfig"),
896 _T(" Writing String '%s' = '%s' to Group '%s'"),
897 strName.c_str(),
898 szValue.c_str(),
899 GetPath().c_str() );
900
901 if ( strName.IsEmpty() )
902 {
903 // setting the value of a group is an error
904
905 wxASSERT_MSG( wxIsEmpty(szValue), wxT("can't set value of a group!") );
906
907 // ... except if it's empty in which case it's a way to force it's creation
908
909 wxLogTrace( _T("wxFileConfig"),
910 _T(" Creating group %s"),
911 m_pCurrentGroup->Name().c_str() );
912
913 m_pCurrentGroup->SetDirty();
914
915 // this will add a line for this group if it didn't have it before
916
917 (void)m_pCurrentGroup->GetGroupLine();
918 }
919 else
920 {
921 // writing an entry
922 // check that the name is reasonable
923
924 if ( strName[0u] == wxCONFIG_IMMUTABLE_PREFIX )
925 {
926 wxLogError( _("Config entry name cannot start with '%c'."),
927 wxCONFIG_IMMUTABLE_PREFIX);
928 return FALSE;
929 }
930
931 wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strName);
932
933 if ( pEntry == 0 )
934 {
935 wxLogTrace( _T("wxFileConfig"),
936 _T(" Adding Entry %s"),
937 strName.c_str() );
938 pEntry = m_pCurrentGroup->AddEntry(strName);
939 }
940
941 wxLogTrace( _T("wxFileConfig"),
942 _T(" Setting value %s"),
943 szValue.c_str() );
944 pEntry->SetValue(szValue);
945 }
946
947 return TRUE;
948 }
949
950 bool wxFileConfig::DoWriteLong(const wxString& key, long lValue)
951 {
952 return Write(key, wxString::Format(_T("%ld"), lValue));
953 }
954
955 bool wxFileConfig::Flush(bool /* bCurrentOnly */)
956 {
957 if ( LineListIsEmpty() || !m_pRootGroup->IsDirty() || !m_strLocalFile )
958 return TRUE;
959
960 #ifdef __UNIX__
961 // set the umask if needed
962 mode_t umaskOld = 0;
963 if ( m_umask != -1 )
964 {
965 umaskOld = umask((mode_t)m_umask);
966 }
967 #endif // __UNIX__
968
969 wxTempFile file(m_strLocalFile);
970
971 if ( !file.IsOpened() )
972 {
973 wxLogError(_("can't open user configuration file."));
974 return FALSE;
975 }
976
977 // write all strings to file
978 for ( wxFileConfigLineList *p = m_linesHead; p != NULL; p = p->Next() )
979 {
980 wxString line = p->Text();
981 line += wxTextFile::GetEOL();
982 if ( !file.Write(line, m_conv) )
983 {
984 wxLogError(_("can't write user configuration file."));
985 return FALSE;
986 }
987 }
988
989 bool ret = file.Commit();
990
991 #if defined(__WXMAC__)
992 if ( ret )
993 {
994 FSSpec spec ;
995
996 wxMacFilename2FSSpec( m_strLocalFile , &spec ) ;
997 FInfo finfo ;
998 if ( FSpGetFInfo( &spec , &finfo ) == noErr )
999 {
1000 finfo.fdType = 'TEXT' ;
1001 finfo.fdCreator = 'ttxt' ;
1002 FSpSetFInfo( &spec , &finfo ) ;
1003 }
1004 }
1005 #endif // __WXMAC__
1006
1007 #ifdef __UNIX__
1008 // restore the old umask if we changed it
1009 if ( m_umask != -1 )
1010 {
1011 (void)umask(umaskOld);
1012 }
1013 #endif // __UNIX__
1014
1015 return ret;
1016 }
1017
1018 // ----------------------------------------------------------------------------
1019 // renaming groups/entries
1020 // ----------------------------------------------------------------------------
1021
1022 bool wxFileConfig::RenameEntry(const wxString& oldName,
1023 const wxString& newName)
1024 {
1025 // check that the entry exists
1026 wxFileConfigEntry *oldEntry = m_pCurrentGroup->FindEntry(oldName);
1027 if ( !oldEntry )
1028 return FALSE;
1029
1030 // check that the new entry doesn't already exist
1031 if ( m_pCurrentGroup->FindEntry(newName) )
1032 return FALSE;
1033
1034 // delete the old entry, create the new one
1035 wxString value = oldEntry->Value();
1036 if ( !m_pCurrentGroup->DeleteEntry(oldName) )
1037 return FALSE;
1038
1039 wxFileConfigEntry *newEntry = m_pCurrentGroup->AddEntry(newName);
1040 newEntry->SetValue(value);
1041
1042 return TRUE;
1043 }
1044
1045 bool wxFileConfig::RenameGroup(const wxString& oldName,
1046 const wxString& newName)
1047 {
1048 // check that the group exists
1049 wxFileConfigGroup *group = m_pCurrentGroup->FindSubgroup(oldName);
1050 if ( !group )
1051 return FALSE;
1052
1053 // check that the new group doesn't already exist
1054 if ( m_pCurrentGroup->FindSubgroup(newName) )
1055 return FALSE;
1056
1057 group->Rename(newName);
1058
1059 return TRUE;
1060 }
1061
1062 // ----------------------------------------------------------------------------
1063 // delete groups/entries
1064 // ----------------------------------------------------------------------------
1065
1066 bool wxFileConfig::DeleteEntry(const wxString& key, bool bGroupIfEmptyAlso)
1067 {
1068 wxConfigPathChanger path(this, key);
1069
1070 if ( !m_pCurrentGroup->DeleteEntry(path.Name()) )
1071 return FALSE;
1072
1073 if ( bGroupIfEmptyAlso && m_pCurrentGroup->IsEmpty() ) {
1074 if ( m_pCurrentGroup != m_pRootGroup ) {
1075 wxFileConfigGroup *pGroup = m_pCurrentGroup;
1076 SetPath(wxT("..")); // changes m_pCurrentGroup!
1077 m_pCurrentGroup->DeleteSubgroupByName(pGroup->Name());
1078 }
1079 //else: never delete the root group
1080 }
1081
1082 return TRUE;
1083 }
1084
1085 bool wxFileConfig::DeleteGroup(const wxString& key)
1086 {
1087 wxConfigPathChanger path(this, key);
1088
1089 return m_pCurrentGroup->DeleteSubgroupByName(path.Name());
1090 }
1091
1092 bool wxFileConfig::DeleteAll()
1093 {
1094 CleanUp();
1095
1096 if ( wxRemove(m_strLocalFile) == -1 )
1097 wxLogSysError(_("can't delete user configuration file '%s'"), m_strLocalFile.c_str());
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 wxASSERT( m_nLine == wxNOT_FOUND ); // consistency check
1843
1844 wxFileConfigLineList *line = Group()->GetLastEntryLine();
1845 m_pLine = Group()->Config()->LineListInsert(strLine, line);
1846
1847 Group()->SetLastEntry(this);
1848 }
1849
1850 SetDirty();
1851 }
1852 }
1853
1854 void wxFileConfigEntry::SetDirty()
1855 {
1856 m_bDirty = TRUE;
1857 Group()->SetDirty();
1858 }
1859
1860 // ============================================================================
1861 // global functions
1862 // ============================================================================
1863
1864 // ----------------------------------------------------------------------------
1865 // compare functions for array sorting
1866 // ----------------------------------------------------------------------------
1867
1868 int CompareEntries(wxFileConfigEntry *p1, wxFileConfigEntry *p2)
1869 {
1870 #if wxCONFIG_CASE_SENSITIVE
1871 return wxStrcmp(p1->Name(), p2->Name());
1872 #else
1873 return wxStricmp(p1->Name(), p2->Name());
1874 #endif
1875 }
1876
1877 int CompareGroups(wxFileConfigGroup *p1, wxFileConfigGroup *p2)
1878 {
1879 #if wxCONFIG_CASE_SENSITIVE
1880 return wxStrcmp(p1->Name(), p2->Name());
1881 #else
1882 return wxStricmp(p1->Name(), p2->Name());
1883 #endif
1884 }
1885
1886 // ----------------------------------------------------------------------------
1887 // filter functions
1888 // ----------------------------------------------------------------------------
1889
1890 // undo FilterOutValue
1891 static wxString FilterInValue(const wxString& str)
1892 {
1893 wxString strResult;
1894 strResult.Alloc(str.Len());
1895
1896 bool bQuoted = !str.IsEmpty() && str[0] == '"';
1897
1898 for ( size_t n = bQuoted ? 1 : 0; n < str.Len(); n++ ) {
1899 if ( str[n] == wxT('\\') ) {
1900 switch ( str[++n] ) {
1901 case wxT('n'):
1902 strResult += wxT('\n');
1903 break;
1904
1905 case wxT('r'):
1906 strResult += wxT('\r');
1907 break;
1908
1909 case wxT('t'):
1910 strResult += wxT('\t');
1911 break;
1912
1913 case wxT('\\'):
1914 strResult += wxT('\\');
1915 break;
1916
1917 case wxT('"'):
1918 strResult += wxT('"');
1919 break;
1920 }
1921 }
1922 else {
1923 if ( str[n] != wxT('"') || !bQuoted )
1924 strResult += str[n];
1925 else if ( n != str.Len() - 1 ) {
1926 wxLogWarning(_("unexpected \" at position %d in '%s'."),
1927 n, str.c_str());
1928 }
1929 //else: it's the last quote of a quoted string, ok
1930 }
1931 }
1932
1933 return strResult;
1934 }
1935
1936 // quote the string before writing it to file
1937 static wxString FilterOutValue(const wxString& str)
1938 {
1939 if ( !str )
1940 return str;
1941
1942 wxString strResult;
1943 strResult.Alloc(str.Len());
1944
1945 // quoting is necessary to preserve spaces in the beginning of the string
1946 bool bQuote = wxIsspace(str[0]) || str[0] == wxT('"');
1947
1948 if ( bQuote )
1949 strResult += wxT('"');
1950
1951 wxChar c;
1952 for ( size_t n = 0; n < str.Len(); n++ ) {
1953 switch ( str[n] ) {
1954 case wxT('\n'):
1955 c = wxT('n');
1956 break;
1957
1958 case wxT('\r'):
1959 c = wxT('r');
1960 break;
1961
1962 case wxT('\t'):
1963 c = wxT('t');
1964 break;
1965
1966 case wxT('\\'):
1967 c = wxT('\\');
1968 break;
1969
1970 case wxT('"'):
1971 if ( bQuote ) {
1972 c = wxT('"');
1973 break;
1974 }
1975 //else: fall through
1976
1977 default:
1978 strResult += str[n];
1979 continue; // nothing special to do
1980 }
1981
1982 // we get here only for special characters
1983 strResult << wxT('\\') << c;
1984 }
1985
1986 if ( bQuote )
1987 strResult += wxT('"');
1988
1989 return strResult;
1990 }
1991
1992 // undo FilterOutEntryName
1993 static wxString FilterInEntryName(const wxString& str)
1994 {
1995 wxString strResult;
1996 strResult.Alloc(str.Len());
1997
1998 for ( const wxChar *pc = str.c_str(); *pc != '\0'; pc++ ) {
1999 if ( *pc == wxT('\\') )
2000 pc++;
2001
2002 strResult += *pc;
2003 }
2004
2005 return strResult;
2006 }
2007
2008 // sanitize entry or group name: insert '\\' before any special characters
2009 static wxString FilterOutEntryName(const wxString& str)
2010 {
2011 wxString strResult;
2012 strResult.Alloc(str.Len());
2013
2014 for ( const wxChar *pc = str.c_str(); *pc != wxT('\0'); pc++ ) {
2015 wxChar c = *pc;
2016
2017 // we explicitly allow some of "safe" chars and 8bit ASCII characters
2018 // which will probably never have special meaning
2019 // NB: note that wxCONFIG_IMMUTABLE_PREFIX and wxCONFIG_PATH_SEPARATOR
2020 // should *not* be quoted
2021 if ( !wxIsalnum(c) && !wxStrchr(wxT("@_/-!.*%"), c) && ((c & 0x80) == 0) )
2022 strResult += wxT('\\');
2023
2024 strResult += c;
2025 }
2026
2027 return strResult;
2028 }
2029
2030 // we can't put ?: in the ctor initializer list because it confuses some
2031 // broken compilers (Borland C++)
2032 static wxString GetAppName(const wxString& appName)
2033 {
2034 if ( !appName && wxTheApp )
2035 return wxTheApp->GetAppName();
2036 else
2037 return appName;
2038 }
2039
2040 #endif // wxUSE_CONFIG
2041
2042
2043 // vi:sts=4:sw=4:et
wxWidgets (Impactor)