]> git.saurik.com Git - wxWidgets.git/blob - src/html/helpdata.cpp
fixed HTML parsing in regard to spaces between tags
[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)
52 {
53 char *writeptr = buf, *readptr = line;
54
55 while (*readptr != 0 && *readptr != '\r' && *readptr != '\n') *(writeptr++) = *(readptr++);
56 *writeptr = 0;
57 while (*readptr == '\r' || *readptr == '\n') readptr++;
58 if (*readptr == 0) return NULL;
59 else return readptr;
60 }
61
62
63
64 static int LINKAGEMODE IndexCompareFunc(const void *a, const void *b)
65 {
66 return wxStrcmp(((wxHtmlContentsItem*)a)->m_Name, ((wxHtmlContentsItem*)b)->m_Name);
67 }
68
69
70 //-----------------------------------------------------------------------------
71 // HP_Parser
72 //-----------------------------------------------------------------------------
73
74 class HP_Parser : public wxHtmlParser
75 {
76 public:
77 wxObject* GetProduct() { return NULL; }
78 protected:
79 virtual void AddText(const wxChar* WXUNUSED(txt)) {}
80 };
81
82
83 //-----------------------------------------------------------------------------
84 // HP_TagHandler
85 //-----------------------------------------------------------------------------
86
87 class HP_TagHandler : public wxHtmlTagHandler
88 {
89 private:
90 wxString m_Name, m_Page;
91 int m_Level;
92 int m_ID;
93 int m_Index;
94 wxHtmlContentsItem *m_Items;
95 int m_ItemsCnt;
96 wxHtmlBookRecord *m_Book;
97
98 public:
99 HP_TagHandler(wxHtmlBookRecord *b) : wxHtmlTagHandler()
100 { m_Book = b; m_Items = NULL; m_ItemsCnt = 0; m_Name = m_Page = wxEmptyString;
101 m_Level = 0; m_ID = -1; }
102 wxString GetSupportedTags() { return wxT("UL,OBJECT,PARAM"); }
103 bool HandleTag(const wxHtmlTag& tag);
104 void WriteOut(wxHtmlContentsItem*& array, int& size);
105 void ReadIn(wxHtmlContentsItem* array, int size);
106 };
107
108
109 bool HP_TagHandler::HandleTag(const wxHtmlTag& tag)
110 {
111 if (tag.GetName() == wxT("UL"))
112 {
113 m_Level++;
114 ParseInner(tag);
115 m_Level--;
116 return TRUE;
117 }
118 else if (tag.GetName() == wxT("OBJECT"))
119 {
120 m_Name = m_Page = wxEmptyString;
121 ParseInner(tag);
122
123 #if 0
124 if (!m_Page.IsEmpty())
125 /* Valid HHW's file may contain only two object tags:
126
127 <OBJECT type="text/site properties">
128 <param name="ImageType" value="Folder">
129 </OBJECT>
130
131 or
132
133 <OBJECT type="text/sitemap">
134 <param name="Name" value="main page">
135 <param name="Local" value="another.htm">
136 </OBJECT>
137
138 We're interested in the latter. !m_Page.IsEmpty() is valid
139 condition because text/site properties does not contain Local param
140 */
141 #endif
142 if (tag.GetParam(wxT("TYPE")) == wxT("text/sitemap"))
143 {
144 if (m_ItemsCnt % wxHTML_REALLOC_STEP == 0)
145 m_Items = (wxHtmlContentsItem*) realloc(m_Items,
146 (m_ItemsCnt + wxHTML_REALLOC_STEP) *
147 sizeof(wxHtmlContentsItem));
148
149 m_Items[m_ItemsCnt].m_Level = m_Level;
150 m_Items[m_ItemsCnt].m_ID = m_ID;
151 m_Items[m_ItemsCnt].m_Page = new wxChar[m_Page.Length() + 1];
152 wxStrcpy(m_Items[m_ItemsCnt].m_Page, m_Page.c_str());
153 m_Items[m_ItemsCnt].m_Name = new wxChar [m_Name.Length() + 1];
154 wxStrcpy(m_Items[m_ItemsCnt].m_Name, m_Name.c_str());
155 m_Items[m_ItemsCnt].m_Book = m_Book;
156 m_ItemsCnt++;
157 }
158
159 return TRUE;
160 }
161 else
162 { // "PARAM"
163 if (m_Name == wxEmptyString && tag.GetParam(wxT("NAME")) == wxT("Name"))
164 m_Name = tag.GetParam(wxT("VALUE"));
165 if (tag.GetParam(wxT("NAME")) == wxT("Local"))
166 m_Page = tag.GetParam(wxT("VALUE"));
167 if (tag.GetParam(wxT("NAME")) == wxT("ID"))
168 tag.GetParamAsInt(wxT("VALUE"), &m_ID);
169 return FALSE;
170 }
171 }
172
173
174
175 void HP_TagHandler::WriteOut(wxHtmlContentsItem*& array, int& size)
176 {
177 array = m_Items;
178 size = m_ItemsCnt;
179 m_Items = NULL;
180 m_ItemsCnt = 0;
181 }
182
183 void HP_TagHandler::ReadIn(wxHtmlContentsItem* array, int size)
184 {
185 m_Items = array;
186 m_ItemsCnt = size;
187 }
188
189
190
191
192 //-----------------------------------------------------------------------------
193 // wxHtmlHelpData
194 //-----------------------------------------------------------------------------
195
196 wxString wxHtmlBookRecord::GetFullPath(const wxString &page) const
197 {
198 if (wxIsAbsolutePath(page))
199 return page;
200 else
201 return m_BasePath + page;
202 }
203
204
205
206 IMPLEMENT_DYNAMIC_CLASS(wxHtmlHelpData, wxObject)
207
208 wxHtmlHelpData::wxHtmlHelpData()
209 {
210 m_TempPath = wxEmptyString;
211
212 m_Contents = NULL;
213 m_ContentsCnt = 0;
214 m_Index = NULL;
215 m_IndexCnt = 0;
216 }
217
218 wxHtmlHelpData::~wxHtmlHelpData()
219 {
220 int i;
221
222 m_BookRecords.Empty();
223 if (m_Contents)
224 {
225 for (i = 0; i < m_ContentsCnt; i++)
226 {
227 delete[] m_Contents[i].m_Page;
228 delete[] m_Contents[i].m_Name;
229 }
230 free(m_Contents);
231 }
232 if (m_Index)
233 {
234 for (i = 0; i < m_IndexCnt; i++)
235 {
236 delete[] m_Index[i].m_Page;
237 delete[] m_Index[i].m_Name;
238 }
239 free(m_Index);
240 }
241 }
242
243 bool wxHtmlHelpData::LoadMSProject(wxHtmlBookRecord *book, wxFileSystem& fsys, const wxString& indexfile, const wxString& contentsfile)
244 {
245 wxFSFile *f;
246 char *buf;
247 int sz;
248 wxString string;
249
250 HP_Parser parser;
251 HP_TagHandler *handler = new HP_TagHandler(book);
252 parser.AddTagHandler(handler);
253
254 f = ( contentsfile.IsEmpty() ? (wxFSFile*) NULL : fsys.OpenFile(contentsfile) );
255 if (f)
256 {
257 sz = f->GetStream()->GetSize();
258 buf = new char[sz + 1];
259 buf[sz] = 0;
260 f->GetStream()->Read(buf, sz);
261 delete f;
262 handler->ReadIn(m_Contents, m_ContentsCnt);
263 parser.Parse(buf);
264 handler->WriteOut(m_Contents, m_ContentsCnt);
265 delete[] buf;
266 }
267 else
268 wxLogError(_("Cannot open contents file: %s"), contentsfile.c_str());
269
270 f = ( indexfile.IsEmpty() ? (wxFSFile*) NULL : fsys.OpenFile(indexfile) );
271 if (f)
272 {
273 sz = f->GetStream()->GetSize();
274 buf = new char[sz + 1];
275 buf[sz] = 0;
276 f->GetStream()->Read(buf, sz);
277 delete f;
278 handler->ReadIn(m_Index, m_IndexCnt);
279 parser.Parse(buf);
280 handler->WriteOut(m_Index, m_IndexCnt);
281 delete[] buf;
282 }
283 else if (!indexfile.IsEmpty())
284 wxLogError(_("Cannot open index file: %s"), indexfile.c_str());
285 return TRUE;
286 }
287
288
289
290
291 #if wxUSE_UNICODE
292
293 #define READ_STRING(f, s, lng) { char tmpc; for (int i = 0; i < lng; i++) { f->Read(&tmpc, 1); s[i] = (wxChar)tmpc;} }
294 #define WRITE_STRING(f, s, lng) { char tmpc; for (int i = 0; i < lng; i++) { tmpc = (char)s[i]; f->Write(&tmpc, 1);} }
295
296 #else
297
298 #define READ_STRING(f, s, lng) f->Read(s, lng * sizeof(char));
299 #define WRITE_STRING(f, s, lng) f->Write(s, lng * sizeof(char));
300
301 #endif
302
303
304 #define CURRENT_CACHED_BOOK_VERSION 1
305
306 bool wxHtmlHelpData::LoadCachedBook(wxHtmlBookRecord *book, wxInputStream *f)
307 {
308 int i, st;
309 wxInt32 x;
310 wxInt32 version;
311
312 /* load header - version info : */
313
314 f->Read(&x, sizeof(x));
315 version = wxINT32_SWAP_ON_BE(x);
316
317 if (version != CURRENT_CACHED_BOOK_VERSION)
318 {
319 wxLogError(_("Incorrect version of HTML help book"));
320 return FALSE;
321 // NOTE: when adding new version, please ensure backward compatibility!
322 }
323
324 /* load contents : */
325
326 f->Read(&x, sizeof(x));
327 st = m_ContentsCnt;
328 m_ContentsCnt += wxINT32_SWAP_ON_BE(x);
329 m_Contents = (wxHtmlContentsItem*) realloc(m_Contents,
330 (m_ContentsCnt / wxHTML_REALLOC_STEP + 1) *
331 wxHTML_REALLOC_STEP * sizeof(wxHtmlContentsItem));
332 for (i = st; i < m_ContentsCnt; i++)
333 {
334 f->Read(&x, sizeof(x));
335 m_Contents[i].m_Level = wxINT32_SWAP_ON_BE(x);
336 f->Read(&x, sizeof(x));
337 m_Contents[i].m_ID = wxINT32_SWAP_ON_BE(x);
338 f->Read(&x, sizeof(x)); x = wxINT32_SWAP_ON_BE(x);
339 m_Contents[i].m_Name = new wxChar[x];
340 READ_STRING(f, m_Contents[i].m_Name, x);
341 f->Read(&x, sizeof(x)); x = wxINT32_SWAP_ON_BE(x);
342 m_Contents[i].m_Page = new wxChar[x];
343 READ_STRING(f, m_Contents[i].m_Page, x);
344 m_Contents[i].m_Book = book;
345 }
346
347 /* load index : */
348
349 f->Read(&x, sizeof(x));
350 st = m_IndexCnt;
351 m_IndexCnt += wxINT32_SWAP_ON_BE(x);
352 m_Index = (wxHtmlContentsItem*) realloc(m_Index, (m_IndexCnt / wxHTML_REALLOC_STEP + 1) *
353 wxHTML_REALLOC_STEP * sizeof(wxHtmlContentsItem));
354 for (i = st; i < m_IndexCnt; i++)
355 {
356 f->Read(&x, sizeof(x)); x = wxINT32_SWAP_ON_BE(x);
357 m_Index[i].m_Name = new wxChar[x];
358 READ_STRING(f, m_Index[i].m_Name, x);
359 f->Read(&x, sizeof(x)); x = wxINT32_SWAP_ON_BE(x);
360 m_Index[i].m_Page = new wxChar[x];
361 READ_STRING(f, m_Index[i].m_Page, x);
362 m_Index[i].m_Book = book;
363 }
364 return TRUE;
365 }
366
367
368 bool wxHtmlHelpData::SaveCachedBook(wxHtmlBookRecord *book, wxOutputStream *f)
369 {
370 int i;
371 wxInt32 x;
372
373 /* save header - version info : */
374
375 x = wxINT32_SWAP_ON_BE(CURRENT_CACHED_BOOK_VERSION);
376 f->Write(&x, sizeof(x));
377
378 /* save contents : */
379
380 x = 0;
381 for (i = 0; i < m_ContentsCnt; i++) if (m_Contents[i].m_Book == book && m_Contents[i].m_Level > 0) x++;
382 x = wxINT32_SWAP_ON_BE(x);
383 f->Write(&x, sizeof(x));
384 for (i = 0; i < m_ContentsCnt; i++)
385 {
386 if (m_Contents[i].m_Book != book || m_Contents[i].m_Level == 0) continue;
387 x = wxINT32_SWAP_ON_BE(m_Contents[i].m_Level);
388 f->Write(&x, sizeof(x));
389 x = wxINT32_SWAP_ON_BE(m_Contents[i].m_ID);
390 f->Write(&x, sizeof(x));
391 x = wxINT32_SWAP_ON_BE(wxStrlen(m_Contents[i].m_Name) + 1);
392 f->Write(&x, sizeof(x));
393 WRITE_STRING(f, m_Contents[i].m_Name, x);
394 x = wxINT32_SWAP_ON_BE(wxStrlen(m_Contents[i].m_Page) + 1);
395 f->Write(&x, sizeof(x));
396 WRITE_STRING(f, m_Contents[i].m_Page, x);
397 }
398
399 /* save index : */
400
401 x = 0;
402 for (i = 0; i < m_IndexCnt; i++) if (m_Index[i].m_Book == book && m_Index[i].m_Level > 0) x++;
403 x = wxINT32_SWAP_ON_BE(x);
404 f->Write(&x, sizeof(x));
405 for (i = 0; i < m_IndexCnt; i++)
406 {
407 if (m_Index[i].m_Book != book || m_Index[i].m_Level == 0) continue;
408 x = wxINT32_SWAP_ON_BE(wxStrlen(m_Index[i].m_Name) + 1);
409 f->Write(&x, sizeof(x));
410 WRITE_STRING(f, m_Index[i].m_Name, x);
411 x = wxINT32_SWAP_ON_BE(wxStrlen(m_Index[i].m_Page) + 1);
412 f->Write(&x, sizeof(x));
413 WRITE_STRING(f, m_Index[i].m_Page, x);
414 }
415 return TRUE;
416 }
417
418
419 void wxHtmlHelpData::SetTempDir(const wxString& path)
420 {
421 if (path == wxEmptyString) m_TempPath = path;
422 else
423 {
424 if (wxIsAbsolutePath(path)) m_TempPath = path;
425 else m_TempPath = wxGetCwd() + _T("/") + path;
426
427 if (m_TempPath[m_TempPath.Length() - 1] != _T('/'))
428 m_TempPath << _T('/');
429 }
430 }
431
432
433
434 static wxString SafeFileName(const wxString& s)
435 {
436 wxString res(s);
437 res.Replace(wxT("#"), wxT("_"));
438 res.Replace(wxT(":"), wxT("_"));
439 res.Replace(wxT("\\"), wxT("_"));
440 res.Replace(wxT("/"), wxT("_"));
441 return res;
442 }
443
444 bool wxHtmlHelpData::AddBookParam(const wxFSFile& bookfile,
445 wxFontEncoding encoding,
446 const wxString& title, const wxString& contfile,
447 const wxString& indexfile, const wxString& deftopic,
448 const wxString& path)
449 {
450 wxFileSystem fsys;
451 wxFSFile *fi;
452 wxHtmlBookRecord *bookr;
453
454 int IndexOld = m_IndexCnt,
455 ContentsOld = m_ContentsCnt;
456
457 if (! path.IsEmpty())
458 fsys.ChangePathTo(path, TRUE);
459
460 bookr = new wxHtmlBookRecord(fsys.GetPath(), title, deftopic);
461
462 if (m_ContentsCnt % wxHTML_REALLOC_STEP == 0)
463 m_Contents = (wxHtmlContentsItem*) realloc(m_Contents, (m_ContentsCnt + wxHTML_REALLOC_STEP) * sizeof(wxHtmlContentsItem));
464 m_Contents[m_ContentsCnt].m_Level = 0;
465 m_Contents[m_ContentsCnt].m_ID = 0;
466 m_Contents[m_ContentsCnt].m_Page = new wxChar[deftopic.Length() + 1];
467 wxStrcpy(m_Contents[m_ContentsCnt].m_Page, deftopic.c_str());
468 m_Contents[m_ContentsCnt].m_Name = new wxChar [title.Length() + 1];
469 wxStrcpy(m_Contents[m_ContentsCnt].m_Name, title.c_str());
470 m_Contents[m_ContentsCnt].m_Book = bookr;
471
472 // store the contents index for later
473 int cont_start = m_ContentsCnt++;
474
475 // Try to find cached binary versions:
476 // 1. save file as book, but with .hhp.cached extension
477 // 2. same as 1. but in temp path
478 // 3. otherwise or if cache load failed, load it from MS.
479
480 fi = fsys.OpenFile(bookfile.GetLocation() + wxT(".cached"));
481
482 if (fi == NULL ||
483 fi->GetModificationTime() < bookfile.GetModificationTime() ||
484 !LoadCachedBook(bookr, fi->GetStream()))
485 {
486 if (fi != NULL) delete fi;
487 fi = fsys.OpenFile(m_TempPath + wxFileNameFromPath(bookfile.GetLocation()) + wxT(".cached"));
488 if (m_TempPath == wxEmptyString || fi == NULL ||
489 fi->GetModificationTime() < bookfile.GetModificationTime() ||
490 !LoadCachedBook(bookr, fi->GetStream()))
491 {
492 LoadMSProject(bookr, fsys, indexfile, contfile);
493 if (m_TempPath != wxEmptyString)
494 {
495 wxFileOutputStream *outs = new wxFileOutputStream(m_TempPath +
496 SafeFileName(wxFileNameFromPath(bookfile.GetLocation())) + wxT(".cached"));
497 SaveCachedBook(bookr, outs);
498 delete outs;
499 }
500 }
501 }
502
503 if (fi != NULL) delete fi;
504
505 // Now store the contents range
506 bookr->SetContentsRange(cont_start, m_ContentsCnt);
507
508 // Convert encoding, if neccessary:
509 if (encoding != wxFONTENCODING_SYSTEM)
510 {
511 wxFontEncodingArray a = wxEncodingConverter::GetPlatformEquivalents(encoding);
512 if (a.GetCount() != 0 && a[0] != encoding)
513 {
514 int i;
515 wxEncodingConverter conv;
516 conv.Init(encoding, a[0]);
517
518 for (i = IndexOld; i < m_IndexCnt; i++)
519 conv.Convert(m_Index[i].m_Name);
520 for (i = ContentsOld; i < m_ContentsCnt; i++)
521 conv.Convert(m_Contents[i].m_Name);
522 }
523 }
524
525 m_BookRecords.Add(bookr);
526 if (m_IndexCnt > 0)
527 qsort(m_Index, m_IndexCnt, sizeof(wxHtmlContentsItem), IndexCompareFunc);
528
529 return TRUE;
530 }
531
532
533 bool wxHtmlHelpData::AddBook(const wxString& book)
534 {
535 if (book.Right(4).Lower() == wxT(".zip") ||
536 book.Right(4).Lower() == wxT(".htb") /*html book*/)
537
538 {
539 wxFileSystem fsys;
540 wxString s;
541 bool rt = FALSE;
542
543 s = fsys.FindFirst(book + wxT("#zip:") + wxT("*.hhp"), wxFILE);
544 while (!s.IsEmpty())
545 {
546 if (AddBook(s)) rt = TRUE;
547 s = fsys.FindNext();
548 }
549
550 return rt;
551 }
552
553
554 else
555 {
556 wxFSFile *fi;
557 wxFileSystem fsys;
558 wxInputStream *s;
559 wxString bookFull;
560
561 int sz;
562 char *buff, *lineptr;
563 char linebuf[300];
564
565 wxString title = _("noname"),
566 safetitle,
567 start = wxEmptyString,
568 contents = wxEmptyString,
569 index = wxEmptyString,
570 charset = wxEmptyString;
571
572 #ifdef __WXMAC__
573 if (wxIsAbsolutePath(book)) bookFull = book;
574 else bookFull = wxGetCwd() + book; // no slash or dot
575 wxFileName fn( bookFull );
576 bookFull = fn.GetFullPath( wxPATH_UNIX );
577 #else
578 if (wxIsAbsolutePath(book)) bookFull = book;
579 else bookFull = wxGetCwd() + "/" + book;
580 #endif
581
582 fi = fsys.OpenFile(bookFull);
583 if (fi == NULL)
584 {
585 wxLogError(_("Cannot open HTML help book: %s"), bookFull.c_str());
586 return FALSE;
587 }
588 fsys.ChangePathTo(bookFull);
589 s = fi->GetStream();
590 sz = s->GetSize();
591 buff = new char[sz + 1];
592 buff[sz] = 0;
593 s->Read(buff, sz);
594 lineptr = buff;
595
596 do {
597 lineptr = ReadLine(lineptr, linebuf);
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