[wxWidgets.git] / src / html / helpdata.cpp

/////////////////////////////////////////////////////////////////////////////
// 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
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation
#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

#ifndef WXPRECOMP
#include "wx/wx.h"
#endif

#include "wx/html/helpdata.h"
#include "wx/tokenzr.h"
#include "wx/wfstream.h"
#include "wx/busyinfo.h"
#include "wx/html/htmlpars.h"
#include "wx/html/htmldefs.h"

#include "wx/arrimpl.cpp"
WX_DEFINE_OBJARRAY(wxHtmlBookRecArray)

//-----------------------------------------------------------------------------
// static helper functions
//-----------------------------------------------------------------------------

// Reads one line, stores it into buf and returns pointer to new line or NULL.
static char* ReadLine(char *line, char *buf)
{
    char *writeptr = buf, *readptr = line;

    while (*readptr != 0 && *readptr != '\r' && *readptr != '\n') *(writeptr++) = *(readptr++);
    *writeptr = 0;
    while (*readptr == '\r' || *readptr == '\n') readptr++;
    if (*readptr == 0) return NULL;
    else return readptr;
}


static wxString SafeFileName(const wxString& s)
{
    wxString res = s;
    res.Replace(wxT(":"), wxT("_"), TRUE);
    res.Replace(wxT(" "), wxT("_"), TRUE);
    res.Replace(wxT("/"), wxT("_"), TRUE);
    res.Replace(wxT("\\"), wxT("_"), TRUE);
    res.Replace(wxT("#"), wxT("_"), TRUE);
    res.Replace(wxT("."), wxT("_"), TRUE);
    return res;
}


static int LINKAGEMODE IndexCompareFunc(const void *a, const void *b)
{
    return wxStrcmp(((wxHtmlContentsItem*)a) -> m_Name, ((wxHtmlContentsItem*)b) -> m_Name);
}


//-----------------------------------------------------------------------------
// HP_Parser
//-----------------------------------------------------------------------------

class HP_Parser : public wxHtmlParser
{
    public:
        void AddText(const char* WXUNUSED(text)) { }
        wxObject* GetProduct() { return NULL; }
};


//-----------------------------------------------------------------------------
// HP_TagHandler
//-----------------------------------------------------------------------------

class HP_TagHandler : public wxHtmlTagHandler
{
    private:
        wxString m_Name, m_Page;
        int m_Level;
        int m_ID;
        int m_Index;
        wxHtmlContentsItem *m_Items;
        int m_ItemsCnt;
        wxHtmlBookRecord *m_Book;

    public:
        HP_TagHandler(wxHtmlBookRecord *b) : wxHtmlTagHandler() {m_Book = b; m_Items = NULL; m_ItemsCnt = 0; m_Name = m_Page = wxEmptyString; m_Level = 0; }
        wxString GetSupportedTags() { return wxT("UL,OBJECT,PARAM"); }
        bool HandleTag(const wxHtmlTag& tag);
        void WriteOut(wxHtmlContentsItem*& array, int& size);
        void ReadIn(wxHtmlContentsItem* array, int size);
};


bool HP_TagHandler::HandleTag(const wxHtmlTag& tag)
{
    if (tag.GetName() == "UL") {
        m_Level++;
        ParseInner(tag);
        m_Level--;
        return TRUE;
    }
    else if (tag.GetName() == wxT("OBJECT")) {
        m_Name = m_Page = wxEmptyString;
        ParseInner(tag);
        if (m_Page != wxEmptyString) {
            if (m_ItemsCnt % wxHTML_REALLOC_STEP == 0)
                m_Items = (wxHtmlContentsItem*) realloc(m_Items, (m_ItemsCnt + wxHTML_REALLOC_STEP) * sizeof(wxHtmlContentsItem));
            m_Items[m_ItemsCnt].m_Level = m_Level;
            m_Items[m_ItemsCnt].m_ID = m_ID;
            m_Items[m_ItemsCnt].m_Page = new wxChar[m_Page.Length() + 1];
            wxStrcpy(m_Items[m_ItemsCnt].m_Page, m_Page.c_str());
            m_Items[m_ItemsCnt].m_Name = new wxChar [m_Name.Length() + 1];
            wxStrcpy(m_Items[m_ItemsCnt].m_Name, m_Name.c_str());
            m_Items[m_ItemsCnt].m_Book = m_Book;
            m_ItemsCnt++;
        }
        return TRUE;
    }
    else { // "PARAM"
        if (m_Name == wxEmptyString && 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.ScanParam(wxT("VALUE"), wxT("%i"), &m_ID);
        return FALSE;
    }
}


void HP_TagHandler::WriteOut(wxHtmlContentsItem*& array, int& size)
{
    array = m_Items;
    size = m_ItemsCnt;
    m_Items = NULL;
    m_ItemsCnt = 0;
}

void HP_TagHandler::ReadIn(wxHtmlContentsItem* array, int size)
{
    m_Items = array;
    m_ItemsCnt = size;
}


//-----------------------------------------------------------------------------
// wxHtmlHelpData
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxHtmlHelpData, wxObject)

wxHtmlHelpData::wxHtmlHelpData()
{
    m_TempPath = wxEmptyString;

    m_Contents = NULL;
    m_ContentsCnt = 0;
    m_Index = NULL;
    m_IndexCnt = 0;
}

wxHtmlHelpData::~wxHtmlHelpData()
{
    int i;

    m_BookRecords.Empty();
    if (m_Contents) {
        for (i = 0; i < m_ContentsCnt; i++) {
            delete[] m_Contents[i].m_Page;
            delete[] m_Contents[i].m_Name;
        }
        free(m_Contents);
    }
    if (m_Index) {
        for (i = 0; i < m_IndexCnt; i++) {
            delete[] m_Index[i].m_Page;
            delete[] m_Index[i].m_Name;
        }
        free(m_Index);
    }
}

bool wxHtmlHelpData::LoadMSProject(wxHtmlBookRecord *book, wxFileSystem& fsys, const wxString& indexfile, const wxString& contentsfile)
{
    wxFSFile *f;
    char *buf;
    int sz;
    wxString string;

    HP_Parser parser;
    HP_TagHandler *handler = new HP_TagHandler(book);
    parser.AddTagHandler(handler);

    f = ( contentsfile.IsEmpty() ? 0 : fsys.OpenFile(contentsfile) );
    if (f) {
        sz = f -> GetStream() -> GetSize();
        buf = new char[sz + 1];
        buf[sz] = 0;
        f -> GetStream() -> Read(buf, sz);
        delete f;
        handler -> ReadIn(m_Contents, m_ContentsCnt);
        parser.Parse(buf);
        handler -> WriteOut(m_Contents, m_ContentsCnt);
        delete[] buf;
    }

    f = ( indexfile.IsEmpty() ? 0 : fsys.OpenFile(indexfile) );
    if (f) {
        sz = f -> GetStream() -> GetSize();
        buf = new char[sz + 1];
        buf[sz] = 0;
        f -> GetStream() -> Read(buf, sz);
        delete f;
        handler -> ReadIn(m_Index, m_IndexCnt);
        parser.Parse(buf);
        handler -> WriteOut(m_Index, m_IndexCnt);
        delete[] buf;
    }
    return TRUE;
}


bool wxHtmlHelpData::LoadCachedBook(wxHtmlBookRecord *book, wxInputStream *f)
{
    int i, st;
    int x;

    /* load contents : */

    f -> Read(&x, sizeof(x));
    st = m_ContentsCnt;
    m_ContentsCnt += x;
    m_Contents = (wxHtmlContentsItem*) realloc(m_Contents, (m_ContentsCnt / wxHTML_REALLOC_STEP + 1) * wxHTML_REALLOC_STEP * sizeof(wxHtmlContentsItem));
    for (i = st; i < m_ContentsCnt; i++) {
        f -> Read(&x, sizeof(x));
        m_Contents[i].m_Level = x;
        f -> Read(&x, sizeof(x));
        m_Contents[i].m_ID = x;
        f -> Read(&x, sizeof(x));
        m_Contents[i].m_Name = new wxChar[x];
        f -> Read(m_Contents[i].m_Name, x*sizeof(wxChar));
        f -> Read(&x, sizeof(x));
        m_Contents[i].m_Page = new wxChar[x];
        f -> Read(m_Contents[i].m_Page, x*sizeof(wxChar));
        m_Contents[i].m_Book = book;
    }

    /* load index : */

    f -> Read(&x, sizeof(x));
    st = m_IndexCnt;
    m_IndexCnt += x;
    m_Index = (wxHtmlContentsItem*) realloc(m_Index, (m_IndexCnt / wxHTML_REALLOC_STEP + 1) * wxHTML_REALLOC_STEP * sizeof(wxHtmlContentsItem));
    for (i = st; i < m_IndexCnt; i++) {
        f -> Read(&x, sizeof(x));
        m_Index[i].m_Name = new wxChar[x];
        f -> Read(m_Index[i].m_Name, x*sizeof(wxChar));
        f -> Read(&x, sizeof(x));
        m_Index[i].m_Page = new wxChar[x];
        f -> Read(m_Index[i].m_Page, x*sizeof(wxChar));
        m_Index[i].m_Book = book;
    }
    return TRUE;
}


bool wxHtmlHelpData::SaveCachedBook(wxHtmlBookRecord *book, wxOutputStream *f)
{
    int i;
    int x;

    /* save contents : */

    x = 0;
    for (i = 0; i < m_ContentsCnt; i++) if (m_Contents[i].m_Book == book && m_Contents[i].m_Level > 0) x++;
    f -> Write(&x, sizeof(x));
    for (i = 0; i < m_ContentsCnt; i++) {
        if (m_Contents[i].m_Book != book || m_Contents[i].m_Level == 0) continue;
        x = m_Contents[i].m_Level;
        f -> Write(&x, sizeof(x));
        x = m_Contents[i].m_ID;
        f -> Write(&x, sizeof(x));
        x = wxStrlen(m_Contents[i].m_Name) + 1;
        f -> Write(&x, sizeof(x));
        f -> Write(m_Contents[i].m_Name, x*sizeof(wxChar));
        x = wxStrlen(m_Contents[i].m_Page) + 1;
        f -> Write(&x, sizeof(x));
        f -> Write(m_Contents[i].m_Page, x*sizeof(wxChar));
    }

    /* save index : */

    x = 0;
    for (i = 0; i < m_IndexCnt; i++) if (m_Index[i].m_Book == book && m_Index[i].m_Level > 0) x++;
    f -> Write(&x, sizeof(x));
    for (i = 0; i < m_IndexCnt; i++) {
        if (m_Index[i].m_Book != book || m_Index[i].m_Level == 0) continue;
        x = wxStrlen(m_Index[i].m_Name) + 1;
        f -> Write(&x, sizeof(x));
        f -> Write(m_Index[i].m_Name, x*sizeof(wxChar));
        x = wxStrlen(m_Index[i].m_Page) + 1;
        f -> Write(&x, sizeof(x));
        f -> Write(m_Index[i].m_Page, x*sizeof(wxChar));
    }
    return TRUE;
}


void wxHtmlHelpData::SetTempDir(const wxString& path)
{
    if (path == wxEmptyString) m_TempPath = path;
    else {
        if (wxIsAbsolutePath(path)) m_TempPath = path;
        else m_TempPath = wxGetCwd() + "/" + path;

        if (m_TempPath[m_TempPath.Length() - 1] != '/')
            m_TempPath << "/";
    }
}


bool wxHtmlHelpData::AddBookParam(const wxString& title, const wxString& contfile,
                                  const wxString& indexfile, const wxString& deftopic,
                                  const wxString& path)
{
    wxFileSystem fsys;
    wxFSFile *fi;
    wxHtmlBookRecord *bookr;
    wxString safetitle;

    if (! path.IsEmpty())
        fsys.ChangePathTo(path, TRUE);

    bookr = new wxHtmlBookRecord(fsys.GetPath(), title, deftopic);

    if (m_ContentsCnt % wxHTML_REALLOC_STEP == 0)
        m_Contents = (wxHtmlContentsItem*) realloc(m_Contents, (m_ContentsCnt + wxHTML_REALLOC_STEP) * sizeof(wxHtmlContentsItem));
    m_Contents[m_ContentsCnt].m_Level = 0;
    m_Contents[m_ContentsCnt].m_ID = 0;
    m_Contents[m_ContentsCnt].m_Page = new wxChar[deftopic.Length() + 1];
    wxStrcpy(m_Contents[m_ContentsCnt].m_Page, deftopic.c_str());
    m_Contents[m_ContentsCnt].m_Name = new wxChar [title.Length() + 1];
    wxStrcpy(m_Contents[m_ContentsCnt].m_Name, title.c_str());
    m_Contents[m_ContentsCnt].m_Book = bookr;

    // store the contents index for later
    int cont_start = m_ContentsCnt++;

    // Try to find cached binary versions:
    safetitle = SafeFileName(title);
    fi = fsys.OpenFile(safetitle + wxT(".cached"));
    if (fi == NULL) fi = fsys.OpenFile(m_TempPath + safetitle + wxT(".cached"));
    if ((fi == NULL) || (m_TempPath == wxEmptyString)) {
        LoadMSProject(bookr, fsys, indexfile, contfile);
        if (m_TempPath != wxEmptyString) {
            wxFileOutputStream *outs = new wxFileOutputStream(m_TempPath + safetitle + wxT(".cached"));
            SaveCachedBook(bookr, outs);
            delete outs;
        }
    } else {
        LoadCachedBook(bookr, fi -> GetStream());
        delete fi;
    }

    // Now store the contents range
    bookr->SetContentsRange(cont_start, m_ContentsCnt);

    m_BookRecords.Add(bookr);
    if (m_IndexCnt > 0)
        qsort(m_Index, m_IndexCnt, sizeof(wxHtmlContentsItem), IndexCompareFunc);

    return TRUE;
}


bool wxHtmlHelpData::AddBook(const wxString& book)
{
    if (book.Right(4).Lower() == wxT(".zip") ||
        book.Right(4).Lower() == wxT(".htb") /*html book*/) 

    {
        wxFileSystem fsys;
        wxString s;
        bool rt = FALSE;

        s = fsys.FindFirst(book + wxT("#zip:") + wxT("*.hhp"), wxFILE);
        while (!s.IsEmpty()) 
        {
            if (AddBook(s)) rt = TRUE;
            s = fsys.FindNext();
        }
        
        return rt;
    }


    else 
    {       
        wxFSFile *fi;
        wxFileSystem fsys;
        wxInputStream *s;
        wxString bookFull;

        int sz;
        char *buff, *lineptr;
        char linebuf[300];

        wxString title = _("noname"),
                         safetitle,
                         start = wxEmptyString,
                                 contents = wxEmptyString, index = wxEmptyString;

        if (wxIsAbsolutePath(book)) bookFull = book;
        else bookFull = wxGetCwd() + "/" + book;

        fi = fsys.OpenFile(bookFull);
        if (fi == NULL) return FALSE;
        fsys.ChangePathTo(bookFull);
        s = fi -> GetStream();
        sz = s -> GetSize();
        buff = new char[sz + 1];
        buff[sz] = 0;
        s -> Read(buff, sz);
        lineptr = buff;
        delete fi;

        do {
            lineptr = ReadLine(lineptr, linebuf);

            if (strstr(linebuf, "Title=") == linebuf)
                title = linebuf + strlen("Title=");
            if (strstr(linebuf, "Default topic=") == linebuf)
                start = linebuf + strlen("Default topic=");
            if (strstr(linebuf, "Index file=") == linebuf)
                index = linebuf + strlen("Index file=");
            if (strstr(linebuf, "Contents file=") == linebuf)
                contents = linebuf + strlen("Contents file=");
        } while (lineptr != NULL);
        delete[] buff;

        return AddBookParam(title, contents, index, start, fsys.GetPath());
    }
}

wxString wxHtmlHelpData::FindPageByName(const wxString& x)
{
    int cnt;
    int i;
    wxFileSystem fsys;
    wxFSFile *f;
    wxString url(wxEmptyString);

    /* 1. try to open given file: */

    cnt = m_BookRecords.GetCount();
    for (i = 0; i < cnt; i++) {
        f = fsys.OpenFile(m_BookRecords[i].GetBasePath() + x);
        if (f) {
            url = m_BookRecords[i].GetBasePath() + x;
            delete f;
            return url;
        }
    }


    /* 2. try to find a book: */

    for (i = 0; i < cnt; i++) {
        if (m_BookRecords[i].GetTitle() == x) {
            url = m_BookRecords[i].GetBasePath() + m_BookRecords[i].GetStart();
            return url;
        }
    }

    /* 3. try to find in contents: */

    cnt = m_ContentsCnt;
    for (i = 0; i < cnt; i++) {
        if (wxStrcmp(m_Contents[i].m_Name, x) == 0) {
            url = m_Contents[i].m_Book -> GetBasePath() + m_Contents[i].m_Page;
            return url;
        }
    }


    /* 4. try to find in index: */

    cnt = m_IndexCnt;
    for (i = 0; i < cnt; i++) {
        if (wxStrcmp(m_Index[i].m_Name, x) == 0) {
            url = m_Index[i].m_Book -> GetBasePath() + m_Index[i].m_Page;
            return url;
        }
    }

    return url;
}

wxString wxHtmlHelpData::FindPageById(int id)
{
    int i;
    wxString url(wxEmptyString);

    for (i = 0; i < m_ContentsCnt; i++) {
        if (m_Contents[i].m_ID == id) {
            url = m_Contents[i].m_Book -> GetBasePath() + m_Contents[i].m_Page;
            return url;
        }
    }

    return url;
}

//----------------------------------------------------------------------------------
// wxHtmlSearchStatus functions
//----------------------------------------------------------------------------------

wxHtmlSearchStatus::wxHtmlSearchStatus(wxHtmlHelpData* data, const wxString& keyword,
                                       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_ContentsCnt;
    }
    m_Engine.LookFor(keyword);
    m_Active = (m_CurIndex < m_MaxIndex);
    m_LastPage = wxEmptyString;
}

bool wxHtmlSearchStatus::Search()
{
    wxFileSystem fsys;
    wxFSFile *file;
    int i = m_CurIndex;  // shortcut
    bool found = FALSE;

    if (! m_Active) {
	// sanity check. Illegal use, but we'll try to prevent a crash anyway
#if !defined(__VISAGECPP__)
wxASSERT(0);
#else
wxASSERT(m_Active);
#endif
	return FALSE;
    }

    m_ContentsItem = NULL;
    m_Name = wxEmptyString;

    file = fsys.OpenFile(m_Data->m_Contents[i].m_Book -> GetBasePath() +
                         m_Data->m_Contents[i].m_Page);
    if (file) {
        if (m_LastPage != file->GetLocation()) {
            m_LastPage = file->GetLocation();
            if (m_Engine.Scan(file -> GetStream())) {
                m_Name = m_Data->m_Contents[i].m_Name;
                m_ContentsItem = m_Data->m_Contents + i;
                found = TRUE;
            }
        }
        delete file;
    }
    m_Active = (++m_CurIndex < m_MaxIndex);
    return found;
}


//--------------------------------------------------------------------------------
// wxSearchEngine
//--------------------------------------------------------------------------------

void wxSearchEngine::LookFor(const wxString& keyword)
{
    if (m_Keyword) delete[] m_Keyword;
    m_Keyword = new wxChar[keyword.Length() + 1];
    wxStrcpy(m_Keyword, keyword.c_str());
    for (int i = wxStrlen(m_Keyword) - 1; i >= 0; i--)
        if ((m_Keyword[i] >= wxT('A')) && (m_Keyword[i] <= wxT('Z')))
            m_Keyword[i] += wxT('a') - wxT('A');
}


bool wxSearchEngine::Scan(wxInputStream *stream)
{
    wxASSERT_MSG(m_Keyword != NULL, _("wxSearchEngine::LookFor must be called before scanning!"));

    int i, j;
    int lng = stream ->GetSize();
    int wrd = wxStrlen(m_Keyword);
    bool found = FALSE;
    char *buf = new char[lng + 1];
    stream -> Read(buf, lng);
    buf[lng] = 0;

    for (i = 0; i < lng; i++)
        if ((buf[i] >= 'A') && (buf[i] <= 'Z')) buf[i] += 'a' - 'A';

    for (i = 0; i < lng - wrd; i++) {
        j = 0;
        while ((j < wrd) && (buf[i + j] == m_Keyword[j])) j++;
    if (j == wrd) {found = TRUE; break; }
    }

    delete[] buf;
    return found;
}


#endif
Commit	Line	Data
8ec2b484 HH	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: helpdata.cpp
	3	// Purpose: wxHtmlHelpData
f42b1601	4	// Notes: Based on htmlhelp.cpp, implementing a monolithic
8ec2b484 HH	5	// HTML Help controller class, by Vaclav Slavik
8ec2b484 HH	6	// Author: Harm van der Heijden and Vaclav Slavik
69941f05	7	// RCS-ID: $Id$
8ec2b484 HH	8	// Copyright: (c) Harm van der Heijden and Vaclav Slavik
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
69941f05	13	#pragma implementation
8ec2b484 HH	14	#endif
	15
	16	// For compilers that support precompilation, includes "wx.h".
	17	#include "wx/wxprec.h"
	18
	19	#ifdef __BORLANDC__
	20	#pragma hdrstop
	21	#endif
	22
	23	#include "wx/defs.h"
	24
	25	#if wxUSE_HTML
	26
	27	#ifndef WXPRECOMP
	28	#include "wx/wx.h"
	29	#endif
	30
	31	#include "wx/html/helpdata.h"
	32	#include "wx/tokenzr.h"
	33	#include "wx/wfstream.h"
	34	#include "wx/busyinfo.h"
69941f05	35	#include "wx/html/htmlpars.h"
8ec2b484 HH	36	#include "wx/html/htmldefs.h"
	37
	38	#include "wx/arrimpl.cpp"
	39	WX_DEFINE_OBJARRAY(wxHtmlBookRecArray)
	40
	41	//-----------------------------------------------------------------------------
	42	// static helper functions
	43	//-----------------------------------------------------------------------------
	44
	45	// Reads one line, stores it into buf and returns pointer to new line or NULL.
	46	static char* ReadLine(char line, char buf)
	47	{
	48	char writeptr = buf, readptr = line;
	49
	50	while (readptr != 0 && readptr != '\r' && readptr != '\n') (writeptr++) = *(readptr++);
	51	*writeptr = 0;
	52	while (readptr == '\r' \|\| readptr == '\n') readptr++;
	53	if (*readptr == 0) return NULL;
	54	else return readptr;
	55	}
	56
	57
	58	static wxString SafeFileName(const wxString& s)
	59	{
	60	wxString res = s;
66a77a74 OK	61	res.Replace(wxT(":"), wxT("_"), TRUE);
	62	res.Replace(wxT(" "), wxT("_"), TRUE);
	63	res.Replace(wxT("/"), wxT("_"), TRUE);
	64	res.Replace(wxT("\\"), wxT("_"), TRUE);
	65	res.Replace(wxT("#"), wxT("_"), TRUE);
	66	res.Replace(wxT("."), wxT("_"), TRUE);
8ec2b484 HH	67	return res;
	68	}
	69
	70
16a12a3d	71	static int LINKAGEMODE IndexCompareFunc(const void a, const void b)
8ec2b484	72	{
66a77a74	73	return wxStrcmp(((wxHtmlContentsItem)a) -> m_Name, ((wxHtmlContentsItem)b) -> m_Name);
8ec2b484 HH	74	}
	75
	76
	77	//-----------------------------------------------------------------------------
	78	// HP_Parser
	79	//-----------------------------------------------------------------------------
	80
	81	class HP_Parser : public wxHtmlParser
	82	{
	83	public:
0c5d3e1c VZ	84	void AddText(const char* WXUNUSED(text)) { }
0c5d3e1c VZ	85	wxObject* GetProduct() { return NULL; }
8ec2b484 HH	86	};
	87
	88
	89	//-----------------------------------------------------------------------------
	90	// HP_TagHandler
	91	//-----------------------------------------------------------------------------
	92
	93	class HP_TagHandler : public wxHtmlTagHandler
	94	{
	95	private:
	96	wxString m_Name, m_Page;
	97	int m_Level;
d5bb85a0	98	int m_ID;
8ec2b484 HH	99	int m_Index;
	100	wxHtmlContentsItem *m_Items;
	101	int m_ItemsCnt;
	102	wxHtmlBookRecord *m_Book;
	103
	104	public:
d5bb85a0	105	HP_TagHandler(wxHtmlBookRecord *b) : wxHtmlTagHandler() {m_Book = b; m_Items = NULL; m_ItemsCnt = 0; m_Name = m_Page = wxEmptyString; m_Level = 0; }
66a77a74	106	wxString GetSupportedTags() { return wxT("UL,OBJECT,PARAM"); }
8ec2b484 HH	107	bool HandleTag(const wxHtmlTag& tag);
	108	void WriteOut(wxHtmlContentsItem*& array, int& size);
	109	void ReadIn(wxHtmlContentsItem* array, int size);
	110	};
	111
	112
	113	bool HP_TagHandler::HandleTag(const wxHtmlTag& tag)
	114	{
	115	if (tag.GetName() == "UL") {
	116	m_Level++;
	117	ParseInner(tag);
	118	m_Level--;
	119	return TRUE;
	120	}
66a77a74	121	else if (tag.GetName() == wxT("OBJECT")) {
8ec2b484 HH	122	m_Name = m_Page = wxEmptyString;
	123	ParseInner(tag);
	124	if (m_Page != wxEmptyString) {
efba2b89 VS	125	if (m_ItemsCnt % wxHTML_REALLOC_STEP == 0)
efba2b89 VS	126	m_Items = (wxHtmlContentsItem) realloc(m_Items, (m_ItemsCnt + wxHTML_REALLOC_STEP) sizeof(wxHtmlContentsItem));
8ec2b484 HH	127	m_Items[m_ItemsCnt].m_Level = m_Level;
8ec2b484 HH	128	m_Items[m_ItemsCnt].m_ID = m_ID;
66a77a74 OK	129	m_Items[m_ItemsCnt].m_Page = new wxChar[m_Page.Length() + 1];
	130	wxStrcpy(m_Items[m_ItemsCnt].m_Page, m_Page.c_str());
	131	m_Items[m_ItemsCnt].m_Name = new wxChar [m_Name.Length() + 1];
	132	wxStrcpy(m_Items[m_ItemsCnt].m_Name, m_Name.c_str());
8ec2b484 HH	133	m_Items[m_ItemsCnt].m_Book = m_Book;
	134	m_ItemsCnt++;
	135	}
	136	return TRUE;
	137	}
8ec2b484	138	else { // "PARAM"
66a77a74 OK	139	if (m_Name == wxEmptyString && tag.GetParam(wxT("NAME")) == wxT("Name")) m_Name = tag.GetParam(wxT("VALUE"));
	140	if (tag.GetParam(wxT("NAME")) == wxT("Local")) m_Page = tag.GetParam(wxT("VALUE"));
	141	if (tag.GetParam(wxT("NAME")) == wxT("ID")) tag.ScanParam(wxT("VALUE"), wxT("%i"), &m_ID);
8ec2b484 HH	142	return FALSE;
	143	}
	144	}
	145
	146
	147
	148	void HP_TagHandler::WriteOut(wxHtmlContentsItem*& array, int& size)
	149	{
	150	array = m_Items;
	151	size = m_ItemsCnt;
	152	m_Items = NULL;
	153	m_ItemsCnt = 0;
	154	}
	155
	156	void HP_TagHandler::ReadIn(wxHtmlContentsItem* array, int size)
	157	{
	158	m_Items = array;
	159	m_ItemsCnt = size;
	160	}
	161
d5bb85a0 VS	162
	163
	164
8ec2b484 HH	165	//-----------------------------------------------------------------------------
	166	// wxHtmlHelpData
	167	//-----------------------------------------------------------------------------
	168
	169	IMPLEMENT_DYNAMIC_CLASS(wxHtmlHelpData, wxObject)
	170
f42b1601	171	wxHtmlHelpData::wxHtmlHelpData()
8ec2b484 HH	172	{
	173	m_TempPath = wxEmptyString;
	174
	175	m_Contents = NULL;
	176	m_ContentsCnt = 0;
	177	m_Index = NULL;
	178	m_IndexCnt = 0;
	179	}
	180
	181	wxHtmlHelpData::~wxHtmlHelpData()
	182	{
	183	int i;
	184
	185	m_BookRecords.Empty();
	186	if (m_Contents) {
	187	for (i = 0; i < m_ContentsCnt; i++) {
	188	delete[] m_Contents[i].m_Page;
	189	delete[] m_Contents[i].m_Name;
	190	}
	191	free(m_Contents);
	192	}
	193	if (m_Index) {
	194	for (i = 0; i < m_IndexCnt; i++) {
	195	delete[] m_Index[i].m_Page;
	196	delete[] m_Index[i].m_Name;
	197	}
	198	free(m_Index);
	199	}
	200	}
	201
	202	bool wxHtmlHelpData::LoadMSProject(wxHtmlBookRecord *book, wxFileSystem& fsys, const wxString& indexfile, const wxString& contentsfile)
	203	{
	204	wxFSFile *f;
	205	char *buf;
	206	int sz;
	207	wxString string;
f42b1601	208
8ec2b484 HH	209	HP_Parser parser;
	210	HP_TagHandler *handler = new HP_TagHandler(book);
	211	parser.AddTagHandler(handler);
	212
af111fc3	213	f = ( contentsfile.IsEmpty() ? 0 : fsys.OpenFile(contentsfile) );
8ec2b484 HH	214	if (f) {
8ec2b484 HH	215	sz = f -> GetStream() -> GetSize();
d5bb85a0	216	buf = new char[sz + 1];
8ec2b484 HH	217	buf[sz] = 0;
	218	f -> GetStream() -> Read(buf, sz);
	219	delete f;
	220	handler -> ReadIn(m_Contents, m_ContentsCnt);
	221	parser.Parse(buf);
	222	handler -> WriteOut(m_Contents, m_ContentsCnt);
	223	delete[] buf;
	224	}
	225
af111fc3	226	f = ( indexfile.IsEmpty() ? 0 : fsys.OpenFile(indexfile) );
8ec2b484 HH	227	if (f) {
8ec2b484 HH	228	sz = f -> GetStream() -> GetSize();
d5bb85a0	229	buf = new char[sz + 1];
8ec2b484 HH	230	buf[sz] = 0;
	231	f -> GetStream() -> Read(buf, sz);
	232	delete f;
	233	handler -> ReadIn(m_Index, m_IndexCnt);
	234	parser.Parse(buf);
	235	handler -> WriteOut(m_Index, m_IndexCnt);
	236	delete[] buf;
	237	}
	238	return TRUE;
	239	}
	240
	241
	242	bool wxHtmlHelpData::LoadCachedBook(wxHtmlBookRecord book, wxInputStream f)
	243	{
	244	int i, st;
	245	int x;
	246
	247	/* load contents : */
	248
	249	f -> Read(&x, sizeof(x));
	250	st = m_ContentsCnt;
	251	m_ContentsCnt += x;
efba2b89	252	m_Contents = (wxHtmlContentsItem) realloc(m_Contents, (m_ContentsCnt / wxHTML_REALLOC_STEP + 1) wxHTML_REALLOC_STEP * sizeof(wxHtmlContentsItem));
8ec2b484 HH	253	for (i = st; i < m_ContentsCnt; i++) {
	254	f -> Read(&x, sizeof(x));
	255	m_Contents[i].m_Level = x;
	256	f -> Read(&x, sizeof(x));
	257	m_Contents[i].m_ID = x;
	258	f -> Read(&x, sizeof(x));
66a77a74 OK	259	m_Contents[i].m_Name = new wxChar[x];
66a77a74 OK	260	f -> Read(m_Contents[i].m_Name, x*sizeof(wxChar));
8ec2b484	261	f -> Read(&x, sizeof(x));
66a77a74 OK	262	m_Contents[i].m_Page = new wxChar[x];
66a77a74 OK	263	f -> Read(m_Contents[i].m_Page, x*sizeof(wxChar));
8ec2b484 HH	264	m_Contents[i].m_Book = book;
	265	}
	266
	267	/* load index : */
	268
	269	f -> Read(&x, sizeof(x));
	270	st = m_IndexCnt;
	271	m_IndexCnt += x;
efba2b89	272	m_Index = (wxHtmlContentsItem) realloc(m_Index, (m_IndexCnt / wxHTML_REALLOC_STEP + 1) wxHTML_REALLOC_STEP * sizeof(wxHtmlContentsItem));
8ec2b484 HH	273	for (i = st; i < m_IndexCnt; i++) {
8ec2b484 HH	274	f -> Read(&x, sizeof(x));
66a77a74 OK	275	m_Index[i].m_Name = new wxChar[x];
66a77a74 OK	276	f -> Read(m_Index[i].m_Name, x*sizeof(wxChar));
8ec2b484	277	f -> Read(&x, sizeof(x));
66a77a74 OK	278	m_Index[i].m_Page = new wxChar[x];
66a77a74 OK	279	f -> Read(m_Index[i].m_Page, x*sizeof(wxChar));
8ec2b484 HH	280	m_Index[i].m_Book = book;
	281	}
	282	return TRUE;
	283	}
	284
	285
	286	bool wxHtmlHelpData::SaveCachedBook(wxHtmlBookRecord book, wxOutputStream f)
	287	{
	288	int i;
	289	int x;
	290
	291	/* save contents : */
	292
	293	x = 0;
	294	for (i = 0; i < m_ContentsCnt; i++) if (m_Contents[i].m_Book == book && m_Contents[i].m_Level > 0) x++;
	295	f -> Write(&x, sizeof(x));
	296	for (i = 0; i < m_ContentsCnt; i++) {
	297	if (m_Contents[i].m_Book != book \|\| m_Contents[i].m_Level == 0) continue;
	298	x = m_Contents[i].m_Level;
	299	f -> Write(&x, sizeof(x));
	300	x = m_Contents[i].m_ID;
	301	f -> Write(&x, sizeof(x));
66a77a74	302	x = wxStrlen(m_Contents[i].m_Name) + 1;
8ec2b484	303	f -> Write(&x, sizeof(x));
66a77a74 OK	304	f -> Write(m_Contents[i].m_Name, x*sizeof(wxChar));
66a77a74 OK	305	x = wxStrlen(m_Contents[i].m_Page) + 1;
8ec2b484	306	f -> Write(&x, sizeof(x));
66a77a74	307	f -> Write(m_Contents[i].m_Page, x*sizeof(wxChar));
8ec2b484 HH	308	}
	309
	310	/* save index : */
	311
	312	x = 0;
	313	for (i = 0; i < m_IndexCnt; i++) if (m_Index[i].m_Book == book && m_Index[i].m_Level > 0) x++;
	314	f -> Write(&x, sizeof(x));
	315	for (i = 0; i < m_IndexCnt; i++) {
	316	if (m_Index[i].m_Book != book \|\| m_Index[i].m_Level == 0) continue;
66a77a74	317	x = wxStrlen(m_Index[i].m_Name) + 1;
8ec2b484	318	f -> Write(&x, sizeof(x));
66a77a74 OK	319	f -> Write(m_Index[i].m_Name, x*sizeof(wxChar));
66a77a74 OK	320	x = wxStrlen(m_Index[i].m_Page) + 1;
8ec2b484	321	f -> Write(&x, sizeof(x));
66a77a74	322	f -> Write(m_Index[i].m_Page, x*sizeof(wxChar));
8ec2b484 HH	323	}
	324	return TRUE;
	325	}
	326
	327
	328	void wxHtmlHelpData::SetTempDir(const wxString& path)
	329	{
	330	if (path == wxEmptyString) m_TempPath = path;
	331	else {
d5bb85a0 VS	332	if (wxIsAbsolutePath(path)) m_TempPath = path;
d5bb85a0 VS	333	else m_TempPath = wxGetCwd() + "/" + path;
8ec2b484	334
d5bb85a0	335	if (m_TempPath[m_TempPath.Length() - 1] != '/')
8ec2b484 HH	336	m_TempPath << "/";
	337	}
	338	}
	339
	340
f42b1601	341	bool wxHtmlHelpData::AddBookParam(const wxString& title, const wxString& contfile,
d5bb85a0 VS	342	const wxString& indexfile, const wxString& deftopic,
d5bb85a0 VS	343	const wxString& path)
8ec2b484 HH	344	{
	345	wxFileSystem fsys;
	346	wxFSFile *fi;
	347	wxHtmlBookRecord *bookr;
	348	wxString safetitle;
f42b1601	349
8ec2b484	350	if (! path.IsEmpty())
d5bb85a0	351	fsys.ChangePathTo(path, TRUE);
8ec2b484	352
68364659	353	bookr = new wxHtmlBookRecord(fsys.GetPath(), title, deftopic);
8ec2b484	354
efba2b89 VS	355	if (m_ContentsCnt % wxHTML_REALLOC_STEP == 0)
efba2b89 VS	356	m_Contents = (wxHtmlContentsItem) realloc(m_Contents, (m_ContentsCnt + wxHTML_REALLOC_STEP) sizeof(wxHtmlContentsItem));
8ec2b484 HH	357	m_Contents[m_ContentsCnt].m_Level = 0;
8ec2b484 HH	358	m_Contents[m_ContentsCnt].m_ID = 0;
66a77a74 OK	359	m_Contents[m_ContentsCnt].m_Page = new wxChar[deftopic.Length() + 1];
	360	wxStrcpy(m_Contents[m_ContentsCnt].m_Page, deftopic.c_str());
	361	m_Contents[m_ContentsCnt].m_Name = new wxChar [title.Length() + 1];
	362	wxStrcpy(m_Contents[m_ContentsCnt].m_Name, title.c_str());
8ec2b484 HH	363	m_Contents[m_ContentsCnt].m_Book = bookr;
	364
	365	// store the contents index for later
	366	int cont_start = m_ContentsCnt++;
	367
	368	// Try to find cached binary versions:
	369	safetitle = SafeFileName(title);
68364659 VS	370	fi = fsys.OpenFile(safetitle + wxT(".cached"));
68364659 VS	371	if (fi == NULL) fi = fsys.OpenFile(m_TempPath + safetitle + wxT(".cached"));
8ec2b484 HH	372	if ((fi == NULL) \|\| (m_TempPath == wxEmptyString)) {
	373	LoadMSProject(bookr, fsys, indexfile, contfile);
	374	if (m_TempPath != wxEmptyString) {
68364659	375	wxFileOutputStream *outs = new wxFileOutputStream(m_TempPath + safetitle + wxT(".cached"));
8ec2b484 HH	376	SaveCachedBook(bookr, outs);
8ec2b484 HH	377	delete outs;
d5bb85a0 VS	378	}
d5bb85a0 VS	379	} else {
8ec2b484 HH	380	LoadCachedBook(bookr, fi -> GetStream());
	381	delete fi;
	382	}
	383
	384	// Now store the contents range
	385	bookr->SetContentsRange(cont_start, m_ContentsCnt);
	386
	387	m_BookRecords.Add(bookr);
	388	if (m_IndexCnt > 0)
	389	qsort(m_Index, m_IndexCnt, sizeof(wxHtmlContentsItem), IndexCompareFunc);
f42b1601	390
8ec2b484 HH	391	return TRUE;
	392	}
	393
	394
	395	bool wxHtmlHelpData::AddBook(const wxString& book)
	396	{
68364659 VS	397	if (book.Right(4).Lower() == wxT(".zip") \|\|
	398	book.Right(4).Lower() == wxT(".htb") /html book/)
	399
	400	{
	401	wxFileSystem fsys;
	402	wxString s;
	403	bool rt = FALSE;
	404
	405	s = fsys.FindFirst(book + wxT("#zip:") + wxT("*.hhp"), wxFILE);
	406	while (!s.IsEmpty())
	407	{
	408	if (AddBook(s)) rt = TRUE;
	409	s = fsys.FindNext();
	410	}
	411
	412	return rt;
	413	}
8ec2b484	414
68364659 VS	415
	416	else
	417	{
	418	wxFSFile *fi;
	419	wxFileSystem fsys;
	420	wxInputStream *s;
	421	wxString bookFull;
	422
	423	int sz;
	424	char buff, lineptr;
	425	char linebuf[300];
	426
	427	wxString title = _("noname"),
	428	safetitle,
	429	start = wxEmptyString,
	430	contents = wxEmptyString, index = wxEmptyString;
	431
	432	if (wxIsAbsolutePath(book)) bookFull = book;
	433	else bookFull = wxGetCwd() + "/" + book;
	434
	435	fi = fsys.OpenFile(bookFull);
	436	if (fi == NULL) return FALSE;
	437	fsys.ChangePathTo(bookFull);
	438	s = fi -> GetStream();
	439	sz = s -> GetSize();
	440	buff = new char[sz + 1];
	441	buff[sz] = 0;
	442	s -> Read(buff, sz);
	443	lineptr = buff;
	444	delete fi;
	445
	446	do {
	447	lineptr = ReadLine(lineptr, linebuf);
	448
	449	if (strstr(linebuf, "Title=") == linebuf)
	450	title = linebuf + strlen("Title=");
	451	if (strstr(linebuf, "Default topic=") == linebuf)
	452	start = linebuf + strlen("Default topic=");
	453	if (strstr(linebuf, "Index file=") == linebuf)
	454	index = linebuf + strlen("Index file=");
	455	if (strstr(linebuf, "Contents file=") == linebuf)
	456	contents = linebuf + strlen("Contents file=");
	457	} while (lineptr != NULL);
	458	delete[] buff;
	459
	460	return AddBookParam(title, contents, index, start, fsys.GetPath());
	461	}
8ec2b484 HH	462	}
	463
	464	wxString wxHtmlHelpData::FindPageByName(const wxString& x)
	465	{
	466	int cnt;
	467	int i;
	468	wxFileSystem fsys;
	469	wxFSFile *f;
	470	wxString url(wxEmptyString);
	471
	472	/* 1. try to open given file: */
	473
	474	cnt = m_BookRecords.GetCount();
	475	for (i = 0; i < cnt; i++) {
	476	f = fsys.OpenFile(m_BookRecords[i].GetBasePath() + x);
	477	if (f) {
	478	url = m_BookRecords[i].GetBasePath() + x;
	479	delete f;
	480	return url;
	481	}
	482	}
	483
	484
	485	/* 2. try to find a book: */
	486
	487	for (i = 0; i < cnt; i++) {
	488	if (m_BookRecords[i].GetTitle() == x) {
	489	url = m_BookRecords[i].GetBasePath() + m_BookRecords[i].GetStart();
	490	return url;
	491	}
	492	}
	493
	494	/* 3. try to find in contents: */
	495
	496	cnt = m_ContentsCnt;
	497	for (i = 0; i < cnt; i++) {
66a77a74	498	if (wxStrcmp(m_Contents[i].m_Name, x) == 0) {
8ec2b484 HH	499	url = m_Contents[i].m_Book -> GetBasePath() + m_Contents[i].m_Page;
	500	return url;
	501	}
	502	}
	503
	504
	505	/* 4. try to find in index: */
	506
	507	cnt = m_IndexCnt;
	508	for (i = 0; i < cnt; i++) {
66a77a74	509	if (wxStrcmp(m_Index[i].m_Name, x) == 0) {
8ec2b484 HH	510	url = m_Index[i].m_Book -> GetBasePath() + m_Index[i].m_Page;
	511	return url;
	512	}
	513	}
	514
	515	return url;
	516	}
	517
	518	wxString wxHtmlHelpData::FindPageById(int id)
f42b1601	519	{
8ec2b484 HH	520	int i;
	521	wxString url(wxEmptyString);
	522
	523	for (i = 0; i < m_ContentsCnt; i++) {
	524	if (m_Contents[i].m_ID == id) {
	525	url = m_Contents[i].m_Book -> GetBasePath() + m_Contents[i].m_Page;
	526	return url;
	527	}
	528	}
	529
	530	return url;
	531	}
	532
	533	//----------------------------------------------------------------------------------
	534	// wxHtmlSearchStatus functions
	535	//----------------------------------------------------------------------------------
	536
	537	wxHtmlSearchStatus::wxHtmlSearchStatus(wxHtmlHelpData* data, const wxString& keyword,
d5bb85a0	538	const wxString& book)
8ec2b484 HH	539	{
	540	m_Data = data;
	541	m_Keyword = keyword;
	542	wxHtmlBookRecord* bookr = NULL;
	543	if (book != wxEmptyString) {
d5bb85a0 VS	544	// we have to search in a specific book. Find it first
	545	int i, cnt = data->m_BookRecords.GetCount();
	546	for (i = 0; i < cnt; i++)
	547	if (data->m_BookRecords[i].GetTitle() == book) {
	548	bookr = &(data->m_BookRecords[i]);
	549	m_CurIndex = bookr->GetContentsStart();
	550	m_MaxIndex = bookr->GetContentsEnd();
	551	break;
	552	}
	553	// check; we won't crash if the book doesn't exist, but it's Bad Anyway.
	554	wxASSERT(bookr);
8ec2b484 HH	555	}
8ec2b484 HH	556	if (! bookr) {
d5bb85a0 VS	557	// no book specified; search all books
	558	m_CurIndex = 0;
	559	m_MaxIndex = m_Data->m_ContentsCnt;
8ec2b484 HH	560	}
	561	m_Engine.LookFor(keyword);
	562	m_Active = (m_CurIndex < m_MaxIndex);
	563	m_LastPage = wxEmptyString;
	564	}
	565
	566	bool wxHtmlSearchStatus::Search()
	567	{
	568	wxFileSystem fsys;
	569	wxFSFile *file;
d5bb85a0	570	int i = m_CurIndex; // shortcut
8ec2b484 HH	571	bool found = FALSE;
	572
	573	if (! m_Active) {
	574	// sanity check. Illegal use, but we'll try to prevent a crash anyway
16a12a3d DW	575	#if !defined(__VISAGECPP__)
	576	wxASSERT(0);
	577	#else
	578	wxASSERT(m_Active);
	579	#endif
8ec2b484 HH	580	return FALSE;
	581	}
	582
	583	m_ContentsItem = NULL;
	584	m_Name = wxEmptyString;
	585
f42b1601	586	file = fsys.OpenFile(m_Data->m_Contents[i].m_Book -> GetBasePath() +
d5bb85a0	587	m_Data->m_Contents[i].m_Page);
8ec2b484	588	if (file) {
d5bb85a0 VS	589	if (m_LastPage != file->GetLocation()) {
	590	m_LastPage = file->GetLocation();
	591	if (m_Engine.Scan(file -> GetStream())) {
	592	m_Name = m_Data->m_Contents[i].m_Name;
	593	m_ContentsItem = m_Data->m_Contents + i;
	594	found = TRUE;
	595	}
	596	}
	597	delete file;
8ec2b484 HH	598	}
	599	m_Active = (++m_CurIndex < m_MaxIndex);
	600	return found;
	601	}
	602
d5bb85a0 VS	603
	604
	605
	606
	607
	608
	609
	610	//--------------------------------------------------------------------------------
	611	// wxSearchEngine
	612	//--------------------------------------------------------------------------------
	613
	614	void wxSearchEngine::LookFor(const wxString& keyword)
	615	{
	616	if (m_Keyword) delete[] m_Keyword;
66a77a74 OK	617	m_Keyword = new wxChar[keyword.Length() + 1];
	618	wxStrcpy(m_Keyword, keyword.c_str());
	619	for (int i = wxStrlen(m_Keyword) - 1; i >= 0; i--)
	620	if ((m_Keyword[i] >= wxT('A')) && (m_Keyword[i] <= wxT('Z')))
	621	m_Keyword[i] += wxT('a') - wxT('A');
d5bb85a0 VS	622	}
	623
	624
	625
	626	bool wxSearchEngine::Scan(wxInputStream *stream)
	627	{
	628	wxASSERT_MSG(m_Keyword != NULL, _("wxSearchEngine::LookFor must be called before scanning!"));
	629
	630	int i, j;
	631	int lng = stream ->GetSize();
66a77a74	632	int wrd = wxStrlen(m_Keyword);
d5bb85a0 VS	633	bool found = FALSE;
	634	char *buf = new char[lng + 1];
	635	stream -> Read(buf, lng);
	636	buf[lng] = 0;
	637
	638	for (i = 0; i < lng; i++)
	639	if ((buf[i] >= 'A') && (buf[i] <= 'Z')) buf[i] += 'a' - 'A';
	640
	641	for (i = 0; i < lng - wrd; i++) {
	642	j = 0;
	643	while ((j < wrd) && (buf[i + j] == m_Keyword[j])) j++;
	644	if (j == wrd) {found = TRUE; break; }
	645	}
	646
	647	delete[] buf;
	648	return found;
	649	}
	650
	651
	652
	653
8ec2b484	654	#endif