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