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