src/html/chm.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/html/chm.cpp
   3 // Purpose:     CHM (Help) support for wxHTML
   4 // Author:      Markus Sinner
   5 // Copyright:   (c) 2003 Herd Software Development
   6 // CVS-ID:      $Id$
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 #include "wx/wxprec.h"
  11
  12 #ifdef __BORLANDC__
  13     #pragma hdrstop
  14 #endif
  15
  16 #if wxUSE_LIBMSPACK
  17
  18 #include <mspack.h>
  19
  20 #ifndef WX_PRECOMP
  21     #include "wx/intl.h"
  22     #include "wx/log.h"
  23     #include "wx/module.h"
  24 #endif
  25
  26 #include "wx/filesys.h"
  27 #include "wx/mstream.h"
  28 #include "wx/wfstream.h"
  29
  30 #include "wx/html/forcelnk.h"
  31 FORCE_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 // ----------------------------------------------------------------------------
  40 class wxChmTools
  41 {
  42 public:
  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
  73     /// get a string for the last error which occurred
  74     const wxString GetLastErrorMessage();
  75
  76     /// Last Error
  77     int m_lasterror;
  78
  79 private:
  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  */
 102 wxChmTools::wxChmTools(const wxFileName &archive)
 103 {
 104     m_chmFileName = archive.GetFullPath();
 105
 106     wxASSERT_MSG( !m_chmFileName.empty(), wxT("empty archive name") );
 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));
 125
 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  */
 153 wxChmTools::~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  */
 181 bool 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
 207  *
 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  */
 212 const 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  */
 253 size_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  */
 298 struct 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
 318 const wxString wxChmTools::GetLastErrorMessage()
 319 {
 320     return ChmErrorMsg(m_lasterror);
 321 }
 322
 323 const 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
 360 class wxChmInputStream : public wxInputStream
 361 {
 362 public:
 363     /// Constructor
 364     wxChmInputStream(const wxString& archive,
 365                      const wxString& file, bool simulate = false);
 366     /// Destructor
 367     virtual ~wxChmInputStream();
 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
 376 protected:
 377     /// See wxInputStream
 378     virtual size_t OnSysRead(void *buffer, size_t bufsize);
 379     /// See wxInputStream
 380     virtual wxFileOffset OnSysSeek(wxFileOffset seek, wxSeekMode mode);
 381     /// See wxInputStream
 382     virtual wxFileOffset OnSysTell() const { return m_pos; }
 383
 384 private:
 385     size_t m_size;
 386     wxFileOffset m_pos;
 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
 417  *                 if false than class does nothing if it doesn't find .hhp
 418  */
 419 wxChmInputStream::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
 438         if ( m_fileName.Find(wxT(".hhp")) != wxNOT_FOUND && m_simulateHHP )
 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
 457 wxChmInputStream::~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
 470 bool 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
 480 size_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
 490     // than the buffer size, then only read the rest
 491     if ( m_pos + bufsize > m_size )
 492         bufsize = m_size - m_pos;
 493
 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;
 513 }
 514
 515
 516
 517
 518 wxFileOffset wxChmInputStream::OnSysSeek(wxFileOffset seek, wxSeekMode mode)
 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
 529     wxFileOffset nextpos;
 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.
 558  * For .chm doesn't include such a file, we need
 559  * to rebuild the information based on stored
 560  * system-files.
 561  */
 562 void
 563 wxChmInputStream::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
 574     // see http://bonedaddy.net/pabs3/chmspec/0.1.2/Internal.html#SYSTEM
 575     if ( ! m_chm->Contains(wxT("/#SYSTEM")) )
 576     {
 577 #ifdef DEBUG
 578         wxLogDebug("Archive doesn't contain #SYSTEM file");
 579 #endif
 580         return;
 581     }
 582     else
 583     {
 584         file = wxFileName(wxT("/#SYSTEM"));
 585     }
 586
 587     if ( CreateFileStream(wxT("/#SYSTEM")) )
 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);
 612             code = wxUINT16_SWAP_ON_BE( code ) ;
 613             i->Read(&len, 2);
 614             len = wxUINT16_SWAP_ON_BE( len ) ;
 615             // data
 616             buf = malloc(len);
 617             i->Read(buf, len);
 618
 619             switch (code)
 620             {
 621                 case 0: // CONTENTS_FILE
 622                     tmp = "Contents file=";
 623                     hhc=true;
 624                     break;
 625                 case 1: // INDEX_FILE
 626                     tmp = "Index file=";
 627                     hhk = true;
 628                     break;
 629                 case 2: // DEFAULT_TOPIC
 630                     tmp = "Default Topic=";
 631                     topic = true;
 632                     break;
 633                 case 3: // TITLE
 634                     tmp = "Title=";
 635                     break;
 636                 //       case 6: // COMPILED_FILE
 637                 //         tmp = "Compiled File=";
 638                 //         break;
 639                 case 7: // COMPILED_FILE
 640                     tmp = "Binary Index=YES\r\n";
 641                     out->Write( (const void *) tmp, strlen(tmp));
 642                     tmp = NULL;
 643                     break;
 644                 case 4: // STRUCT SYSTEM INFO
 645                     tmp = NULL ;
 646                     if ( len >= 28 )
 647                     {
 648                         char *structptr = (char*) buf ;
 649                         // LCID at position 0
 650                         wxUint32 dummy = *((wxUint32 *)(structptr+0)) ;
 651                         wxUint32 lcid = wxUINT32_SWAP_ON_BE( dummy ) ;
 652                         wxString msg ;
 653                         msg.Printf(wxT("Language=0x%X\r\n"),lcid) ;
 654                         out->Write(msg.c_str() , msg.length() ) ;
 655                     }
 656                     break ;
 657                 default:
 658                     tmp=NULL;
 659             }
 660
 661             if (tmp)
 662             {
 663                 out->Write((const void *) tmp, strlen(tmp));
 664                 out->Write(buf, strlen((char*)buf));
 665                 out->Write("\r\n", 2);
 666             }
 667
 668             free(buf);
 669             buf=NULL;
 670         }
 671
 672
 673         // Free the old data which wont be used any more
 674         delete m_contentStream;
 675         if (m_content)
 676             free (m_content);
 677
 678         // Now add entries which are missing
 679         if ( !hhc && m_chm->Contains(wxT("*.hhc")) )
 680         {
 681             tmp = "Contents File=*.hhc\r\n";
 682             out->Write((const void *) tmp, strlen(tmp));
 683         }
 684
 685         if ( !hhk && m_chm->Contains(wxT("*.hhk")) )
 686         {
 687             tmp = "Index File=*.hhk\r\n";
 688             out->Write((const void *) tmp, strlen(tmp));
 689         }
 690
 691         // Now copy the Data from the memory
 692         out->SeekO(0, wxFromEnd);
 693         m_size = out->TellO();
 694         out->SeekO(0, wxFromStart);
 695         m_content = (char *) malloc (m_size+1);
 696         out->CopyTo(m_content, m_size);
 697         m_content[m_size]='\0';
 698         m_size++;
 699         m_contentStream = new wxMemoryInputStream(m_content, m_size);
 700
 701         delete out;
 702     }
 703 }
 704
 705
 706 /**
 707  * Creates a Stream pointing to a virtual file in
 708  * the current archive
 709  */
 710 bool wxChmInputStream::CreateFileStream(const wxString& pattern)
 711 {
 712     wxFileInputStream * fin;
 713     wxString tmpfile = wxFileName::CreateTempFileName(wxT("chmstrm"));
 714
 715     if ( tmpfile.empty() )
 716     {
 717         wxLogError(_("Could not create temporary file '%s'"), tmpfile.c_str());
 718         return false;
 719     }
 720
 721     // try to extract the file
 722     if ( m_chm->Extract(pattern, tmpfile) <= 0 )
 723     {
 724         wxLogError(_("Extraction of '%s' into '%s' failed."),
 725                    pattern.c_str(), tmpfile.c_str());
 726         if ( wxFileExists(tmpfile) )
 727             wxRemoveFile(tmpfile);
 728         return false;
 729     }
 730     else
 731     {
 732         // Open a filestream to extracted file
 733         fin = new wxFileInputStream(tmpfile);
 734         if (!fin->IsOk())
 735             return false;
 736
 737         m_size = fin->GetSize();
 738         m_content = (char *) malloc(m_size+1);
 739         fin->Read(m_content, m_size);
 740         m_content[m_size]='\0';
 741
 742         wxRemoveFile(tmpfile);
 743
 744         delete fin;
 745
 746         m_contentStream = new wxMemoryInputStream (m_content, m_size);
 747
 748         return m_contentStream->IsOk();
 749     }
 750 }
 751
 752
 753
 754 // ----------------------------------------------------------------------------
 755 // wxChmFSHandler
 756 // ----------------------------------------------------------------------------
 757
 758 class wxChmFSHandler : public wxFileSystemHandler
 759 {
 760 public:
 761     /// Constructor and Destructor
 762     wxChmFSHandler();
 763     virtual ~wxChmFSHandler();
 764
 765     /// Is able to open location?
 766     virtual bool CanOpen(const wxString& location);
 767     /// Open a file
 768     virtual wxFSFile* OpenFile(wxFileSystem& fs, const wxString& location);
 769     /// Find first occurrence of spec
 770     virtual wxString FindFirst(const wxString& spec, int flags = 0);
 771     /// Find next occurrence of spec
 772     virtual wxString FindNext();
 773
 774 private:
 775     int m_lasterror;
 776     wxString m_pattern;
 777     wxString m_found;
 778     wxChmTools * m_chm;
 779 };
 780
 781 wxChmFSHandler::wxChmFSHandler() : wxFileSystemHandler()
 782 {
 783     m_lasterror=0;
 784     m_pattern=wxEmptyString;
 785     m_found=wxEmptyString;
 786     m_chm=NULL;
 787 }
 788
 789 wxChmFSHandler::~wxChmFSHandler()
 790 {
 791     if (m_chm)
 792         delete m_chm;
 793 }
 794
 795 bool wxChmFSHandler::CanOpen(const wxString& location)
 796 {
 797     wxString p = GetProtocol(location);
 798     return (p == wxT("chm")) &&
 799            (GetProtocol(GetLeftLocation(location)) == wxT("file"));
 800 }
 801
 802 wxFSFile* wxChmFSHandler::OpenFile(wxFileSystem& WXUNUSED(fs),
 803                                    const wxString& location)
 804 {
 805     wxString right = GetRightLocation(location);
 806     wxString left = GetLeftLocation(location);
 807
 808     wxInputStream *s;
 809
 810     int index;
 811
 812     if ( GetProtocol(left) != wxT("file") )
 813     {
 814         wxLogError(_("CHM handler currently supports only local files!"));
 815         return NULL;
 816     }
 817
 818     // Work around javascript
 819     wxString tmp = wxString(right);
 820     if ( tmp.MakeLower().Contains(wxT("javascipt")) && tmp.Contains(wxT("\'")) )
 821     {
 822         right = right.AfterFirst(wxT('\'')).BeforeLast(wxT('\''));
 823     }
 824
 825     // now work on the right location
 826     if (right.Contains(wxT("..")))
 827     {
 828         wxFileName abs(right);
 829         abs.MakeAbsolute(wxT("/"));
 830         right = abs.GetFullPath();
 831     }
 832
 833     // a workaround for absolute links to root
 834     if ( (index=right.Index(wxT("//"))) != wxNOT_FOUND )
 835     {
 836         right=wxString(right.Mid(index+1));
 837         wxLogWarning(_("Link contained '//', converted to absolute link."));
 838     }
 839
 840     wxFileName leftFilename = wxFileSystem::URLToFileName(left);
 841
 842     // Open a stream to read the content of the chm-file
 843     s = new wxChmInputStream(leftFilename.GetFullPath(), right, true);
 844
 845     if ( s )
 846     {
 847         return new wxFSFile(s,
 848                             left + wxT("#chm:") + right,
 849                             wxEmptyString,
 850                             GetAnchor(location),
 851                             wxDateTime(wxFileModificationTime(left)));
 852     }
 853
 854     delete s;
 855     return NULL;
 856 }
 857
 858
 859
 860 /**
 861  * Doku see wxFileSystemHandler
 862  */
 863 wxString wxChmFSHandler::FindFirst(const wxString& spec, int flags)
 864 {
 865     wxString right = GetRightLocation(spec);
 866     wxString left = GetLeftLocation(spec);
 867     wxString nativename = wxFileSystem::URLToFileName(left).GetFullPath();
 868
 869     if ( GetProtocol(left) != wxT("file") )
 870     {
 871         wxLogError(_("CHM handler currently supports only local files!"));
 872         return wxEmptyString;
 873     }
 874
 875     m_chm = new wxChmTools(wxFileName(nativename));
 876     m_pattern = right.AfterLast(wxT('/'));
 877
 878     wxString m_found = m_chm->Find(m_pattern);
 879
 880     // now fake around hhp-files which are not existing in projects...
 881     if (m_found.empty() &&
 882         m_pattern.Contains(wxT(".hhp")) &&
 883         !m_pattern.Contains(wxT(".hhp.cached")))
 884     {
 885         m_found.Printf(wxT("%s#chm:%s.hhp"),
 886                        left.c_str(), m_pattern.BeforeLast(wxT('.')).c_str());
 887     }
 888
 889     return m_found;
 890
 891 }
 892
 893
 894
 895 wxString wxChmFSHandler::FindNext()
 896 {
 897     if (m_pattern.empty())
 898         return wxEmptyString;
 899     else
 900         return m_chm->Find(m_pattern, m_found);
 901 }
 902
 903 // ---------------------------------------------------------------------------
 904 // wxModule to register CHM handler
 905 // ---------------------------------------------------------------------------
 906
 907 class wxChmSupportModule : public wxModule
 908 {
 909     DECLARE_DYNAMIC_CLASS(wxChmSupportModule)
 910
 911 public:
 912     virtual bool OnInit()
 913     {
 914         wxFileSystem::AddHandler(new wxChmFSHandler);
 915         return true;
 916     }
 917     virtual void OnExit() {}
 918 }
 919 ;
 920
 921 IMPLEMENT_DYNAMIC_CLASS(wxChmSupportModule, wxModule)
 922
 923 #endif // wxUSE_LIBMSPACK