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 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 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 wxFileOffset wxChmInputStream::OnSysSeek(wxFileOffset 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     wxFileOffset 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.2/Internal.html#SYSTEM
 561     if ( ! m_chm->Contains(_T("/#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             code = wxUINT16_SWAP_ON_BE( code ) ;
 599             i->Read(&len, 2);
 600             len = wxUINT16_SWAP_ON_BE( len ) ;
 601             // data
 602             buf = malloc(len);
 603             i->Read(buf, len);
 604
 605             switch (code)
 606             {
 607                 case 0: // CONTENTS_FILE
 608                     tmp = "Contents file=";
 609                     hhc=true;
 610                     break;
 611                 case 1: // INDEX_FILE
 612                     tmp = "Index file=";
 613                     hhk = true;
 614                     break;
 615                 case 2: // DEFAULT_TOPIC
 616                     tmp = "Default Topic=";
 617                     topic = true;
 618                     break;
 619                 case 3: // TITLE
 620                     tmp = "Title=";
 621                     break;
 622                 //       case 6: // COMPILED_FILE
 623                 //         tmp = "Compiled File=";
 624                 //         break;
 625                 case 7: // COMPILED_FILE
 626                     tmp = "Binary Index=YES\r\n";
 627                     out->Write( (const void *) tmp, strlen(tmp));
 628                     tmp = NULL;
 629                     break;
 630                 case 4: // STRUCT SYSTEM INFO
 631                     tmp = NULL ;
 632                     if ( len >= 28 )
 633                     {
 634                         char *structptr = (char*) buf ;
 635                         // LCID at position 0
 636                         wxUint32 dummy = *((wxUint32 *)(structptr+0)) ;
 637                         wxUint32 lcid = wxUINT32_SWAP_ON_BE( dummy ) ;
 638                         wxString msg ;
 639                         msg.Printf(_T("Language=0x%X\r\n"),lcid) ;
 640                         out->Write(msg.c_str() , msg.Length() ) ;
 641                     }
 642                     break ;
 643                 default:
 644                     tmp=NULL;
 645             }
 646
 647             if (tmp)
 648             {
 649                 out->Write((const void *) tmp, strlen(tmp));
 650                 out->Write(buf, strlen((char*)buf));
 651                 out->Write("\r\n", 2);
 652             }
 653
 654             free(buf);
 655             buf=NULL;
 656         }
 657
 658
 659         // Free the old data which wont be used any more
 660         delete m_contentStream;
 661         if (m_content)
 662             free (m_content);
 663
 664         // Now add entries which are missing
 665         if ( !hhc && m_chm->Contains(_T("*.hhc")) )
 666         {
 667             tmp = "Contents File=*.hhc\r\n";
 668             out->Write((const void *) tmp, strlen(tmp));
 669         }
 670
 671         if ( !hhk && m_chm->Contains(_T("*.hhk")) )
 672         {
 673             tmp = "Index File=*.hhk\r\n";
 674             out->Write((const void *) tmp, strlen(tmp));
 675         }
 676
 677         // Now copy the Data from the memory
 678         out->SeekO(0, wxFromEnd);
 679         m_size = out->TellO();
 680         out->SeekO(0, wxFromStart);
 681         m_content = (char *) malloc (m_size+1);
 682         out->CopyTo(m_content, m_size);
 683         m_content[m_size]='\0';
 684         m_size++;
 685         m_contentStream = new wxMemoryInputStream(m_content, m_size);
 686
 687         delete out;
 688     }
 689 }
 690
 691
 692 /**
 693  * Creates a Stream pointing to a virtual file in
 694  * the current archive
 695  */
 696 bool wxChmInputStream::CreateFileStream(const wxString& pattern)
 697 {
 698     wxFileInputStream * fin;
 699     wxString tmpfile = wxFileName::CreateTempFileName(_T("chmstrm"), NULL);
 700
 701     if ( tmpfile.empty() )
 702     {
 703         wxLogError(_("Could not create temporary file '%s'"), tmpfile.c_str());
 704         return false;
 705     }
 706
 707     // try to extract the file
 708     if ( m_chm->Extract(pattern, tmpfile) <= 0 )
 709     {
 710         wxLogError(_("Extraction of '%s' into '%s' failed."),
 711                    pattern.c_str(), tmpfile.c_str());
 712         if ( wxFileExists(tmpfile) )
 713             wxRemoveFile(tmpfile);
 714         return false;
 715     }
 716     else
 717     {
 718         // Open a filestream to extracted file
 719         fin = new wxFileInputStream(tmpfile);
 720         m_size = fin->GetSize();
 721         m_content = (char *) malloc(m_size+1);
 722         fin->Read(m_content, m_size);
 723         m_content[m_size]='\0';
 724
 725         wxRemoveFile(tmpfile);
 726
 727         delete fin;
 728
 729         m_contentStream = new wxMemoryInputStream (m_content, m_size);
 730
 731         return m_contentStream->IsOk();
 732     }
 733 }
 734
 735
 736
 737 // ----------------------------------------------------------------------------
 738 // wxChmFSHandler
 739 // ----------------------------------------------------------------------------
 740
 741 class wxChmFSHandler : public wxFileSystemHandler
 742 {
 743 public:
 744     /// Constructor and Destructor
 745     wxChmFSHandler();
 746     ~wxChmFSHandler();
 747
 748     /// Is able to open location?
 749     virtual bool CanOpen(const wxString& location);
 750     /// Open a file
 751     virtual wxFSFile* OpenFile(wxFileSystem& fs, const wxString& location);
 752     /// Find first occurence of spec
 753     virtual wxString FindFirst(const wxString& spec, int flags = 0);
 754     /// Find next occurence of spec
 755     virtual wxString FindNext();
 756
 757 private:
 758     int m_lasterror;
 759     wxString m_pattern;
 760     wxString m_found;
 761     wxChmTools * m_chm;
 762 };
 763
 764 wxChmFSHandler::wxChmFSHandler() : wxFileSystemHandler()
 765 {
 766     m_lasterror=0;
 767     m_pattern=wxEmptyString;
 768     m_found=wxEmptyString;
 769     m_chm=NULL;
 770 }
 771
 772 wxChmFSHandler::~wxChmFSHandler()
 773 {
 774     if (m_chm)
 775         delete m_chm;
 776 }
 777
 778 bool wxChmFSHandler::CanOpen(const wxString& location)
 779 {
 780     wxString p = GetProtocol(location);
 781     return (p == _T("chm")) &&
 782            (GetProtocol(GetLeftLocation(location)) == _T("file"));
 783 }
 784
 785 wxFSFile* wxChmFSHandler::OpenFile(wxFileSystem& WXUNUSED(fs),
 786                                    const wxString& location)
 787 {
 788     wxString right = GetRightLocation(location);
 789     wxString left = GetLeftLocation(location);
 790
 791     wxInputStream *s;
 792
 793     int index;
 794
 795     if ( GetProtocol(left) != _T("file") )
 796     {
 797         wxLogError(_("CHM handler currently supports only local files!"));
 798         return NULL;
 799     }
 800
 801     // Work around javascript
 802     wxString tmp = wxString(right);
 803     if ( tmp.MakeLower().Contains(_T("javascipt")) && tmp.Contains(_T("\'")) )
 804     {
 805         right = right.AfterFirst(_T('\'')).BeforeLast(_T('\''));
 806     }
 807
 808     // now work on the right location
 809     if (right.Contains(_T("..")))
 810     {
 811         wxFileName abs(right);
 812         abs.MakeAbsolute(_T("/"));
 813         right = abs.GetFullPath();
 814     }
 815
 816     // a workaround for absolute links to root
 817     if ( (index=right.Index(_T("//"))) != wxNOT_FOUND )
 818     {
 819         right=wxString(right.Mid(index+1));
 820         wxLogWarning(_("Link contained '//', converted to absolute link."));
 821     }
 822
 823     wxFileName leftFilename = wxFileSystem::URLToFileName(left);
 824
 825     // Open a stream to read the content of the chm-file
 826     s = new wxChmInputStream(leftFilename.GetFullPath(), right, true);
 827
 828     wxString mime = GetMimeTypeFromExt(location);
 829
 830     if ( s )
 831     {
 832         return new wxFSFile(s,
 833                             left + _T("#chm:") + right,
 834                             mime,
 835                             GetAnchor(location),
 836                             wxDateTime(wxFileModificationTime(left)));
 837     }
 838
 839     delete s;
 840     return NULL;
 841 }
 842
 843
 844
 845 /**
 846  * Doku see wxFileSystemHandler
 847  */
 848 wxString wxChmFSHandler::FindFirst(const wxString& spec, int flags)
 849 {
 850     wxString right = GetRightLocation(spec);
 851     wxString left = GetLeftLocation(spec);
 852     wxString nativename = wxFileSystem::URLToFileName(left).GetFullPath();
 853
 854     if ( GetProtocol(left) != _T("file") )
 855     {
 856         wxLogError(_("CHM handler currently supports only local files!"));
 857         return wxEmptyString;
 858     }
 859
 860     m_chm = new wxChmTools(wxFileName(nativename));
 861     m_pattern = right.AfterLast(_T('/'));
 862
 863     wxString m_found = m_chm->Find(m_pattern);
 864
 865     // now fake around hhp-files which are not existing in projects...
 866     if (m_found.empty() &&
 867         m_pattern.Contains(_T(".hhp")) &&
 868         !m_pattern.Contains(_T(".hhp.cached")))
 869     {
 870         m_found.Printf(_T("%s#chm:%s.hhp"),
 871                        left.c_str(), m_pattern.BeforeLast(_T('.')).c_str());
 872     }
 873
 874     return m_found;
 875
 876 }
 877
 878
 879
 880 wxString wxChmFSHandler::FindNext()
 881 {
 882     if (m_pattern.empty())
 883         return wxEmptyString;
 884     else
 885         return m_chm->Find(m_pattern, m_found);
 886 }
 887
 888 // ---------------------------------------------------------------------------
 889 // wxModule to register CHM handler
 890 // ---------------------------------------------------------------------------
 891
 892 class wxChmSupportModule : public wxModule
 893 {
 894     DECLARE_DYNAMIC_CLASS(wxChmSupportModule)
 895
 896 public:
 897     virtual bool OnInit()
 898     {
 899         wxFileSystem::AddHandler(new wxChmFSHandler);
 900         return true;
 901     }
 902     virtual void OnExit() {}
 903 }
 904 ;
 905
 906 IMPLEMENT_DYNAMIC_CLASS(wxChmSupportModule, wxModule)
 907
 908 #endif // wxUSE_LIBMSPACK