]> git.saurik.com Git - wxWidgets.git/blame - src/html/chm.cpp
Add ClearSelection for msw ie and gtk webkit, with a stub for osx webkit. Document...
[wxWidgets.git] / src / html / chm.cpp
CommitLineData
3527f29c 1/////////////////////////////////////////////////////////////////////////////
02761f6c 2// Name: src/html/chm.cpp
3527f29c
VS
3// Purpose: CHM (Help) support for wxHTML
4// Author: Markus Sinner
5// Copyright: (c) 2003 Herd Software Development
6// CVS-ID: $Id$
65571936 7// Licence: wxWindows licence
3527f29c
VS
8/////////////////////////////////////////////////////////////////////////////
9
10#include "wx/wxprec.h"
11
12#ifdef __BORLANDC__
02761f6c 13 #pragma hdrstop
3527f29c
VS
14#endif
15
16#if wxUSE_LIBMSPACK
17
18#include <mspack.h>
19
b4f4d3dd 20#ifndef WX_PRECOMP
02761f6c
WS
21 #include "wx/intl.h"
22 #include "wx/log.h"
23 #include "wx/module.h"
3527f29c
VS
24#endif
25
3527f29c
VS
26#include "wx/filesys.h"
27#include "wx/mstream.h"
28#include "wx/wfstream.h"
29
30#include "wx/html/forcelnk.h"
31FORCE_LINK_ME(wxhtml_chm_support)
32
33// ----------------------------------------------------------------------------
34/// wxChmTools
35/// <p>
36/// this class is used to abstract access to CHM-Archives
37/// with library mspack written by Stuart Caie
38/// http://www.kyz.uklinux.net/libmspack/
39// ----------------------------------------------------------------------------
40class wxChmTools
41{
42public:
43 /// constructor
44 wxChmTools(const wxFileName &archive);
45 /// destructor
46 ~wxChmTools();
47
48 /// Generate error-string for error-code
49 static const wxString ChmErrorMsg(int error);
50
51 /// get an array of archive-member-filenames
52 const wxArrayString *GetFileNames()
53 {
54 return m_fileNames;
55 };
56
57 /// get the name of the archive representated by this class
58 const wxString GetArchiveName()
59 {
60 return m_chmFileName;
61 };
62
63 /// Find a file in the archive
64 const wxString Find(const wxString& pattern,
65 const wxString& startfrom = wxEmptyString);
66
67 /// Extract a file in the archive into a file
68 size_t Extract(const wxString& pattern, const wxString& filename);
69
70 /// check archive for a file
71 bool Contains(const wxString& pattern);
72
3103e8a9 73 /// get a string for the last error which occurred
3527f29c
VS
74 const wxString GetLastErrorMessage();
75
76 /// Last Error
77 int m_lasterror;
78
79private:
80 // these vars are used by FindFirst/Next:
81 wxString m_chmFileName;
82 char *m_chmFileNameANSI;
83
84 /// mspack-pointer to mschmd_header
85 struct mschmd_header *m_archive;
86 /// mspack-pointer to mschm_decompressor
87 struct mschm_decompressor *m_decompressor;
88
89 /// Array of filenames in archive
90 wxArrayString * m_fileNames;
91
92 /// Internal function to get filepointer
93 struct mschmd_file *GetMschmdFile(const wxString& pattern);
94};
95
96
97/***
98 * constructor
99 *
100 * @param archive The filename of the archive to open
101 */
102wxChmTools::wxChmTools(const wxFileName &archive)
103{
104 m_chmFileName = archive.GetFullPath();
105
9a83f860 106 wxASSERT_MSG( !m_chmFileName.empty(), wxT("empty archive name") );
3527f29c
VS
107
108 m_archive = NULL;
109 m_decompressor = NULL;
110 m_fileNames = NULL;
111 m_lasterror = 0;
112
113 struct mschmd_header *chmh;
114 struct mschm_decompressor *chmd;
115 struct mschmd_file *file;
116
117 // Create decompressor
118 chmd = mspack_create_chm_decompressor(NULL);
119 m_decompressor = (struct mschm_decompressor *) chmd;
120
121 // NB: we must make a copy of the string because chmd->open won't call
122 // strdup() [libmspack-20030726], which would cause crashes in
123 // Unicode build when mb_str() returns temporary buffer
124 m_chmFileNameANSI = strdup((const char*)m_chmFileName.mb_str(wxConvFile));
d1da8872 125
3527f29c
VS
126 // Open the archive and store it in class:
127 if ( (chmh = chmd->open(chmd, (char*)m_chmFileNameANSI)) )
128 {
129 m_archive = chmh;
130
131 // Create Filenamearray
132 m_fileNames = new wxArrayString;
133
134 // Store Filenames in array
135 for (file = chmh->files; file; file = file->next)
136 {
137 m_fileNames->Add(wxString::FromAscii(file->filename));
138 }
139 }
140 else
141 {
142 wxLogError(_("Failed to open CHM archive '%s'."),
143 archive.GetFullPath().c_str());
144 m_lasterror = (chmd->last_error(chmd));
145 return;
146 }
147}
148
149
150/***
151 * Destructor
152 */
153wxChmTools::~wxChmTools()
154{
155 struct mschm_decompressor *chmd = m_decompressor;
156 struct mschmd_header *chmh = m_archive;
157
158 delete m_fileNames;
159
160 // Close Archive
161 if (chmh && chmd)
162 chmd->close(chmd, chmh);
163
164 free(m_chmFileNameANSI);
165
166 // Destroy Decompressor
167 if (chmd)
168 mspack_destroy_chm_decompressor(chmd);
169}
170
171
172
173/**
174 * Checks if the given pattern matches to any
175 * filename stored in archive
176 *
177 * @param pattern The filename pattern, may include '*' and/or '?'
178 * @return true, if any file matching pattern has been found,
179 * false if not
180 */
181bool wxChmTools::Contains(const wxString& pattern)
182{
183 int count;
184 wxString pattern_tmp = wxString(pattern).MakeLower();
185
186 // loop through filearay
187 if ( m_fileNames && (count = m_fileNames->GetCount()) > 0 )
188 {
189 for (int i = 0; i < count; i++)
190 {
191 wxString tmp = m_fileNames->Item(i).MakeLower();
192 if ( tmp.Matches(pattern_tmp) || tmp.Mid(1).Matches(pattern_tmp))
193 return true;
194 }
195 }
196
197 return false;
198}
199
200
201
202/**
203 * Find()
204 *
205 * Finds the next file descibed by a pattern in the archive, starting
206 * the file given by second parameter
d1da8872 207 *
3527f29c
VS
208 * @param pattern The file-pattern to search for. May contain '*' and/or '?'
209 * @param startfrom The filename which the search should start after
210 * @returns The full pathname of the found file
211 */
212const wxString wxChmTools::Find(const wxString& pattern,
213 const wxString& startfrom)
214{
215 int count;
216 wxString tmp;
217 wxString pattern_tmp(pattern);
218 wxString startfrom_tmp(startfrom);
219 pattern_tmp.MakeLower();
220 startfrom_tmp.MakeLower();
221
222 if ( m_fileNames && (count = m_fileNames->GetCount()) > 0 )
223 {
224 for (int i = 0; i < count; i++)
225 {
226 tmp = m_fileNames->Item(i).MakeLower();
227 // if we find the string where the search should began
228 if ( tmp.Matches(startfrom_tmp) ||
229 tmp.Mid(1).Matches(startfrom_tmp) )
230 continue;
231 if ( tmp.Matches(pattern_tmp) ||
232 tmp.Mid(1).Matches(pattern_tmp) )
233 {
234 return tmp;
235 }
236 }
237 }
238
239 return wxEmptyString;
240}
241
242
243/**
244 * Extract ()
245 *
246 * extracts the first hit of pattern to the given position
247 *
248 * @param pattern A filename pattern (may contain * and ? chars)
249 * @param filename The FileName where to temporary extract the file to
250 * @return 0 at no file extracted<br>
251 * number of bytes extracted else
252 */
253size_t wxChmTools::Extract(const wxString& pattern, const wxString& filename)
254{
255 struct mschm_decompressor *d = m_decompressor;
256 struct mschmd_header *h = m_archive;
257 struct mschmd_file *f;
258
259 wxString tmp;
260 wxString pattern_tmp = (wxString(pattern)).MakeLower();
261
262 for (f = h->files; f; f = f->next)
263 {
264 tmp = wxString::FromAscii(f->filename).MakeLower();
265 if ( tmp.Matches(pattern_tmp) ||
266 tmp.Mid(1).Matches(pattern_tmp) )
267 {
268 // ignore leading '/'
269 if (d->extract(d, f,
270 (char*)(const char*)filename.mb_str(wxConvFile)))
271 {
272 // Error
273 m_lasterror = d->last_error(d);
274 wxLogError(_("Could not extract %s into %s: %s"),
275 wxString::FromAscii(f->filename).c_str(),
276 filename.c_str(),
277 ChmErrorMsg(m_lasterror).c_str());
278 return 0;
279 }
280 else
281 {
282 return (size_t) f->length;
283 }
284 }
285 }
286
287 return 0;
288}
289
290
291
292/**
293 * Find a file by pattern
294 *
295 * @param pattern A filename pattern (may contain * and ? chars)
296 * @return A pointer to the file (mschmd_file*)
297 */
298struct mschmd_file *wxChmTools::GetMschmdFile(const wxString& pattern_orig)
299{
300 struct mschmd_file *f;
301 struct mschmd_header *h = (struct mschmd_header *) m_archive;
302 wxString tmp;
303 wxString pattern = wxString(pattern_orig).MakeLower();
304
305 for (f = h->files; f; f = f->next)
306 {
307 tmp = wxString::FromAscii(f->filename).MakeLower();
308 if ( tmp.Matches(pattern) || tmp.Mid(1).Matches(pattern) )
309 {
310 // ignore leading '/'
311 return f;
312 }
313 }
314
315 return NULL;
316}
317
318const wxString wxChmTools::GetLastErrorMessage()
319{
320 return ChmErrorMsg(m_lasterror);
321}
322
323const wxString wxChmTools::ChmErrorMsg(int error)
324{
325 switch (error)
326 {
327 case MSPACK_ERR_OK:
328 return _("no error");
329 case MSPACK_ERR_ARGS:
330 return _("bad arguments to library function");
331 case MSPACK_ERR_OPEN:
332 return _("error opening file");
333 case MSPACK_ERR_READ:
334 return _("read error");
335 case MSPACK_ERR_WRITE:
336 return _("write error");
337 case MSPACK_ERR_SEEK:
338 return _("seek error");
339 case MSPACK_ERR_NOMEMORY:
340 return _("out of memory");
341 case MSPACK_ERR_SIGNATURE:
342 return _("bad signature");
343 case MSPACK_ERR_DATAFORMAT:
344 return _("error in data format");
345 case MSPACK_ERR_CHECKSUM:
346 return _("checksum error");
347 case MSPACK_ERR_CRUNCH:
348 return _("compression error");
349 case MSPACK_ERR_DECRUNCH:
350 return _("decompression error");
351 }
352 return _("unknown error");
353}
354
355
356// ---------------------------------------------------------------------------
357/// wxChmInputStream
358// ---------------------------------------------------------------------------
359
360class wxChmInputStream : public wxInputStream
361{
362public:
363 /// Constructor
364 wxChmInputStream(const wxString& archive,
365 const wxString& file, bool simulate = false);
366 /// Destructor
d3c7fc99 367 virtual ~wxChmInputStream();
3527f29c
VS
368
369 /// Return the size of the accessed file in archive
370 virtual size_t GetSize() const { return m_size; }
371 /// End of Stream?
372 virtual bool Eof() const;
373 /// Set simulation-mode of HHP-File (if non is found)
374 void SimulateHHP(bool sim) { m_simulateHHP = sim; }
375
376protected:
377 /// See wxInputStream
378 virtual size_t OnSysRead(void *buffer, size_t bufsize);
379 /// See wxInputStream
30984dea 380 virtual wxFileOffset OnSysSeek(wxFileOffset seek, wxSeekMode mode);
3527f29c 381 /// See wxInputStream
30984dea 382 virtual wxFileOffset OnSysTell() const { return m_pos; }
3527f29c
VS
383
384private:
385 size_t m_size;
30984dea 386 wxFileOffset m_pos;
3527f29c
VS
387 bool m_simulateHHP;
388
389 char * m_content;
390 wxInputStream * m_contentStream;
391
392 void CreateHHPStream();
393 bool CreateFileStream(const wxString& pattern);
394 // this void* is handle of archive . I'm sorry it is void and not proper
395 // type but I don't want to make unzip.h header public.
396
397
398 // locates the file and returns a mspack_file *
399 mspack_file *LocateFile(wxString filename);
400
401 // should store pointer to current file
402 mspack_file *m_file;
403
404 // The Chm-Class for extracting the data
405 wxChmTools *m_chm;
406
407 wxString m_fileName;
408};
409
410
411/**
412 * Constructor
413 * @param archive The name of the .chm archive. Remember that archive must
414 * be local file accesible via fopen, fread functions!
415 * @param filename The Name of the file to be extracted from archive
416 * @param simulate if true than class should simulate .HHP-File based on #SYSTEM
90523bdb 417 * if false than class does nothing if it doesn't find .hhp
3527f29c
VS
418 */
419wxChmInputStream::wxChmInputStream(const wxString& archive,
420 const wxString& filename, bool simulate)
421 : wxInputStream()
422{
423 m_pos = 0;
424 m_size = 0;
425 m_content = NULL;
426 m_contentStream = NULL;
427 m_lasterror = wxSTREAM_NO_ERROR;
428 m_chm = new wxChmTools (wxFileName(archive));
429 m_file = NULL;
430 m_fileName = wxString(filename).MakeLower();
431 m_simulateHHP = simulate;
432
433 if ( !m_chm->Contains(m_fileName) )
434 {
435 // if the file could not be located, but was *.hhp, than we create
436 // the content of the hhp-file on the fly and store it for reading
437 // by the application
9a83f860 438 if ( m_fileName.Find(wxT(".hhp")) != wxNOT_FOUND && m_simulateHHP )
3527f29c
VS
439 {
440 // now we open an hhp-file
441 CreateHHPStream();
442 }
443 else
444 {
445 wxLogError(_("Could not locate file '%s'."), filename.c_str());
446 m_lasterror = wxSTREAM_READ_ERROR;
447 return;
448 }
449 }
450 else
451 { // file found
452 CreateFileStream(m_fileName);
453 }
454}
455
456
457wxChmInputStream::~wxChmInputStream()
458{
459 delete m_chm;
460
461 delete m_contentStream;
462
463 if (m_content)
464 {
465 free (m_content);
466 m_content=NULL;
467 }
468}
469
470bool wxChmInputStream::Eof() const
471{
472 return (m_content==NULL ||
473 m_contentStream==NULL ||
474 m_contentStream->Eof() ||
475 m_pos>m_size);
476}
477
478
479
480size_t wxChmInputStream::OnSysRead(void *buffer, size_t bufsize)
481{
482 if ( m_pos >= m_size )
483 {
484 m_lasterror = wxSTREAM_EOF;
485 return 0;
486 }
487 m_lasterror = wxSTREAM_NO_ERROR;
488
489 // If the rest to read from the stream is less
b81e4506 490 // than the buffer size, then only read the rest
3527f29c
VS
491 if ( m_pos + bufsize > m_size )
492 bufsize = m_size - m_pos;
493
b81e4506
FM
494 if (m_contentStream->SeekI(m_pos) == wxInvalidOffset)
495 {
496 m_lasterror = wxSTREAM_EOF;
497 return 0;
498 }
499
500 size_t read = m_contentStream->Read(buffer, bufsize).LastRead();
501 m_pos += read;
502
503 if (m_contentStream->SeekI(m_pos) == wxInvalidOffset)
504 {
505 m_lasterror = wxSTREAM_READ_ERROR;
506 return 0;
507 }
508
509 if (read != bufsize)
510 m_lasterror = m_contentStream->GetLastError();
511
512 return read;
3527f29c
VS
513}
514
515
516
517
30984dea 518wxFileOffset wxChmInputStream::OnSysSeek(wxFileOffset seek, wxSeekMode mode)
3527f29c
VS
519{
520 wxString mode_str = wxEmptyString;
521
522 if ( !m_contentStream || m_contentStream->Eof() )
523 {
524 m_lasterror = wxSTREAM_EOF;
525 return 0;
526 }
527 m_lasterror = wxSTREAM_NO_ERROR;
528
30984dea 529 wxFileOffset nextpos;
3527f29c
VS
530
531 switch ( mode )
532 {
533 case wxFromCurrent:
534 nextpos = seek + m_pos;
535 break;
536 case wxFromStart:
537 nextpos = seek;
538 break;
539 case wxFromEnd:
540 nextpos = m_size - 1 + seek;
541 break;
542 default:
543 nextpos = m_pos;
544 break; /* just to fool compiler, never happens */
545 }
546 m_pos=nextpos;
547
548 // Set current position on stream
549 m_contentStream->SeekI(m_pos);
550 return m_pos;
551}
552
553
554
555/**
556 * Help Browser tries to read the contents of the
557 * file by interpreting a .hhp file in the Archiv.
90523bdb 558 * For .chm doesn't include such a file, we need
3527f29c
VS
559 * to rebuild the information based on stored
560 * system-files.
561 */
562void
563wxChmInputStream::CreateHHPStream()
564{
565 wxFileName file;
566 bool topic = false;
567 bool hhc = false;
568 bool hhk = false;
569 wxInputStream *i;
570 wxMemoryOutputStream *out;
571 const char *tmp;
572
573 // Try to open the #SYSTEM-File and create the HHP File out of it
05d89f2c 574 // see http://bonedaddy.net/pabs3/chmspec/0.1.2/Internal.html#SYSTEM
9a83f860 575 if ( ! m_chm->Contains(wxT("/#SYSTEM")) )
3527f29c
VS
576 {
577#ifdef DEBUG
90523bdb 578 wxLogDebug("Archive doesn't contain #SYSTEM file");
3527f29c
VS
579#endif
580 return;
581 }
582 else
583 {
9a83f860 584 file = wxFileName(wxT("/#SYSTEM"));
3527f29c
VS
585 }
586
9a83f860 587 if ( CreateFileStream(wxT("/#SYSTEM")) )
3527f29c
VS
588 {
589 // New stream for writing a memory area to simulate the
590 // .hhp-file
591 out = new wxMemoryOutputStream();
592
593 tmp = "[OPTIONS]\r\n";
594 out->Write((const void *) tmp, strlen(tmp));
595
596 wxUint16 code;
597 wxUint16 len;
598 void *buf;
599
600 // use the actual stream for reading
601 i = m_contentStream;
602
603 /* Now read the contents, and try to get the needed information */
604
605 // First 4 Bytes are Version information, skip
606 i->SeekI(4);
607
608 while (!i->Eof())
609 {
610 // Read #SYSTEM-Code and length
611 i->Read(&code, 2);
fbd35620 612 code = wxUINT16_SWAP_ON_BE( code ) ;
3527f29c 613 i->Read(&len, 2);
fbd35620 614 len = wxUINT16_SWAP_ON_BE( len ) ;
3527f29c
VS
615 // data
616 buf = malloc(len);
617 i->Read(buf, len);
618
619 switch (code)
620 {
621 case 0: // CONTENTS_FILE
348a9a6f
MW
622 if (len)
623 {
624 tmp = "Contents file=";
625 hhc=true;
626 }
3527f29c
VS
627 break;
628 case 1: // INDEX_FILE
629 tmp = "Index file=";
630 hhk = true;
631 break;
632 case 2: // DEFAULT_TOPIC
633 tmp = "Default Topic=";
634 topic = true;
635 break;
636 case 3: // TITLE
637 tmp = "Title=";
638 break;
639 // case 6: // COMPILED_FILE
640 // tmp = "Compiled File=";
641 // break;
642 case 7: // COMPILED_FILE
643 tmp = "Binary Index=YES\r\n";
644 out->Write( (const void *) tmp, strlen(tmp));
645 tmp = NULL;
646 break;
fbd35620
SC
647 case 4: // STRUCT SYSTEM INFO
648 tmp = NULL ;
649 if ( len >= 28 )
650 {
651 char *structptr = (char*) buf ;
652 // LCID at position 0
653 wxUint32 dummy = *((wxUint32 *)(structptr+0)) ;
654 wxUint32 lcid = wxUINT32_SWAP_ON_BE( dummy ) ;
348a9a6f
MW
655 char msg[64];
656 int len = sprintf(msg, "Language=0x%X\r\n", lcid) ;
657 if (len > 0)
658 out->Write(msg, len) ;
fbd35620
SC
659 }
660 break ;
3527f29c
VS
661 default:
662 tmp=NULL;
663 }
664
665 if (tmp)
666 {
667 out->Write((const void *) tmp, strlen(tmp));
668 out->Write(buf, strlen((char*)buf));
669 out->Write("\r\n", 2);
670 }
671
672 free(buf);
673 buf=NULL;
674 }
675
676
677 // Free the old data which wont be used any more
678 delete m_contentStream;
679 if (m_content)
680 free (m_content);
681
682 // Now add entries which are missing
9a83f860 683 if ( !hhc && m_chm->Contains(wxT("*.hhc")) )
3527f29c
VS
684 {
685 tmp = "Contents File=*.hhc\r\n";
686 out->Write((const void *) tmp, strlen(tmp));
687 }
688
9a83f860 689 if ( !hhk && m_chm->Contains(wxT("*.hhk")) )
3527f29c
VS
690 {
691 tmp = "Index File=*.hhk\r\n";
692 out->Write((const void *) tmp, strlen(tmp));
693 }
02761f6c 694
3527f29c
VS
695 // Now copy the Data from the memory
696 out->SeekO(0, wxFromEnd);
697 m_size = out->TellO();
698 out->SeekO(0, wxFromStart);
699 m_content = (char *) malloc (m_size+1);
700 out->CopyTo(m_content, m_size);
701 m_content[m_size]='\0';
702 m_size++;
703 m_contentStream = new wxMemoryInputStream(m_content, m_size);
704
705 delete out;
706 }
707}
708
709
710/**
711 * Creates a Stream pointing to a virtual file in
712 * the current archive
713 */
714bool wxChmInputStream::CreateFileStream(const wxString& pattern)
715{
716 wxFileInputStream * fin;
9a83f860 717 wxString tmpfile = wxFileName::CreateTempFileName(wxT("chmstrm"));
3527f29c
VS
718
719 if ( tmpfile.empty() )
720 {
721 wxLogError(_("Could not create temporary file '%s'"), tmpfile.c_str());
722 return false;
723 }
724
725 // try to extract the file
726 if ( m_chm->Extract(pattern, tmpfile) <= 0 )
727 {
728 wxLogError(_("Extraction of '%s' into '%s' failed."),
729 pattern.c_str(), tmpfile.c_str());
730 if ( wxFileExists(tmpfile) )
731 wxRemoveFile(tmpfile);
732 return false;
733 }
734 else
735 {
736 // Open a filestream to extracted file
737 fin = new wxFileInputStream(tmpfile);
9690b006
FM
738 if (!fin->IsOk())
739 return false;
740
3527f29c
VS
741 m_size = fin->GetSize();
742 m_content = (char *) malloc(m_size+1);
743 fin->Read(m_content, m_size);
744 m_content[m_size]='\0';
745
746 wxRemoveFile(tmpfile);
747
748 delete fin;
749
750 m_contentStream = new wxMemoryInputStream (m_content, m_size);
751
752 return m_contentStream->IsOk();
753 }
754}
755
756
757
758// ----------------------------------------------------------------------------
759// wxChmFSHandler
760// ----------------------------------------------------------------------------
761
762class wxChmFSHandler : public wxFileSystemHandler
763{
764public:
765 /// Constructor and Destructor
766 wxChmFSHandler();
d3c7fc99 767 virtual ~wxChmFSHandler();
3527f29c
VS
768
769 /// Is able to open location?
770 virtual bool CanOpen(const wxString& location);
771 /// Open a file
772 virtual wxFSFile* OpenFile(wxFileSystem& fs, const wxString& location);
3103e8a9 773 /// Find first occurrence of spec
3527f29c 774 virtual wxString FindFirst(const wxString& spec, int flags = 0);
3103e8a9 775 /// Find next occurrence of spec
3527f29c
VS
776 virtual wxString FindNext();
777
778private:
779 int m_lasterror;
780 wxString m_pattern;
781 wxString m_found;
782 wxChmTools * m_chm;
783};
784
785wxChmFSHandler::wxChmFSHandler() : wxFileSystemHandler()
786{
787 m_lasterror=0;
788 m_pattern=wxEmptyString;
789 m_found=wxEmptyString;
790 m_chm=NULL;
791}
792
793wxChmFSHandler::~wxChmFSHandler()
794{
795 if (m_chm)
796 delete m_chm;
797}
798
799bool wxChmFSHandler::CanOpen(const wxString& location)
800{
801 wxString p = GetProtocol(location);
9a83f860
VZ
802 return (p == wxT("chm")) &&
803 (GetProtocol(GetLeftLocation(location)) == wxT("file"));
3527f29c
VS
804}
805
806wxFSFile* wxChmFSHandler::OpenFile(wxFileSystem& WXUNUSED(fs),
807 const wxString& location)
808{
809 wxString right = GetRightLocation(location);
810 wxString left = GetLeftLocation(location);
811
812 wxInputStream *s;
813
814 int index;
815
9a83f860 816 if ( GetProtocol(left) != wxT("file") )
3527f29c
VS
817 {
818 wxLogError(_("CHM handler currently supports only local files!"));
819 return NULL;
820 }
821
822 // Work around javascript
823 wxString tmp = wxString(right);
9a83f860 824 if ( tmp.MakeLower().Contains(wxT("javascipt")) && tmp.Contains(wxT("\'")) )
3527f29c 825 {
9a83f860 826 right = right.AfterFirst(wxT('\'')).BeforeLast(wxT('\''));
3527f29c
VS
827 }
828
829 // now work on the right location
9a83f860 830 if (right.Contains(wxT("..")))
3527f29c
VS
831 {
832 wxFileName abs(right);
9a83f860 833 abs.MakeAbsolute(wxT("/"));
3527f29c
VS
834 right = abs.GetFullPath();
835 }
836
837 // a workaround for absolute links to root
9a83f860 838 if ( (index=right.Index(wxT("//"))) != wxNOT_FOUND )
3527f29c
VS
839 {
840 right=wxString(right.Mid(index+1));
841 wxLogWarning(_("Link contained '//', converted to absolute link."));
842 }
843
844 wxFileName leftFilename = wxFileSystem::URLToFileName(left);
15552854
MW
845 if (!leftFilename.FileExists())
846 return NULL;
3527f29c
VS
847
848 // Open a stream to read the content of the chm-file
849 s = new wxChmInputStream(leftFilename.GetFullPath(), right, true);
850
3527f29c
VS
851 if ( s )
852 {
853 return new wxFSFile(s,
9a83f860 854 left + wxT("#chm:") + right,
69cce151 855 wxEmptyString,
3527f29c 856 GetAnchor(location),
348a9a6f 857 wxDateTime(leftFilename.GetModificationTime()));
3527f29c
VS
858 }
859
860 delete s;
861 return NULL;
862}
863
864
865
866/**
867 * Doku see wxFileSystemHandler
868 */
869wxString wxChmFSHandler::FindFirst(const wxString& spec, int flags)
870{
871 wxString right = GetRightLocation(spec);
872 wxString left = GetLeftLocation(spec);
873 wxString nativename = wxFileSystem::URLToFileName(left).GetFullPath();
874
9a83f860 875 if ( GetProtocol(left) != wxT("file") )
3527f29c
VS
876 {
877 wxLogError(_("CHM handler currently supports only local files!"));
878 return wxEmptyString;
879 }
880
881 m_chm = new wxChmTools(wxFileName(nativename));
9a83f860 882 m_pattern = right.AfterLast(wxT('/'));
3527f29c
VS
883
884 wxString m_found = m_chm->Find(m_pattern);
885
886 // now fake around hhp-files which are not existing in projects...
887 if (m_found.empty() &&
9a83f860
VZ
888 m_pattern.Contains(wxT(".hhp")) &&
889 !m_pattern.Contains(wxT(".hhp.cached")))
3527f29c 890 {
9a83f860
VZ
891 m_found.Printf(wxT("%s#chm:%s.hhp"),
892 left.c_str(), m_pattern.BeforeLast(wxT('.')).c_str());
3527f29c
VS
893 }
894
895 return m_found;
896
897}
898
899
900
901wxString wxChmFSHandler::FindNext()
902{
903 if (m_pattern.empty())
904 return wxEmptyString;
905 else
906 return m_chm->Find(m_pattern, m_found);
907}
908
909// ---------------------------------------------------------------------------
910// wxModule to register CHM handler
911// ---------------------------------------------------------------------------
912
913class wxChmSupportModule : public wxModule
914{
915 DECLARE_DYNAMIC_CLASS(wxChmSupportModule)
916
917public:
918 virtual bool OnInit()
919 {
920 wxFileSystem::AddHandler(new wxChmFSHandler);
921 return true;
922 }
923 virtual void OnExit() {}
924}
925;
926
927IMPLEMENT_DYNAMIC_CLASS(wxChmSupportModule, wxModule)
928
929#endif // wxUSE_LIBMSPACK