src/common/fileconf.cpp

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