]> git.saurik.com Git - wxWidgets.git/blob - src/html/helpdata.cpp
Added chapter on collection and container classes to contents
[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/wx.h"
29 #endif
30
31 #include "wx/html/helpdata.h"
32 #include "wx/tokenzr.h"
33 #include "wx/wfstream.h"
34 #include "wx/busyinfo.h"
35 #include "wx/encconv.h"
36 #include "wx/fontmap.h"
37 #include "wx/log.h"
38 #include "wx/html/htmlpars.h"
39 #include "wx/html/htmldefs.h"
40
41 #include "wx/arrimpl.cpp"
42 WX_DEFINE_OBJARRAY(wxHtmlBookRecArray)
43
44 //-----------------------------------------------------------------------------
45 // static helper functions
46 //-----------------------------------------------------------------------------
47
48 // Reads one line, stores it into buf and returns pointer to new line or NULL.
49 static char* ReadLine(char *line, char *buf)
50 {
51 char *writeptr = buf, *readptr = line;
52
53 while (*readptr != 0 && *readptr != '\r' && *readptr != '\n') *(writeptr++) = *(readptr++);
54 *writeptr = 0;
55 while (*readptr == '\r' || *readptr == '\n') readptr++;
56 if (*readptr == 0) return NULL;
57 else return readptr;
58 }
59
60
61
62 static int LINKAGEMODE IndexCompareFunc(const void *a, const void *b)
63 {
64 return wxStrcmp(((wxHtmlContentsItem*)a) -> m_Name, ((wxHtmlContentsItem*)b) -> m_Name);
65 }
66
67
68 //-----------------------------------------------------------------------------
69 // HP_Parser
70 //-----------------------------------------------------------------------------
71
72 class HP_Parser : public wxHtmlParser
73 {
74 public:
75 void AddText(const char* WXUNUSED(text)) { }
76 wxObject* GetProduct() { return NULL; }
77 };
78
79
80 //-----------------------------------------------------------------------------
81 // HP_TagHandler
82 //-----------------------------------------------------------------------------
83
84 class HP_TagHandler : public wxHtmlTagHandler
85 {
86 private:
87 wxString m_Name, m_Page;
88 int m_Level;
89 int m_ID;
90 int m_Index;
91 wxHtmlContentsItem *m_Items;
92 int m_ItemsCnt;
93 wxHtmlBookRecord *m_Book;
94
95 public:
96 HP_TagHandler(wxHtmlBookRecord *b) : wxHtmlTagHandler() {m_Book = b; m_Items = NULL; m_ItemsCnt = 0; m_Name = m_Page = wxEmptyString; m_Level = 0; m_ID = -1; }
97 wxString GetSupportedTags() { return wxT("UL,OBJECT,PARAM"); }
98 bool HandleTag(const wxHtmlTag& tag);
99 void WriteOut(wxHtmlContentsItem*& array, int& size);
100 void ReadIn(wxHtmlContentsItem* array, int size);
101 };
102
103
104 bool HP_TagHandler::HandleTag(const wxHtmlTag& tag)
105 {
106 if (tag.GetName() == wxT("UL")) {
107 m_Level++;
108 ParseInner(tag);
109 m_Level--;
110 return TRUE;
111 }
112 else if (tag.GetName() == wxT("OBJECT")) {
113 m_Name = m_Page = wxEmptyString;
114 ParseInner(tag);
115
116 if (!m_Page.IsEmpty())
117 /* should be 'if (tag.GetParam("TYPE") == "text/sitemap")'
118 but this works fine. Valid HHW's file may contain only two
119 object tags:
120
121 <OBJECT type="text/site properties">
122 <param name="ImageType" value="Folder">
123 </OBJECT>
124
125 or
126
127 <OBJECT type="text/sitemap">
128 <param name="Name" value="main page">
129 <param name="Local" value="another.htm">
130 </OBJECT>
131
132 We're interested in the latter. !m_Page.IsEmpty() is valid
133 condition because text/site properties does not contain Local param
134 */
135 {
136 if (m_ItemsCnt % wxHTML_REALLOC_STEP == 0)
137 m_Items = (wxHtmlContentsItem*) realloc(m_Items, (m_ItemsCnt + wxHTML_REALLOC_STEP) * sizeof(wxHtmlContentsItem));
138 m_Items[m_ItemsCnt].m_Level = m_Level;
139 m_Items[m_ItemsCnt].m_ID = m_ID;
140 m_Items[m_ItemsCnt].m_Page = new wxChar[m_Page.Length() + 1];
141 wxStrcpy(m_Items[m_ItemsCnt].m_Page, m_Page.c_str());
142 m_Items[m_ItemsCnt].m_Name = new wxChar [m_Name.Length() + 1];
143 wxStrcpy(m_Items[m_ItemsCnt].m_Name, m_Name.c_str());
144 m_Items[m_ItemsCnt].m_Book = m_Book;
145 m_ItemsCnt++;
146 }
147
148 return TRUE;
149 }
150 else { // "PARAM"
151 if (m_Name == wxEmptyString && tag.GetParam(wxT("NAME")) == wxT("Name"))
152 {
153 m_Name = tag.GetParam(wxT("VALUE"));
154 if (m_Name.Find(wxT('&')) != -1)
155 {
156 #define ESCSEQ(escape, subst) \
157 { _T("&") _T(escape) _T(";"), _T("&") _T(escape) _T(" "), _T(subst) }
158 static wxChar* substitutions[][3] =
159 {
160 ESCSEQ("quot", "\""),
161 ESCSEQ("lt", "<"),
162 ESCSEQ("gt", ">"),
163
164 ESCSEQ("nbsp", " "),
165 ESCSEQ("iexcl", "!"),
166 ESCSEQ("cent", "¢"),
167
168 ESCSEQ("yen", " "),
169 ESCSEQ("brkbar", " "),
170 ESCSEQ("sect", " "),
171 ESCSEQ("uml", " "),
172
173 ESCSEQ("copy", "(c)"),
174 ESCSEQ("ordf", " "),
175 ESCSEQ("laquo", " "),
176 ESCSEQ("not", " "),
177
178 ESCSEQ("reg", "(r)"),
179
180 ESCSEQ("deg", " "),
181 ESCSEQ("plusm", " "),
182
183 ESCSEQ("acute", " "),
184 ESCSEQ("micro", " "),
185 ESCSEQ("para", " "),
186
187 ESCSEQ("ordm", " "),
188 ESCSEQ("raquo", " "),
189
190 ESCSEQ("iquest", " "),
191 ESCSEQ("Agrave", "À"),
192
193 ESCSEQ("Acirc", "Â"),
194 ESCSEQ("Atilde", "Ã"),
195 ESCSEQ("Auml", "Ä"),
196 ESCSEQ("Aring", " "),
197 ESCSEQ("AElig", " "),
198 ESCSEQ("Ccedil", "ç"),
199 ESCSEQ("Egrave", "È"),
200 ESCSEQ("Eacute", "É"),
201 ESCSEQ("Ecirc", "Ê"),
202 ESCSEQ("Euml", "Ë"),
203 ESCSEQ("Igrave", "Ì"),
204
205 ESCSEQ("Icirc", "Î"),
206 ESCSEQ("Iuml", "Ï"),
207
208 ESCSEQ("Ntilde", "Ñ"),
209 ESCSEQ("Ograve", "Ò"),
210
211 ESCSEQ("Ocirc", "Ô"),
212 ESCSEQ("Otilde", "Õ"),
213 ESCSEQ("Ouml", "Ö"),
214
215 ESCSEQ("Oslash", " "),
216 ESCSEQ("Ugrave", "Ù"),
217
218 ESCSEQ("Ucirc", " "),
219 ESCSEQ("Uuml", "Ü"),
220
221 ESCSEQ("szlig", "§"),
222 ESCSEQ("agrave;","à"),
223 ESCSEQ("aacute", "á"),
224 ESCSEQ("acirc", "â"),
225 ESCSEQ("atilde", "ã"),
226 ESCSEQ("auml", "ä"),
227 ESCSEQ("aring", "a"),
228 ESCSEQ("aelig", "ae"),
229 ESCSEQ("ccedil", "ç"),
230 ESCSEQ("egrave", "è"),
231 ESCSEQ("eacute", "é"),
232 ESCSEQ("ecirc", "ê"),
233 ESCSEQ("euml", "ë"),
234 ESCSEQ("igrave", "ì"),
235 ESCSEQ("iacute", "í"),
236 ESCSEQ("icirc", " "),
237 ESCSEQ("iuml", "ï"),
238 ESCSEQ("eth", " "),
239 ESCSEQ("ntilde", "ñ"),
240 ESCSEQ("ograve", "ò"),
241 ESCSEQ("oacute", "ó"),
242 ESCSEQ("ocirc", "ô"),
243 ESCSEQ("otilde", "õ"),
244 ESCSEQ("ouml", "ö"),
245 ESCSEQ("divide", " "),
246 ESCSEQ("oslash", " "),
247 ESCSEQ("ugrave", "ù"),
248 ESCSEQ("uacute", "ú"),
249 ESCSEQ("ucirc", "û"),
250 ESCSEQ("uuml", "ü"),
251
252 ESCSEQ("yuml", ""),
253
254 /* this one should ALWAYS stay the last one!!! */
255 ESCSEQ("amp", "&"),
256
257 { NULL, NULL, NULL }
258 };
259
260 for (int i = 0; substitutions[i][0] != NULL; i++)
261 {
262 m_Name.Replace(substitutions[i][0], substitutions[i][2], TRUE);
263 m_Name.Replace(substitutions[i][1], substitutions[i][2], TRUE);
264 }
265 }
266 }
267 if (tag.GetParam(wxT("NAME")) == wxT("Local")) m_Page = tag.GetParam(wxT("VALUE"));
268 if (tag.GetParam(wxT("NAME")) == wxT("ID")) tag.ScanParam(wxT("VALUE"), wxT("%i"), &m_ID);
269 return FALSE;
270 }
271 }
272
273
274
275 void HP_TagHandler::WriteOut(wxHtmlContentsItem*& array, int& size)
276 {
277 array = m_Items;
278 size = m_ItemsCnt;
279 m_Items = NULL;
280 m_ItemsCnt = 0;
281 }
282
283 void HP_TagHandler::ReadIn(wxHtmlContentsItem* array, int size)
284 {
285 m_Items = array;
286 m_ItemsCnt = size;
287 }
288
289
290
291
292 //-----------------------------------------------------------------------------
293 // wxHtmlHelpData
294 //-----------------------------------------------------------------------------
295
296 IMPLEMENT_DYNAMIC_CLASS(wxHtmlHelpData, wxObject)
297
298 wxHtmlHelpData::wxHtmlHelpData()
299 {
300 m_TempPath = wxEmptyString;
301
302 m_Contents = NULL;
303 m_ContentsCnt = 0;
304 m_Index = NULL;
305 m_IndexCnt = 0;
306 }
307
308 wxHtmlHelpData::~wxHtmlHelpData()
309 {
310 int i;
311
312 m_BookRecords.Empty();
313 if (m_Contents) {
314 for (i = 0; i < m_ContentsCnt; i++) {
315 delete[] m_Contents[i].m_Page;
316 delete[] m_Contents[i].m_Name;
317 }
318 free(m_Contents);
319 }
320 if (m_Index) {
321 for (i = 0; i < m_IndexCnt; i++) {
322 delete[] m_Index[i].m_Page;
323 delete[] m_Index[i].m_Name;
324 }
325 free(m_Index);
326 }
327 }
328
329 bool wxHtmlHelpData::LoadMSProject(wxHtmlBookRecord *book, wxFileSystem& fsys, const wxString& indexfile, const wxString& contentsfile)
330 {
331 wxFSFile *f;
332 char *buf;
333 int sz;
334 wxString string;
335
336 HP_Parser parser;
337 HP_TagHandler *handler = new HP_TagHandler(book);
338 parser.AddTagHandler(handler);
339
340 f = ( contentsfile.IsEmpty() ? (wxFSFile*) NULL : fsys.OpenFile(contentsfile) );
341 if (f) {
342 sz = f -> GetStream() -> GetSize();
343 buf = new char[sz + 1];
344 buf[sz] = 0;
345 f -> GetStream() -> Read(buf, sz);
346 delete f;
347 handler -> ReadIn(m_Contents, m_ContentsCnt);
348 parser.Parse(buf);
349 handler -> WriteOut(m_Contents, m_ContentsCnt);
350 delete[] buf;
351 }
352 else
353 wxLogError(_("Cannot open contents file: %s"), contentsfile.c_str());
354
355 f = ( indexfile.IsEmpty() ? (wxFSFile*) NULL : fsys.OpenFile(indexfile) );
356 if (f) {
357 sz = f -> GetStream() -> GetSize();
358 buf = new char[sz + 1];
359 buf[sz] = 0;
360 f -> GetStream() -> Read(buf, sz);
361 delete f;
362 handler -> ReadIn(m_Index, m_IndexCnt);
363 parser.Parse(buf);
364 handler -> WriteOut(m_Index, m_IndexCnt);
365 delete[] buf;
366 }
367 else if (!indexfile.IsEmpty())
368 wxLogError(_("Cannot open index file: %s"), indexfile.c_str());
369 return TRUE;
370 }
371
372
373
374
375 #if wxUSE_UNICODE
376
377 #define READ_STRING(f, s, lng) { char tmpc; for (int i = 0; i < lng; i++) { f -> Read(&tmpc, 1); s[i] = (wxChar)tmpc;} }
378 #define WRITE_STRING(f, s, lng) { char tmpc; for (int i = 0; i < lng; i++) { tmpc = (char)s[i]; f -> Write(&tmpc, 1);} }
379
380 #else
381
382 #define READ_STRING(f, s, lng) f -> Read(s, lng * sizeof(char));
383 #define WRITE_STRING(f, s, lng) f -> Write(s, lng * sizeof(char));
384
385 #endif
386
387
388 #define CURRENT_CACHED_BOOK_VERSION 1
389
390 bool wxHtmlHelpData::LoadCachedBook(wxHtmlBookRecord *book, wxInputStream *f)
391 {
392 int i, st;
393 wxInt32 x;
394 wxInt32 version;
395
396 /* load header - version info : */
397
398 f -> Read(&x, sizeof(x));
399 version = wxINT32_SWAP_ON_BE(x);
400
401 if (version != CURRENT_CACHED_BOOK_VERSION)
402 {
403 wxLogError(_("Incorrect version of HTML help book"));
404 return FALSE;
405 // NOTE: when adding new version, please ensure backward compatibility!
406 }
407
408 /* load contents : */
409
410 f -> Read(&x, sizeof(x));
411 st = m_ContentsCnt;
412 m_ContentsCnt += wxINT32_SWAP_ON_BE(x);
413 m_Contents = (wxHtmlContentsItem*) realloc(m_Contents,
414 (m_ContentsCnt / wxHTML_REALLOC_STEP + 1) *
415 wxHTML_REALLOC_STEP * sizeof(wxHtmlContentsItem));
416 for (i = st; i < m_ContentsCnt; i++) {
417 f -> Read(&x, sizeof(x));
418 m_Contents[i].m_Level = wxINT32_SWAP_ON_BE(x);
419 f -> Read(&x, sizeof(x));
420 m_Contents[i].m_ID = wxINT32_SWAP_ON_BE(x);
421 f -> Read(&x, sizeof(x)); x = wxINT32_SWAP_ON_BE(x);
422 m_Contents[i].m_Name = new wxChar[x];
423 READ_STRING(f, m_Contents[i].m_Name, x);
424 f -> Read(&x, sizeof(x)); x = wxINT32_SWAP_ON_BE(x);
425 m_Contents[i].m_Page = new wxChar[x];
426 READ_STRING(f, m_Contents[i].m_Page, x);
427 m_Contents[i].m_Book = book;
428 }
429
430 /* load index : */
431
432 f -> Read(&x, sizeof(x));
433 st = m_IndexCnt;
434 m_IndexCnt += wxINT32_SWAP_ON_BE(x);
435 m_Index = (wxHtmlContentsItem*) realloc(m_Index, (m_IndexCnt / wxHTML_REALLOC_STEP + 1) *
436 wxHTML_REALLOC_STEP * sizeof(wxHtmlContentsItem));
437 for (i = st; i < m_IndexCnt; i++) {
438 f -> Read(&x, sizeof(x)); x = wxINT32_SWAP_ON_BE(x);
439 m_Index[i].m_Name = new wxChar[x];
440 READ_STRING(f, m_Index[i].m_Name, x);
441 f -> Read(&x, sizeof(x)); x = wxINT32_SWAP_ON_BE(x);
442 m_Index[i].m_Page = new wxChar[x];
443 READ_STRING(f, m_Index[i].m_Page, x);
444 m_Index[i].m_Book = book;
445 }
446 return TRUE;
447 }
448
449
450 bool wxHtmlHelpData::SaveCachedBook(wxHtmlBookRecord *book, wxOutputStream *f)
451 {
452 int i;
453 wxInt32 x;
454
455 /* save header - version info : */
456
457 x = wxINT32_SWAP_ON_BE(CURRENT_CACHED_BOOK_VERSION);
458 f -> Write(&x, sizeof(x));
459
460 /* save contents : */
461
462 x = 0;
463 for (i = 0; i < m_ContentsCnt; i++) if (m_Contents[i].m_Book == book && m_Contents[i].m_Level > 0) x++;
464 x = wxINT32_SWAP_ON_BE(x);
465 f -> Write(&x, sizeof(x));
466 for (i = 0; i < m_ContentsCnt; i++) {
467 if (m_Contents[i].m_Book != book || m_Contents[i].m_Level == 0) continue;
468 x = wxINT32_SWAP_ON_BE(m_Contents[i].m_Level);
469 f -> Write(&x, sizeof(x));
470 x = wxINT32_SWAP_ON_BE(m_Contents[i].m_ID);
471 f -> Write(&x, sizeof(x));
472 x = wxINT32_SWAP_ON_BE(wxStrlen(m_Contents[i].m_Name) + 1);
473 f -> Write(&x, sizeof(x));
474 WRITE_STRING(f, m_Contents[i].m_Name, x);
475 x = wxINT32_SWAP_ON_BE(wxStrlen(m_Contents[i].m_Page) + 1);
476 f -> Write(&x, sizeof(x));
477 WRITE_STRING(f, m_Contents[i].m_Page, x);
478 }
479
480 /* save index : */
481
482 x = 0;
483 for (i = 0; i < m_IndexCnt; i++) if (m_Index[i].m_Book == book && m_Index[i].m_Level > 0) x++;
484 x = wxINT32_SWAP_ON_BE(x);
485 f -> Write(&x, sizeof(x));
486 for (i = 0; i < m_IndexCnt; i++) {
487 if (m_Index[i].m_Book != book || m_Index[i].m_Level == 0) continue;
488 x = wxINT32_SWAP_ON_BE(wxStrlen(m_Index[i].m_Name) + 1);
489 f -> Write(&x, sizeof(x));
490 WRITE_STRING(f, m_Index[i].m_Name, x);
491 x = wxINT32_SWAP_ON_BE(wxStrlen(m_Index[i].m_Page) + 1);
492 f -> Write(&x, sizeof(x));
493 WRITE_STRING(f, m_Index[i].m_Page, x);
494 }
495 return TRUE;
496 }
497
498
499 void wxHtmlHelpData::SetTempDir(const wxString& path)
500 {
501 if (path == wxEmptyString) m_TempPath = path;
502 else {
503 if (wxIsAbsolutePath(path)) m_TempPath = path;
504 else m_TempPath = wxGetCwd() + _T("/") + path;
505
506 if (m_TempPath[m_TempPath.Length() - 1] != _T('/'))
507 m_TempPath << _T('/');
508 }
509 }
510
511
512
513 static wxString SafeFileName(const wxString& s)
514 {
515 wxString res(s);
516 res.Replace(wxT("#"), wxT("_"));
517 res.Replace(wxT(":"), wxT("_"));
518 res.Replace(wxT("\\"), wxT("_"));
519 res.Replace(wxT("/"), wxT("_"));
520 return res;
521 }
522
523 bool wxHtmlHelpData::AddBookParam(const wxFSFile& bookfile,
524 wxFontEncoding encoding,
525 const wxString& title, const wxString& contfile,
526 const wxString& indexfile, const wxString& deftopic,
527 const wxString& path)
528 {
529 wxFileSystem fsys;
530 wxFSFile *fi;
531 wxHtmlBookRecord *bookr;
532
533 int IndexOld = m_IndexCnt,
534 ContentsOld = m_ContentsCnt;
535
536 if (! path.IsEmpty())
537 fsys.ChangePathTo(path, TRUE);
538
539 bookr = new wxHtmlBookRecord(fsys.GetPath(), title, deftopic);
540
541 if (m_ContentsCnt % wxHTML_REALLOC_STEP == 0)
542 m_Contents = (wxHtmlContentsItem*) realloc(m_Contents, (m_ContentsCnt + wxHTML_REALLOC_STEP) * sizeof(wxHtmlContentsItem));
543 m_Contents[m_ContentsCnt].m_Level = 0;
544 m_Contents[m_ContentsCnt].m_ID = 0;
545 m_Contents[m_ContentsCnt].m_Page = new wxChar[deftopic.Length() + 1];
546 wxStrcpy(m_Contents[m_ContentsCnt].m_Page, deftopic.c_str());
547 m_Contents[m_ContentsCnt].m_Name = new wxChar [title.Length() + 1];
548 wxStrcpy(m_Contents[m_ContentsCnt].m_Name, title.c_str());
549 m_Contents[m_ContentsCnt].m_Book = bookr;
550
551 // store the contents index for later
552 int cont_start = m_ContentsCnt++;
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 fi -> GetModificationTime() < bookfile.GetModificationTime() ||
563 !LoadCachedBook(bookr, fi -> GetStream()))
564 {
565 if (fi != NULL) delete fi;
566 fi = fsys.OpenFile(m_TempPath + wxFileNameFromPath(bookfile.GetLocation()) + wxT(".cached"));
567 if (m_TempPath == wxEmptyString || fi == NULL ||
568 fi -> GetModificationTime() < bookfile.GetModificationTime() ||
569 !LoadCachedBook(bookr, fi -> GetStream()))
570 {
571 LoadMSProject(bookr, fsys, indexfile, contfile);
572 if (m_TempPath != wxEmptyString)
573 {
574 wxFileOutputStream *outs = new wxFileOutputStream(m_TempPath +
575 SafeFileName(wxFileNameFromPath(bookfile.GetLocation())) + wxT(".cached"));
576 SaveCachedBook(bookr, outs);
577 delete outs;
578 }
579 }
580 }
581
582 if (fi != NULL) delete fi;
583
584 // Now store the contents range
585 bookr->SetContentsRange(cont_start, m_ContentsCnt);
586
587 // Convert encoding, if neccessary:
588 if (encoding != wxFONTENCODING_SYSTEM)
589 {
590 wxFontEncodingArray a = wxEncodingConverter::GetPlatformEquivalents(encoding);
591 if (a.GetCount() != 0 && a[0] != encoding)
592 {
593 int i;
594 wxEncodingConverter conv;
595 conv.Init(encoding, a[0]);
596
597 for (i = IndexOld; i < m_IndexCnt; i++)
598 conv.Convert(m_Index[i].m_Name);
599 for (i = ContentsOld; i < m_ContentsCnt; i++)
600 conv.Convert(m_Contents[i].m_Name);
601 }
602 }
603
604 m_BookRecords.Add(bookr);
605 if (m_IndexCnt > 0)
606 qsort(m_Index, m_IndexCnt, sizeof(wxHtmlContentsItem), IndexCompareFunc);
607
608 return TRUE;
609 }
610
611
612 bool wxHtmlHelpData::AddBook(const wxString& book)
613 {
614 if (book.Right(4).Lower() == wxT(".zip") ||
615 book.Right(4).Lower() == wxT(".htb") /*html book*/)
616
617 {
618 wxFileSystem fsys;
619 wxString s;
620 bool rt = FALSE;
621
622 s = fsys.FindFirst(book + wxT("#zip:") + wxT("*.hhp"), wxFILE);
623 while (!s.IsEmpty())
624 {
625 if (AddBook(s)) rt = TRUE;
626 s = fsys.FindNext();
627 }
628
629 return rt;
630 }
631
632
633 else
634 {
635 wxFSFile *fi;
636 wxFileSystem fsys;
637 wxInputStream *s;
638 wxString bookFull;
639
640 int sz;
641 char *buff, *lineptr;
642 char linebuf[300];
643
644 wxString title = _("noname"),
645 safetitle,
646 start = wxEmptyString,
647 contents = wxEmptyString,
648 index = wxEmptyString,
649 charset = wxEmptyString;
650
651 if (wxIsAbsolutePath(book)) bookFull = book;
652 else bookFull = wxGetCwd() + "/" + book;
653
654 fi = fsys.OpenFile(bookFull);
655 if (fi == NULL)
656 {
657 wxLogError(_("Cannot open HTML help book: %s"), bookFull.c_str());
658 return FALSE;
659 }
660 fsys.ChangePathTo(bookFull);
661 s = fi -> GetStream();
662 sz = s -> GetSize();
663 buff = new char[sz + 1];
664 buff[sz] = 0;
665 s -> Read(buff, sz);
666 lineptr = buff;
667
668 do {
669 lineptr = ReadLine(lineptr, linebuf);
670
671 if (strstr(linebuf, "Title=") == linebuf)
672 title = linebuf + strlen("Title=");
673 if (strstr(linebuf, "Default topic=") == linebuf)
674 start = linebuf + strlen("Default topic=");
675 if (strstr(linebuf, "Index file=") == linebuf)
676 index = linebuf + strlen("Index file=");
677 if (strstr(linebuf, "Contents file=") == linebuf)
678 contents = linebuf + strlen("Contents file=");
679 if (strstr(linebuf, "Charset=") == linebuf)
680 charset = linebuf + strlen("Charset=");
681 } while (lineptr != NULL);
682 delete[] buff;
683
684 wxFontEncoding enc;
685 if (charset == wxEmptyString) enc = wxFONTENCODING_SYSTEM;
686 else enc = wxTheFontMapper -> CharsetToEncoding(charset);
687 bool rtval = AddBookParam(*fi, enc,
688 title, contents, index, start, fsys.GetPath());
689 delete fi;
690 return rtval;
691 }
692 }
693
694 wxString wxHtmlHelpData::FindPageByName(const wxString& x)
695 {
696 int cnt;
697 int i;
698 wxFileSystem fsys;
699 wxFSFile *f;
700 wxString url(wxEmptyString);
701
702 /* 1. try to open given file: */
703
704 cnt = m_BookRecords.GetCount();
705 for (i = 0; i < cnt; i++) {
706 f = fsys.OpenFile(m_BookRecords[i].GetBasePath() + x);
707 if (f) {
708 url = m_BookRecords[i].GetBasePath() + x;
709 delete f;
710 return url;
711 }
712 }
713
714
715 /* 2. try to find a book: */
716
717 for (i = 0; i < cnt; i++) {
718 if (m_BookRecords[i].GetTitle() == x) {
719 url = m_BookRecords[i].GetBasePath() + m_BookRecords[i].GetStart();
720 return url;
721 }
722 }
723
724 /* 3. try to find in contents: */
725
726 cnt = m_ContentsCnt;
727 for (i = 0; i < cnt; i++) {
728 if (wxStrcmp(m_Contents[i].m_Name, x) == 0) {
729 url = m_Contents[i].m_Book -> GetBasePath() + m_Contents[i].m_Page;
730 return url;
731 }
732 }
733
734
735 /* 4. try to find in index: */
736
737 cnt = m_IndexCnt;
738 for (i = 0; i < cnt; i++) {
739 if (wxStrcmp(m_Index[i].m_Name, x) == 0) {
740 url = m_Index[i].m_Book -> GetBasePath() + m_Index[i].m_Page;
741 return url;
742 }
743 }
744
745 return url;
746 }
747
748 wxString wxHtmlHelpData::FindPageById(int id)
749 {
750 int i;
751 wxString url(wxEmptyString);
752
753 for (i = 0; i < m_ContentsCnt; i++) {
754 if (m_Contents[i].m_ID == id) {
755 url = m_Contents[i].m_Book -> GetBasePath() + m_Contents[i].m_Page;
756 return url;
757 }
758 }
759
760 return url;
761 }
762
763 //----------------------------------------------------------------------------------
764 // wxHtmlSearchStatus functions
765 //----------------------------------------------------------------------------------
766
767 wxHtmlSearchStatus::wxHtmlSearchStatus(wxHtmlHelpData* data, const wxString& keyword,
768 bool case_sensitive, bool whole_words_only,
769 const wxString& book)
770 {
771 m_Data = data;
772 m_Keyword = keyword;
773 wxHtmlBookRecord* bookr = NULL;
774 if (book != wxEmptyString) {
775 // we have to search in a specific book. Find it first
776 int i, cnt = data->m_BookRecords.GetCount();
777 for (i = 0; i < cnt; i++)
778 if (data->m_BookRecords[i].GetTitle() == book) {
779 bookr = &(data->m_BookRecords[i]);
780 m_CurIndex = bookr->GetContentsStart();
781 m_MaxIndex = bookr->GetContentsEnd();
782 break;
783 }
784 // check; we won't crash if the book doesn't exist, but it's Bad Anyway.
785 wxASSERT(bookr);
786 }
787 if (! bookr) {
788 // no book specified; search all books
789 m_CurIndex = 0;
790 m_MaxIndex = m_Data->m_ContentsCnt;
791 }
792 m_Engine.LookFor(keyword, case_sensitive, whole_words_only);
793 m_Active = (m_CurIndex < m_MaxIndex);
794 m_LastPage = NULL;
795 }
796
797 bool wxHtmlSearchStatus::Search()
798 {
799 wxFSFile *file;
800 int i = m_CurIndex; // shortcut
801 bool found = FALSE;
802 wxChar *thepage;
803
804 if (!m_Active) {
805 // sanity check. Illegal use, but we'll try to prevent a crash anyway
806 wxASSERT(m_Active);
807 return FALSE;
808 }
809
810 m_Name = wxEmptyString;
811 m_ContentsItem = NULL;
812 thepage = m_Data->m_Contents[i].m_Page;
813
814 m_Active = (++m_CurIndex < m_MaxIndex);
815 // check if it is same page with different anchor:
816 if (m_LastPage != NULL)
817 {
818 wxChar *p1, *p2;
819 for (p1 = thepage, p2 = m_LastPage;
820 *p1 != 0 && *p1 != _T('#') && *p1 == *p2; p1++, p2++) {}
821
822 m_LastPage = thepage;
823
824 if (*p1 == 0 || *p1 == _T('#'))
825 return FALSE;
826 }
827 else m_LastPage = thepage;
828
829 wxFileSystem fsys;
830 file = fsys.OpenFile(m_Data->m_Contents[i].m_Book -> GetBasePath() + thepage);
831 if (file)
832 {
833 if (m_Engine.Scan(file -> GetStream())) {
834 m_Name = m_Data->m_Contents[i].m_Name;
835 m_ContentsItem = m_Data->m_Contents + i;
836 found = TRUE;
837 }
838 delete file;
839 }
840 return found;
841 }
842
843
844
845
846
847
848
849
850 //--------------------------------------------------------------------------------
851 // wxSearchEngine
852 //--------------------------------------------------------------------------------
853
854 void wxSearchEngine::LookFor(const wxString& keyword, bool case_sensitive, bool whole_words_only)
855 {
856 m_CaseSensitive = case_sensitive;
857 m_WholeWords = whole_words_only;
858 if (m_Keyword) delete[] m_Keyword;
859 m_Keyword = new wxChar[keyword.Length() + 1];
860 wxStrcpy(m_Keyword, keyword.c_str());
861
862 if (!m_CaseSensitive)
863 for (int i = wxStrlen(m_Keyword) - 1; i >= 0; i--)
864 if ((m_Keyword[i] >= wxT('A')) && (m_Keyword[i] <= wxT('Z')))
865 m_Keyword[i] += wxT('a') - wxT('A');
866 }
867
868
869
870 #define WHITESPACE(c) (c == ' ' || c == '\n' || c == '\r' || c == '\t')
871
872 bool wxSearchEngine::Scan(wxInputStream *stream)
873 {
874 wxASSERT_MSG(m_Keyword != NULL, wxT("wxSearchEngine::LookFor must be called before scanning!"));
875
876 int i, j;
877 int lng = stream ->GetSize();
878 int wrd = wxStrlen(m_Keyword);
879 bool found = FALSE;
880 char *buf = new char[lng + 1];
881 stream -> Read(buf, lng);
882 buf[lng] = 0;
883
884 if (!m_CaseSensitive)
885 for (i = 0; i < lng; i++)
886 if ((buf[i] >= 'A') && (buf[i] <= 'Z')) buf[i] += 'a' - 'A';
887
888 if (m_WholeWords)
889 {
890 for (i = 0; i < lng - wrd; i++) {
891 if (WHITESPACE(buf[i])) continue;
892 j = 0;
893 while ((j < wrd) && (buf[i + j] == m_Keyword[j])) j++;
894 if (j == wrd && WHITESPACE(buf[i + j])) {found = TRUE; break; }
895 }
896 }
897
898 else
899 {
900 for (i = 0; i < lng - wrd; i++) {
901 j = 0;
902 while ((j < wrd) && (buf[i + j] == m_Keyword[j])) j++;
903 if (j == wrd) {found = TRUE; break; }
904 }
905 }
906
907 delete[] buf;
908 return found;
909 }
910
911
912
913
914 #endif