]> git.saurik.com Git - wxWidgets.git/blob - src/html/helpdata.cpp
Darwin dlopen functions is needed both for DYNLIB_CLASS and DYNAMIC_LOADER
[wxWidgets.git] / 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 #ifdef __GNUG__
13 #pragma implementation
14 #endif
15
16 // For compilers that support precompilation, includes "wx.h".
17 #include "wx/wxprec.h"
18
19 #ifdef __BORLANDC__
20 #pragma hdrstop
21 #endif
22
23 #include "wx/defs.h"
24
25 #if wxUSE_HTML && wxUSE_STREAMS
26
27 #ifndef WXPRECOMP
28 #include "wx/intl.h"
29 #include "wx/log.h"
30 #endif
31
32 #include "wx/html/helpdata.h"
33 #include "wx/tokenzr.h"
34 #include "wx/wfstream.h"
35 #include "wx/busyinfo.h"
36 #include "wx/encconv.h"
37 #include "wx/fontmap.h"
38 #include "wx/log.h"
39 #include "wx/html/htmlpars.h"
40 #include "wx/html/htmldefs.h"
41 #include "wx/filename.h"
42
43 #include "wx/arrimpl.cpp"
44 WX_DEFINE_OBJARRAY(wxHtmlBookRecArray)
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 char* ReadLine(char *line, char *buf, size_t bufsize)
52 {
53 char *writeptr = buf;
54 char *endptr = buf + bufsize - 1;
55 char *readptr = line;
56
57 while (*readptr != 0 && *readptr != '\r' && *readptr != '\n' &&
58 writeptr != endptr)
59 *(writeptr++) = *(readptr++);
60 *writeptr = 0;
61 while (*readptr == '\r' || *readptr == '\n')
62 readptr++;
63 if (*readptr == 0)
64 return NULL;
65 else
66 return readptr;
67 }
68
69
70
71 extern "C" int LINKAGEMODE
72 wxHtmlHelpIndexCompareFunc(const void *a, const void *b)
73 {
74 return wxStricmp(((wxHtmlContentsItem*)a)->m_Name, ((wxHtmlContentsItem*)b)->m_Name);
75 }
76
77
78 //-----------------------------------------------------------------------------
79 // HP_Parser
80 //-----------------------------------------------------------------------------
81
82 class HP_Parser : public wxHtmlParser
83 {
84 public:
85 wxObject* GetProduct() { return NULL; }
86 protected:
87 virtual void AddText(const wxChar* WXUNUSED(txt)) {}
88 };
89
90
91 //-----------------------------------------------------------------------------
92 // HP_TagHandler
93 //-----------------------------------------------------------------------------
94
95 class HP_TagHandler : public wxHtmlTagHandler
96 {
97 private:
98 wxString m_Name, m_Page;
99 int m_Level;
100 int m_ID;
101 int m_Index;
102 wxHtmlContentsItem *m_Items;
103 int m_ItemsCnt;
104 wxHtmlBookRecord *m_Book;
105
106 public:
107 HP_TagHandler(wxHtmlBookRecord *b) : wxHtmlTagHandler()
108 { m_Book = b; m_Items = NULL; m_ItemsCnt = 0; m_Name = m_Page = wxEmptyString;
109 m_Level = 0; m_ID = -1; }
110 wxString GetSupportedTags() { return wxT("UL,OBJECT,PARAM"); }
111 bool HandleTag(const wxHtmlTag& tag);
112 void WriteOut(wxHtmlContentsItem*& array, int& size);
113 void ReadIn(wxHtmlContentsItem* array, int size);
114 };
115
116
117 bool HP_TagHandler::HandleTag(const wxHtmlTag& tag)
118 {
119 if (tag.GetName() == wxT("UL"))
120 {
121 m_Level++;
122 ParseInner(tag);
123 m_Level--;
124 return TRUE;
125 }
126 else if (tag.GetName() == wxT("OBJECT"))
127 {
128 m_Name = m_Page = wxEmptyString;
129 ParseInner(tag);
130
131 #if 0
132 if (!m_Page.IsEmpty())
133 /* Valid HHW's file may contain only two object tags:
134
135 <OBJECT type="text/site properties">
136 <param name="ImageType" value="Folder">
137 </OBJECT>
138
139 or
140
141 <OBJECT type="text/sitemap">
142 <param name="Name" value="main page">
143 <param name="Local" value="another.htm">
144 </OBJECT>
145
146 We're interested in the latter. !m_Page.IsEmpty() is valid
147 condition because text/site properties does not contain Local param
148 */
149 #endif
150 if (tag.GetParam(wxT("TYPE")) == wxT("text/sitemap"))
151 {
152 if (m_ItemsCnt % wxHTML_REALLOC_STEP == 0)
153 m_Items = (wxHtmlContentsItem*) realloc(m_Items,
154 (m_ItemsCnt + wxHTML_REALLOC_STEP) *
155 sizeof(wxHtmlContentsItem));
156
157 m_Items[m_ItemsCnt].m_Level = m_Level;
158 m_Items[m_ItemsCnt].m_ID = m_ID;
159 m_Items[m_ItemsCnt].m_Page = new wxChar[m_Page.Length() + 1];
160 wxStrcpy(m_Items[m_ItemsCnt].m_Page, m_Page.c_str());
161 m_Items[m_ItemsCnt].m_Name = new wxChar [m_Name.Length() + 1];
162 wxStrcpy(m_Items[m_ItemsCnt].m_Name, m_Name.c_str());
163 m_Items[m_ItemsCnt].m_Book = m_Book;
164 m_ItemsCnt++;
165 }
166
167 return TRUE;
168 }
169 else
170 { // "PARAM"
171 if (m_Name == wxEmptyString && tag.GetParam(wxT("NAME")) == wxT("Name"))
172 m_Name = tag.GetParam(wxT("VALUE"));
173 if (tag.GetParam(wxT("NAME")) == wxT("Local"))
174 m_Page = tag.GetParam(wxT("VALUE"));
175 if (tag.GetParam(wxT("NAME")) == wxT("ID"))
176 tag.GetParamAsInt(wxT("VALUE"), &m_ID);
177 return FALSE;
178 }
179 }
180
181
182
183 void HP_TagHandler::WriteOut(wxHtmlContentsItem*& array, int& size)
184 {
185 array = m_Items;
186 size = m_ItemsCnt;
187 m_Items = NULL;
188 m_ItemsCnt = 0;
189 }
190
191 void HP_TagHandler::ReadIn(wxHtmlContentsItem* array, int size)
192 {
193 m_Items = array;
194 m_ItemsCnt = size;
195 }
196
197
198
199
200 //-----------------------------------------------------------------------------
201 // wxHtmlHelpData
202 //-----------------------------------------------------------------------------
203
204 wxString wxHtmlBookRecord::GetFullPath(const wxString &page) const
205 {
206 if (wxIsAbsolutePath(page))
207 return page;
208 else
209 return m_BasePath + page;
210 }
211
212
213
214 IMPLEMENT_DYNAMIC_CLASS(wxHtmlHelpData, wxObject)
215
216 wxHtmlHelpData::wxHtmlHelpData()
217 {
218 m_TempPath = wxEmptyString;
219
220 m_Contents = NULL;
221 m_ContentsCnt = 0;
222 m_Index = NULL;
223 m_IndexCnt = 0;
224 }
225
226 wxHtmlHelpData::~wxHtmlHelpData()
227 {
228 int i;
229
230 m_BookRecords.Empty();
231 if (m_Contents)
232 {
233 for (i = 0; i < m_ContentsCnt; i++)
234 {
235 delete[] m_Contents[i].m_Page;
236 delete[] m_Contents[i].m_Name;
237 }
238 free(m_Contents);
239 }
240 if (m_Index)
241 {
242 for (i = 0; i < m_IndexCnt; i++)
243 {
244 delete[] m_Index[i].m_Page;
245 delete[] m_Index[i].m_Name;
246 }
247 free(m_Index);
248 }
249 }
250
251 bool wxHtmlHelpData::LoadMSProject(wxHtmlBookRecord *book, wxFileSystem& fsys, const wxString& indexfile, const wxString& contentsfile)
252 {
253 wxFSFile *f;
254 char *buf;
255 int sz;
256 wxString string;
257
258 HP_Parser parser;
259 HP_TagHandler *handler = new HP_TagHandler(book);
260 parser.AddTagHandler(handler);
261
262 f = ( contentsfile.IsEmpty() ? (wxFSFile*) NULL : fsys.OpenFile(contentsfile) );
263 if (f)
264 {
265 sz = f->GetStream()->GetSize();
266 buf = new char[sz + 1];
267 buf[sz] = 0;
268 f->GetStream()->Read(buf, sz);
269 delete f;
270 handler->ReadIn(m_Contents, m_ContentsCnt);
271 parser.Parse(buf);
272 handler->WriteOut(m_Contents, m_ContentsCnt);
273 delete[] buf;
274 }
275 else
276 wxLogError(_("Cannot open contents file: %s"), contentsfile.c_str());
277
278 f = ( indexfile.IsEmpty() ? (wxFSFile*) NULL : fsys.OpenFile(indexfile) );
279 if (f)
280 {
281 sz = f->GetStream()->GetSize();
282 buf = new char[sz + 1];
283 buf[sz] = 0;
284 f->GetStream()->Read(buf, sz);
285 delete f;
286 handler->ReadIn(m_Index, m_IndexCnt);
287 parser.Parse(buf);
288 handler->WriteOut(m_Index, m_IndexCnt);
289 delete[] buf;
290 }
291 else if (!indexfile.IsEmpty())
292 wxLogError(_("Cannot open index file: %s"), indexfile.c_str());
293 return TRUE;
294 }
295
296
297
298 inline static void CacheWriteInt32(wxOutputStream *f, wxInt32 value)
299 {
300 wxInt32 x = wxINT32_SWAP_ON_BE(value);
301 f->Write(&x, sizeof(x));
302 }
303
304 inline static wxInt32 CacheReadInt32(wxInputStream *f)
305 {
306 wxInt32 x;
307 f->Read(&x, sizeof(x));
308 return wxINT32_SWAP_ON_BE(x);
309 }
310
311 inline static void CacheWriteString(wxOutputStream *f, const wxChar *str)
312 {
313 size_t len = wxStrlen(str)+1;
314 CacheWriteInt32(f, len);
315 f->Write(str, len * sizeof(wxChar));
316 }
317
318 inline static wxChar *CacheReadString(wxInputStream *f)
319 {
320 wxChar *str;
321 size_t len = (size_t)CacheReadInt32(f);
322 str = new wxChar[len];
323 f->Read(str, len * sizeof(wxChar));
324 return str;
325 }
326
327 #define CURRENT_CACHED_BOOK_VERSION 2
328
329 bool wxHtmlHelpData::LoadCachedBook(wxHtmlBookRecord *book, wxInputStream *f)
330 {
331 int i, st;
332 wxInt32 version;
333
334 /* load header - version info : */
335 version = CacheReadInt32(f);
336
337 if (version != CURRENT_CACHED_BOOK_VERSION)
338 {
339 // NB: We can just silently return FALSE here and don't worry about
340 // it anymore, because AddBookParam will load the MS project in
341 // absence of (properly versioned) .cached file and automatically
342 // create new .cached file immediately afterward.
343 return FALSE;
344 }
345
346 /* load contents : */
347 st = m_ContentsCnt;
348 m_ContentsCnt += CacheReadInt32(f);
349 m_Contents = (wxHtmlContentsItem*) realloc(m_Contents,
350 (m_ContentsCnt / wxHTML_REALLOC_STEP + 1) *
351 wxHTML_REALLOC_STEP * sizeof(wxHtmlContentsItem));
352 for (i = st; i < m_ContentsCnt; i++)
353 {
354 m_Contents[i].m_Level = CacheReadInt32(f);
355 m_Contents[i].m_ID = CacheReadInt32(f);
356 m_Contents[i].m_Name = CacheReadString(f);
357 m_Contents[i].m_Page = CacheReadString(f);
358 m_Contents[i].m_Book = book;
359 }
360
361 /* load index : */
362 st = m_IndexCnt;
363 m_IndexCnt += CacheReadInt32(f);
364 m_Index = (wxHtmlContentsItem*) realloc(m_Index, (m_IndexCnt / wxHTML_REALLOC_STEP + 1) *
365 wxHTML_REALLOC_STEP * sizeof(wxHtmlContentsItem));
366 for (i = st; i < m_IndexCnt; i++)
367 {
368 m_Index[i].m_Name = CacheReadString(f);
369 m_Index[i].m_Page = CacheReadString(f);
370 m_Index[i].m_Book = book;
371 }
372 return TRUE;
373 }
374
375
376 bool wxHtmlHelpData::SaveCachedBook(wxHtmlBookRecord *book, wxOutputStream *f)
377 {
378 int i;
379 wxInt32 cnt;
380
381 /* save header - version info : */
382 CacheWriteInt32(f, CURRENT_CACHED_BOOK_VERSION);
383
384 /* save contents : */
385 for (cnt = 0, i = 0; i < m_ContentsCnt; i++)
386 if (m_Contents[i].m_Book == book && m_Contents[i].m_Level > 0)
387 cnt++;
388 CacheWriteInt32(f, cnt);
389
390 for (i = 0; i < m_ContentsCnt; i++)
391 {
392 if (m_Contents[i].m_Book != book || m_Contents[i].m_Level == 0)
393 continue;
394 CacheWriteInt32(f, m_Contents[i].m_Level);
395 CacheWriteInt32(f, m_Contents[i].m_ID);
396 CacheWriteString(f, m_Contents[i].m_Name);
397 CacheWriteString(f, m_Contents[i].m_Page);
398 }
399
400 /* save index : */
401 for (cnt = 0, i = 0; i < m_IndexCnt; i++)
402 if (m_Index[i].m_Book == book && m_Index[i].m_Level > 0)
403 cnt++;
404 CacheWriteInt32(f, cnt);
405
406 for (i = 0; i < m_IndexCnt; i++)
407 {
408 if (m_Index[i].m_Book != book || m_Index[i].m_Level == 0)
409 continue;
410 CacheWriteString(f, m_Index[i].m_Name);
411 CacheWriteString(f, m_Index[i].m_Page);
412 }
413 return TRUE;
414 }
415
416
417 void wxHtmlHelpData::SetTempDir(const wxString& path)
418 {
419 if (path == wxEmptyString) m_TempPath = path;
420 else
421 {
422 if (wxIsAbsolutePath(path)) m_TempPath = path;
423 else m_TempPath = wxGetCwd() + _T("/") + path;
424
425 if (m_TempPath[m_TempPath.Length() - 1] != _T('/'))
426 m_TempPath << _T('/');
427 }
428 }
429
430
431
432 static wxString SafeFileName(const wxString& s)
433 {
434 wxString res(s);
435 res.Replace(wxT("#"), wxT("_"));
436 res.Replace(wxT(":"), wxT("_"));
437 res.Replace(wxT("\\"), wxT("_"));
438 res.Replace(wxT("/"), wxT("_"));
439 return res;
440 }
441
442 bool wxHtmlHelpData::AddBookParam(const wxFSFile& bookfile,
443 wxFontEncoding encoding,
444 const wxString& title, const wxString& contfile,
445 const wxString& indexfile, const wxString& deftopic,
446 const wxString& path)
447 {
448 wxFileSystem fsys;
449 wxFSFile *fi;
450 wxHtmlBookRecord *bookr;
451
452 int IndexOld = m_IndexCnt,
453 ContentsOld = m_ContentsCnt;
454
455 if (! path.IsEmpty())
456 fsys.ChangePathTo(path, TRUE);
457
458 bookr = new wxHtmlBookRecord(fsys.GetPath(), title, deftopic);
459
460 if (m_ContentsCnt % wxHTML_REALLOC_STEP == 0)
461 m_Contents = (wxHtmlContentsItem*) realloc(m_Contents, (m_ContentsCnt + wxHTML_REALLOC_STEP) * sizeof(wxHtmlContentsItem));
462 m_Contents[m_ContentsCnt].m_Level = 0;
463 m_Contents[m_ContentsCnt].m_ID = 0;
464 m_Contents[m_ContentsCnt].m_Page = new wxChar[deftopic.Length() + 1];
465 wxStrcpy(m_Contents[m_ContentsCnt].m_Page, deftopic.c_str());
466 m_Contents[m_ContentsCnt].m_Name = new wxChar [title.Length() + 1];
467 wxStrcpy(m_Contents[m_ContentsCnt].m_Name, title.c_str());
468 m_Contents[m_ContentsCnt].m_Book = bookr;
469
470 // store the contents index for later
471 int cont_start = m_ContentsCnt++;
472
473 // Try to find cached binary versions:
474 // 1. save file as book, but with .hhp.cached extension
475 // 2. same as 1. but in temp path
476 // 3. otherwise or if cache load failed, load it from MS.
477
478 fi = fsys.OpenFile(bookfile.GetLocation() + wxT(".cached"));
479
480 if (fi == NULL ||
481 fi->GetModificationTime() < bookfile.GetModificationTime() ||
482 !LoadCachedBook(bookr, fi->GetStream()))
483 {
484 if (fi != NULL) delete fi;
485 fi = fsys.OpenFile(m_TempPath + wxFileNameFromPath(bookfile.GetLocation()) + wxT(".cached"));
486 if (m_TempPath == wxEmptyString || fi == NULL ||
487 fi->GetModificationTime() < bookfile.GetModificationTime() ||
488 !LoadCachedBook(bookr, fi->GetStream()))
489 {
490 LoadMSProject(bookr, fsys, indexfile, contfile);
491 if (m_TempPath != wxEmptyString)
492 {
493 wxFileOutputStream *outs = new wxFileOutputStream(m_TempPath +
494 SafeFileName(wxFileNameFromPath(bookfile.GetLocation())) + wxT(".cached"));
495 SaveCachedBook(bookr, outs);
496 delete outs;
497 }
498 }
499 }
500
501 if (fi != NULL) delete fi;
502
503 // Now store the contents range
504 bookr->SetContentsRange(cont_start, m_ContentsCnt);
505
506 // Convert encoding, if neccessary:
507 if (encoding != wxFONTENCODING_SYSTEM)
508 {
509 wxFontEncodingArray a = wxEncodingConverter::GetPlatformEquivalents(encoding);
510 if (a.GetCount() != 0 && a[0] != encoding)
511 {
512 int i;
513 wxEncodingConverter conv;
514 conv.Init(encoding, a[0]);
515
516 for (i = IndexOld; i < m_IndexCnt; i++)
517 conv.Convert(m_Index[i].m_Name);
518 for (i = ContentsOld; i < m_ContentsCnt; i++)
519 conv.Convert(m_Contents[i].m_Name);
520 }
521 }
522
523 m_BookRecords.Add(bookr);
524 if (m_IndexCnt > 0)
525 qsort(m_Index, m_IndexCnt, sizeof(wxHtmlContentsItem), wxHtmlHelpIndexCompareFunc);
526
527 return TRUE;
528 }
529
530
531 bool wxHtmlHelpData::AddBook(const wxString& book)
532 {
533 if (book.Right(4).Lower() == wxT(".zip") ||
534 book.Right(4).Lower() == wxT(".htb") /*html book*/)
535 {
536 wxFileSystem fsys;
537 wxString s;
538 bool rt = FALSE;
539
540 s = fsys.FindFirst(book + wxT("#zip:") + wxT("*.hhp"), wxFILE);
541 while (!s.IsEmpty())
542 {
543 if (AddBook(s)) rt = TRUE;
544 s = fsys.FindNext();
545 }
546
547 return rt;
548 }
549 else
550 {
551 wxFSFile *fi;
552 wxFileSystem fsys;
553 wxInputStream *s;
554 wxString bookFull;
555
556 wxString title = _("noname"),
557 safetitle,
558 start = wxEmptyString,
559 contents = wxEmptyString,
560 index = wxEmptyString,
561 charset = wxEmptyString;
562
563 #if defined(__WXMAC__) && !defined(__DARWIN__)
564 if (wxIsAbsolutePath(book)) bookFull = book;
565 else bookFull = wxGetCwd() + book; // no slash or dot
566 wxFileName fn( bookFull );
567 bookFull = fn.GetFullPath( wxPATH_UNIX );
568 #else
569 if (wxIsAbsolutePath(book)) bookFull = book;
570 else bookFull = wxGetCwd() + "/" + book;
571 #endif
572
573 fi = fsys.OpenFile(bookFull);
574 if (fi == NULL)
575 {
576 wxLogError(_("Cannot open HTML help book: %s"), bookFull.c_str());
577 return FALSE;
578 }
579 fsys.ChangePathTo(bookFull);
580 s = fi->GetStream();
581
582 int sz;
583 char *buff, *lineptr;
584 char linebuf[300];
585
586 sz = s->GetSize();
587 buff = new char[sz + 1];
588 buff[sz] = 0;
589 s->Read(buff, sz);
590 lineptr = buff;
591
592 do
593 {
594 lineptr = ReadLine(lineptr, linebuf, 300);
595
596 for (char *ch = linebuf; *ch != '\0' && *ch != '='; ch++)
597 *ch = tolower(*ch);
598
599 if (strstr(linebuf, "title=") == linebuf)
600 title = linebuf + strlen("title=");
601 if (strstr(linebuf, "default topic=") == linebuf)
602 start = linebuf + strlen("default topic=");
603 if (strstr(linebuf, "index file=") == linebuf)
604 index = linebuf + strlen("index file=");
605 if (strstr(linebuf, "contents file=") == linebuf)
606 contents = linebuf + strlen("contents file=");
607 if (strstr(linebuf, "charset=") == linebuf)
608 charset = linebuf + strlen("charset=");
609 } while (lineptr != NULL);
610 delete[] buff;
611
612 wxFontEncoding enc;
613 if (charset == wxEmptyString) enc = wxFONTENCODING_SYSTEM;
614 else enc = wxTheFontMapper->CharsetToEncoding(charset);
615 bool rtval = AddBookParam(*fi, enc,
616 title, contents, index, start, fsys.GetPath());
617 delete fi;
618 return rtval;
619 }
620 }
621
622 wxString wxHtmlHelpData::FindPageByName(const wxString& x)
623 {
624 int cnt;
625 int i;
626 wxFileSystem fsys;
627 wxFSFile *f;
628 wxString url(wxEmptyString);
629
630 /* 1. try to open given file: */
631
632 cnt = m_BookRecords.GetCount();
633 for (i = 0; i < cnt; i++)
634 {
635 f = fsys.OpenFile(m_BookRecords[i].GetFullPath(x));
636 if (f)
637 {
638 url = m_BookRecords[i].GetFullPath(x);
639 delete f;
640 return url;
641 }
642 }
643
644
645 /* 2. try to find a book: */
646
647 for (i = 0; i < cnt; i++)
648 {
649 if (m_BookRecords[i].GetTitle() == x)
650 {
651 url = m_BookRecords[i].GetFullPath(m_BookRecords[i].GetStart());
652 return url;
653 }
654 }
655
656 /* 3. try to find in contents: */
657
658 cnt = m_ContentsCnt;
659 for (i = 0; i < cnt; i++)
660 {
661 if (wxStrcmp(m_Contents[i].m_Name, x) == 0)
662 {
663 url = m_Contents[i].GetFullPath();
664 return url;
665 }
666 }
667
668
669 /* 4. try to find in index: */
670
671 cnt = m_IndexCnt;
672 for (i = 0; i < cnt; i++)
673 {
674 if (wxStrcmp(m_Index[i].m_Name, x) == 0)
675 {
676 url = m_Index[i].GetFullPath();
677 return url;
678 }
679 }
680
681 return url;
682 }
683
684 wxString wxHtmlHelpData::FindPageById(int id)
685 {
686 int i;
687 wxString url(wxEmptyString);
688
689 for (i = 0; i < m_ContentsCnt; i++)
690 {
691 if (m_Contents[i].m_ID == id)
692 {
693 url = m_Contents[i].GetFullPath();
694 return url;
695 }
696 }
697
698 return url;
699 }
700
701 //----------------------------------------------------------------------------------
702 // wxHtmlSearchStatus functions
703 //----------------------------------------------------------------------------------
704
705 wxHtmlSearchStatus::wxHtmlSearchStatus(wxHtmlHelpData* data, const wxString& keyword,
706 bool case_sensitive, bool whole_words_only,
707 const wxString& book)
708 {
709 m_Data = data;
710 m_Keyword = keyword;
711 wxHtmlBookRecord* bookr = NULL;
712 if (book != wxEmptyString)
713 {
714 // we have to search in a specific book. Find it first
715 int i, cnt = data->m_BookRecords.GetCount();
716 for (i = 0; i < cnt; i++)
717 if (data->m_BookRecords[i].GetTitle() == book)
718 {
719 bookr = &(data->m_BookRecords[i]);
720 m_CurIndex = bookr->GetContentsStart();
721 m_MaxIndex = bookr->GetContentsEnd();
722 break;
723 }
724 // check; we won't crash if the book doesn't exist, but it's Bad Anyway.
725 wxASSERT(bookr);
726 }
727 if (! bookr)
728 {
729 // no book specified; search all books
730 m_CurIndex = 0;
731 m_MaxIndex = m_Data->m_ContentsCnt;
732 }
733 m_Engine.LookFor(keyword, case_sensitive, whole_words_only);
734 m_Active = (m_CurIndex < m_MaxIndex);
735 m_LastPage = NULL;
736 }
737
738 bool wxHtmlSearchStatus::Search()
739 {
740 wxFSFile *file;
741 int i = m_CurIndex; // shortcut
742 bool found = FALSE;
743 wxChar *thepage;
744
745 if (!m_Active)
746 {
747 // sanity check. Illegal use, but we'll try to prevent a crash anyway
748 wxASSERT(m_Active);
749 return FALSE;
750 }
751
752 m_Name = wxEmptyString;
753 m_ContentsItem = NULL;
754 thepage = m_Data->m_Contents[i].m_Page;
755
756 m_Active = (++m_CurIndex < m_MaxIndex);
757 // check if it is same page with different anchor:
758 if (m_LastPage != NULL)
759 {
760 wxChar *p1, *p2;
761 for (p1 = thepage, p2 = m_LastPage;
762 *p1 != 0 && *p1 != _T('#') && *p1 == *p2; p1++, p2++) {}
763
764 m_LastPage = thepage;
765
766 if (*p1 == 0 || *p1 == _T('#'))
767 return FALSE;
768 }
769 else m_LastPage = thepage;
770
771 wxFileSystem fsys;
772 file = fsys.OpenFile(m_Data->m_Contents[i].m_Book->GetFullPath(thepage));
773 if (file)
774 {
775 if (m_Engine.Scan(file->GetStream()))
776 {
777 m_Name = m_Data->m_Contents[i].m_Name;
778 m_ContentsItem = m_Data->m_Contents + i;
779 found = TRUE;
780 }
781 delete file;
782 }
783 return found;
784 }
785
786
787
788
789
790
791
792
793 //--------------------------------------------------------------------------------
794 // wxSearchEngine
795 //--------------------------------------------------------------------------------
796
797 void wxSearchEngine::LookFor(const wxString& keyword, bool case_sensitive, bool whole_words_only)
798 {
799 m_CaseSensitive = case_sensitive;
800 m_WholeWords = whole_words_only;
801 if (m_Keyword) delete[] m_Keyword;
802 m_Keyword = new wxChar[keyword.Length() + 1];
803 wxStrcpy(m_Keyword, keyword.c_str());
804
805 if (!m_CaseSensitive)
806 {
807 for (int i = wxStrlen(m_Keyword) - 1; i >= 0; i--)
808 {
809 if ((m_Keyword[i] >= wxT('A')) && (m_Keyword[i] <= wxT('Z')))
810 m_Keyword[i] += wxT('a') - wxT('A');
811 }
812 }
813 }
814
815
816
817 #define WHITESPACE(c) (c == ' ' || c == '\n' || c == '\r' || c == '\t')
818
819 bool wxSearchEngine::Scan(wxInputStream *stream)
820 {
821 wxASSERT_MSG(m_Keyword != NULL, wxT("wxSearchEngine::LookFor must be called before scanning!"));
822
823 int i, j;
824 int lng = stream ->GetSize();
825 int wrd = wxStrlen(m_Keyword);
826 bool found = FALSE;
827 char *buf = new char[lng + 1];
828 stream->Read(buf, lng);
829 buf[lng] = 0;
830
831 if (!m_CaseSensitive)
832 for (i = 0; i < lng; i++)
833 if ((buf[i] >= 'A') && (buf[i] <= 'Z')) buf[i] += 'a' - 'A';
834
835 if (m_WholeWords)
836 {
837 for (i = 0; i < lng - wrd; i++)
838 {
839 if (WHITESPACE(buf[i])) continue;
840 j = 0;
841 while ((j < wrd) && (buf[i + j] == m_Keyword[j])) j++;
842 if (j == wrd && WHITESPACE(buf[i + j])) { found = TRUE; break; }
843 }
844 }
845
846 else
847 {
848 for (i = 0; i < lng - wrd; i++)
849 {
850 j = 0;
851 while ((j < wrd) && (buf[i + j] == m_Keyword[j])) j++;
852 if (j == wrd) { found = TRUE; break; }
853 }
854 }
855
856 delete[] buf;
857 return found;
858 }
859
860
861
862 #endif