src/html/helpdata.cpp

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