src/html/chm.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 WXPRECOMP
  21 #include "wx/intl.h"
  22 #include "wx/log.h"
  23 #endif
  24
  25 #include "wx/module.h"
  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 occured
  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(), _T("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     ~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 off_t OnSysSeek(off_t seek, wxSeekMode mode);
 381     /// See wxInputStream
 382     virtual off_t OnSysTell() const { return m_pos; }
 383
 384 private:
 385     size_t m_size;
 386     off_t 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 doesnt 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(_T(".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, than only read the rest
 491     if ( m_pos + bufsize > m_size )
 492         bufsize = m_size - m_pos;
 493
 494     m_contentStream->SeekI(m_pos);
 495     m_contentStream->Read(buffer, bufsize);
 496     m_pos +=bufsize;
 497     m_contentStream->SeekI(m_pos);
 498     return bufsize;
 499 }
 500
 501
 502
 503
 504 off_t wxChmInputStream::OnSysSeek(off_t seek, wxSeekMode mode)
 505 {
 506     wxString mode_str = wxEmptyString;
 507
 508     if ( !m_contentStream || m_contentStream->Eof() )
 509     {
 510         m_lasterror = wxSTREAM_EOF;
 511         return 0;
 512     }
 513     m_lasterror = wxSTREAM_NO_ERROR;
 514
 515     off_t nextpos;
 516
 517     switch ( mode )
 518     {
 519         case wxFromCurrent:
 520             nextpos = seek + m_pos;
 521             break;
 522         case wxFromStart:
 523             nextpos = seek;
 524             break;
 525         case wxFromEnd:
 526             nextpos = m_size - 1 + seek;
 527             break;
 528         default:
 529             nextpos = m_pos;
 530             break; /* just to fool compiler, never happens */
 531     }
 532     m_pos=nextpos;
 533
 534     // Set current position on stream
 535     m_contentStream->SeekI(m_pos);
 536     return m_pos;
 537 }
 538
 539
 540
 541 /**
 542  * Help Browser tries to read the contents of the
 543  * file by interpreting a .hhp file in the Archiv.
 544  * For .chm doesnt include such a file, we need
 545  * to rebuild the information based on stored
 546  * system-files.
 547  */
 548 void
 549 wxChmInputStream::CreateHHPStream()
 550 {
 551     wxFileName file;
 552     bool topic = false;
 553     bool hhc = false;
 554     bool hhk = false;
 555     wxInputStream *i;
 556     wxMemoryOutputStream *out;
 557     const char *tmp;
 558
 559     // Try to open the #SYSTEM-File and create the HHP File out of it
 560     // see http://bonedaddy.net/pabs3/chmspec/0.1/ch05s03.html#SYSTEM
 561     if ( ! m_chm->Contains(_("/#SYSTEM")) )
 562     {
 563 #ifdef DEBUG
 564         wxLogDebug("Archive doesnt contain #SYSTEM file");
 565 #endif
 566         return;
 567     }
 568     else
 569     {
 570         file = wxFileName(_T("/#SYSTEM"));
 571     }
 572
 573     if ( CreateFileStream(_T("/#SYSTEM")) )
 574     {
 575         // New stream for writing a memory area to simulate the
 576         // .hhp-file
 577         out = new wxMemoryOutputStream();
 578
 579         tmp = "[OPTIONS]\r\n";
 580         out->Write((const void *) tmp, strlen(tmp));
 581
 582         wxUint16 code;
 583         wxUint16 len;
 584         void *buf;
 585
 586         // use the actual stream for reading
 587         i = m_contentStream;
 588
 589         /* Now read the contents, and try to get the needed information */
 590
 591         // First 4 Bytes are Version information, skip
 592         i->SeekI(4);
 593
 594         while (!i->Eof())
 595         {
 596             // Read #SYSTEM-Code and length
 597             i->Read(&code, 2);
 598             i->Read(&len, 2);
 599             // data
 600             buf = malloc(len);
 601             i->Read(buf, len);
 602
 603             switch (code)
 604             {
 605                 case 0: // CONTENTS_FILE
 606                     tmp = "Contents file=";
 607                     hhc=true;
 608                     break;
 609                 case 1: // INDEX_FILE
 610                     tmp = "Index file=";
 611                     hhk = true;
 612                     break;
 613                 case 2: // DEFAULT_TOPIC
 614                     tmp = "Default Topic=";
 615                     topic = true;
 616                     break;
 617                 case 3: // TITLE
 618                     tmp = "Title=";
 619                     break;
 620                 //       case 6: // COMPILED_FILE
 621                 //         tmp = "Compiled File=";
 622                 //         break;
 623                 case 7: // COMPILED_FILE
 624                     tmp = "Binary Index=YES\r\n";
 625                     out->Write( (const void *) tmp, strlen(tmp));
 626                     tmp = NULL;
 627                     break;
 628                 case 4: // STRUCT
 629                 default:
 630                     tmp=NULL;
 631             }
 632
 633             if (tmp)
 634             {
 635                 out->Write((const void *) tmp, strlen(tmp));
 636                 out->Write(buf, strlen((char*)buf));
 637                 out->Write("\r\n", 2);
 638             }
 639
 640             free(buf);
 641             buf=NULL;
 642         }
 643
 644
 645         // Free the old data which wont be used any more
 646         delete m_contentStream;
 647         if (m_content)
 648             free (m_content);
 649
 650         // Now add entries which are missing
 651         if ( !hhc && m_chm->Contains(_T("*.hhc")) )
 652         {
 653             tmp = "Contents File=*.hhc\r\n";
 654             out->Write((const void *) tmp, strlen(tmp));
 655         }
 656
 657         if ( !hhk && m_chm->Contains(_T("*.hhk")) )
 658         {
 659             tmp = "Index File=*.hhk\r\n";
 660             out->Write((const void *) tmp, strlen(tmp));
 661         }
 662
 663         // Now copy the Data from the memory
 664         out->SeekO(0, wxFromEnd);
 665         m_size = out->TellO();
 666         out->SeekO(0, wxFromStart);
 667         m_content = (char *) malloc (m_size+1);
 668         out->CopyTo(m_content, m_size);
 669         m_content[m_size]='\0';
 670         m_size++;
 671         m_contentStream = new wxMemoryInputStream(m_content, m_size);
 672
 673         delete out;
 674     }
 675 }
 676
 677
 678 /**
 679  * Creates a Stream pointing to a virtual file in
 680  * the current archive
 681  */
 682 bool wxChmInputStream::CreateFileStream(const wxString& pattern)
 683 {
 684     wxFileInputStream * fin;
 685     wxString tmpfile = wxFileName::CreateTempFileName(_T("chmstrm"), NULL);
 686
 687     if ( tmpfile.empty() )
 688     {
 689         wxLogError(_("Could not create temporary file '%s'"), tmpfile.c_str());
 690         return false;
 691     }
 692
 693     // try to extract the file
 694     if ( m_chm->Extract(pattern, tmpfile) <= 0 )
 695     {
 696         wxLogError(_("Extraction of '%s' into '%s' failed."),
 697                    pattern.c_str(), tmpfile.c_str());
 698         if ( wxFileExists(tmpfile) )
 699             wxRemoveFile(tmpfile);
 700         return false;
 701     }
 702     else
 703     {
 704         // Open a filestream to extracted file
 705         fin = new wxFileInputStream(tmpfile);
 706         m_size = fin->GetSize();
 707         m_content = (char *) malloc(m_size+1);
 708         fin->Read(m_content, m_size);
 709         m_content[m_size]='\0';
 710
 711         wxRemoveFile(tmpfile);
 712
 713         delete fin;
 714
 715         m_contentStream = new wxMemoryInputStream (m_content, m_size);
 716
 717         return m_contentStream->IsOk();
 718     }
 719 }
 720
 721
 722
 723 // ----------------------------------------------------------------------------
 724 // wxChmFSHandler
 725 // ----------------------------------------------------------------------------
 726
 727 class wxChmFSHandler : public wxFileSystemHandler
 728 {
 729 public:
 730     /// Constructor and Destructor
 731     wxChmFSHandler();
 732     ~wxChmFSHandler();
 733
 734     /// Is able to open location?
 735     virtual bool CanOpen(const wxString& location);
 736     /// Open a file
 737     virtual wxFSFile* OpenFile(wxFileSystem& fs, const wxString& location);
 738     /// Find first occurence of spec
 739     virtual wxString FindFirst(const wxString& spec, int flags = 0);
 740     /// Find next occurence of spec
 741     virtual wxString FindNext();
 742
 743 private:
 744     int m_lasterror;
 745     wxString m_pattern;
 746     wxString m_found;
 747     wxChmTools * m_chm;
 748 };
 749
 750 wxChmFSHandler::wxChmFSHandler() : wxFileSystemHandler()
 751 {
 752     m_lasterror=0;
 753     m_pattern=wxEmptyString;
 754     m_found=wxEmptyString;
 755     m_chm=NULL;
 756 }
 757
 758 wxChmFSHandler::~wxChmFSHandler()
 759 {
 760     if (m_chm)
 761         delete m_chm;
 762 }
 763
 764 bool wxChmFSHandler::CanOpen(const wxString& location)
 765 {
 766     wxString p = GetProtocol(location);
 767     return (p == _T("chm")) &&
 768            (GetProtocol(GetLeftLocation(location)) == _T("file"));
 769 }
 770
 771 wxFSFile* wxChmFSHandler::OpenFile(wxFileSystem& WXUNUSED(fs),
 772                                    const wxString& location)
 773 {
 774     wxString right = GetRightLocation(location);
 775     wxString left = GetLeftLocation(location);
 776
 777     wxInputStream *s;
 778
 779     int index;
 780
 781     if ( GetProtocol(left) != _T("file") )
 782     {
 783         wxLogError(_("CHM handler currently supports only local files!"));
 784         return NULL;
 785     }
 786
 787     // Work around javascript
 788     wxString tmp = wxString(right);
 789     if ( tmp.MakeLower().Contains(_T("javascipt")) && tmp.Contains(_T("\'")) )
 790     {
 791         right = right.AfterFirst(_T('\'')).BeforeLast(_T('\''));
 792     }
 793
 794     // now work on the right location
 795     if (right.Contains(_T("..")))
 796     {
 797         wxFileName abs(right);
 798         abs.MakeAbsolute(_T("/"));
 799         right = abs.GetFullPath();
 800     }
 801
 802     // a workaround for absolute links to root
 803     if ( (index=right.Index(_T("//"))) != wxNOT_FOUND )
 804     {
 805         right=wxString(right.Mid(index+1));
 806         wxLogWarning(_("Link contained '//', converted to absolute link."));
 807     }
 808
 809     wxFileName leftFilename = wxFileSystem::URLToFileName(left);
 810
 811     // Open a stream to read the content of the chm-file
 812     s = new wxChmInputStream(leftFilename.GetFullPath(), right, true);
 813
 814     wxString mime = GetMimeTypeFromExt(location);
 815
 816     if ( s )
 817     {
 818         return new wxFSFile(s,
 819                             left + _T("#chm:") + right,
 820                             mime,
 821                             GetAnchor(location),
 822                             wxDateTime(wxFileModificationTime(left)));
 823     }
 824
 825     delete s;
 826     return NULL;
 827 }
 828
 829
 830
 831 /**
 832  * Doku see wxFileSystemHandler
 833  */
 834 wxString wxChmFSHandler::FindFirst(const wxString& spec, int flags)
 835 {
 836     wxString right = GetRightLocation(spec);
 837     wxString left = GetLeftLocation(spec);
 838     wxString nativename = wxFileSystem::URLToFileName(left).GetFullPath();
 839
 840     if ( GetProtocol(left) != _T("file") )
 841     {
 842         wxLogError(_("CHM handler currently supports only local files!"));
 843         return wxEmptyString;
 844     }
 845
 846     m_chm = new wxChmTools(wxFileName(nativename));
 847     m_pattern = right.AfterLast(_T('/'));
 848
 849     wxString m_found = m_chm->Find(m_pattern);
 850
 851     // now fake around hhp-files which are not existing in projects...
 852     if (m_found.empty() &&
 853         m_pattern.Contains(_T(".hhp")) &&
 854         !m_pattern.Contains(_T(".hhp.cached")))
 855     {
 856         m_found.Printf(_T("%s#chm:%s.hhp"),
 857                        left.c_str(), m_pattern.BeforeLast(_T('.')).c_str());
 858     }
 859
 860     return m_found;
 861
 862 }
 863
 864
 865
 866 wxString wxChmFSHandler::FindNext()
 867 {
 868     if (m_pattern.empty())
 869         return wxEmptyString;
 870     else
 871         return m_chm->Find(m_pattern, m_found);
 872 }
 873
 874 // ---------------------------------------------------------------------------
 875 // wxModule to register CHM handler
 876 // ---------------------------------------------------------------------------
 877
 878 class wxChmSupportModule : public wxModule
 879 {
 880     DECLARE_DYNAMIC_CLASS(wxChmSupportModule)
 881
 882 public:
 883     virtual bool OnInit()
 884     {
 885         wxFileSystem::AddHandler(new wxChmFSHandler);
 886         return true;
 887     }
 888     virtual void OnExit() {}
 889 }
 890 ;
 891
 892 IMPLEMENT_DYNAMIC_CLASS(wxChmSupportModule, wxModule)
 893
 894 #endif // wxUSE_LIBMSPACK