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                     if (len)
 623                     {
 624                         tmp = "Contents file=";
 625                         hhc=true;
 626                     }
 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;
 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 ) ;
 655                         char msg[64];
 656                         int len = sprintf(msg, "Language=0x%X\r\n", lcid) ;
 657                         if (len > 0)
 658                             out->Write(msg, len) ;
 659                     }
 660                     break ;
 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
 683         if ( !hhc && m_chm->Contains(wxT("*.hhc")) )
 684         {
 685             tmp = "Contents File=*.hhc\r\n";
 686             out->Write((const void *) tmp, strlen(tmp));
 687         }
 688
 689         if ( !hhk && m_chm->Contains(wxT("*.hhk")) )
 690         {
 691             tmp = "Index File=*.hhk\r\n";
 692             out->Write((const void *) tmp, strlen(tmp));
 693         }
 694
 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  */
 714 bool wxChmInputStream::CreateFileStream(const wxString& pattern)
 715 {
 716     wxFileInputStream * fin;
 717     wxString tmpfile = wxFileName::CreateTempFileName(wxT("chmstrm"));
 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);
 738         if (!fin->IsOk())
 739             return false;
 740
 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
 762 class wxChmFSHandler : public wxFileSystemHandler
 763 {
 764 public:
 765     /// Constructor and Destructor
 766     wxChmFSHandler();
 767     virtual ~wxChmFSHandler();
 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);
 773     /// Find first occurrence of spec
 774     virtual wxString FindFirst(const wxString& spec, int flags = 0);
 775     /// Find next occurrence of spec
 776     virtual wxString FindNext();
 777
 778 private:
 779     int m_lasterror;
 780     wxString m_pattern;
 781     wxString m_found;
 782     wxChmTools * m_chm;
 783 };
 784
 785 wxChmFSHandler::wxChmFSHandler() : wxFileSystemHandler()
 786 {
 787     m_lasterror=0;
 788     m_pattern=wxEmptyString;
 789     m_found=wxEmptyString;
 790     m_chm=NULL;
 791 }
 792
 793 wxChmFSHandler::~wxChmFSHandler()
 794 {
 795     if (m_chm)
 796         delete m_chm;
 797 }
 798
 799 bool wxChmFSHandler::CanOpen(const wxString& location)
 800 {
 801     wxString p = GetProtocol(location);
 802     return (p == wxT("chm")) &&
 803            (GetProtocol(GetLeftLocation(location)) == wxT("file"));
 804 }
 805
 806 wxFSFile* 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
 816     if ( GetProtocol(left) != wxT("file") )
 817     {
 818         wxLogError(_("CHM handler currently supports only local files!"));
 819         return NULL;
 820     }
 821
 822     // Work around javascript
 823     wxString tmp = wxString(right);
 824     if ( tmp.MakeLower().Contains(wxT("javascipt")) && tmp.Contains(wxT("\'")) )
 825     {
 826         right = right.AfterFirst(wxT('\'')).BeforeLast(wxT('\''));
 827     }
 828
 829     // now work on the right location
 830     if (right.Contains(wxT("..")))
 831     {
 832         wxFileName abs(right);
 833         abs.MakeAbsolute(wxT("/"));
 834         right = abs.GetFullPath();
 835     }
 836
 837     // a workaround for absolute links to root
 838     if ( (index=right.Index(wxT("//"))) != wxNOT_FOUND )
 839     {
 840         right=wxString(right.Mid(index+1));
 841         wxLogWarning(_("Link contained '//', converted to absolute link."));
 842     }
 843
 844     wxFileName leftFilename = wxFileSystem::URLToFileName(left);
 845     if (!leftFilename.FileExists())
 846         return NULL;
 847
 848     // Open a stream to read the content of the chm-file
 849     s = new wxChmInputStream(leftFilename.GetFullPath(), right, true);
 850
 851     if ( s )
 852     {
 853         return new wxFSFile(s,
 854                             left + wxT("#chm:") + right,
 855                             wxEmptyString,
 856                             GetAnchor(location),
 857                             wxDateTime(leftFilename.GetModificationTime()));
 858     }
 859
 860     delete s;
 861     return NULL;
 862 }
 863
 864
 865
 866 /**
 867  * Doku see wxFileSystemHandler
 868  */
 869 wxString 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
 875     if ( GetProtocol(left) != wxT("file") )
 876     {
 877         wxLogError(_("CHM handler currently supports only local files!"));
 878         return wxEmptyString;
 879     }
 880
 881     m_chm = new wxChmTools(wxFileName(nativename));
 882     m_pattern = right.AfterLast(wxT('/'));
 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() &&
 888         m_pattern.Contains(wxT(".hhp")) &&
 889         !m_pattern.Contains(wxT(".hhp.cached")))
 890     {
 891         m_found.Printf(wxT("%s#chm:%s.hhp"),
 892                        left.c_str(), m_pattern.BeforeLast(wxT('.')).c_str());
 893     }
 894
 895     return m_found;
 896
 897 }
 898
 899
 900
 901 wxString 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
 913 class wxChmSupportModule : public wxModule
 914 {
 915     DECLARE_DYNAMIC_CLASS(wxChmSupportModule)
 916
 917 public:
 918     virtual bool OnInit()
 919     {
 920         wxFileSystem::AddHandler(new wxChmFSHandler);
 921         return true;
 922     }
 923     virtual void OnExit() {}
 924 }
 925 ;
 926
 927 IMPLEMENT_DYNAMIC_CLASS(wxChmSupportModule, wxModule)
 928
 929 #endif // wxUSE_LIBMSPACK