5a969262e1
Compile without fontmapper. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@31255 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
1035 lines
27 KiB
C++
1035 lines
27 KiB
C++
/////////////////////////////////////////////////////////////////////////////
|
|
// Name: helpdata.cpp
|
|
// Purpose: wxHtmlHelpData
|
|
// Notes: Based on htmlhelp.cpp, implementing a monolithic
|
|
// HTML Help controller class, by Vaclav Slavik
|
|
// Author: Harm van der Heijden and Vaclav Slavik
|
|
// RCS-ID: $Id$
|
|
// Copyright: (c) Harm van der Heijden and Vaclav Slavik
|
|
// Licence: wxWindows licence
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
|
|
#pragma implementation "helpdata.h"
|
|
#endif
|
|
|
|
// For compilers that support precompilation, includes "wx.h".
|
|
#include "wx/wxprec.h"
|
|
|
|
#ifdef __BORLANDC__
|
|
#pragma hdrstop
|
|
#endif
|
|
|
|
#include "wx/defs.h"
|
|
|
|
#if wxUSE_HTML && wxUSE_STREAMS
|
|
|
|
#ifndef WXPRECOMP
|
|
#include "wx/intl.h"
|
|
#include "wx/log.h"
|
|
#endif
|
|
|
|
#include <ctype.h>
|
|
|
|
#include "wx/html/helpdata.h"
|
|
#include "wx/tokenzr.h"
|
|
#include "wx/wfstream.h"
|
|
#include "wx/busyinfo.h"
|
|
#include "wx/encconv.h"
|
|
#include "wx/fontmap.h"
|
|
#include "wx/log.h"
|
|
#include "wx/html/htmlpars.h"
|
|
#include "wx/html/htmldefs.h"
|
|
#include "wx/html/htmlfilt.h"
|
|
#include "wx/filename.h"
|
|
|
|
#include "wx/arrimpl.cpp"
|
|
WX_DEFINE_OBJARRAY(wxHtmlBookRecArray)
|
|
WX_DEFINE_OBJARRAY(wxHtmlHelpDataItems)
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// static helper functions
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Reads one line, stores it into buf and returns pointer to new line or NULL.
|
|
static const wxChar* ReadLine(const wxChar *line, wxChar *buf, size_t bufsize)
|
|
{
|
|
wxChar *writeptr = buf;
|
|
wxChar *endptr = buf + bufsize - 1;
|
|
const wxChar *readptr = line;
|
|
|
|
while (*readptr != 0 && *readptr != _T('\r') && *readptr != _T('\n') &&
|
|
writeptr != endptr)
|
|
*(writeptr++) = *(readptr++);
|
|
*writeptr = 0;
|
|
while (*readptr == _T('\r') || *readptr == _T('\n'))
|
|
readptr++;
|
|
if (*readptr == 0)
|
|
return NULL;
|
|
else
|
|
return readptr;
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
wxHtmlHelpIndexCompareFunc(wxHtmlHelpDataItem **a, wxHtmlHelpDataItem **b)
|
|
{
|
|
wxHtmlHelpDataItem *ia = *a;
|
|
wxHtmlHelpDataItem *ib = *b;
|
|
|
|
if (ia == NULL)
|
|
return -1;
|
|
if (ib == NULL)
|
|
return 1;
|
|
|
|
if (ia->parent == ib->parent)
|
|
{
|
|
return ia->name.CmpNoCase(ib->name);
|
|
}
|
|
else if (ia->level == ib->level)
|
|
{
|
|
return wxHtmlHelpIndexCompareFunc(&ia->parent, &ib->parent);
|
|
}
|
|
else
|
|
{
|
|
wxHtmlHelpDataItem *ia2 = ia;
|
|
wxHtmlHelpDataItem *ib2 = ib;
|
|
|
|
while (ia2->level > ib2->level)
|
|
{
|
|
ia2 = ia2->parent;
|
|
}
|
|
while (ib2->level > ia2->level)
|
|
{
|
|
ib2 = ib2->parent;
|
|
}
|
|
|
|
wxASSERT(ia2);
|
|
wxASSERT(ib2);
|
|
int res = wxHtmlHelpIndexCompareFunc(&ia2, &ib2);
|
|
if (res != 0)
|
|
return res;
|
|
else if (ia->level > ib->level)
|
|
return 1;
|
|
else
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// HP_Parser
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class HP_Parser : public wxHtmlParser
|
|
{
|
|
public:
|
|
HP_Parser()
|
|
{
|
|
GetEntitiesParser()->SetEncoding(wxFONTENCODING_ISO8859_1);
|
|
}
|
|
|
|
wxObject* GetProduct() { return NULL; }
|
|
|
|
protected:
|
|
virtual void AddText(const wxChar* WXUNUSED(txt)) {}
|
|
|
|
DECLARE_NO_COPY_CLASS(HP_Parser)
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// HP_TagHandler
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class HP_TagHandler : public wxHtmlTagHandler
|
|
{
|
|
private:
|
|
wxString m_name, m_page;
|
|
int m_level;
|
|
int m_id;
|
|
int m_index;
|
|
int m_count;
|
|
wxHtmlHelpDataItem *m_parentItem;
|
|
wxHtmlBookRecord *m_book;
|
|
|
|
wxHtmlHelpDataItems *m_data;
|
|
|
|
public:
|
|
HP_TagHandler(wxHtmlBookRecord *b) : wxHtmlTagHandler()
|
|
{
|
|
m_data = NULL;
|
|
m_book = b;
|
|
m_name = m_page = wxEmptyString;
|
|
m_level = 0;
|
|
m_id = wxID_ANY;
|
|
m_count = 0;
|
|
m_parentItem = NULL;
|
|
}
|
|
wxString GetSupportedTags() { return wxT("UL,OBJECT,PARAM"); }
|
|
bool HandleTag(const wxHtmlTag& tag);
|
|
|
|
void Reset(wxHtmlHelpDataItems& data)
|
|
{
|
|
m_data = &data;
|
|
m_count = 0;
|
|
m_level = 0;
|
|
m_parentItem = NULL;
|
|
}
|
|
|
|
DECLARE_NO_COPY_CLASS(HP_TagHandler)
|
|
};
|
|
|
|
|
|
bool HP_TagHandler::HandleTag(const wxHtmlTag& tag)
|
|
{
|
|
if (tag.GetName() == wxT("UL"))
|
|
{
|
|
wxHtmlHelpDataItem *oldparent = m_parentItem;
|
|
m_level++;
|
|
m_parentItem = (m_count > 0) ? &(*m_data)[m_data->size()-1] : NULL;
|
|
ParseInner(tag);
|
|
m_level--;
|
|
m_parentItem = oldparent;
|
|
return true;
|
|
}
|
|
else if (tag.GetName() == wxT("OBJECT"))
|
|
{
|
|
m_name = m_page = wxEmptyString;
|
|
ParseInner(tag);
|
|
|
|
#if 0
|
|
if (!page.IsEmpty())
|
|
/* Valid HHW's file may contain only two object tags:
|
|
|
|
<OBJECT type="text/site properties">
|
|
<param name="ImageType" value="Folder">
|
|
</OBJECT>
|
|
|
|
or
|
|
|
|
<OBJECT type="text/sitemap">
|
|
<param name="Name" value="main page">
|
|
<param name="Local" value="another.htm">
|
|
</OBJECT>
|
|
|
|
We're interested in the latter. !page.IsEmpty() is valid
|
|
condition because text/site properties does not contain Local param
|
|
*/
|
|
#endif
|
|
if (tag.GetParam(wxT("TYPE")) == wxT("text/sitemap"))
|
|
{
|
|
wxHtmlHelpDataItem *item = new wxHtmlHelpDataItem();
|
|
item->parent = m_parentItem;
|
|
item->level = m_level;
|
|
item->id = m_id;
|
|
item->page = m_page;
|
|
item->name = m_name;
|
|
|
|
item->book = m_book;
|
|
m_data->Add(item);
|
|
m_count++;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{ // "PARAM"
|
|
if (m_name.empty() && tag.GetParam(wxT("NAME")) == wxT("Name"))
|
|
m_name = tag.GetParam(wxT("VALUE"));
|
|
if (tag.GetParam(wxT("NAME")) == wxT("Local"))
|
|
m_page = tag.GetParam(wxT("VALUE"));
|
|
if (tag.GetParam(wxT("NAME")) == wxT("ID"))
|
|
tag.GetParamAsInt(wxT("VALUE"), &m_id);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// wxHtmlHelpData
|
|
//-----------------------------------------------------------------------------
|
|
|
|
wxString wxHtmlBookRecord::GetFullPath(const wxString &page) const
|
|
{
|
|
if (wxIsAbsolutePath(page))
|
|
return page;
|
|
else
|
|
return m_BasePath + page;
|
|
}
|
|
|
|
wxString wxHtmlHelpDataItem::GetIndentedName() const
|
|
{
|
|
wxString s;
|
|
for (int i = 1; i < level; i++)
|
|
s << _T(" ");
|
|
s << name;
|
|
return s;
|
|
}
|
|
|
|
|
|
IMPLEMENT_DYNAMIC_CLASS(wxHtmlHelpData, wxObject)
|
|
|
|
wxHtmlHelpData::wxHtmlHelpData()
|
|
{
|
|
#if WXWIN_COMPATIBILITY_2_4
|
|
m_cacheContents = NULL;
|
|
m_cacheIndex = NULL;
|
|
#endif
|
|
}
|
|
|
|
wxHtmlHelpData::~wxHtmlHelpData()
|
|
{
|
|
#if WXWIN_COMPATIBILITY_2_4
|
|
CleanCompatibilityData();
|
|
#endif
|
|
}
|
|
|
|
bool wxHtmlHelpData::LoadMSProject(wxHtmlBookRecord *book, wxFileSystem& fsys,
|
|
const wxString& indexfile,
|
|
const wxString& contentsfile)
|
|
{
|
|
wxFSFile *f;
|
|
wxHtmlFilterHTML filter;
|
|
wxString buf;
|
|
wxString string;
|
|
|
|
HP_Parser parser;
|
|
HP_TagHandler *handler = new HP_TagHandler(book);
|
|
parser.AddTagHandler(handler);
|
|
|
|
f = ( contentsfile.IsEmpty() ? (wxFSFile*) NULL : fsys.OpenFile(contentsfile) );
|
|
if (f)
|
|
{
|
|
buf.clear();
|
|
buf = filter.ReadFile(*f);
|
|
delete f;
|
|
handler->Reset(m_contents);
|
|
parser.Parse(buf);
|
|
}
|
|
else
|
|
{
|
|
wxLogError(_("Cannot open contents file: %s"), contentsfile.c_str());
|
|
}
|
|
|
|
f = ( indexfile.IsEmpty() ? (wxFSFile*) NULL : fsys.OpenFile(indexfile) );
|
|
if (f)
|
|
{
|
|
buf.clear();
|
|
buf = filter.ReadFile(*f);
|
|
delete f;
|
|
handler->Reset(m_index);
|
|
parser.Parse(buf);
|
|
}
|
|
else if (!indexfile.IsEmpty())
|
|
{
|
|
wxLogError(_("Cannot open index file: %s"), indexfile.c_str());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
inline static void CacheWriteInt32(wxOutputStream *f, wxInt32 value)
|
|
{
|
|
wxInt32 x = wxINT32_SWAP_ON_BE(value);
|
|
f->Write(&x, sizeof(x));
|
|
}
|
|
|
|
inline static wxInt32 CacheReadInt32(wxInputStream *f)
|
|
{
|
|
wxInt32 x;
|
|
f->Read(&x, sizeof(x));
|
|
return wxINT32_SWAP_ON_BE(x);
|
|
}
|
|
|
|
inline static void CacheWriteString(wxOutputStream *f, const wxString& str)
|
|
{
|
|
const wxWX2MBbuf mbstr = str.mb_str(wxConvUTF8);
|
|
size_t len = strlen((const char*)mbstr)+1;
|
|
CacheWriteInt32(f, len);
|
|
f->Write((const char*)mbstr, len);
|
|
}
|
|
|
|
inline static wxString CacheReadString(wxInputStream *f)
|
|
{
|
|
size_t len = (size_t)CacheReadInt32(f);
|
|
wxCharBuffer str(len-1);
|
|
f->Read(str.data(), len);
|
|
return wxString(str, wxConvUTF8);
|
|
}
|
|
|
|
#define CURRENT_CACHED_BOOK_VERSION 5
|
|
|
|
// Additional flags to detect incompatibilities of the runtime environment:
|
|
#define CACHED_BOOK_FORMAT_FLAGS \
|
|
(wxUSE_UNICODE << 0)
|
|
|
|
|
|
bool wxHtmlHelpData::LoadCachedBook(wxHtmlBookRecord *book, wxInputStream *f)
|
|
{
|
|
int i, st, newsize;
|
|
wxInt32 version;
|
|
|
|
/* load header - version info : */
|
|
version = CacheReadInt32(f);
|
|
|
|
if (version != CURRENT_CACHED_BOOK_VERSION)
|
|
{
|
|
// NB: We can just silently return false here and don't worry about
|
|
// it anymore, because AddBookParam will load the MS project in
|
|
// absence of (properly versioned) .cached file and automatically
|
|
// create new .cached file immediately afterward.
|
|
return false;
|
|
}
|
|
|
|
if (CacheReadInt32(f) != CACHED_BOOK_FORMAT_FLAGS)
|
|
return false;
|
|
|
|
/* load contents : */
|
|
st = m_contents.size();
|
|
newsize = st + CacheReadInt32(f);
|
|
m_contents.Alloc(newsize);
|
|
for (i = st; i < newsize; i++)
|
|
{
|
|
wxHtmlHelpDataItem *item = new wxHtmlHelpDataItem;
|
|
item->level = CacheReadInt32(f);
|
|
item->id = CacheReadInt32(f);
|
|
item->name = CacheReadString(f);
|
|
item->page = CacheReadString(f);
|
|
item->book = book;
|
|
m_contents.Add(item);
|
|
}
|
|
|
|
/* load index : */
|
|
st = m_index.size();
|
|
newsize = st + CacheReadInt32(f);
|
|
m_index.Alloc(newsize);
|
|
for (i = st; i < newsize; i++)
|
|
{
|
|
wxHtmlHelpDataItem *item = new wxHtmlHelpDataItem;
|
|
item->name = CacheReadString(f);
|
|
item->page = CacheReadString(f);
|
|
item->level = CacheReadInt32(f);
|
|
item->book = book;
|
|
int parentShift = CacheReadInt32(f);
|
|
if (parentShift != 0)
|
|
item->parent = &m_index[m_index.size() - parentShift];
|
|
m_index.Add(item);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
bool wxHtmlHelpData::SaveCachedBook(wxHtmlBookRecord *book, wxOutputStream *f)
|
|
{
|
|
int i;
|
|
wxInt32 cnt;
|
|
|
|
/* save header - version info : */
|
|
CacheWriteInt32(f, CURRENT_CACHED_BOOK_VERSION);
|
|
CacheWriteInt32(f, CACHED_BOOK_FORMAT_FLAGS);
|
|
|
|
/* save contents : */
|
|
int len = m_contents.size();
|
|
for (cnt = 0, i = 0; i < len; i++)
|
|
if (m_contents[i].book == book && m_contents[i].level > 0)
|
|
cnt++;
|
|
CacheWriteInt32(f, cnt);
|
|
|
|
for (i = 0; i < len; i++)
|
|
{
|
|
if (m_contents[i].book != book || m_contents[i].level == 0)
|
|
continue;
|
|
CacheWriteInt32(f, m_contents[i].level);
|
|
CacheWriteInt32(f, m_contents[i].id);
|
|
CacheWriteString(f, m_contents[i].name);
|
|
CacheWriteString(f, m_contents[i].page);
|
|
}
|
|
|
|
/* save index : */
|
|
len = m_index.size();
|
|
for (cnt = 0, i = 0; i < len; i++)
|
|
if (m_index[i].book == book && m_index[i].level > 0)
|
|
cnt++;
|
|
CacheWriteInt32(f, cnt);
|
|
|
|
for (i = 0; i < len; i++)
|
|
{
|
|
if (m_index[i].book != book || m_index[i].level == 0)
|
|
continue;
|
|
CacheWriteString(f, m_index[i].name);
|
|
CacheWriteString(f, m_index[i].page);
|
|
CacheWriteInt32(f, m_index[i].level);
|
|
// save distance to parent item, if any:
|
|
if (m_index[i].parent == NULL)
|
|
{
|
|
CacheWriteInt32(f, 0);
|
|
}
|
|
else
|
|
{
|
|
int cnt = 0;
|
|
wxHtmlHelpDataItem *parent = m_index[i].parent;
|
|
for (int j = i-1; j >= 0; j--)
|
|
{
|
|
if (m_index[j].book == book && m_index[j].level > 0)
|
|
cnt++;
|
|
if (&m_index[j] == parent)
|
|
break;
|
|
}
|
|
wxASSERT(cnt > 0);
|
|
CacheWriteInt32(f, cnt);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
void wxHtmlHelpData::SetTempDir(const wxString& path)
|
|
{
|
|
if (path.empty())
|
|
m_tempPath = path;
|
|
else
|
|
{
|
|
if (wxIsAbsolutePath(path)) m_tempPath = path;
|
|
else m_tempPath = wxGetCwd() + _T("/") + path;
|
|
|
|
if (m_tempPath[m_tempPath.Length() - 1] != _T('/'))
|
|
m_tempPath << _T('/');
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static wxString SafeFileName(const wxString& s)
|
|
{
|
|
wxString res(s);
|
|
res.Replace(wxT("#"), wxT("_"));
|
|
res.Replace(wxT(":"), wxT("_"));
|
|
res.Replace(wxT("\\"), wxT("_"));
|
|
res.Replace(wxT("/"), wxT("_"));
|
|
return res;
|
|
}
|
|
|
|
bool wxHtmlHelpData::AddBookParam(const wxFSFile& bookfile,
|
|
wxFontEncoding encoding,
|
|
const wxString& title, const wxString& contfile,
|
|
const wxString& indexfile, const wxString& deftopic,
|
|
const wxString& path)
|
|
{
|
|
wxFileSystem fsys;
|
|
wxFSFile *fi;
|
|
wxHtmlBookRecord *bookr;
|
|
|
|
int IndexOld = m_index.size(),
|
|
ContentsOld = m_contents.size();
|
|
|
|
if (!path.IsEmpty())
|
|
fsys.ChangePathTo(path, true);
|
|
|
|
size_t booksCnt = m_bookRecords.GetCount();
|
|
for (size_t i = 0; i < booksCnt; i++)
|
|
{
|
|
if ( m_bookRecords[i].GetBookFile() == bookfile.GetLocation() )
|
|
return true; // book is (was) loaded
|
|
}
|
|
|
|
bookr = new wxHtmlBookRecord(bookfile.GetLocation(), fsys.GetPath(), title, deftopic);
|
|
|
|
wxHtmlHelpDataItem *bookitem = new wxHtmlHelpDataItem;
|
|
bookitem->level = 0;
|
|
bookitem->id = 0;
|
|
bookitem->page = deftopic;
|
|
bookitem->name = title;
|
|
bookitem->book = bookr;
|
|
|
|
// store the contents index for later
|
|
int cont_start = m_contents.size();
|
|
|
|
m_contents.Add(bookitem);
|
|
|
|
// Try to find cached binary versions:
|
|
// 1. save file as book, but with .hhp.cached extension
|
|
// 2. same as 1. but in temp path
|
|
// 3. otherwise or if cache load failed, load it from MS.
|
|
|
|
fi = fsys.OpenFile(bookfile.GetLocation() + wxT(".cached"));
|
|
|
|
if (fi == NULL ||
|
|
#if wxUSE_DATETIME
|
|
fi->GetModificationTime() < bookfile.GetModificationTime() ||
|
|
#endif // wxUSE_DATETIME
|
|
!LoadCachedBook(bookr, fi->GetStream()))
|
|
{
|
|
if (fi != NULL) delete fi;
|
|
fi = fsys.OpenFile(m_tempPath + wxFileNameFromPath(bookfile.GetLocation()) + wxT(".cached"));
|
|
if (m_tempPath.empty() || fi == NULL ||
|
|
#if wxUSE_DATETIME
|
|
fi->GetModificationTime() < bookfile.GetModificationTime() ||
|
|
#endif // wxUSE_DATETIME
|
|
!LoadCachedBook(bookr, fi->GetStream()))
|
|
{
|
|
LoadMSProject(bookr, fsys, indexfile, contfile);
|
|
if (!m_tempPath.empty())
|
|
{
|
|
wxFileOutputStream *outs = new wxFileOutputStream(m_tempPath +
|
|
SafeFileName(wxFileNameFromPath(bookfile.GetLocation())) + wxT(".cached"));
|
|
SaveCachedBook(bookr, outs);
|
|
delete outs;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fi != NULL) delete fi;
|
|
|
|
// Now store the contents range
|
|
bookr->SetContentsRange(cont_start, m_contents.size());
|
|
|
|
#if wxUSE_WCHAR_T
|
|
// MS HTML Help files [written by MS HTML Help Workshop] are broken
|
|
// in that the data are iso-8859-1 (including HTML entities), but must
|
|
// be interpreted as being in language's windows charset. Correct the
|
|
// differences here and also convert to wxConvLocal in ANSI build
|
|
if (encoding != wxFONTENCODING_SYSTEM)
|
|
{
|
|
#if wxUSE_UNICODE
|
|
#define CORRECT_STR(str, conv) \
|
|
str = wxString((str).mb_str(wxConvISO8859_1), conv)
|
|
#else
|
|
#define CORRECT_STR(str, conv) \
|
|
str = wxString((str).wc_str(conv), wxConvLocal)
|
|
#endif
|
|
wxCSConv conv(encoding);
|
|
size_t IndexCnt = m_index.size();
|
|
size_t ContentsCnt = m_contents.size();
|
|
size_t i;
|
|
for (i = IndexOld; i < IndexCnt; i++)
|
|
{
|
|
CORRECT_STR(m_index[i].name, conv);
|
|
}
|
|
for (i = ContentsOld; i < ContentsCnt; i++)
|
|
{
|
|
CORRECT_STR(m_contents[i].name, conv);
|
|
}
|
|
#undef CORRECT_STR
|
|
}
|
|
#else
|
|
wxUnusedVar(IndexOld);
|
|
wxUnusedVar(ContentsOld);
|
|
wxASSERT_MSG(encoding == wxFONTENCODING_SYSTEM, wxT("Help files need charset conversion, but wxUSE_WCHAR_T is 0"));
|
|
#endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T
|
|
|
|
m_bookRecords.Add(bookr);
|
|
if (!m_index.empty())
|
|
{
|
|
m_index.Sort(wxHtmlHelpIndexCompareFunc);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool wxHtmlHelpData::AddBook(const wxString& book)
|
|
{
|
|
wxString extension(book.Right(4).Lower());
|
|
if (extension == wxT(".zip") ||
|
|
#if wxUSE_LIBMSPACK
|
|
extension == wxT(".chm") /*compressed html help book*/ ||
|
|
#endif
|
|
extension == wxT(".htb") /*html book*/)
|
|
{
|
|
wxFileSystem fsys;
|
|
wxString s;
|
|
bool rt = false;
|
|
|
|
#if wxUSE_LIBMSPACK
|
|
if (extension == wxT(".chm"))
|
|
s = fsys.FindFirst(book + wxT("#chm:*.hhp"), wxFILE);
|
|
else
|
|
#endif
|
|
s = fsys.FindFirst(book + wxT("#zip:*.hhp"), wxFILE);
|
|
|
|
while (!s.IsEmpty())
|
|
{
|
|
if (AddBook(s)) rt = true;
|
|
s = fsys.FindNext();
|
|
}
|
|
|
|
return rt;
|
|
}
|
|
|
|
wxFSFile *fi;
|
|
wxFileSystem fsys;
|
|
|
|
wxString title = _("noname"),
|
|
safetitle,
|
|
start = wxEmptyString,
|
|
contents = wxEmptyString,
|
|
index = wxEmptyString,
|
|
charset = wxEmptyString;
|
|
|
|
fi = fsys.OpenFile(book);
|
|
if (fi == NULL)
|
|
{
|
|
wxLogError(_("Cannot open HTML help book: %s"), book.c_str());
|
|
return false;
|
|
}
|
|
fsys.ChangePathTo(book);
|
|
|
|
const wxChar *lineptr;
|
|
wxChar linebuf[300];
|
|
wxString tmp;
|
|
wxHtmlFilterPlainText filter;
|
|
tmp = filter.ReadFile(*fi);
|
|
lineptr = tmp.c_str();
|
|
|
|
do
|
|
{
|
|
lineptr = ReadLine(lineptr, linebuf, 300);
|
|
|
|
for (wxChar *ch = linebuf; *ch != wxT('\0') && *ch != wxT('='); ch++)
|
|
*ch = (wxChar)wxTolower(*ch);
|
|
|
|
if (wxStrstr(linebuf, _T("title=")) == linebuf)
|
|
title = linebuf + wxStrlen(_T("title="));
|
|
if (wxStrstr(linebuf, _T("default topic=")) == linebuf)
|
|
start = linebuf + wxStrlen(_T("default topic="));
|
|
if (wxStrstr(linebuf, _T("index file=")) == linebuf)
|
|
index = linebuf + wxStrlen(_T("index file="));
|
|
if (wxStrstr(linebuf, _T("contents file=")) == linebuf)
|
|
contents = linebuf + wxStrlen(_T("contents file="));
|
|
if (wxStrstr(linebuf, _T("charset=")) == linebuf)
|
|
charset = linebuf + wxStrlen(_T("charset="));
|
|
} while (lineptr != NULL);
|
|
|
|
wxFontEncoding enc = wxFONTENCODING_SYSTEM;
|
|
#if wxUSE_FONTMAP
|
|
if (charset != wxEmptyString)
|
|
enc = wxFontMapper::Get()->CharsetToEncoding(charset);
|
|
#endif
|
|
|
|
bool rtval = AddBookParam(*fi, enc,
|
|
title, contents, index, start, fsys.GetPath());
|
|
delete fi;
|
|
|
|
#if WXWIN_COMPATIBILITY_2_4
|
|
CleanCompatibilityData();
|
|
#endif
|
|
|
|
return rtval;
|
|
}
|
|
|
|
wxString wxHtmlHelpData::FindPageByName(const wxString& x)
|
|
{
|
|
int cnt;
|
|
int i;
|
|
wxFileSystem fsys;
|
|
wxFSFile *f;
|
|
|
|
/* 1. try to open given file: */
|
|
|
|
cnt = m_bookRecords.GetCount();
|
|
for (i = 0; i < cnt; i++)
|
|
{
|
|
f = fsys.OpenFile(m_bookRecords[i].GetFullPath(x));
|
|
if (f)
|
|
{
|
|
wxString url = m_bookRecords[i].GetFullPath(x);
|
|
delete f;
|
|
return url;
|
|
}
|
|
}
|
|
|
|
|
|
/* 2. try to find a book: */
|
|
|
|
for (i = 0; i < cnt; i++)
|
|
{
|
|
if (m_bookRecords[i].GetTitle() == x)
|
|
return m_bookRecords[i].GetFullPath(m_bookRecords[i].GetStart());
|
|
}
|
|
|
|
/* 3. try to find in contents: */
|
|
|
|
cnt = m_contents.size();
|
|
for (i = 0; i < cnt; i++)
|
|
{
|
|
if (m_contents[i].name == x)
|
|
return m_contents[i].GetFullPath();
|
|
}
|
|
|
|
|
|
/* 4. try to find in index: */
|
|
|
|
cnt = m_index.size();
|
|
for (i = 0; i < cnt; i++)
|
|
{
|
|
if (m_index[i].name == x)
|
|
return m_index[i].GetFullPath();
|
|
}
|
|
|
|
return wxEmptyString;
|
|
}
|
|
|
|
wxString wxHtmlHelpData::FindPageById(int id)
|
|
{
|
|
size_t cnt = m_contents.size();
|
|
for (size_t i = 0; i < cnt; i++)
|
|
{
|
|
if (m_contents[i].id == id)
|
|
{
|
|
return m_contents[i].GetFullPath();
|
|
}
|
|
}
|
|
|
|
return wxEmptyString;
|
|
}
|
|
|
|
#if WXWIN_COMPATIBILITY_2_4
|
|
wxHtmlContentsItem::wxHtmlContentsItem()
|
|
: m_Level(0), m_ID(wxID_ANY), m_Name(NULL), m_Page(NULL), m_Book(NULL),
|
|
m_autofree(false)
|
|
{
|
|
}
|
|
|
|
wxHtmlContentsItem::wxHtmlContentsItem(const wxHtmlHelpDataItem& d)
|
|
{
|
|
m_autofree = true;
|
|
m_Level = d.level;
|
|
m_ID = d.id;
|
|
m_Name = wxStrdup(d.name.c_str());
|
|
m_Page = wxStrdup(d.page.c_str());
|
|
m_Book = d.book;
|
|
}
|
|
|
|
wxHtmlContentsItem& wxHtmlContentsItem::operator=(const wxHtmlContentsItem& d)
|
|
{
|
|
if (m_autofree)
|
|
{
|
|
free(m_Name);
|
|
free(m_Page);
|
|
}
|
|
m_autofree = true;
|
|
m_Level = d.m_Level;
|
|
m_ID = d.m_ID;
|
|
m_Name = d.m_Name ? wxStrdup(d.m_Name) : NULL;
|
|
m_Page = d.m_Page ? wxStrdup(d.m_Page) : NULL;
|
|
m_Book = d.m_Book;
|
|
return *this;
|
|
}
|
|
|
|
wxHtmlContentsItem::~wxHtmlContentsItem()
|
|
{
|
|
if (m_autofree)
|
|
{
|
|
free(m_Name);
|
|
free(m_Page);
|
|
}
|
|
}
|
|
|
|
wxHtmlContentsItem* wxHtmlHelpData::GetContents()
|
|
{
|
|
if (!m_cacheContents && !m_contents.empty())
|
|
{
|
|
size_t len = m_contents.size();
|
|
m_cacheContents = new wxHtmlContentsItem[len];
|
|
for (size_t i = 0; i < len; i++)
|
|
m_cacheContents[i] = m_contents[i];
|
|
}
|
|
return m_cacheContents;
|
|
}
|
|
|
|
int wxHtmlHelpData::GetContentsCnt()
|
|
{
|
|
return m_contents.size();
|
|
}
|
|
|
|
wxHtmlContentsItem* wxHtmlHelpData::GetIndex()
|
|
{
|
|
if (!m_cacheContents && !m_index.empty())
|
|
{
|
|
size_t len = m_index.size();
|
|
m_cacheContents = new wxHtmlContentsItem[len];
|
|
for (size_t i = 0; i < len; i++)
|
|
m_cacheContents[i] = m_index[i];
|
|
}
|
|
return m_cacheContents;
|
|
}
|
|
|
|
int wxHtmlHelpData::GetIndexCnt()
|
|
{
|
|
return m_index.size();
|
|
}
|
|
|
|
void wxHtmlHelpData::CleanCompatibilityData()
|
|
{
|
|
delete[] m_cacheContents;
|
|
m_cacheContents = NULL;
|
|
delete[] m_cacheIndex;
|
|
m_cacheIndex = NULL;
|
|
}
|
|
#endif // WXWIN_COMPATIBILITY_2_4
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// wxHtmlSearchStatus functions
|
|
//----------------------------------------------------------------------------------
|
|
|
|
wxHtmlSearchStatus::wxHtmlSearchStatus(wxHtmlHelpData* data, const wxString& keyword,
|
|
bool case_sensitive, bool whole_words_only,
|
|
const wxString& book)
|
|
{
|
|
m_Data = data;
|
|
m_Keyword = keyword;
|
|
wxHtmlBookRecord* bookr = NULL;
|
|
if (book != wxEmptyString)
|
|
{
|
|
// we have to search in a specific book. Find it first
|
|
int i, cnt = data->m_bookRecords.GetCount();
|
|
for (i = 0; i < cnt; i++)
|
|
if (data->m_bookRecords[i].GetTitle() == book)
|
|
{
|
|
bookr = &(data->m_bookRecords[i]);
|
|
m_CurIndex = bookr->GetContentsStart();
|
|
m_MaxIndex = bookr->GetContentsEnd();
|
|
break;
|
|
}
|
|
// check; we won't crash if the book doesn't exist, but it's Bad Anyway.
|
|
wxASSERT(bookr);
|
|
}
|
|
if (! bookr)
|
|
{
|
|
// no book specified; search all books
|
|
m_CurIndex = 0;
|
|
m_MaxIndex = m_Data->m_contents.size();
|
|
}
|
|
m_Engine.LookFor(keyword, case_sensitive, whole_words_only);
|
|
m_Active = (m_CurIndex < m_MaxIndex);
|
|
}
|
|
|
|
#if WXWIN_COMPATIBILITY_2_4
|
|
wxHtmlContentsItem* wxHtmlSearchStatus::GetContentsItem()
|
|
{
|
|
static wxHtmlContentsItem it;
|
|
it = wxHtmlContentsItem(*m_CurItem);
|
|
return ⁢
|
|
}
|
|
#endif
|
|
|
|
bool wxHtmlSearchStatus::Search()
|
|
{
|
|
wxFSFile *file;
|
|
int i = m_CurIndex; // shortcut
|
|
bool found = false;
|
|
wxString thepage;
|
|
|
|
if (!m_Active)
|
|
{
|
|
// sanity check. Illegal use, but we'll try to prevent a crash anyway
|
|
wxASSERT(m_Active);
|
|
return false;
|
|
}
|
|
|
|
m_Name = wxEmptyString;
|
|
m_CurItem = NULL;
|
|
thepage = m_Data->m_contents[i].page;
|
|
|
|
m_Active = (++m_CurIndex < m_MaxIndex);
|
|
// check if it is same page with different anchor:
|
|
if (!m_LastPage.empty())
|
|
{
|
|
const wxChar *p1, *p2;
|
|
for (p1 = thepage.c_str(), p2 = m_LastPage.c_str();
|
|
*p1 != 0 && *p1 != _T('#') && *p1 == *p2; p1++, p2++) {}
|
|
|
|
m_LastPage = thepage;
|
|
|
|
if (*p1 == 0 || *p1 == _T('#'))
|
|
return false;
|
|
}
|
|
else m_LastPage = thepage;
|
|
|
|
wxFileSystem fsys;
|
|
file = fsys.OpenFile(m_Data->m_contents[i].book->GetFullPath(thepage));
|
|
if (file)
|
|
{
|
|
if (m_Engine.Scan(*file))
|
|
{
|
|
m_Name = m_Data->m_contents[i].name;
|
|
m_CurItem = &m_Data->m_contents[i];
|
|
found = true;
|
|
}
|
|
delete file;
|
|
}
|
|
return found;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// wxHtmlSearchEngine
|
|
//--------------------------------------------------------------------------------
|
|
|
|
void wxHtmlSearchEngine::LookFor(const wxString& keyword, bool case_sensitive, bool whole_words_only)
|
|
{
|
|
m_CaseSensitive = case_sensitive;
|
|
m_WholeWords = whole_words_only;
|
|
m_Keyword = keyword;
|
|
|
|
if (!m_CaseSensitive)
|
|
m_Keyword.LowerCase();
|
|
}
|
|
|
|
|
|
static inline bool WHITESPACE(wxChar c)
|
|
{
|
|
return c == _T(' ') || c == _T('\n') || c == _T('\r') || c == _T('\t');
|
|
}
|
|
|
|
bool wxHtmlSearchEngine::Scan(const wxFSFile& file)
|
|
{
|
|
wxASSERT_MSG(!m_Keyword.empty(), wxT("wxHtmlSearchEngine::LookFor must be called before scanning!"));
|
|
|
|
int i, j;
|
|
int wrd = m_Keyword.Length();
|
|
bool found = false;
|
|
wxHtmlFilterHTML filter;
|
|
wxString tmp = filter.ReadFile(file);
|
|
int lng = tmp.length();
|
|
const wxChar *buf = tmp.c_str();
|
|
|
|
if (!m_CaseSensitive)
|
|
tmp.LowerCase();
|
|
|
|
const wxChar *kwd = m_Keyword.c_str();
|
|
|
|
if (m_WholeWords)
|
|
{
|
|
for (i = 0; i < lng - wrd; i++)
|
|
{
|
|
if (WHITESPACE(buf[i])) continue;
|
|
j = 0;
|
|
while ((j < wrd) && (buf[i + j] == kwd[j])) j++;
|
|
if (j == wrd && WHITESPACE(buf[i + j])) { found = true; break; }
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
for (i = 0; i < lng - wrd; i++)
|
|
{
|
|
j = 0;
|
|
while ((j < wrd) && (buf[i + j] == kwd[j])) j++;
|
|
if (j == wrd) { found = true; break; }
|
|
}
|
|
}
|
|
|
|
return found;
|
|
}
|
|
|
|
|
|
|
|
#endif
|