src/common/fileconf.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        fileconf.cpp
   3 // Purpose:     implementation of wxFileConfig derivation of wxConfig
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     07.04.98 (adapted from appconf.cpp)
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1997 Karsten Ballüder   &  Vadim Zeitlin
   9 //                       Ballueder@usa.net     <zeitlin@dptmaths.ens-cachan.fr>
  10 // Licence:     wxWindows license
  11 ///////////////////////////////////////////////////////////////////////////////
  12
  13 #ifdef __GNUG__
  14 #pragma implementation "fileconf.h"
  15 #endif
  16
  17 // ----------------------------------------------------------------------------
  18 // headers
  19 // ----------------------------------------------------------------------------
  20
  21 #include  "wx/wxprec.h"
  22
  23 #ifdef    __BORLANDC__
  24   #pragma hdrstop
  25 #endif  //__BORLANDC__
  26
  27 #if wxUSE_CONFIG
  28
  29 #ifndef   WX_PRECOMP
  30   #include  "wx/string.h"
  31   #include  "wx/intl.h"
  32 #endif  //WX_PRECOMP
  33
  34 #include  "wx/app.h"
  35 #include  "wx/dynarray.h"
  36 #include  "wx/file.h"
  37 #include  "wx/log.h"
  38 #include  "wx/textfile.h"
  39 #include  "wx/memtext.h"
  40 #include  "wx/config.h"
  41 #include  "wx/fileconf.h"
  42
  43 #if wxUSE_STREAMS
  44     #include  "wx/stream.h"
  45 #endif // wxUSE_STREAMS
  46
  47 #include  "wx/utils.h"    // for wxGetHomeDir
  48
  49 #if defined(__WXMAC__)
  50   #include  "wx/mac/private.h"  // includes mac headers
  51 #endif
  52
  53 #if defined(__WXMSW__)
  54   #include "wx/msw/private.h"
  55 #endif  //windows.h
  56 #if defined(__WXPM__)
  57   #define INCL_DOS
  58   #include <os2.h>
  59 #endif
  60
  61 #include  <stdlib.h>
  62 #include  <ctype.h>
  63
  64 // headers needed for umask()
  65 #ifdef __UNIX__
  66     #include <sys/types.h>
  67     #include <sys/stat.h>
  68 #endif // __UNIX__
  69
  70 // ----------------------------------------------------------------------------
  71 // macros
  72 // ----------------------------------------------------------------------------
  73 #define CONST_CAST ((wxFileConfig *)this)->
  74
  75 // ----------------------------------------------------------------------------
  76 // constants
  77 // ----------------------------------------------------------------------------
  78
  79 #ifndef MAX_PATH
  80   #define MAX_PATH 512
  81 #endif
  82
  83 // ----------------------------------------------------------------------------
  84 // global functions declarations
  85 // ----------------------------------------------------------------------------
  86
  87 // compare functions for sorting the arrays
  88 static int LINKAGEMODE CompareEntries(wxFileConfigEntry *p1, wxFileConfigEntry *p2);
  89 static int LINKAGEMODE CompareGroups(wxFileConfigGroup *p1, wxFileConfigGroup *p2);
  90
  91 // filter strings
  92 static wxString FilterInValue(const wxString& str);
  93 static wxString FilterOutValue(const wxString& str);
  94
  95 static wxString FilterInEntryName(const wxString& str);
  96 static wxString FilterOutEntryName(const wxString& str);
  97
  98 // get the name to use in wxFileConfig ctor
  99 static wxString GetAppName(const wxString& appname);
 100
 101 // ============================================================================
 102 // private classes
 103 // ============================================================================
 104
 105 // ----------------------------------------------------------------------------
 106 // "template" array types
 107 // ----------------------------------------------------------------------------
 108
 109 WX_DEFINE_SORTED_EXPORTED_ARRAY(wxFileConfigEntry *, ArrayEntries);
 110 WX_DEFINE_SORTED_EXPORTED_ARRAY(wxFileConfigGroup *, ArrayGroups);
 111
 112 // ----------------------------------------------------------------------------
 113 // wxFileConfigLineList
 114 // ----------------------------------------------------------------------------
 115
 116 // we store all lines of the local config file as a linked list in memory
 117 class wxFileConfigLineList
 118 {
 119 public:
 120   void SetNext(wxFileConfigLineList *pNext)  { m_pNext = pNext; }
 121   void SetPrev(wxFileConfigLineList *pPrev)  { m_pPrev = pPrev; }
 122
 123   // ctor
 124   wxFileConfigLineList(const wxString& str,
 125                        wxFileConfigLineList *pNext = NULL) : m_strLine(str)
 126     { SetNext(pNext); SetPrev(NULL); }
 127
 128   // next/prev nodes in the linked list
 129   wxFileConfigLineList *Next() const { return m_pNext;  }
 130   wxFileConfigLineList *Prev() const { return m_pPrev;  }
 131
 132   // get/change lines text
 133   void SetText(const wxString& str) { m_strLine = str;  }
 134   const wxString& Text() const { return m_strLine; }
 135
 136 private:
 137   wxString  m_strLine;                  // line contents
 138   wxFileConfigLineList *m_pNext,        // next node
 139                        *m_pPrev;        // previous one
 140
 141     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 << " 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 << " 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       LineListAppend(strLine);
 569
 570     // skip leading spaces
 571     for ( pStart = strLine; wxIsspace(*pStart); pStart++ )
 572       ;
 573
 574     // skip blank/comment lines
 575     if ( *pStart == wxT('\0')|| *pStart == wxT(';') || *pStart == wxT('#') )
 576       continue;
 577
 578     if ( *pStart == wxT('[') ) {          // a new group
 579       pEnd = pStart;
 580
 581       while ( *++pEnd != wxT(']') ) {
 582         if ( *pEnd == wxT('\\') ) {
 583             // the next char is escaped, so skip it even if it is ']'
 584             pEnd++;
 585         }
 586
 587         if ( *pEnd == wxT('\n') || *pEnd == wxT('\0') ) {
 588             // we reached the end of line, break out of the loop
 589             break;
 590         }
 591       }
 592
 593       if ( *pEnd != wxT(']') ) {
 594         wxLogError(_("file '%s': unexpected character %c at line %d."),
 595                    buffer.GetName(), *pEnd, n + 1);
 596         continue; // skip this line
 597       }
 598
 599       // group name here is always considered as abs path
 600       wxString strGroup;
 601       pStart++;
 602       strGroup << wxCONFIG_PATH_SEPARATOR
 603                << FilterInEntryName(wxString(pStart, pEnd - pStart));
 604
 605       // will create it if doesn't yet exist
 606       SetPath(strGroup);
 607
 608       if ( bLocal )
 609         m_pCurrentGroup->SetLine(m_linesTail);
 610
 611       // check that there is nothing except comments left on this line
 612       bool bCont = TRUE;
 613       while ( *++pEnd != wxT('\0') && bCont ) {
 614         switch ( *pEnd ) {
 615           case wxT('#'):
 616           case wxT(';'):
 617             bCont = FALSE;
 618             break;
 619
 620           case wxT(' '):
 621           case wxT('\t'):
 622             // ignore whitespace ('\n' impossible here)
 623             break;
 624
 625           default:
 626             wxLogWarning(_("file '%s', line %d: '%s' ignored after group header."),
 627                          buffer.GetName(), n + 1, pEnd);
 628             bCont = FALSE;
 629         }
 630       }
 631     }
 632     else {                        // a key
 633       const wxChar *pEnd = pStart;
 634       while ( *pEnd && *pEnd != wxT('=') && !wxIsspace(*pEnd) ) {
 635         if ( *pEnd == wxT('\\') ) {
 636           // next character may be space or not - still take it because it's
 637           // quoted (unless there is nothing)
 638           pEnd++;
 639           if ( !*pEnd ) {
 640             // the error message will be given below anyhow
 641             break;
 642           }
 643         }
 644
 645         pEnd++;
 646       }
 647
 648       wxString strKey(FilterInEntryName(wxString(pStart, pEnd)));
 649
 650       // skip whitespace
 651       while ( wxIsspace(*pEnd) )
 652         pEnd++;
 653
 654       if ( *pEnd++ != wxT('=') ) {
 655         wxLogError(_("file '%s', line %d: '=' expected."),
 656                    buffer.GetName(), n + 1);
 657       }
 658       else {
 659         wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(strKey);
 660
 661         if ( pEntry == NULL ) {
 662           // new entry
 663           pEntry = m_pCurrentGroup->AddEntry(strKey, n);
 664
 665           if ( bLocal )
 666             pEntry->SetLine(m_linesTail);
 667         }
 668         else {
 669           if ( bLocal && pEntry->IsImmutable() ) {
 670             // immutable keys can't be changed by user
 671             wxLogWarning(_("file '%s', line %d: value for immutable key '%s' ignored."),
 672                          buffer.GetName(), n + 1, strKey.c_str());
 673             continue;
 674           }
 675           // the condition below catches the cases (a) and (b) but not (c):
 676           //  (a) global key found second time in global file
 677           //  (b) key found second (or more) time in local file
 678           //  (c) key from global file now found in local one
 679           // which is exactly what we want.
 680           else if ( !bLocal || pEntry->IsLocal() ) {
 681             wxLogWarning(_("file '%s', line %d: key '%s' was first found at line %d."),
 682                          buffer.GetName(), n + 1, strKey.c_str(), pEntry->Line());
 683
 684             if ( bLocal )
 685               pEntry->SetLine(m_linesTail);
 686           }
 687         }
 688
 689         // skip whitespace
 690         while ( wxIsspace(*pEnd) )
 691           pEnd++;
 692
 693         wxString value = pEnd;
 694         if ( !(GetStyle() & wxCONFIG_USE_NO_ESCAPE_CHARACTERS) )
 695             value = FilterInValue(value);
 696
 697         pEntry->SetValue(value, FALSE);
 698       }
 699     }
 700   }
 701 }
 702
 703 // ----------------------------------------------------------------------------
 704 // set/retrieve path
 705 // ----------------------------------------------------------------------------
 706
 707 void wxFileConfig::SetRootPath()
 708 {
 709   m_strPath.Empty();
 710   m_pCurrentGroup = m_pRootGroup;
 711 }
 712
 713 void wxFileConfig::SetPath(const wxString& strPath)
 714 {
 715   wxArrayString aParts;
 716
 717   if ( strPath.IsEmpty() ) {
 718     SetRootPath();
 719     return;
 720   }
 721
 722   if ( strPath[0] == wxCONFIG_PATH_SEPARATOR ) {
 723     // absolute path
 724     wxSplitPath(aParts, strPath);
 725   }
 726   else {
 727     // relative path, combine with current one
 728     wxString strFullPath = m_strPath;
 729     strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
 730     wxSplitPath(aParts, strFullPath);
 731   }
 732
 733   // change current group
 734   size_t n;
 735   m_pCurrentGroup = m_pRootGroup;
 736   for ( n = 0; n < aParts.Count(); n++ ) {
 737     wxFileConfigGroup *pNextGroup = m_pCurrentGroup->FindSubgroup(aParts[n]);
 738     if ( pNextGroup == NULL )
 739       pNextGroup = m_pCurrentGroup->AddSubgroup(aParts[n]);
 740     m_pCurrentGroup = pNextGroup;
 741   }
 742
 743   // recombine path parts in one variable
 744   m_strPath.Empty();
 745   for ( n = 0; n < aParts.Count(); n++ ) {
 746     m_strPath << wxCONFIG_PATH_SEPARATOR << aParts[n];
 747   }
 748 }
 749
 750 // ----------------------------------------------------------------------------
 751 // enumeration
 752 // ----------------------------------------------------------------------------
 753
 754 bool wxFileConfig::GetFirstGroup(wxString& str, long& lIndex) const
 755 {
 756   lIndex = 0;
 757   return GetNextGroup(str, lIndex);
 758 }
 759
 760 bool wxFileConfig::GetNextGroup (wxString& str, long& lIndex) const
 761 {
 762   if ( size_t(lIndex) < m_pCurrentGroup->Groups().Count() ) {
 763     str = m_pCurrentGroup->Groups()[(size_t)lIndex++]->Name();
 764     return TRUE;
 765   }
 766   else
 767     return FALSE;
 768 }
 769
 770 bool wxFileConfig::GetFirstEntry(wxString& str, long& lIndex) const
 771 {
 772   lIndex = 0;
 773   return GetNextEntry(str, lIndex);
 774 }
 775
 776 bool wxFileConfig::GetNextEntry (wxString& str, long& lIndex) const
 777 {
 778   if ( size_t(lIndex) < m_pCurrentGroup->Entries().Count() ) {
 779     str = m_pCurrentGroup->Entries()[(size_t)lIndex++]->Name();
 780     return TRUE;
 781   }
 782   else
 783     return FALSE;
 784 }
 785
 786 size_t wxFileConfig::GetNumberOfEntries(bool bRecursive) const
 787 {
 788   size_t n = m_pCurrentGroup->Entries().Count();
 789   if ( bRecursive ) {
 790     wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
 791     size_t nSubgroups = m_pCurrentGroup->Groups().Count();
 792     for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
 793       CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
 794       n += GetNumberOfEntries(TRUE);
 795       CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
 796     }
 797   }
 798
 799   return n;
 800 }
 801
 802 size_t wxFileConfig::GetNumberOfGroups(bool bRecursive) const
 803 {
 804   size_t n = m_pCurrentGroup->Groups().Count();
 805   if ( bRecursive ) {
 806     wxFileConfigGroup *pOldCurrentGroup = m_pCurrentGroup;
 807     size_t nSubgroups = m_pCurrentGroup->Groups().Count();
 808     for ( size_t nGroup = 0; nGroup < nSubgroups; nGroup++ ) {
 809       CONST_CAST m_pCurrentGroup = m_pCurrentGroup->Groups()[nGroup];
 810       n += GetNumberOfGroups(TRUE);
 811       CONST_CAST m_pCurrentGroup = pOldCurrentGroup;
 812     }
 813   }
 814
 815   return n;
 816 }
 817
 818 // ----------------------------------------------------------------------------
 819 // tests for existence
 820 // ----------------------------------------------------------------------------
 821
 822 bool wxFileConfig::HasGroup(const wxString& strName) const
 823 {
 824   wxConfigPathChanger path(this, strName);
 825
 826   wxFileConfigGroup *pGroup = m_pCurrentGroup->FindSubgroup(path.Name());
 827   return pGroup != NULL;
 828 }
 829
 830 bool wxFileConfig::HasEntry(const wxString& strName) const
 831 {
 832   wxConfigPathChanger path(this, strName);
 833
 834   wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
 835   return pEntry != NULL;
 836 }
 837
 838 // ----------------------------------------------------------------------------
 839 // read/write values
 840 // ----------------------------------------------------------------------------
 841
 842 bool wxFileConfig::DoReadString(const wxString& key, wxString* pStr) const
 843 {
 844   wxConfigPathChanger path(this, key);
 845
 846   wxFileConfigEntry *pEntry = m_pCurrentGroup->FindEntry(path.Name());
 847   if (pEntry == NULL) {
 848     return FALSE;
 849   }
 850
 851   *pStr = pEntry->Value();
 852
 853   return TRUE;
 854 }
 855
 856 bool wxFileConfig::DoReadLong(const wxString& key, long *pl) const
 857 {
 858   wxString str;
 859   if ( !Read(key, & str) )
 860   {
 861     return FALSE;
 862   }
 863   return str.ToLong(pl) ;
 864 }
 865
 866 bool wxFileConfig::DoWriteString(const wxString& key, const wxString& szValue)
 867 {
 868     wxConfigPathChanger     path(this, key);
 869     wxString                strName = path.Name();
 870
 871     wxLogTrace( _T("wxFileConfig"),
 872                 _T("  Writing String '%s' = '%s' to Group '%s'"),
 873                 strName.c_str(),
 874                 szValue.c_str(),
 875                 GetPath().c_str() );
 876
 877     if ( strName.IsEmpty() )
 878     {
 879             // setting the value of a group is an error
 880
 881         wxASSERT_MSG( wxIsEmpty(szValue), wxT("can't set value of a group!") );
 882
 883             // ... except if it's empty in which case it's a way to force it's creation
 884
 885         wxLogTrace( _T("wxFileConfig"),
 886                     _T("  Creating group %s"),
 887                     m_pCurrentGroup->Name().c_str() );
 888
 889         m_pCurrentGroup->SetDirty();
 890
 891             // this will add a line for this group if it didn't have it before
 892
 893         (void)m_pCurrentGroup->GetGroupLine();
 894     }
 895     else
 896     {
 897             // writing an entry
 898             // check that the name is reasonable
 899
 900         if ( strName[0u] == wxCONFIG_IMMUTABLE_PREFIX )
 901         {
 902             wxLogError( _("Config entry name cannot start with '%c'."),
 903                         wxCONFIG_IMMUTABLE_PREFIX);
 904             return FALSE;
 905         }
 906
 907         wxFileConfigEntry   *pEntry = m_pCurrentGroup->FindEntry(strName);
 908
 909         if ( pEntry == 0 )
 910         {
 911             wxLogTrace( _T("wxFileConfig"),
 912                         _T("  Adding Entry %s"),
 913                         strName.c_str() );
 914             pEntry = m_pCurrentGroup->AddEntry(strName);
 915         }
 916
 917         wxLogTrace( _T("wxFileConfig"),
 918                     _T("  Setting value %s"),
 919                     szValue.c_str() );
 920         pEntry->SetValue(szValue);
 921     }
 922
 923     return TRUE;
 924 }
 925
 926 bool wxFileConfig::DoWriteLong(const wxString& key, long lValue)
 927 {
 928   return Write(key, wxString::Format(_T("%ld"), lValue));
 929 }
 930
 931 bool wxFileConfig::Flush(bool /* bCurrentOnly */)
 932 {
 933   if ( LineListIsEmpty() || !m_pRootGroup->IsDirty() || !m_strLocalFile )
 934     return TRUE;
 935
 936 #ifdef __UNIX__
 937   // set the umask if needed
 938   mode_t umaskOld = 0;
 939   if ( m_umask != -1 )
 940   {
 941       umaskOld = umask((mode_t)m_umask);
 942   }
 943 #endif // __UNIX__
 944
 945   wxTempFile file(m_strLocalFile);
 946
 947   if ( !file.IsOpened() )
 948   {
 949     wxLogError(_("can't open user configuration file."));
 950     return FALSE;
 951   }
 952
 953   // write all strings to file
 954   for ( wxFileConfigLineList *p = m_linesHead; p != NULL; p = p->Next() )
 955   {
 956     wxString line = p->Text();
 957     line += wxTextFile::GetEOL();
 958     if ( !file.Write(line, m_conv) )
 959     {
 960       wxLogError(_("can't write user configuration file."));
 961       return FALSE;
 962     }
 963   }
 964
 965   bool ret = file.Commit();
 966
 967 #if defined(__WXMAC__)
 968   if ( ret )
 969   {
 970         FSSpec spec ;
 971
 972         wxMacFilename2FSSpec( m_strLocalFile , &spec ) ;
 973         FInfo finfo ;
 974         if ( FSpGetFInfo( &spec , &finfo ) == noErr )
 975         {
 976                 finfo.fdType = 'TEXT' ;
 977                 finfo.fdCreator = 'ttxt' ;
 978                 FSpSetFInfo( &spec , &finfo ) ;
 979         }
 980   }
 981 #endif // __WXMAC__
 982
 983 #ifdef __UNIX__
 984   // restore the old umask if we changed it
 985   if ( m_umask != -1 )
 986   {
 987       (void)umask(umaskOld);
 988   }
 989 #endif // __UNIX__
 990
 991   return ret;
 992 }
 993
 994 // ----------------------------------------------------------------------------
 995 // renaming groups/entries
 996 // ----------------------------------------------------------------------------
 997
 998 bool wxFileConfig::RenameEntry(const wxString& oldName,
 999                                const wxString& newName)
1000 {
1001     // check that the entry exists
1002     wxFileConfigEntry *oldEntry = m_pCurrentGroup->FindEntry(oldName);
1003     if ( !oldEntry )
1004         return FALSE;
1005
1006     // check that the new entry doesn't already exist
1007     if ( m_pCurrentGroup->FindEntry(newName) )
1008         return FALSE;
1009
1010     // delete the old entry, create the new one
1011     wxString value = oldEntry->Value();
1012     if ( !m_pCurrentGroup->DeleteEntry(oldName) )
1013         return FALSE;
1014
1015     wxFileConfigEntry *newEntry = m_pCurrentGroup->AddEntry(newName);
1016     newEntry->SetValue(value);
1017
1018     return TRUE;
1019 }
1020
1021 bool wxFileConfig::RenameGroup(const wxString& oldName,
1022                                const wxString& newName)
1023 {
1024     // check that the group exists
1025     wxFileConfigGroup *group = m_pCurrentGroup->FindSubgroup(oldName);
1026     if ( !group )
1027         return FALSE;
1028
1029     // check that the new group doesn't already exist
1030     if ( m_pCurrentGroup->FindSubgroup(newName) )
1031         return FALSE;
1032
1033     group->Rename(newName);
1034
1035     return TRUE;
1036 }
1037
1038 // ----------------------------------------------------------------------------
1039 // delete groups/entries
1040 // ----------------------------------------------------------------------------
1041
1042 bool wxFileConfig::DeleteEntry(const wxString& key, bool bGroupIfEmptyAlso)
1043 {
1044   wxConfigPathChanger path(this, key);
1045
1046   if ( !m_pCurrentGroup->DeleteEntry(path.Name()) )
1047     return FALSE;
1048
1049   if ( bGroupIfEmptyAlso && m_pCurrentGroup->IsEmpty() ) {
1050     if ( m_pCurrentGroup != m_pRootGroup ) {
1051       wxFileConfigGroup *pGroup = m_pCurrentGroup;
1052       SetPath(wxT(".."));  // changes m_pCurrentGroup!
1053       m_pCurrentGroup->DeleteSubgroupByName(pGroup->Name());
1054     }
1055     //else: never delete the root group
1056   }
1057
1058   return TRUE;
1059 }
1060
1061 bool wxFileConfig::DeleteGroup(const wxString& key)
1062 {
1063   wxConfigPathChanger path(this, key);
1064
1065   return m_pCurrentGroup->DeleteSubgroupByName(path.Name());
1066 }
1067
1068 bool wxFileConfig::DeleteAll()
1069 {
1070   CleanUp();
1071
1072   if ( wxRemove(m_strLocalFile) == -1 )
1073     wxLogSysError(_("can't delete user configuration file '%s'"), m_strLocalFile.c_str());
1074
1075   m_strLocalFile = m_strGlobalFile = wxT("");
1076   Init();
1077
1078   return TRUE;
1079 }
1080
1081 // ----------------------------------------------------------------------------
1082 // linked list functions
1083 // ----------------------------------------------------------------------------
1084
1085     // append a new line to the end of the list
1086
1087 wxFileConfigLineList *wxFileConfig::LineListAppend(const wxString& str)
1088 {
1089     wxLogTrace( _T("wxFileConfig"),
1090                 _T("    ** Adding Line '%s'"),
1091                 str.c_str() );
1092     wxLogTrace( _T("wxFileConfig"),
1093                 _T("        head: %s"),
1094                 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1095     wxLogTrace( _T("wxFileConfig"),
1096                 _T("        tail: %s"),
1097                 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1098
1099     wxFileConfigLineList *pLine = new wxFileConfigLineList(str);
1100
1101     if ( m_linesTail == NULL )
1102     {
1103         // list is empty
1104         m_linesHead = pLine;
1105     }
1106     else
1107     {
1108         // adjust pointers
1109         m_linesTail->SetNext(pLine);
1110         pLine->SetPrev(m_linesTail);
1111     }
1112
1113     m_linesTail = pLine;
1114
1115     wxLogTrace( _T("wxFileConfig"),
1116                 _T("        head: %s"),
1117                 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1118     wxLogTrace( _T("wxFileConfig"),
1119                 _T("        tail: %s"),
1120                 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1121
1122     return m_linesTail;
1123 }
1124
1125     // insert a new line after the given one or in the very beginning if !pLine
1126
1127 wxFileConfigLineList *wxFileConfig::LineListInsert(const wxString& str,
1128                                                    wxFileConfigLineList *pLine)
1129 {
1130     wxLogTrace( _T("wxFileConfig"),
1131                 _T("    ** Inserting Line '%s' after '%s'"),
1132                 str.c_str(),
1133                 ((pLine) ? pLine->Text().c_str() : wxEmptyString) );
1134     wxLogTrace( _T("wxFileConfig"),
1135                 _T("        head: %s"),
1136                 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1137     wxLogTrace( _T("wxFileConfig"),
1138                 _T("        tail: %s"),
1139                 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1140
1141     if ( pLine == m_linesTail )
1142         return LineListAppend(str);
1143
1144     wxFileConfigLineList *pNewLine = new wxFileConfigLineList(str);
1145     if ( pLine == NULL )
1146     {
1147         // prepend to the list
1148         pNewLine->SetNext(m_linesHead);
1149         m_linesHead->SetPrev(pNewLine);
1150         m_linesHead = pNewLine;
1151     }
1152     else
1153     {
1154         // insert before pLine
1155         wxFileConfigLineList *pNext = pLine->Next();
1156         pNewLine->SetNext(pNext);
1157         pNewLine->SetPrev(pLine);
1158         pNext->SetPrev(pNewLine);
1159         pLine->SetNext(pNewLine);
1160     }
1161
1162     wxLogTrace( _T("wxFileConfig"),
1163                 _T("        head: %s"),
1164                 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1165     wxLogTrace( _T("wxFileConfig"),
1166                 _T("        tail: %s"),
1167                 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1168
1169     return pNewLine;
1170 }
1171
1172 void wxFileConfig::LineListRemove(wxFileConfigLineList *pLine)
1173 {
1174     wxLogTrace( _T("wxFileConfig"),
1175                 _T("    ** Removing Line '%s'"),
1176                 pLine->Text().c_str() );
1177     wxLogTrace( _T("wxFileConfig"),
1178                 _T("        head: %s"),
1179                 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1180     wxLogTrace( _T("wxFileConfig"),
1181                 _T("        tail: %s"),
1182                 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1183
1184     wxFileConfigLineList    *pPrev = pLine->Prev(),
1185                             *pNext = pLine->Next();
1186
1187         // first entry?
1188
1189     if ( pPrev == NULL )
1190         m_linesHead = pNext;
1191     else
1192         pPrev->SetNext(pNext);
1193
1194         // last entry?
1195
1196     if ( pNext == NULL )
1197         m_linesTail = pPrev;
1198     else
1199         pNext->SetPrev(pPrev);
1200
1201     wxLogTrace( _T("wxFileConfig"),
1202                 _T("        head: %s"),
1203                 ((m_linesHead) ? m_linesHead->Text().c_str() : wxEmptyString) );
1204     wxLogTrace( _T("wxFileConfig"),
1205                 _T("        tail: %s"),
1206                 ((m_linesTail) ? m_linesTail->Text().c_str() : wxEmptyString) );
1207
1208     delete pLine;
1209 }
1210
1211 bool wxFileConfig::LineListIsEmpty()
1212 {
1213     return m_linesHead == NULL;
1214 }
1215
1216 // ============================================================================
1217 // wxFileConfig::wxFileConfigGroup
1218 // ============================================================================
1219
1220 // ----------------------------------------------------------------------------
1221 // ctor/dtor
1222 // ----------------------------------------------------------------------------
1223
1224 // ctor
1225 wxFileConfigGroup::wxFileConfigGroup(wxFileConfigGroup *pParent,
1226                                        const wxString& strName,
1227                                        wxFileConfig *pConfig)
1228                          : m_aEntries(CompareEntries),
1229                            m_aSubgroups(CompareGroups),
1230                            m_strName(strName)
1231 {
1232   m_pConfig = pConfig;
1233   m_pParent = pParent;
1234   m_bDirty  = FALSE;
1235   m_pLine   = NULL;
1236
1237   m_pLastEntry = NULL;
1238   m_pLastGroup = NULL;
1239 }
1240
1241 // dtor deletes all children
1242 wxFileConfigGroup::~wxFileConfigGroup()
1243 {
1244   // entries
1245   size_t n, nCount = m_aEntries.Count();
1246   for ( n = 0; n < nCount; n++ )
1247     delete m_aEntries[n];
1248
1249   // subgroups
1250   nCount = m_aSubgroups.Count();
1251   for ( n = 0; n < nCount; n++ )
1252     delete m_aSubgroups[n];
1253 }
1254
1255 // ----------------------------------------------------------------------------
1256 // line
1257 // ----------------------------------------------------------------------------
1258
1259 void wxFileConfigGroup::SetLine(wxFileConfigLineList *pLine)
1260 {
1261     wxASSERT( m_pLine == 0 ); // shouldn't be called twice
1262     m_pLine = pLine;
1263 }
1264
1265 /*
1266   This is a bit complicated, so let me explain it in details. All lines that
1267   were read from the local file (the only one we will ever modify) are stored
1268   in a (doubly) linked list. Our problem is to know at which position in this
1269   list should we insert the new entries/subgroups. To solve it we keep three
1270   variables for each group: m_pLine, m_pLastEntry and m_pLastGroup.
1271
1272   m_pLine points to the line containing "[group_name]"
1273   m_pLastEntry points to the last entry of this group in the local file.
1274   m_pLastGroup                   subgroup
1275
1276   Initially, they're NULL all three. When the group (an entry/subgroup) is read
1277   from the local file, the corresponding variable is set. However, if the group
1278   was read from the global file and then modified or created by the application
1279   these variables are still NULL and we need to create the corresponding lines.
1280   See the following functions (and comments preceding them) for the details of
1281   how we do it.
1282
1283   Also, when our last entry/group are deleted we need to find the new last
1284   element - the code in DeleteEntry/Subgroup does this by backtracking the list
1285   of lines until it either founds an entry/subgroup (and this is the new last
1286   element) or the m_pLine of the group, in which case there are no more entries
1287   (or subgroups) left and m_pLast<element> becomes NULL.
1288
1289   NB: This last problem could be avoided for entries if we added new entries
1290       immediately after m_pLine, but in this case the entries would appear
1291       backwards in the config file (OTOH, it's not that important) and as we
1292       would still need to do it for the subgroups the code wouldn't have been
1293       significantly less complicated.
1294 */
1295
1296 // Return the line which contains "[our name]". If we're still not in the list,
1297 // add our line to it immediately after the last line of our parent group if we
1298 // have it or in the very beginning if we're the root group.
1299 wxFileConfigLineList *wxFileConfigGroup::GetGroupLine()
1300 {
1301     wxLogTrace( _T("wxFileConfig"),
1302                 _T("  GetGroupLine() for Group '%s'"),
1303                 Name().c_str() );
1304
1305     if ( m_pLine == 0 )
1306     {
1307         wxLogTrace( _T("wxFileConfig"),
1308                     _T("    Getting Line item pointer") );
1309
1310         wxFileConfigGroup   *pParent = Parent();
1311
1312             // this group wasn't present in local config file, add it now
1313
1314         if ( pParent != 0 )
1315         {
1316             wxLogTrace( _T("wxFileConfig"),
1317                         _T("    checking parent '%s'"),
1318                         pParent->Name().c_str() );
1319
1320             wxString    strFullName;
1321
1322             strFullName << wxT("[")         // +1: no '/'
1323                         << FilterOutEntryName(GetFullName().c_str() + 1)
1324                         << wxT("]");
1325             m_pLine = m_pConfig->LineListInsert(strFullName,
1326                                                 pParent->GetLastGroupLine());
1327             pParent->SetLastGroup(this);  // we're surely after all the others
1328         }
1329         else
1330         {
1331             // we return NULL, so that LineListInsert() will insert us in the
1332             // very beginning
1333         }
1334     }
1335
1336     return m_pLine;
1337 }
1338
1339 // Return the last line belonging to the subgroups of this group (after which
1340 // we can add a new subgroup), if we don't have any subgroups or entries our
1341 // last line is the group line (m_pLine) itself.
1342 wxFileConfigLineList *wxFileConfigGroup::GetLastGroupLine()
1343 {
1344         // if we have any subgroups, our last line is
1345         // the last line of the last subgroup
1346
1347     if ( m_pLastGroup != 0 )
1348     {
1349         wxFileConfigLineList *pLine = m_pLastGroup->GetLastGroupLine();
1350
1351         wxASSERT( pLine != 0 );  // last group must have !NULL associated line
1352         return pLine;
1353     }
1354
1355         // no subgroups, so the last line is the line of thelast entry (if any)
1356
1357     return GetLastEntryLine();
1358 }
1359
1360 // return the last line belonging to the entries of this group (after which
1361 // we can add a new entry), if we don't have any entries we will add the new
1362 // one immediately after the group line itself.
1363 wxFileConfigLineList *wxFileConfigGroup::GetLastEntryLine()
1364 {
1365     wxLogTrace( _T("wxFileConfig"),
1366                 _T("  GetLastEntryLine() for Group '%s'"),
1367                 Name().c_str() );
1368
1369     if ( m_pLastEntry != 0 )
1370     {
1371         wxFileConfigLineList    *pLine = m_pLastEntry->GetLine();
1372
1373         wxASSERT( pLine != 0 );  // last entry must have !NULL associated line
1374         return pLine;
1375     }
1376
1377         // no entries: insert after the group header
1378
1379     return GetGroupLine();
1380 }
1381
1382 // ----------------------------------------------------------------------------
1383 // group name
1384 // ----------------------------------------------------------------------------
1385
1386 void wxFileConfigGroup::Rename(const wxString& newName)
1387 {
1388     m_strName = newName;
1389
1390     wxFileConfigLineList *line = GetGroupLine();
1391     wxString strFullName;
1392     strFullName << wxT("[") << (GetFullName().c_str() + 1) << wxT("]"); // +1: no '/'
1393     line->SetText(strFullName);
1394
1395     SetDirty();
1396 }
1397
1398 wxString wxFileConfigGroup::GetFullName() const
1399 {
1400   if ( Parent() )
1401     return Parent()->GetFullName() + wxCONFIG_PATH_SEPARATOR + Name();
1402   else
1403     return wxT("");
1404 }
1405
1406 // ----------------------------------------------------------------------------
1407 // find an item
1408 // ----------------------------------------------------------------------------
1409
1410 // use binary search because the array is sorted
1411 wxFileConfigEntry *
1412 wxFileConfigGroup::FindEntry(const wxChar *szName) const
1413 {
1414   size_t i,
1415        lo = 0,
1416        hi = m_aEntries.Count();
1417   int res;
1418   wxFileConfigEntry *pEntry;
1419
1420   while ( lo < hi ) {
1421     i = (lo + hi)/2;
1422     pEntry = m_aEntries[i];
1423
1424     #if wxCONFIG_CASE_SENSITIVE
1425       res = wxStrcmp(pEntry->Name(), szName);
1426     #else
1427       res = wxStricmp(pEntry->Name(), szName);
1428     #endif
1429
1430     if ( res > 0 )
1431       hi = i;
1432     else if ( res < 0 )
1433       lo = i + 1;
1434     else
1435       return pEntry;
1436   }
1437
1438   return NULL;
1439 }
1440
1441 wxFileConfigGroup *
1442 wxFileConfigGroup::FindSubgroup(const wxChar *szName) const
1443 {
1444   size_t i,
1445        lo = 0,
1446        hi = m_aSubgroups.Count();
1447   int res;
1448   wxFileConfigGroup *pGroup;
1449
1450   while ( lo < hi ) {
1451     i = (lo + hi)/2;
1452     pGroup = m_aSubgroups[i];
1453
1454     #if wxCONFIG_CASE_SENSITIVE
1455       res = wxStrcmp(pGroup->Name(), szName);
1456     #else
1457       res = wxStricmp(pGroup->Name(), szName);
1458     #endif
1459
1460     if ( res > 0 )
1461       hi = i;
1462     else if ( res < 0 )
1463       lo = i + 1;
1464     else
1465       return pGroup;
1466   }
1467
1468   return NULL;
1469 }
1470
1471 // ----------------------------------------------------------------------------
1472 // create a new item
1473 // ----------------------------------------------------------------------------
1474
1475 // create a new entry and add it to the current group
1476 wxFileConfigEntry *wxFileConfigGroup::AddEntry(const wxString& strName, int nLine)
1477 {
1478     wxASSERT( FindEntry(strName) == 0 );
1479
1480     wxFileConfigEntry   *pEntry = new wxFileConfigEntry(this, strName, nLine);
1481
1482     m_aEntries.Add(pEntry);
1483     return pEntry;
1484 }
1485
1486 // create a new group and add it to the current group
1487 wxFileConfigGroup *wxFileConfigGroup::AddSubgroup(const wxString& strName)
1488 {
1489     wxASSERT( FindSubgroup(strName) == 0 );
1490
1491     wxFileConfigGroup   *pGroup = new wxFileConfigGroup(this, strName, m_pConfig);
1492
1493     m_aSubgroups.Add(pGroup);
1494     return pGroup;
1495 }
1496
1497 // ----------------------------------------------------------------------------
1498 // delete an item
1499 // ----------------------------------------------------------------------------
1500
1501 /*
1502   The delete operations are _very_ slow if we delete the last item of this
1503   group (see comments before GetXXXLineXXX functions for more details),
1504   so it's much better to start with the first entry/group if we want to
1505   delete several of them.
1506  */
1507
1508 bool wxFileConfigGroup::DeleteSubgroupByName(const wxChar *szName)
1509 {
1510     wxFileConfigGroup * const pGroup = FindSubgroup(szName);
1511
1512     return pGroup ? DeleteSubgroup(pGroup) : FALSE;
1513 }
1514
1515 // Delete the subgroup and remove all references to it from
1516 // other data structures.
1517 bool wxFileConfigGroup::DeleteSubgroup(wxFileConfigGroup *pGroup)
1518 {
1519     wxCHECK_MSG( pGroup, FALSE, _T("deleting non existing group?") );
1520
1521     wxLogTrace( _T("wxFileConfig"),
1522                 _T("Deleting group '%s' from '%s'"),
1523                 pGroup->Name().c_str(),
1524                 Name().c_str() );
1525
1526     wxLogTrace( _T("wxFileConfig"),
1527                 _T("  (m_pLine) = prev: %p, this %p, next %p"),
1528                 ((m_pLine) ? m_pLine->Prev() : 0),
1529                 m_pLine,
1530                 ((m_pLine) ? m_pLine->Next() : 0) );
1531     wxLogTrace( _T("wxFileConfig"),
1532                 _T("  text: '%s'"),
1533                 ((m_pLine) ? m_pLine->Text().c_str() : wxEmptyString) );
1534
1535     // delete all entries
1536     size_t nCount = pGroup->m_aEntries.Count();
1537
1538     wxLogTrace(_T("wxFileConfig"),
1539                _T("Removing %lu Entries"),
1540                (unsigned long)nCount );
1541
1542     for ( size_t nEntry = 0; nEntry < nCount; nEntry++ )
1543     {
1544         wxFileConfigLineList    *pLine = pGroup->m_aEntries[nEntry]->GetLine();
1545
1546         if ( pLine != 0 )
1547         {
1548             wxLogTrace( _T("wxFileConfig"),
1549                         _T("    '%s'"),
1550                         pLine->Text().c_str() );
1551             m_pConfig->LineListRemove(pLine);
1552         }
1553     }
1554
1555         // and subgroups of this subgroup
1556
1557     nCount = pGroup->m_aSubgroups.Count();
1558
1559     wxLogTrace( _T("wxFileConfig"),
1560                 _T("Removing %lu SubGroups"),
1561                 (unsigned long)nCount );
1562
1563     for ( size_t nGroup = 0; nGroup < nCount; nGroup++ )
1564     {
1565         pGroup->DeleteSubgroup(pGroup->m_aSubgroups[0]);
1566     }
1567
1568         // finally the group itself
1569
1570     wxFileConfigLineList    *pLine = pGroup->m_pLine;
1571
1572     if ( pLine != 0 )
1573     {
1574         wxLogTrace( _T("wxFileConfig"),
1575                     _T("  Removing line entry for Group '%s' : '%s'"),
1576                     pGroup->Name().c_str(),
1577                     pLine->Text().c_str() );
1578         wxLogTrace( _T("wxFileConfig"),
1579                     _T("  Removing from Group '%s' : '%s'"),
1580                     Name().c_str(),
1581                     ((m_pLine) ? m_pLine->Text().c_str() : wxEmptyString) );
1582
1583             // notice that we may do this test inside the previous "if"
1584             // because the last entry's line is surely !NULL
1585
1586         if ( pGroup == m_pLastGroup )
1587         {
1588             wxLogTrace( _T("wxFileConfig"),
1589                         _T("  ------- Removing last group -------") );
1590
1591                 // our last entry is being deleted, so find the last one which stays.
1592                 // go back until we find a subgroup or reach the group's line, unless
1593                 // we are the root group, which we'll notice shortly.
1594
1595             wxFileConfigGroup       *pNewLast = 0;
1596             size_t                   nSubgroups = m_aSubgroups.Count();
1597             wxFileConfigLineList    *pl;
1598
1599             for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() )
1600             {
1601                     // is it our subgroup?
1602
1603                 for ( size_t n = 0; (pNewLast == 0) && (n < nSubgroups); n++ )
1604                 {
1605                     // do _not_ call GetGroupLine! we don't want to add it to the local
1606                     // file if it's not already there
1607
1608                     if ( m_aSubgroups[n]->m_pLine == m_pLine )
1609                         pNewLast = m_aSubgroups[n];
1610                 }
1611
1612                 if ( pNewLast != 0 ) // found?
1613                     break;
1614             }
1615
1616             if ( pl == m_pLine || m_pParent == 0 )
1617             {
1618                 wxLogTrace( _T("wxFileConfig"),
1619                             _T("  ------- No previous group found -------") );
1620
1621                 wxASSERT_MSG( !pNewLast || m_pLine == 0,
1622                               _T("how comes it has the same line as we?") );
1623
1624                     // we've reached the group line without finding any subgroups,
1625                     // or realised we removed the last group from the root.
1626
1627                 m_pLastGroup = 0;
1628             }
1629             else
1630             {
1631                 wxLogTrace( _T("wxFileConfig"),
1632                             _T("  ------- Last Group set to '%s' -------"),
1633                             pNewLast->Name().c_str() );
1634
1635                 m_pLastGroup = pNewLast;
1636             }
1637         }
1638
1639         m_pConfig->LineListRemove(pLine);
1640     }
1641     else
1642     {
1643         wxLogTrace( _T("wxFileConfig"),
1644                     _T("  No line entry for Group '%s'?"),
1645                     pGroup->Name().c_str() );
1646     }
1647
1648     SetDirty();
1649
1650     m_aSubgroups.Remove(pGroup);
1651     delete pGroup;
1652
1653     return TRUE;
1654 }
1655
1656 bool wxFileConfigGroup::DeleteEntry(const wxChar *szName)
1657 {
1658   wxFileConfigEntry *pEntry = FindEntry(szName);
1659   wxCHECK( pEntry != NULL, FALSE );  // deleting non existing item?
1660
1661   wxFileConfigLineList *pLine = pEntry->GetLine();
1662   if ( pLine != NULL ) {
1663     // notice that we may do this test inside the previous "if" because the
1664     // last entry's line is surely !NULL
1665     if ( pEntry == m_pLastEntry ) {
1666       // our last entry is being deleted - find the last one which stays
1667       wxASSERT( m_pLine != NULL );  // if we have an entry with !NULL pLine...
1668
1669       // go back until we find another entry or reach the group's line
1670       wxFileConfigEntry *pNewLast = NULL;
1671       size_t n, nEntries = m_aEntries.Count();
1672       wxFileConfigLineList *pl;
1673       for ( pl = pLine->Prev(); pl != m_pLine; pl = pl->Prev() ) {
1674         // is it our subgroup?
1675         for ( n = 0; (pNewLast == NULL) && (n < nEntries); n++ ) {
1676           if ( m_aEntries[n]->GetLine() == m_pLine )
1677             pNewLast = m_aEntries[n];
1678         }
1679
1680         if ( pNewLast != NULL ) // found?
1681           break;
1682       }
1683
1684       if ( pl == m_pLine ) {
1685         wxASSERT( !pNewLast );  // how comes it has the same line as we?
1686
1687         // we've reached the group line without finding any subgroups
1688         m_pLastEntry = NULL;
1689       }
1690       else
1691         m_pLastEntry = pNewLast;
1692     }
1693
1694     m_pConfig->LineListRemove(pLine);
1695   }
1696
1697   // we must be written back for the changes to be saved
1698   SetDirty();
1699
1700   m_aEntries.Remove(pEntry);
1701   delete pEntry;
1702
1703   return TRUE;
1704 }
1705
1706 // ----------------------------------------------------------------------------
1707 //
1708 // ----------------------------------------------------------------------------
1709 void wxFileConfigGroup::SetDirty()
1710 {
1711   m_bDirty = TRUE;
1712   if ( Parent() != NULL )             // propagate upwards
1713     Parent()->SetDirty();
1714 }
1715
1716 // ============================================================================
1717 // wxFileConfig::wxFileConfigEntry
1718 // ============================================================================
1719
1720 // ----------------------------------------------------------------------------
1721 // ctor
1722 // ----------------------------------------------------------------------------
1723 wxFileConfigEntry::wxFileConfigEntry(wxFileConfigGroup *pParent,
1724                                        const wxString& strName,
1725                                        int nLine)
1726                          : m_strName(strName)
1727 {
1728   wxASSERT( !strName.IsEmpty() );
1729
1730   m_pParent = pParent;
1731   m_nLine   = nLine;
1732   m_pLine   = NULL;
1733
1734   m_bDirty =
1735   m_bHasValue = FALSE;
1736
1737   m_bImmutable = strName[0] == wxCONFIG_IMMUTABLE_PREFIX;
1738   if ( m_bImmutable )
1739     m_strName.erase(0, 1);  // remove first character
1740 }
1741
1742 // ----------------------------------------------------------------------------
1743 // set value
1744 // ----------------------------------------------------------------------------
1745
1746 void wxFileConfigEntry::SetLine(wxFileConfigLineList *pLine)
1747 {
1748   if ( m_pLine != NULL ) {
1749     wxLogWarning(_("entry '%s' appears more than once in group '%s'"),
1750                  Name().c_str(), m_pParent->GetFullName().c_str());
1751   }
1752
1753   m_pLine = pLine;
1754   Group()->SetLastEntry(this);
1755 }
1756
1757 // second parameter is FALSE if we read the value from file and prevents the
1758 // entry from being marked as 'dirty'
1759 void wxFileConfigEntry::SetValue(const wxString& strValue, bool bUser)
1760 {
1761     if ( bUser && IsImmutable() )
1762     {
1763         wxLogWarning( _("attempt to change immutable key '%s' ignored."),
1764                       Name().c_str());
1765         return;
1766     }
1767
1768         // do nothing if it's the same value: but don't test for it
1769         // if m_bHasValue hadn't been set yet or we'd never write
1770         // empty values to the file
1771
1772     if ( m_bHasValue && strValue == m_strValue )
1773         return;
1774
1775     m_bHasValue = TRUE;
1776     m_strValue = strValue;
1777
1778     if ( bUser )
1779     {
1780         wxString    strValFiltered;
1781
1782         if ( Group()->Config()->GetStyle() & wxCONFIG_USE_NO_ESCAPE_CHARACTERS )
1783         {
1784             strValFiltered = strValue;
1785         }
1786         else {
1787             strValFiltered = FilterOutValue(strValue);
1788         }
1789
1790         wxString    strLine;
1791         strLine << FilterOutEntryName(m_strName) << wxT('=') << strValFiltered;
1792
1793         if ( m_pLine != 0 )
1794         {
1795             // entry was read from the local config file, just modify the line
1796             m_pLine->SetText(strLine);
1797         }
1798         else {
1799             // add a new line to the file
1800             wxASSERT( m_nLine == wxNOT_FOUND );   // consistency check
1801
1802             m_pLine = Group()->Config()->LineListInsert(strLine,
1803                                                         Group()->GetLastEntryLine());
1804             Group()->SetLastEntry(this);
1805         }
1806
1807         SetDirty();
1808     }
1809 }
1810
1811 void wxFileConfigEntry::SetDirty()
1812 {
1813   m_bDirty = TRUE;
1814   Group()->SetDirty();
1815 }
1816
1817 // ============================================================================
1818 // global functions
1819 // ============================================================================
1820
1821 // ----------------------------------------------------------------------------
1822 // compare functions for array sorting
1823 // ----------------------------------------------------------------------------
1824
1825 int CompareEntries(wxFileConfigEntry *p1, wxFileConfigEntry *p2)
1826 {
1827   #if wxCONFIG_CASE_SENSITIVE
1828     return wxStrcmp(p1->Name(), p2->Name());
1829   #else
1830     return wxStricmp(p1->Name(), p2->Name());
1831   #endif
1832 }
1833
1834 int CompareGroups(wxFileConfigGroup *p1, wxFileConfigGroup *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 // ----------------------------------------------------------------------------
1844 // filter functions
1845 // ----------------------------------------------------------------------------
1846
1847 // undo FilterOutValue
1848 static wxString FilterInValue(const wxString& str)
1849 {
1850   wxString strResult;
1851   strResult.Alloc(str.Len());
1852
1853   bool bQuoted = !str.IsEmpty() && str[0] == '"';
1854
1855   for ( size_t n = bQuoted ? 1 : 0; n < str.Len(); n++ ) {
1856     if ( str[n] == wxT('\\') ) {
1857       switch ( str[++n] ) {
1858         case wxT('n'):
1859           strResult += wxT('\n');
1860           break;
1861
1862         case wxT('r'):
1863           strResult += wxT('\r');
1864           break;
1865
1866         case wxT('t'):
1867           strResult += wxT('\t');
1868           break;
1869
1870         case wxT('\\'):
1871           strResult += wxT('\\');
1872           break;
1873
1874         case wxT('"'):
1875           strResult += wxT('"');
1876           break;
1877       }
1878     }
1879     else {
1880       if ( str[n] != wxT('"') || !bQuoted )
1881         strResult += str[n];
1882       else if ( n != str.Len() - 1 ) {
1883         wxLogWarning(_("unexpected \" at position %d in '%s'."),
1884                      n, str.c_str());
1885       }
1886       //else: it's the last quote of a quoted string, ok
1887     }
1888   }
1889
1890   return strResult;
1891 }
1892
1893 // quote the string before writing it to file
1894 static wxString FilterOutValue(const wxString& str)
1895 {
1896    if ( !str )
1897       return str;
1898
1899   wxString strResult;
1900   strResult.Alloc(str.Len());
1901
1902   // quoting is necessary to preserve spaces in the beginning of the string
1903   bool bQuote = wxIsspace(str[0]) || str[0] == wxT('"');
1904
1905   if ( bQuote )
1906     strResult += wxT('"');
1907
1908   wxChar c;
1909   for ( size_t n = 0; n < str.Len(); n++ ) {
1910     switch ( str[n] ) {
1911       case wxT('\n'):
1912         c = wxT('n');
1913         break;
1914
1915       case wxT('\r'):
1916         c = wxT('r');
1917         break;
1918
1919       case wxT('\t'):
1920         c = wxT('t');
1921         break;
1922
1923       case wxT('\\'):
1924         c = wxT('\\');
1925         break;
1926
1927       case wxT('"'):
1928         if ( bQuote ) {
1929           c = wxT('"');
1930           break;
1931         }
1932         //else: fall through
1933
1934       default:
1935         strResult += str[n];
1936         continue;   // nothing special to do
1937     }
1938
1939     // we get here only for special characters
1940     strResult << wxT('\\') << c;
1941   }
1942
1943   if ( bQuote )
1944     strResult += wxT('"');
1945
1946   return strResult;
1947 }
1948
1949 // undo FilterOutEntryName
1950 static wxString FilterInEntryName(const wxString& str)
1951 {
1952   wxString strResult;
1953   strResult.Alloc(str.Len());
1954
1955   for ( const wxChar *pc = str.c_str(); *pc != '\0'; pc++ ) {
1956     if ( *pc == wxT('\\') )
1957       pc++;
1958
1959     strResult += *pc;
1960   }
1961
1962   return strResult;
1963 }
1964
1965 // sanitize entry or group name: insert '\\' before any special characters
1966 static wxString FilterOutEntryName(const wxString& str)
1967 {
1968   wxString strResult;
1969   strResult.Alloc(str.Len());
1970
1971   for ( const wxChar *pc = str.c_str(); *pc != wxT('\0'); pc++ ) {
1972     wxChar c = *pc;
1973
1974     // we explicitly allow some of "safe" chars and 8bit ASCII characters
1975     // which will probably never have special meaning
1976     // NB: note that wxCONFIG_IMMUTABLE_PREFIX and wxCONFIG_PATH_SEPARATOR
1977     //     should *not* be quoted
1978     if ( !wxIsalnum(c) && !wxStrchr(wxT("@_/-!.*%"), c) && ((c & 0x80) == 0) )
1979       strResult += wxT('\\');
1980
1981     strResult += c;
1982   }
1983
1984   return strResult;
1985 }
1986
1987 // we can't put ?: in the ctor initializer list because it confuses some
1988 // broken compilers (Borland C++)
1989 static wxString GetAppName(const wxString& appName)
1990 {
1991     if ( !appName && wxTheApp )
1992         return wxTheApp->GetAppName();
1993     else
1994         return appName;
1995 }
1996
1997 #endif // wxUSE_CONFIG
1998
1999
2000 // vi:sts=4:sw=4:et