src/html/helpdata.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        helpdata.cpp
   3 // Purpose:     wxHtmlHelpData
   4 // Notes:       Based on htmlhelp.cpp, implementing a monolithic
   5 //              HTML Help controller class,  by Vaclav Slavik
   6 // Author:      Harm van der Heijden and Vaclav Slavik
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Harm van der Heijden and Vaclav Slavik
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16 #pragma hdrstop
  17 #endif
  18
  19 #include "wx/defs.h"
  20
  21 #if wxUSE_HTML && wxUSE_STREAMS
  22
  23 #ifndef WXPRECOMP
  24     #include "wx/intl.h"
  25     #include "wx/log.h"
  26 #endif
  27
  28 #include <ctype.h>
  29
  30 #include "wx/html/helpdata.h"
  31 #include "wx/tokenzr.h"
  32 #include "wx/wfstream.h"
  33 #include "wx/busyinfo.h"
  34 #include "wx/encconv.h"
  35 #include "wx/fontmap.h"
  36 #include "wx/log.h"
  37 #include "wx/html/htmlpars.h"
  38 #include "wx/html/htmldefs.h"
  39 #include "wx/html/htmlfilt.h"
  40 #include "wx/filename.h"
  41
  42 #include "wx/arrimpl.cpp"
  43 WX_DEFINE_OBJARRAY(wxHtmlBookRecArray)
  44 WX_DEFINE_OBJARRAY(wxHtmlHelpDataItems)
  45
  46 //-----------------------------------------------------------------------------
  47 // static helper functions
  48 //-----------------------------------------------------------------------------
  49
  50 // Reads one line, stores it into buf and returns pointer to new line or NULL.
  51 static const wxChar* ReadLine(const wxChar *line, wxChar *buf, size_t bufsize)
  52 {
  53     wxChar *writeptr = buf;
  54     wxChar *endptr = buf + bufsize - 1;
  55     const wxChar *readptr = line;
  56
  57     while (*readptr != 0 && *readptr != _T('\r') && *readptr != _T('\n') &&
  58            writeptr != endptr)
  59         *(writeptr++) = *(readptr++);
  60     *writeptr = 0;
  61     while (*readptr == _T('\r') || *readptr == _T('\n'))
  62         readptr++;
  63     if (*readptr == 0)
  64         return NULL;
  65     else
  66         return readptr;
  67 }
  68
  69
  70
  71 static int
  72 wxHtmlHelpIndexCompareFunc(wxHtmlHelpDataItem **a, wxHtmlHelpDataItem **b)
  73 {
  74     wxHtmlHelpDataItem *ia = *a;
  75     wxHtmlHelpDataItem *ib = *b;
  76
  77     if (ia == NULL)
  78         return -1;
  79     if (ib == NULL)
  80         return 1;
  81
  82     if (ia->parent == ib->parent)
  83     {
  84         return ia->name.CmpNoCase(ib->name);
  85     }
  86     else if (ia->level == ib->level)
  87     {
  88         return wxHtmlHelpIndexCompareFunc(&ia->parent, &ib->parent);
  89     }
  90     else
  91     {
  92         wxHtmlHelpDataItem *ia2 = ia;
  93         wxHtmlHelpDataItem *ib2 = ib;
  94
  95         while (ia2->level > ib2->level)
  96         {
  97             ia2 = ia2->parent;
  98         }
  99         while (ib2->level > ia2->level)
 100         {
 101             ib2 = ib2->parent;
 102         }
 103
 104         wxASSERT(ia2);
 105         wxASSERT(ib2);
 106         int res = wxHtmlHelpIndexCompareFunc(&ia2, &ib2);
 107         if (res != 0)
 108             return res;
 109         else if (ia->level > ib->level)
 110             return 1;
 111         else
 112             return -1;
 113     }
 114 }
 115
 116 //-----------------------------------------------------------------------------
 117 // HP_Parser
 118 //-----------------------------------------------------------------------------
 119
 120 class HP_Parser : public wxHtmlParser
 121 {
 122 public:
 123     HP_Parser()
 124     {
 125         GetEntitiesParser()->SetEncoding(wxFONTENCODING_ISO8859_1);
 126     }
 127
 128     wxObject* GetProduct() { return NULL; }
 129
 130 protected:
 131     virtual void AddText(const wxChar* WXUNUSED(txt)) {}
 132
 133     DECLARE_NO_COPY_CLASS(HP_Parser)
 134 };
 135
 136
 137 //-----------------------------------------------------------------------------
 138 // HP_TagHandler
 139 //-----------------------------------------------------------------------------
 140
 141 class HP_TagHandler : public wxHtmlTagHandler
 142 {
 143     private:
 144         wxString m_name, m_page;
 145         int m_level;
 146         int m_id;
 147         int m_index;
 148         int m_count;
 149         wxHtmlHelpDataItem *m_parentItem;
 150         wxHtmlBookRecord *m_book;
 151
 152         wxHtmlHelpDataItems *m_data;
 153
 154     public:
 155         HP_TagHandler(wxHtmlBookRecord *b) : wxHtmlTagHandler()
 156         {
 157             m_data = NULL;
 158             m_book = b;
 159             m_name = m_page = wxEmptyString;
 160             m_level = 0;
 161             m_id = wxID_ANY;
 162             m_count = 0;
 163             m_parentItem = NULL;
 164         }
 165         wxString GetSupportedTags() { return wxT("UL,OBJECT,PARAM"); }
 166         bool HandleTag(const wxHtmlTag& tag);
 167
 168         void Reset(wxHtmlHelpDataItems& data)
 169         {
 170             m_data = &data;
 171             m_count = 0;
 172             m_level = 0;
 173             m_parentItem = NULL;
 174         }
 175
 176     DECLARE_NO_COPY_CLASS(HP_TagHandler)
 177 };
 178
 179
 180 bool HP_TagHandler::HandleTag(const wxHtmlTag& tag)
 181 {
 182     if (tag.GetName() == wxT("UL"))
 183     {
 184         wxHtmlHelpDataItem *oldparent = m_parentItem;
 185         m_level++;
 186         m_parentItem = (m_count > 0) ? &(*m_data)[m_data->size()-1] : NULL;
 187         ParseInner(tag);
 188         m_level--;
 189         m_parentItem = oldparent;
 190         return true;
 191     }
 192     else if (tag.GetName() == wxT("OBJECT"))
 193     {
 194         m_name = m_page = wxEmptyString;
 195         ParseInner(tag);
 196
 197 #if 0
 198          if (!page.IsEmpty())
 199         /* Valid HHW's file may contain only two object tags:
 200
 201            <OBJECT type="text/site properties">
 202                <param name="ImageType" value="Folder">
 203            </OBJECT>
 204
 205            or
 206
 207            <OBJECT type="text/sitemap">
 208                <param name="Name" value="main page">
 209                <param name="Local" value="another.htm">
 210            </OBJECT>
 211
 212            We're interested in the latter. !page.IsEmpty() is valid
 213            condition because text/site properties does not contain Local param
 214         */
 215 #endif
 216         if (tag.GetParam(wxT("TYPE")) == wxT("text/sitemap"))
 217         {
 218             wxHtmlHelpDataItem *item = new wxHtmlHelpDataItem();
 219             item->parent = m_parentItem;
 220             item->level = m_level;
 221             item->id = m_id;
 222             item->page = m_page;
 223             item->name = m_name;
 224
 225             item->book = m_book;
 226             m_data->Add(item);
 227             m_count++;
 228         }
 229
 230         return true;
 231     }
 232     else
 233     { // "PARAM"
 234         if (m_name.empty() && tag.GetParam(wxT("NAME")) == wxT("Name"))
 235             m_name = tag.GetParam(wxT("VALUE"));
 236         if (tag.GetParam(wxT("NAME")) == wxT("Local"))
 237             m_page = tag.GetParam(wxT("VALUE"));
 238         if (tag.GetParam(wxT("NAME")) == wxT("ID"))
 239             tag.GetParamAsInt(wxT("VALUE"), &m_id);
 240         return false;
 241     }
 242 }
 243
 244
 245 //-----------------------------------------------------------------------------
 246 // wxHtmlHelpData
 247 //-----------------------------------------------------------------------------
 248
 249 wxString wxHtmlBookRecord::GetFullPath(const wxString &page) const
 250 {
 251     if (wxIsAbsolutePath(page))
 252         return page;
 253     else
 254         return m_BasePath + page;
 255 }
 256
 257 wxString wxHtmlHelpDataItem::GetIndentedName() const
 258 {
 259     wxString s;
 260     for (int i = 1; i < level; i++)
 261         s << _T("   ");
 262     s << name;
 263     return s;
 264 }
 265
 266
 267 IMPLEMENT_DYNAMIC_CLASS(wxHtmlHelpData, wxObject)
 268
 269 wxHtmlHelpData::wxHtmlHelpData()
 270 {
 271 #if WXWIN_COMPATIBILITY_2_4
 272     m_cacheContents = NULL;
 273     m_cacheIndex = NULL;
 274 #endif
 275 }
 276
 277 wxHtmlHelpData::~wxHtmlHelpData()
 278 {
 279 #if WXWIN_COMPATIBILITY_2_4
 280     CleanCompatibilityData();
 281 #endif
 282 }
 283
 284 bool wxHtmlHelpData::LoadMSProject(wxHtmlBookRecord *book, wxFileSystem& fsys,
 285                                    const wxString& indexfile,
 286                                    const wxString& contentsfile)
 287 {
 288     wxFSFile *f;
 289     wxHtmlFilterHTML filter;
 290     wxString buf;
 291     wxString string;
 292
 293     HP_Parser parser;
 294     HP_TagHandler *handler = new HP_TagHandler(book);
 295     parser.AddTagHandler(handler);
 296
 297     f = ( contentsfile.IsEmpty() ? (wxFSFile*) NULL : fsys.OpenFile(contentsfile) );
 298     if (f)
 299     {
 300         buf.clear();
 301         buf = filter.ReadFile(*f);
 302         delete f;
 303         handler->Reset(m_contents);
 304         parser.Parse(buf);
 305     }
 306     else
 307     {
 308         wxLogError(_("Cannot open contents file: %s"), contentsfile.c_str());
 309     }
 310
 311     f = ( indexfile.IsEmpty() ? (wxFSFile*) NULL : fsys.OpenFile(indexfile) );
 312     if (f)
 313     {
 314         buf.clear();
 315         buf = filter.ReadFile(*f);
 316         delete f;
 317         handler->Reset(m_index);
 318         parser.Parse(buf);
 319     }
 320     else if (!indexfile.IsEmpty())
 321     {
 322         wxLogError(_("Cannot open index file: %s"), indexfile.c_str());
 323     }
 324     return true;
 325 }
 326
 327 inline static void CacheWriteInt32(wxOutputStream *f, wxInt32 value)
 328 {
 329     wxInt32 x = wxINT32_SWAP_ON_BE(value);
 330     f->Write(&x, sizeof(x));
 331 }
 332
 333 inline static wxInt32 CacheReadInt32(wxInputStream *f)
 334 {
 335     wxInt32 x;
 336     f->Read(&x, sizeof(x));
 337     return wxINT32_SWAP_ON_BE(x);
 338 }
 339
 340 inline static void CacheWriteString(wxOutputStream *f, const wxString& str)
 341 {
 342     const wxWX2MBbuf mbstr = str.mb_str(wxConvUTF8);
 343     size_t len = strlen((const char*)mbstr)+1;
 344     CacheWriteInt32(f, len);
 345     f->Write((const char*)mbstr, len);
 346 }
 347
 348 inline static wxString CacheReadString(wxInputStream *f)
 349 {
 350     size_t len = (size_t)CacheReadInt32(f);
 351     wxCharBuffer str(len-1);
 352     f->Read(str.data(), len);
 353     return wxString(str, wxConvUTF8);
 354 }
 355
 356 #define CURRENT_CACHED_BOOK_VERSION     5
 357
 358 // Additional flags to detect incompatibilities of the runtime environment:
 359 #define CACHED_BOOK_FORMAT_FLAGS \
 360                      (wxUSE_UNICODE << 0)
 361
 362
 363 bool wxHtmlHelpData::LoadCachedBook(wxHtmlBookRecord *book, wxInputStream *f)
 364 {
 365     int i, st, newsize;
 366     wxInt32 version;
 367
 368     /* load header - version info : */
 369     version = CacheReadInt32(f);
 370
 371     if (version != CURRENT_CACHED_BOOK_VERSION)
 372     {
 373         // NB: We can just silently return false here and don't worry about
 374         //     it anymore, because AddBookParam will load the MS project in
 375         //     absence of (properly versioned) .cached file and automatically
 376         //     create new .cached file immediately afterward.
 377         return false;
 378     }
 379
 380     if (CacheReadInt32(f) != CACHED_BOOK_FORMAT_FLAGS)
 381         return false;
 382
 383     /* load contents : */
 384     st = m_contents.size();
 385     newsize = st + CacheReadInt32(f);
 386     m_contents.Alloc(newsize);
 387     for (i = st; i < newsize; i++)
 388     {
 389         wxHtmlHelpDataItem *item = new wxHtmlHelpDataItem;
 390         item->level = CacheReadInt32(f);
 391         item->id = CacheReadInt32(f);
 392         item->name = CacheReadString(f);
 393         item->page = CacheReadString(f);
 394         item->book = book;
 395         m_contents.Add(item);
 396     }
 397
 398     /* load index : */
 399     st = m_index.size();
 400     newsize = st + CacheReadInt32(f);
 401     m_index.Alloc(newsize);
 402     for (i = st; i < newsize; i++)
 403     {
 404         wxHtmlHelpDataItem *item = new wxHtmlHelpDataItem;
 405         item->name = CacheReadString(f);
 406         item->page = CacheReadString(f);
 407         item->level = CacheReadInt32(f);
 408         item->book = book;
 409         int parentShift = CacheReadInt32(f);
 410         if (parentShift != 0)
 411             item->parent = &m_index[m_index.size() - parentShift];
 412         m_index.Add(item);
 413     }
 414     return true;
 415 }
 416
 417
 418 bool wxHtmlHelpData::SaveCachedBook(wxHtmlBookRecord *book, wxOutputStream *f)
 419 {
 420     int i;
 421     wxInt32 cnt;
 422
 423     /* save header - version info : */
 424     CacheWriteInt32(f, CURRENT_CACHED_BOOK_VERSION);
 425     CacheWriteInt32(f, CACHED_BOOK_FORMAT_FLAGS);
 426
 427     /* save contents : */
 428     int len = m_contents.size();
 429     for (cnt = 0, i = 0; i < len; i++)
 430         if (m_contents[i].book == book && m_contents[i].level > 0)
 431             cnt++;
 432     CacheWriteInt32(f, cnt);
 433
 434     for (i = 0; i < len; i++)
 435     {
 436         if (m_contents[i].book != book || m_contents[i].level == 0)
 437             continue;
 438         CacheWriteInt32(f, m_contents[i].level);
 439         CacheWriteInt32(f, m_contents[i].id);
 440         CacheWriteString(f, m_contents[i].name);
 441         CacheWriteString(f, m_contents[i].page);
 442     }
 443
 444     /* save index : */
 445     len = m_index.size();
 446     for (cnt = 0, i = 0; i < len; i++)
 447         if (m_index[i].book == book && m_index[i].level > 0)
 448             cnt++;
 449     CacheWriteInt32(f, cnt);
 450
 451     for (i = 0; i < len; i++)
 452     {
 453         if (m_index[i].book != book || m_index[i].level == 0)
 454             continue;
 455         CacheWriteString(f, m_index[i].name);
 456         CacheWriteString(f, m_index[i].page);
 457         CacheWriteInt32(f, m_index[i].level);
 458         // save distance to parent item, if any:
 459         if (m_index[i].parent == NULL)
 460         {
 461             CacheWriteInt32(f, 0);
 462         }
 463         else
 464         {
 465             int cnt = 0;
 466             wxHtmlHelpDataItem *parent = m_index[i].parent;
 467             for (int j = i-1; j >= 0; j--)
 468             {
 469                 if (m_index[j].book == book && m_index[j].level > 0)
 470                     cnt++;
 471                 if (&m_index[j] == parent)
 472                     break;
 473             }
 474             wxASSERT(cnt > 0);
 475             CacheWriteInt32(f, cnt);
 476         }
 477     }
 478     return true;
 479 }
 480
 481
 482 void wxHtmlHelpData::SetTempDir(const wxString& path)
 483 {
 484     if (path.empty())
 485         m_tempPath = path;
 486     else
 487     {
 488         if (wxIsAbsolutePath(path)) m_tempPath = path;
 489         else m_tempPath = wxGetCwd() + _T("/") + path;
 490
 491         if (m_tempPath[m_tempPath.Length() - 1] != _T('/'))
 492             m_tempPath << _T('/');
 493     }
 494 }
 495
 496
 497
 498 static wxString SafeFileName(const wxString& s)
 499 {
 500     wxString res(s);
 501     res.Replace(wxT("#"), wxT("_"));
 502     res.Replace(wxT(":"), wxT("_"));
 503     res.Replace(wxT("\\"), wxT("_"));
 504     res.Replace(wxT("/"), wxT("_"));
 505     return res;
 506 }
 507
 508 bool wxHtmlHelpData::AddBookParam(const wxFSFile& bookfile,
 509                                   wxFontEncoding encoding,
 510                                   const wxString& title, const wxString& contfile,
 511                                   const wxString& indexfile, const wxString& deftopic,
 512                                   const wxString& path)
 513 {
 514     wxFileSystem fsys;
 515     wxFSFile *fi;
 516     wxHtmlBookRecord *bookr;
 517
 518     int IndexOld = m_index.size(),
 519         ContentsOld = m_contents.size();
 520
 521     if (!path.IsEmpty())
 522         fsys.ChangePathTo(path, true);
 523
 524     size_t booksCnt = m_bookRecords.GetCount();
 525     for (size_t i = 0; i < booksCnt; i++)
 526     {
 527         if ( m_bookRecords[i].GetBookFile() == bookfile.GetLocation() )
 528             return true; // book is (was) loaded
 529     }
 530
 531     bookr = new wxHtmlBookRecord(bookfile.GetLocation(), fsys.GetPath(), title, deftopic);
 532
 533     wxHtmlHelpDataItem *bookitem = new wxHtmlHelpDataItem;
 534     bookitem->level = 0;
 535     bookitem->id = 0;
 536     bookitem->page = deftopic;
 537     bookitem->name = title;
 538     bookitem->book = bookr;
 539
 540     // store the contents index for later
 541     int cont_start = m_contents.size();
 542
 543     m_contents.Add(bookitem);
 544
 545     // Try to find cached binary versions:
 546     // 1. save file as book, but with .hhp.cached extension
 547     // 2. same as 1. but in temp path
 548     // 3. otherwise or if cache load failed, load it from MS.
 549
 550     fi = fsys.OpenFile(bookfile.GetLocation() + wxT(".cached"));
 551
 552     if (fi == NULL ||
 553 #if wxUSE_DATETIME
 554           fi->GetModificationTime() < bookfile.GetModificationTime() ||
 555 #endif // wxUSE_DATETIME
 556           !LoadCachedBook(bookr, fi->GetStream()))
 557     {
 558         if (fi != NULL) delete fi;
 559         fi = fsys.OpenFile(m_tempPath + wxFileNameFromPath(bookfile.GetLocation()) + wxT(".cached"));
 560         if (m_tempPath.empty() || fi == NULL ||
 561 #if wxUSE_DATETIME
 562             fi->GetModificationTime() < bookfile.GetModificationTime() ||
 563 #endif // wxUSE_DATETIME
 564             !LoadCachedBook(bookr, fi->GetStream()))
 565         {
 566             LoadMSProject(bookr, fsys, indexfile, contfile);
 567             if (!m_tempPath.empty())
 568             {
 569                 wxFileOutputStream *outs = new wxFileOutputStream(m_tempPath +
 570                                                   SafeFileName(wxFileNameFromPath(bookfile.GetLocation())) + wxT(".cached"));
 571                 SaveCachedBook(bookr, outs);
 572                 delete outs;
 573             }
 574         }
 575     }
 576
 577     if (fi != NULL) delete fi;
 578
 579     // Now store the contents range
 580     bookr->SetContentsRange(cont_start, m_contents.size());
 581
 582 #if wxUSE_WCHAR_T
 583     // MS HTML Help files [written by MS HTML Help Workshop] are broken
 584     // in that the data are iso-8859-1 (including HTML entities), but must
 585     // be interpreted as being in language's windows charset. Correct the
 586     // differences here and also convert to wxConvLocal in ANSI build
 587     if (encoding != wxFONTENCODING_SYSTEM)
 588     {
 589         #if wxUSE_UNICODE
 590             #define CORRECT_STR(str, conv) \
 591                 str = wxString((str).mb_str(wxConvISO8859_1), conv)
 592         #else
 593             #define CORRECT_STR(str, conv) \
 594                 str = wxString((str).wc_str(conv), wxConvLocal)
 595         #endif
 596         wxCSConv conv(encoding);
 597         size_t IndexCnt = m_index.size();
 598         size_t ContentsCnt = m_contents.size();
 599         size_t i;
 600         for (i = IndexOld; i < IndexCnt; i++)
 601         {
 602             CORRECT_STR(m_index[i].name, conv);
 603         }
 604         for (i = ContentsOld; i < ContentsCnt; i++)
 605         {
 606             CORRECT_STR(m_contents[i].name, conv);
 607         }
 608         #undef CORRECT_STR
 609     }
 610 #else
 611     wxUnusedVar(IndexOld);
 612     wxUnusedVar(ContentsOld);
 613     wxASSERT_MSG(encoding == wxFONTENCODING_SYSTEM, wxT("Help files need charset conversion, but wxUSE_WCHAR_T is 0"));
 614 #endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T
 615
 616     m_bookRecords.Add(bookr);
 617     if (!m_index.empty())
 618     {
 619         m_index.Sort(wxHtmlHelpIndexCompareFunc);
 620     }
 621
 622     return true;
 623 }
 624
 625
 626 bool wxHtmlHelpData::AddBook(const wxString& book)
 627 {
 628     wxString extension(book.Right(4).Lower());
 629     if (extension == wxT(".zip") ||
 630 #if wxUSE_LIBMSPACK
 631         extension == wxT(".chm") /*compressed html help book*/ ||
 632 #endif
 633         extension == wxT(".htb") /*html book*/)
 634     {
 635         wxFileSystem fsys;
 636         wxString s;
 637         bool rt = false;
 638
 639 #if wxUSE_LIBMSPACK
 640         if (extension == wxT(".chm"))
 641             s = fsys.FindFirst(book + wxT("#chm:*.hhp"), wxFILE);
 642         else
 643 #endif
 644             s = fsys.FindFirst(book + wxT("#zip:*.hhp"), wxFILE);
 645
 646         while (!s.IsEmpty())
 647         {
 648             if (AddBook(s)) rt = true;
 649             s = fsys.FindNext();
 650         }
 651
 652         return rt;
 653     }
 654
 655     wxFSFile *fi;
 656     wxFileSystem fsys;
 657
 658     wxString title = _("noname"),
 659              safetitle,
 660              start = wxEmptyString,
 661              contents = wxEmptyString,
 662              index = wxEmptyString,
 663              charset = wxEmptyString;
 664
 665     fi = fsys.OpenFile(book);
 666     if (fi == NULL)
 667     {
 668         wxLogError(_("Cannot open HTML help book: %s"), book.c_str());
 669         return false;
 670     }
 671     fsys.ChangePathTo(book);
 672
 673     const wxChar *lineptr;
 674     wxChar linebuf[300];
 675     wxString tmp;
 676     wxHtmlFilterPlainText filter;
 677     tmp = filter.ReadFile(*fi);
 678     lineptr = tmp.c_str();
 679
 680     do
 681     {
 682         lineptr = ReadLine(lineptr, linebuf, 300);
 683
 684         for (wxChar *ch = linebuf; *ch != wxT('\0') && *ch != wxT('='); ch++)
 685            *ch = (wxChar)wxTolower(*ch);
 686
 687         if (wxStrstr(linebuf, _T("title=")) == linebuf)
 688             title = linebuf + wxStrlen(_T("title="));
 689         if (wxStrstr(linebuf, _T("default topic=")) == linebuf)
 690             start = linebuf + wxStrlen(_T("default topic="));
 691         if (wxStrstr(linebuf, _T("index file=")) == linebuf)
 692             index = linebuf + wxStrlen(_T("index file="));
 693         if (wxStrstr(linebuf, _T("contents file=")) == linebuf)
 694             contents = linebuf + wxStrlen(_T("contents file="));
 695         if (wxStrstr(linebuf, _T("charset=")) == linebuf)
 696             charset = linebuf + wxStrlen(_T("charset="));
 697     } while (lineptr != NULL);
 698
 699     wxFontEncoding enc = wxFONTENCODING_SYSTEM;
 700 #if wxUSE_FONTMAP
 701     if (charset != wxEmptyString)
 702         enc = wxFontMapper::Get()->CharsetToEncoding(charset);
 703 #endif
 704
 705     bool rtval = AddBookParam(*fi, enc,
 706                               title, contents, index, start, fsys.GetPath());
 707     delete fi;
 708
 709 #if WXWIN_COMPATIBILITY_2_4
 710     CleanCompatibilityData();
 711 #endif
 712
 713     return rtval;
 714 }
 715
 716 wxString wxHtmlHelpData::FindPageByName(const wxString& x)
 717 {
 718     int cnt;
 719     int i;
 720     wxFileSystem fsys;
 721     wxFSFile *f;
 722
 723     /* 1. try to open given file: */
 724
 725     cnt = m_bookRecords.GetCount();
 726     for (i = 0; i < cnt; i++)
 727     {
 728         f = fsys.OpenFile(m_bookRecords[i].GetFullPath(x));
 729         if (f)
 730         {
 731             wxString url = m_bookRecords[i].GetFullPath(x);
 732             delete f;
 733             return url;
 734         }
 735     }
 736
 737
 738     /* 2. try to find a book: */
 739
 740     for (i = 0; i < cnt; i++)
 741     {
 742         if (m_bookRecords[i].GetTitle() == x)
 743             return m_bookRecords[i].GetFullPath(m_bookRecords[i].GetStart());
 744     }
 745
 746     /* 3. try to find in contents: */
 747
 748     cnt = m_contents.size();
 749     for (i = 0; i < cnt; i++)
 750     {
 751         if (m_contents[i].name == x)
 752             return m_contents[i].GetFullPath();
 753     }
 754
 755
 756     /* 4. try to find in index: */
 757
 758     cnt = m_index.size();
 759     for (i = 0; i < cnt; i++)
 760     {
 761         if (m_index[i].name == x)
 762             return m_index[i].GetFullPath();
 763     }
 764
 765     return wxEmptyString;
 766 }
 767
 768 wxString wxHtmlHelpData::FindPageById(int id)
 769 {
 770     size_t cnt = m_contents.size();
 771     for (size_t i = 0; i < cnt; i++)
 772     {
 773         if (m_contents[i].id == id)
 774         {
 775             return m_contents[i].GetFullPath();
 776         }
 777     }
 778
 779     return wxEmptyString;
 780 }
 781
 782 #if WXWIN_COMPATIBILITY_2_4
 783 wxHtmlContentsItem::wxHtmlContentsItem()
 784     : m_Level(0), m_ID(wxID_ANY), m_Name(NULL), m_Page(NULL), m_Book(NULL),
 785       m_autofree(false)
 786 {
 787 }
 788
 789 wxHtmlContentsItem::wxHtmlContentsItem(const wxHtmlHelpDataItem& d)
 790 {
 791     m_autofree = true;
 792     m_Level = d.level;
 793     m_ID = d.id;
 794     m_Name = wxStrdup(d.name.c_str());
 795     m_Page = wxStrdup(d.page.c_str());
 796     m_Book = d.book;
 797 }
 798
 799 wxHtmlContentsItem& wxHtmlContentsItem::operator=(const wxHtmlContentsItem& d)
 800 {
 801     if (m_autofree)
 802     {
 803         free(m_Name);
 804         free(m_Page);
 805     }
 806     m_autofree = true;
 807     m_Level = d.m_Level;
 808     m_ID = d.m_ID;
 809     m_Name = d.m_Name ? wxStrdup(d.m_Name) : NULL;
 810     m_Page = d.m_Page ? wxStrdup(d.m_Page) : NULL;
 811     m_Book = d.m_Book;
 812     return *this;
 813 }
 814
 815 wxHtmlContentsItem::~wxHtmlContentsItem()
 816 {
 817     if (m_autofree)
 818     {
 819         free(m_Name);
 820         free(m_Page);
 821     }
 822 }
 823
 824 wxHtmlContentsItem* wxHtmlHelpData::GetContents()
 825 {
 826     if (!m_cacheContents && !m_contents.empty())
 827     {
 828         size_t len = m_contents.size();
 829         m_cacheContents = new wxHtmlContentsItem[len];
 830         for (size_t i = 0; i < len; i++)
 831             m_cacheContents[i] = m_contents[i];
 832     }
 833     return m_cacheContents;
 834 }
 835
 836 int wxHtmlHelpData::GetContentsCnt()
 837 {
 838     return m_contents.size();
 839 }
 840
 841 wxHtmlContentsItem* wxHtmlHelpData::GetIndex()
 842 {
 843     if (!m_cacheContents && !m_index.empty())
 844     {
 845         size_t len = m_index.size();
 846         m_cacheContents = new wxHtmlContentsItem[len];
 847         for (size_t i = 0; i < len; i++)
 848             m_cacheContents[i] = m_index[i];
 849     }
 850     return m_cacheContents;
 851 }
 852
 853 int wxHtmlHelpData::GetIndexCnt()
 854 {
 855     return m_index.size();
 856 }
 857
 858 void wxHtmlHelpData::CleanCompatibilityData()
 859 {
 860     delete[] m_cacheContents;
 861     m_cacheContents = NULL;
 862     delete[] m_cacheIndex;
 863     m_cacheIndex = NULL;
 864 }
 865 #endif // WXWIN_COMPATIBILITY_2_4
 866
 867 //----------------------------------------------------------------------------------
 868 // wxHtmlSearchStatus functions
 869 //----------------------------------------------------------------------------------
 870
 871 wxHtmlSearchStatus::wxHtmlSearchStatus(wxHtmlHelpData* data, const wxString& keyword,
 872                                        bool case_sensitive, bool whole_words_only,
 873                                        const wxString& book)
 874 {
 875     m_Data = data;
 876     m_Keyword = keyword;
 877     wxHtmlBookRecord* bookr = NULL;
 878     if (book != wxEmptyString)
 879     {
 880         // we have to search in a specific book. Find it first
 881         int i, cnt = data->m_bookRecords.GetCount();
 882         for (i = 0; i < cnt; i++)
 883             if (data->m_bookRecords[i].GetTitle() == book)
 884             {
 885                 bookr = &(data->m_bookRecords[i]);
 886                 m_CurIndex = bookr->GetContentsStart();
 887                 m_MaxIndex = bookr->GetContentsEnd();
 888                 break;
 889             }
 890         // check; we won't crash if the book doesn't exist, but it's Bad Anyway.
 891         wxASSERT(bookr);
 892     }
 893     if (! bookr)
 894     {
 895         // no book specified; search all books
 896         m_CurIndex = 0;
 897         m_MaxIndex = m_Data->m_contents.size();
 898     }
 899     m_Engine.LookFor(keyword, case_sensitive, whole_words_only);
 900     m_Active = (m_CurIndex < m_MaxIndex);
 901 }
 902
 903 #if WXWIN_COMPATIBILITY_2_4
 904 wxHtmlContentsItem* wxHtmlSearchStatus::GetContentsItem()
 905 {
 906     static wxHtmlContentsItem it;
 907     it = wxHtmlContentsItem(*m_CurItem);
 908     return &it;
 909 }
 910 #endif
 911
 912 bool wxHtmlSearchStatus::Search()
 913 {
 914     wxFSFile *file;
 915     int i = m_CurIndex;  // shortcut
 916     bool found = false;
 917     wxString thepage;
 918
 919     if (!m_Active)
 920     {
 921         // sanity check. Illegal use, but we'll try to prevent a crash anyway
 922         wxASSERT(m_Active);
 923         return false;
 924     }
 925
 926     m_Name = wxEmptyString;
 927     m_CurItem = NULL;
 928     thepage = m_Data->m_contents[i].page;
 929
 930     m_Active = (++m_CurIndex < m_MaxIndex);
 931     // check if it is same page with different anchor:
 932     if (!m_LastPage.empty())
 933     {
 934         const wxChar *p1, *p2;
 935         for (p1 = thepage.c_str(), p2 = m_LastPage.c_str();
 936              *p1 != 0 && *p1 != _T('#') && *p1 == *p2; p1++, p2++) {}
 937
 938         m_LastPage = thepage;
 939
 940         if (*p1 == 0 || *p1 == _T('#'))
 941             return false;
 942     }
 943     else m_LastPage = thepage;
 944
 945     wxFileSystem fsys;
 946     file = fsys.OpenFile(m_Data->m_contents[i].book->GetFullPath(thepage));
 947     if (file)
 948     {
 949         if (m_Engine.Scan(*file))
 950         {
 951             m_Name = m_Data->m_contents[i].name;
 952             m_CurItem = &m_Data->m_contents[i];
 953             found = true;
 954         }
 955         delete file;
 956     }
 957     return found;
 958 }
 959
 960
 961
 962
 963
 964
 965
 966
 967 //--------------------------------------------------------------------------------
 968 // wxHtmlSearchEngine
 969 //--------------------------------------------------------------------------------
 970
 971 void wxHtmlSearchEngine::LookFor(const wxString& keyword, bool case_sensitive, bool whole_words_only)
 972 {
 973     m_CaseSensitive = case_sensitive;
 974     m_WholeWords = whole_words_only;
 975     m_Keyword = keyword;
 976
 977     if (!m_CaseSensitive)
 978         m_Keyword.LowerCase();
 979 }
 980
 981
 982 static inline bool WHITESPACE(wxChar c)
 983 {
 984     return c == _T(' ') || c == _T('\n') || c == _T('\r') || c == _T('\t');
 985 }
 986
 987 bool wxHtmlSearchEngine::Scan(const wxFSFile& file)
 988 {
 989     wxASSERT_MSG(!m_Keyword.empty(), wxT("wxHtmlSearchEngine::LookFor must be called before scanning!"));
 990
 991     int i, j;
 992     int wrd = m_Keyword.Length();
 993     bool found = false;
 994     wxHtmlFilterHTML filter;
 995     wxString tmp = filter.ReadFile(file);
 996     int lng = tmp.length();
 997     const wxChar *buf = tmp.c_str();
 998
 999     if (!m_CaseSensitive)
1000         tmp.LowerCase();
1001
1002     const wxChar *kwd = m_Keyword.c_str();
1003
1004     if (m_WholeWords)
1005     {
1006         for (i = 0; i < lng - wrd; i++)
1007         {
1008             if (WHITESPACE(buf[i])) continue;
1009             j = 0;
1010             while ((j < wrd) && (buf[i + j] == kwd[j])) j++;
1011             if (j == wrd && WHITESPACE(buf[i + j])) { found = true; break; }
1012         }
1013     }
1014
1015     else
1016     {
1017         for (i = 0; i < lng - wrd; i++)
1018         {
1019             j = 0;
1020             while ((j < wrd) && (buf[i + j] == kwd[j])) j++;
1021             if (j == wrd) { found = true; break; }
1022         }
1023     }
1024
1025     return found;
1026 }
1027
1028
1029
1030 #endif