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