src/common/fileconf.cpp

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