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