src/html/m_image.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        m_image.cpp
// Purpose:     wxHtml module for displaying images
// Author:      Vaclav Slavik
// RCS-ID:      $Id$
// Copyright:   (c) 1999 Vaclav Slavik, Joel Lucsy
// Licence:     wxWindows Licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation
#endif

#include "wx/wxprec.h"

#include "wx/defs.h"
#if wxUSE_HTML && wxUSE_STREAMS

#ifdef __BORDLANDC__
#pragma hdrstop
#endif

#ifndef WXPRECOMP
    #include "wx/dc.h"
    #include "wx/scrolwin.h"
    #include "wx/timer.h"
    #include "wx/dcmemory.h"
#endif

#include "wx/html/forcelnk.h"
#include "wx/html/m_templ.h"
#include "wx/html/htmlwin.h"

#include "wx/image.h"
#include "wx/gifdecod.h"
#include "wx/dynarray.h"

#include <math.h>
#include <float.h>

FORCE_LINK_ME(m_image)


WX_DECLARE_OBJARRAY(int, CoordArray);
#include "wx/arrimpl.cpp" // this is a magic incantation which must be done!
WX_DEFINE_OBJARRAY(CoordArray);


//--------------------------------------------------------------------------------
// wxHtmlImageMapAreaCell
//                  0-width, 0-height cell that represents single area in imagemap
//                  (it's GetLink is called from wxHtmlImageCell's)
//--------------------------------------------------------------------------------

class wxHtmlImageMapAreaCell : public wxHtmlCell
{
    public:
        enum celltype { CIRCLE, RECT, POLY };
    protected:
        CoordArray coords;
        celltype type;
        int radius;
    public:
        wxHtmlImageMapAreaCell( celltype t, wxString &coords, double pixel_scale = 1.0);
        virtual wxHtmlLinkInfo *GetLink( int x = 0, int y = 0 ) const;
};


wxHtmlImageMapAreaCell::wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::celltype t, wxString &incoords, double pixel_scale )
{
    int i;
    wxString x = incoords, y;

    type = t;
    while ((i = x.Find( ',' )) != -1)
    {
        coords.Add( (int)(pixel_scale * (double)wxAtoi( x.Left( i ).c_str())) );
        x = x.Mid( i + 1 );
    }
    coords.Add( (int)(pixel_scale * (double)wxAtoi( x.c_str())) );
}

wxHtmlLinkInfo *wxHtmlImageMapAreaCell::GetLink( int x, int y ) const
{
    switch (type)
    {
        case RECT:
            {
                int l, t, r, b;

                l = coords[ 0 ];
                t = coords[ 1 ];
                r = coords[ 2 ];
                b = coords[ 3 ];
                if (x >= l && x <= r && y >= t && y <= b)
                {
                    return m_Link;
                }
                break;
            }
        case CIRCLE:
            {
                int l, t, r;
                double  d;

                l = coords[ 0 ];
                t = coords[ 1 ];
                r = coords[ 2 ];
                d = sqrt( (double) (((x - l) * (x - l)) + ((y - t) * (y - t))) );
                if (d < (double)r)
                {
                    return m_Link;
                }
            }
            break;
        case POLY:
            {
                if (coords.GetCount() >= 6)
                {
                    int intersects = 0;
                    int wherex = x;
                    int wherey = y;
                    int totalv = coords.GetCount() / 2;
                    int totalc = totalv * 2;
                    int xval = coords[totalc - 2];
                    int yval = coords[totalc - 1];
                    int end = totalc;
                    int pointer = 1;

                    if ((yval >= wherey) != (coords[pointer] >= wherey))
                    {
                        if ((xval >= wherex) == (coords[0] >= wherex))
                        {
                            intersects += (xval >= wherex) ? 1 : 0;
                        }
                        else
                        {
                            intersects += ((xval - (yval - wherey) *
                                            (coords[0] - xval) /
                                            (coords[pointer] - yval)) >= wherex) ? 1 : 0;
                        }
                    }

                    while (pointer < end)
                    {
                        yval = coords[pointer];
                        pointer += 2;
                        if (yval >= wherey)
                        {
                            while ((pointer < end) && (coords[pointer] >= wherey))
                            {
                                pointer += 2;
                            }
                            if (pointer >= end)
                            {
                                break;
                            }
                            if ((coords[pointer - 3] >= wherex) ==
                                    (coords[pointer - 1] >= wherex)) {
                                intersects += (coords[pointer - 3] >= wherex) ? 1 : 0;
                            }
                            else
                            {
                                intersects +=
                                    ((coords[pointer - 3] - (coords[pointer - 2] - wherey) *
                                      (coords[pointer - 1] - coords[pointer - 3]) /
                                      (coords[pointer] - coords[pointer - 2])) >= wherex) ? 1 : 0;
                            }
                        }
                        else
                        {
                            while ((pointer < end) && (coords[pointer] < wherey))
                            {
                                pointer += 2;
                            }
                            if (pointer >= end)
                            {
                                break;
                            }
                            if ((coords[pointer - 3] >= wherex) ==
                                    (coords[pointer - 1] >= wherex))
                            {
                                intersects += (coords[pointer - 3] >= wherex) ? 1 : 0;
                            }
                            else
                            {
                                intersects +=
                                    ((coords[pointer - 3] - (coords[pointer - 2] - wherey) *
                                      (coords[pointer - 1] - coords[pointer - 3]) /
                                      (coords[pointer] - coords[pointer - 2])) >= wherex) ? 1 : 0;
                            }
                        }
                    }
                    if ((intersects & 1) != 0)
                    {
                        return m_Link;
                    }
                }
            }
            break;
    }

    if (m_Next)
    {
        wxHtmlImageMapAreaCell  *a = (wxHtmlImageMapAreaCell*)m_Next;
        return a->GetLink( x, y );
    }
    return NULL;
}


//--------------------------------------------------------------------------------
// wxHtmlImageMapCell
//                  0-width, 0-height cell that represents map from imagemaps
//                  it is always placed before wxHtmlImageMapAreaCells
//                  It responds to Find(wxHTML_COND_ISIMAGEMAP)
//--------------------------------------------------------------------------------


class wxHtmlImageMapCell : public wxHtmlCell
{
    public:
        wxHtmlImageMapCell( wxString &name );
    protected:
        wxString m_Name;
    public:
        virtual wxHtmlLinkInfo *GetLink( int x = 0, int y = 0 ) const;
        virtual const wxHtmlCell *Find( int cond, const void *param ) const;
};


wxHtmlImageMapCell::wxHtmlImageMapCell( wxString &name )
{
    m_Name = name ;
}

wxHtmlLinkInfo *wxHtmlImageMapCell::GetLink( int x, int y ) const
{
    wxHtmlImageMapAreaCell  *a = (wxHtmlImageMapAreaCell*)m_Next;
    if (a)
        return a->GetLink( x, y );
    return wxHtmlCell::GetLink( x, y );
}

const wxHtmlCell *wxHtmlImageMapCell::Find( int cond, const void *param ) const
{
    if (cond == wxHTML_COND_ISIMAGEMAP)
    {
        if (m_Name == *((wxString*)(param)))
            return this;
    }
    return wxHtmlCell::Find(cond, param);
}


//--------------------------------------------------------------------------------
// wxHtmlImageCell
//                  Image/bitmap
//--------------------------------------------------------------------------------

class wxHtmlImageCell : public wxHtmlCell
{
public:
    wxHtmlImageCell(wxWindow *window,
                    wxFSFile *input, int w = -1, int h = -1,
                    double scale = 1.0, int align = wxHTML_ALIGN_BOTTOM,
                    const wxString& mapname = wxEmptyString);
    ~wxHtmlImageCell();
    void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2);
    virtual wxHtmlLinkInfo *GetLink(int x = 0, int y = 0) const;

    void SetImage(const wxImage& img);
#if wxUSE_GIF && wxUSE_TIMER
    void AdvanceAnimation(wxTimer *timer);
    virtual void Layout(int w);
#endif

private:
    wxBitmap           *m_bitmap;
    int                 m_bmpW, m_bmpH;
    bool                m_showFrame:1;
    wxScrolledWindow   *m_window;
#if wxUSE_GIF && wxUSE_TIMER
    wxGIFDecoder       *m_gifDecoder;
    wxTimer            *m_gifTimer;
    int                 m_physX, m_physY;
#endif
    double              m_scale;
    wxHtmlImageMapCell *m_imageMap;
    wxString            m_mapName;
};

#if wxUSE_GIF && wxUSE_TIMER
class wxGIFTimer : public wxTimer
{
    public:
        wxGIFTimer(wxHtmlImageCell *cell) : m_cell(cell) {}
        virtual void Notify()
        {
            m_cell->AdvanceAnimation(this);
        }

    private:
        wxHtmlImageCell *m_cell;
};
#endif


//--------------------------------------------------------------------------------
// wxHtmlImageCell
//--------------------------------------------------------------------------------

/* XPM */
static const char * broken_image_xpm[] = {
"29 31 7 1",
" 	c None",
".	c #808080",
"+	c #FFFFFF",
"@	c #C0C0C0",
"#	c #000000",
"$	c #333366",
"%	c #B2B2B2",
".....................        ",
".+++++++++++++++++++..       ",
".+++++++++++++++++++.@.      ",
".++@@@@@@@@@@@@@@@@@.+@.     ",
".++@@@@@@@@@@@@@@@@@.++@.    ",
".++@@@@@.@@@@.@@@@@@.+++@.   ",
".++@@@@@@@@@@@@@@@@@.++++@.  ",
".++@@@@@@@@@@@@@@@@@.+++++@. ",
".++@@.@@@@@@@@@@.@@@######## ",
".++@@@@@@@@@@@@@@@@@@$$$$$$#.",
".######@@@@@@@@@@@@@@@.....#.",
"       ###@@@@@@@@@@@@@@@++#.",
"          #####@@@@@@@@@@++#.",
"              #@.@@@@@@@@++#.",
"..             ###@@@@@@@++#.",
".+....            #@@@@@@++#.",
".++@@@...          ####@@++#.",
".++@@@@@@..            #####.",
".++@@@@@@@@...               ",
".++@@@@@@%%%%@.              ",
".++@@@@@@%%%%@@....          ",
".++@@@@@@%%%%@@@@@@....      ",
".++@@@@@@%%%%@@@@@@@@@@....  ",
".++@@@@@@@@@@@@@@@@@@@@@@++#.",
".++@@@@@@@@@@@@@@@@@@@@@@++#.",
".++@@@@@@@@@@@@@@@@@@@@@@++#.",
".++@@@@@@@@@@@@@@@@@@@@@@++#.",
".++@@@@@@@@@@@@@@@@@@@@@@++#.",
".++++++++++++++++++++++++++#.",
".++++++++++++++++++++++++++#.",
"############################."};

wxHtmlImageCell::wxHtmlImageCell(wxWindow *window, wxFSFile *input,
                                 int w, int h, double scale, int align,
                                 const wxString& mapname) : wxHtmlCell()
{
    m_window = window ? wxStaticCast(window, wxScrolledWindow) : NULL;
    m_scale = scale;
    m_showFrame = FALSE;
    m_bitmap = NULL;
    m_bmpW = w;
    m_bmpH = h;
    m_imageMap = NULL;
    m_mapName = mapname;
    SetCanLiveOnPagebreak(FALSE);
#if wxUSE_GIF && wxUSE_TIMER
    m_gifDecoder = NULL;
    m_gifTimer = NULL;
    m_physX = m_physY = -1;
#endif

    if ( input )
    {
        wxInputStream *s = input->GetStream();

        if ( s )
        {
            bool readImg = TRUE;

#if wxUSE_GIF && wxUSE_TIMER
            if ( (input->GetLocation().Matches(wxT("*.gif")) ||
                  input->GetLocation().Matches(wxT("*.GIF"))) && m_window )
            {
                m_gifDecoder = new wxGIFDecoder(s, TRUE);
                if ( m_gifDecoder->ReadGIF() == wxGIF_OK )
                {
                    wxImage img;
                    if ( m_gifDecoder->ConvertToImage(&img) )
                        SetImage(img);

                    readImg = FALSE;

                    if ( m_gifDecoder->IsAnimation() )
                    {
                        m_gifTimer = new wxGIFTimer(this);
                        m_gifTimer->Start(m_gifDecoder->GetDelay(), TRUE);
                    }
                    else
                    {
                        wxDELETE(m_gifDecoder);
                    }
                }
                else
                {
                    wxDELETE(m_gifDecoder);
                }
            }

            if ( readImg )
#endif // wxUSE_GIF && wxUSE_TIMER
            {
                SetImage(wxImage(*s, wxBITMAP_TYPE_ANY));
            }
        }
    }
    else // input==NULL, use "broken image" bitmap
    {
        if ( m_bmpW == -1 && m_bmpH == -1 )
        {
            m_bmpW = 29;
            m_bmpH = 31;
        }
        else
        {
            m_showFrame = TRUE;
            if ( m_bmpW == -1 ) m_bmpW = 31;
            if ( m_bmpH == -1 ) m_bmpH = 33;
        }
        m_bitmap = new wxBitmap(broken_image_xpm);
    }

    m_Width = (int)(scale * (double)m_bmpW);
    m_Height = (int)(scale * (double)m_bmpH);

    switch (align)
    {
        case wxHTML_ALIGN_TOP :
            m_Descent = m_Height;
            break;
        case wxHTML_ALIGN_CENTER :
            m_Descent = m_Height / 2;
            break;
        case wxHTML_ALIGN_BOTTOM :
        default :
            m_Descent = 0;
            break;
    }
 }

void wxHtmlImageCell::SetImage(const wxImage& img)
{
    if ( img.Ok() )
    {
        delete m_bitmap;

        int ww, hh;
        ww = img.GetWidth();
        hh = img.GetHeight();

        if ( m_bmpW == -1 )
            m_bmpW = ww;
        if ( m_bmpH == -1 )
            m_bmpH = hh;

        if ((m_bmpW != ww) || (m_bmpH != hh))
        {
            wxImage img2 = img.Scale(m_bmpW, m_bmpH);
            m_bitmap = new wxBitmap(img2);
        }
        else
            m_bitmap = new wxBitmap(img);
    }
}

#if wxUSE_GIF && wxUSE_TIMER
void wxHtmlImageCell::AdvanceAnimation(wxTimer *timer)
{
    wxImage img;

    m_gifDecoder->GoNextFrame(TRUE);

    if ( m_physX == -1 )
    {
        m_physX = m_physY = 0;
        for (wxHtmlCell *cell = this; cell; cell = cell->GetParent())
        {
            m_physX += cell->GetPosX();
            m_physY += cell->GetPosY();
        }
    }

    int x, y;
    m_window->CalcScrolledPosition(m_physX, m_physY, &x, &y);
    wxRect rect(x, y, m_Width, m_Height);

    if ( m_window->GetClientRect().Intersects(rect) &&
         m_gifDecoder->ConvertToImage(&img) )
    {
        if ( (int)m_gifDecoder->GetWidth() != m_Width ||
             (int)m_gifDecoder->GetHeight() != m_Height ||
             m_gifDecoder->GetLeft() != 0 || m_gifDecoder->GetTop() != 0 )
        {
            wxBitmap bmp(img);
            wxMemoryDC dc;
            dc.SelectObject(*m_bitmap);
            dc.DrawBitmap(bmp, m_gifDecoder->GetLeft(), m_gifDecoder->GetTop());
        }
        else
            SetImage(img);
        m_window->Refresh(img.HasMask(), &rect);
    }

    timer->Start(m_gifDecoder->GetDelay(), TRUE);
}

void wxHtmlImageCell::Layout(int w)
{
    wxHtmlCell::Layout(w);
    m_physX = m_physY = -1;
}

#endif

wxHtmlImageCell::~wxHtmlImageCell()
{
    delete m_bitmap;
#if wxUSE_GIF && wxUSE_TIMER
    delete m_gifTimer;
    delete m_gifDecoder;
#endif
}


void wxHtmlImageCell::Draw(wxDC& dc, int x, int y, int WXUNUSED(view_y1), int WXUNUSED(view_y2))
{
    if ( m_showFrame )
    {
        dc.SetBrush(*wxTRANSPARENT_BRUSH);
        dc.SetPen(*wxBLACK_PEN);
        dc.DrawRectangle(x + m_PosX, y + m_PosY, m_Width, m_Height);
        x++, y++;
    }
    if ( m_bitmap )
    {
        double us_x, us_y;
        dc.GetUserScale(&us_x, &us_y);
        dc.SetUserScale(us_x * m_scale, us_y * m_scale);

        dc.DrawBitmap(*m_bitmap, (int) ((x + m_PosX) / m_scale),
                                 (int) ((y + m_PosY) / m_scale), TRUE);
        dc.SetUserScale(us_x, us_y);
    }
}

wxHtmlLinkInfo *wxHtmlImageCell::GetLink( int x, int y ) const
{
    if (m_mapName.IsEmpty())
        return wxHtmlCell::GetLink( x, y );
    if (!m_imageMap)
    {
        wxHtmlContainerCell *p, *op;
        op = p = GetParent();
        while (p)
        {
            op = p;
            p = p->GetParent();
        }
        p = op;
        wxHtmlCell *cell = (wxHtmlCell*)p->Find(wxHTML_COND_ISIMAGEMAP,
                                                (const void*)(&m_mapName));
        if (!cell)
        {
            ((wxString&)m_mapName).Clear();
            return wxHtmlCell::GetLink( x, y );
        }
        {   // dirty hack, ask Joel why he fills m_ImageMap in this place
            // THE problem is that we're in const method and we can't modify m_ImageMap
            wxHtmlImageMapCell **cx = (wxHtmlImageMapCell**)(&m_imageMap);
            *cx = (wxHtmlImageMapCell*)cell;
        }
    }
    return m_imageMap->GetLink(x, y);
}


//--------------------------------------------------------------------------------
// tag handler
//--------------------------------------------------------------------------------

TAG_HANDLER_BEGIN(IMG, "IMG,MAP,AREA")

    TAG_HANDLER_PROC(tag)
    {
        if (tag.GetName() == wxT("IMG"))
        {
            if (tag.HasParam(wxT("SRC")))
            {
                int w = -1, h = -1;
                int al;
                wxFSFile *str;
                wxString tmp = tag.GetParam(wxT("SRC"));
                wxString mn = wxEmptyString;

                str = m_WParser->OpenURL(wxHTML_URL_IMAGE, tmp);

                if (tag.HasParam(wxT("WIDTH")))
                    tag.GetParamAsInt(wxT("WIDTH"), &w);
                if (tag.HasParam(wxT("HEIGHT")))
                    tag.GetParamAsInt(wxT("HEIGHT"), &h);
                al = wxHTML_ALIGN_BOTTOM;
                if (tag.HasParam(wxT("ALIGN")))
                {
                    wxString alstr = tag.GetParam(wxT("ALIGN"));
                    alstr.MakeUpper();  // for the case alignment was in ".."
                    if (alstr == wxT("TEXTTOP"))
                        al = wxHTML_ALIGN_TOP;
                    else if ((alstr == wxT("CENTER")) || (alstr == wxT("ABSCENTER")))
                        al = wxHTML_ALIGN_CENTER;
                }
                if (tag.HasParam(wxT("USEMAP")))
                {
                    mn = tag.GetParam( wxT("USEMAP") );
                    if (mn.GetChar(0) == wxT('#'))
                    {
                        mn = mn.Mid( 1 );
                    }
                }
                wxHtmlImageCell *cel = new wxHtmlImageCell(
                                          m_WParser->GetWindow(),
                                          str, w, h,
                                          m_WParser->GetPixelScale(),
                                          al, mn);
                cel->SetLink(m_WParser->GetLink());
                cel->SetId(tag.GetParam(wxT("id"))); // may be empty
                m_WParser->GetContainer()->InsertCell(cel);
                if (str)
                    delete str;
            }
        }
        if (tag.GetName() == wxT("MAP"))
        {
            m_WParser->CloseContainer();
            m_WParser->OpenContainer();
            if (tag.HasParam(wxT("NAME")))
            {
                wxString tmp = tag.GetParam(wxT("NAME"));
                wxHtmlImageMapCell *cel = new wxHtmlImageMapCell( tmp );
                m_WParser->GetContainer()->InsertCell( cel );
            }
            ParseInner( tag );
            m_WParser->CloseContainer();
            m_WParser->OpenContainer();
        }
        if (tag.GetName() == wxT("AREA"))
        {
            if (tag.HasParam(wxT("SHAPE")))
            {
                wxString tmp = tag.GetParam(wxT("SHAPE"));
                wxString coords = wxEmptyString;
                tmp.MakeUpper();
                wxHtmlImageMapAreaCell *cel = NULL;
                if (tag.HasParam(wxT("COORDS")))
                {
                    coords = tag.GetParam(wxT("COORDS"));
                }
                if (tmp == wxT("POLY"))
                {
                    cel = new wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::POLY, coords, m_WParser->GetPixelScale() );
                }
                else if (tmp == wxT("CIRCLE"))
                {
                    cel = new wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::CIRCLE, coords, m_WParser->GetPixelScale() );
                }
                else if (tmp == wxT("RECT"))
                {
                    cel = new wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::RECT, coords, m_WParser->GetPixelScale() );
                }
                if (cel != NULL && tag.HasParam(wxT("HREF")))
                {
                    wxString tmp = tag.GetParam(wxT("HREF"));
                    wxString target = wxEmptyString;
                    if (tag.HasParam(wxT("TARGET"))) target = tag.GetParam(wxT("TARGET"));
                    cel->SetLink( wxHtmlLinkInfo(tmp, target));
                }
                if (cel != NULL) m_WParser->GetContainer()->InsertCell( cel );
            }
        }

        return FALSE;
    }

TAG_HANDLER_END(IMG)


TAGS_MODULE_BEGIN(Image)

    TAGS_MODULE_ADD(IMG)

TAGS_MODULE_END(Image)


#endif
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: m_image.cpp
	3	// Purpose: wxHtml module for displaying images
	4	// Author: Vaclav Slavik
	5	// RCS-ID: $Id$
	6	// Copyright: (c) 1999 Vaclav Slavik, Joel Lucsy
	7	// Licence: wxWindows Licence
	8	/////////////////////////////////////////////////////////////////////////////
	9
	10	#ifdef __GNUG__
	11	#pragma implementation
	12	#endif
	13
	14	#include "wx/wxprec.h"
	15
	16	#include "wx/defs.h"
	17	#if wxUSE_HTML && wxUSE_STREAMS
	18
	19	#ifdef __BORDLANDC__
	20	#pragma hdrstop
	21	#endif
	22
	23	#ifndef WXPRECOMP
	24	#include "wx/dc.h"
	25	#include "wx/scrolwin.h"
	26	#include "wx/timer.h"
	27	#include "wx/dcmemory.h"
	28	#endif
	29
	30	#include "wx/html/forcelnk.h"
	31	#include "wx/html/m_templ.h"
	32	#include "wx/html/htmlwin.h"
	33
	34	#include "wx/image.h"
	35	#include "wx/gifdecod.h"
	36	#include "wx/dynarray.h"
	37
	38	#include <math.h>
	39	#include <float.h>
	40
	41	FORCE_LINK_ME(m_image)
	42
	43
	44
	45
	46	WX_DECLARE_OBJARRAY(int, CoordArray);
	47	#include "wx/arrimpl.cpp" // this is a magic incantation which must be done!
	48	WX_DEFINE_OBJARRAY(CoordArray);
	49
	50
	51	//--------------------------------------------------------------------------------
	52	// wxHtmlImageMapAreaCell
	53	// 0-width, 0-height cell that represents single area in imagemap
	54	// (it's GetLink is called from wxHtmlImageCell's)
	55	//--------------------------------------------------------------------------------
	56
	57	class wxHtmlImageMapAreaCell : public wxHtmlCell
	58	{
	59	public:
	60	enum celltype { CIRCLE, RECT, POLY };
	61	protected:
	62	CoordArray coords;
	63	celltype type;
	64	int radius;
	65	public:
	66	wxHtmlImageMapAreaCell( celltype t, wxString &coords, double pixel_scale = 1.0);
	67	virtual wxHtmlLinkInfo *GetLink( int x = 0, int y = 0 ) const;
	68	};
	69
	70
	71
	72
	73
	74	wxHtmlImageMapAreaCell::wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::celltype t, wxString &incoords, double pixel_scale )
	75	{
	76	int i;
	77	wxString x = incoords, y;
	78
	79	type = t;
	80	while ((i = x.Find( ',' )) != -1)
	81	{
	82	coords.Add( (int)(pixel_scale * (double)wxAtoi( x.Left( i ).c_str())) );
	83	x = x.Mid( i + 1 );
	84	}
	85	coords.Add( (int)(pixel_scale * (double)wxAtoi( x.c_str())) );
	86	}
	87
	88	wxHtmlLinkInfo *wxHtmlImageMapAreaCell::GetLink( int x, int y ) const
	89	{
	90	switch (type)
	91	{
	92	case RECT:
	93	{
	94	int l, t, r, b;
	95
	96	l = coords[ 0 ];
	97	t = coords[ 1 ];
	98	r = coords[ 2 ];
	99	b = coords[ 3 ];
	100	if (x >= l && x <= r && y >= t && y <= b)
	101	{
	102	return m_Link;
	103	}
	104	break;
	105	}
	106	case CIRCLE:
	107	{
	108	int l, t, r;
	109	double d;
	110
	111	l = coords[ 0 ];
	112	t = coords[ 1 ];
	113	r = coords[ 2 ];
	114	d = sqrt( (double) (((x - l) * (x - l)) + ((y - t) * (y - t))) );
	115	if (d < (double)r)
	116	{
	117	return m_Link;
	118	}
	119	}
	120	break;
	121	case POLY:
	122	{
	123	if (coords.GetCount() >= 6)
	124	{
	125	int intersects = 0;
	126	int wherex = x;
	127	int wherey = y;
	128	int totalv = coords.GetCount() / 2;
	129	int totalc = totalv * 2;
	130	int xval = coords[totalc - 2];
	131	int yval = coords[totalc - 1];
	132	int end = totalc;
	133	int pointer = 1;
	134
	135	if ((yval >= wherey) != (coords[pointer] >= wherey))
	136	{
	137	if ((xval >= wherex) == (coords[0] >= wherex))
	138	{
	139	intersects += (xval >= wherex) ? 1 : 0;
	140	}
	141	else
	142	{
	143	intersects += ((xval - (yval - wherey) *
	144	(coords[0] - xval) /
	145	(coords[pointer] - yval)) >= wherex) ? 1 : 0;
	146	}
	147	}
	148
	149	while (pointer < end)
	150	{
	151	yval = coords[pointer];
	152	pointer += 2;
	153	if (yval >= wherey)
	154	{
	155	while ((pointer < end) && (coords[pointer] >= wherey))
	156	{
	157	pointer += 2;
	158	}
	159	if (pointer >= end)
	160	{
	161	break;
	162	}
	163	if ((coords[pointer - 3] >= wherex) ==
	164	(coords[pointer - 1] >= wherex)) {
	165	intersects += (coords[pointer - 3] >= wherex) ? 1 : 0;
	166	}
	167	else
	168	{
	169	intersects +=
	170	((coords[pointer - 3] - (coords[pointer - 2] - wherey) *
	171	(coords[pointer - 1] - coords[pointer - 3]) /
	172	(coords[pointer] - coords[pointer - 2])) >= wherex) ? 1 : 0;
	173	}
	174	}
	175	else
	176	{
	177	while ((pointer < end) && (coords[pointer] < wherey))
	178	{
	179	pointer += 2;
	180	}
	181	if (pointer >= end)
	182	{
	183	break;
	184	}
	185	if ((coords[pointer - 3] >= wherex) ==
	186	(coords[pointer - 1] >= wherex))
	187	{
	188	intersects += (coords[pointer - 3] >= wherex) ? 1 : 0;
	189	}
	190	else
	191	{
	192	intersects +=
	193	((coords[pointer - 3] - (coords[pointer - 2] - wherey) *
	194	(coords[pointer - 1] - coords[pointer - 3]) /
	195	(coords[pointer] - coords[pointer - 2])) >= wherex) ? 1 : 0;
	196	}
	197	}
	198	}
	199	if ((intersects & 1) != 0)
	200	{
	201	return m_Link;
	202	}
	203	}
	204	}
	205	break;
	206	}
	207
	208	if (m_Next)
	209	{
	210	wxHtmlImageMapAreaCell a = (wxHtmlImageMapAreaCell)m_Next;
	211	return a->GetLink( x, y );
	212	}
	213	return NULL;
	214	}
	215
	216
	217
	218
	219
	220
	221
	222
	223	//--------------------------------------------------------------------------------
	224	// wxHtmlImageMapCell
	225	// 0-width, 0-height cell that represents map from imagemaps
	226	// it is always placed before wxHtmlImageMapAreaCells
	227	// It responds to Find(wxHTML_COND_ISIMAGEMAP)
	228	//--------------------------------------------------------------------------------
	229
	230
	231	class wxHtmlImageMapCell : public wxHtmlCell
	232	{
	233	public:
	234	wxHtmlImageMapCell( wxString &name );
	235	protected:
	236	wxString m_Name;
	237	public:
	238	virtual wxHtmlLinkInfo *GetLink( int x = 0, int y = 0 ) const;
	239	virtual const wxHtmlCell Find( int cond, const void param ) const;
	240	};
	241
	242
	243	wxHtmlImageMapCell::wxHtmlImageMapCell( wxString &name )
	244	{
	245	m_Name = name ;
	246	}
	247
	248	wxHtmlLinkInfo *wxHtmlImageMapCell::GetLink( int x, int y ) const
	249	{
	250	wxHtmlImageMapAreaCell a = (wxHtmlImageMapAreaCell)m_Next;
	251	if (a)
	252	return a->GetLink( x, y );
	253	return wxHtmlCell::GetLink( x, y );
	254	}
	255
	256	const wxHtmlCell wxHtmlImageMapCell::Find( int cond, const void param ) const
	257	{
	258	if (cond == wxHTML_COND_ISIMAGEMAP)
	259	{
	260	if (m_Name == ((wxString)(param)))
	261	return this;
	262	}
	263	return wxHtmlCell::Find(cond, param);
	264	}
	265
	266
	267
	268
	269
	270	//--------------------------------------------------------------------------------
	271	// wxHtmlImageCell
	272	// Image/bitmap
	273	//--------------------------------------------------------------------------------
	274
	275	class wxHtmlImageCell : public wxHtmlCell
	276	{
	277	public:
	278	wxHtmlImageCell(wxWindow *window,
	279	wxFSFile *input, int w = -1, int h = -1,
	280	double scale = 1.0, int align = wxHTML_ALIGN_BOTTOM,
	281	const wxString& mapname = wxEmptyString);
	282	~wxHtmlImageCell();
	283	void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2);
	284	virtual wxHtmlLinkInfo *GetLink(int x = 0, int y = 0) const;
	285
	286	void SetImage(const wxImage& img);
	287	#if wxUSE_GIF && wxUSE_TIMER
	288	void AdvanceAnimation(wxTimer *timer);
	289	virtual void Layout(int w);
	290	#endif
	291
	292	private:
	293	wxBitmap *m_bitmap;
	294	int m_bmpW, m_bmpH;
	295	bool m_showFrame:1;
	296	wxScrolledWindow *m_window;
	297	#if wxUSE_GIF && wxUSE_TIMER
	298	wxGIFDecoder *m_gifDecoder;
	299	wxTimer *m_gifTimer;
	300	int m_physX, m_physY;
	301	#endif
	302	double m_scale;
	303	wxHtmlImageMapCell *m_imageMap;
	304	wxString m_mapName;
	305	};
	306
	307	#if wxUSE_GIF && wxUSE_TIMER
	308	class wxGIFTimer : public wxTimer
	309	{
	310	public:
	311	wxGIFTimer(wxHtmlImageCell *cell) : m_cell(cell) {}
	312	virtual void Notify()
	313	{
	314	m_cell->AdvanceAnimation(this);
	315	}
	316
	317	private:
	318	wxHtmlImageCell *m_cell;
	319	};
	320	#endif
	321
	322
	323	//--------------------------------------------------------------------------------
	324	// wxHtmlImageCell
	325	//--------------------------------------------------------------------------------
	326
	327	/* XPM */
	328	static const char * broken_image_xpm[] = {
	329	"29 31 7 1",
	330	" c None",
	331	". c #808080",
	332	"+ c #FFFFFF",
	333	"@ c #C0C0C0",
	334	"# c #000000",
	335	"$ c #333366",
	336	"% c #B2B2B2",
	337	"..................... ",
	338	".+++++++++++++++++++.. ",
	339	".+++++++++++++++++++.@. ",
	340	".++@@@@@@@@@@@@@@@@@.+@. ",
	341	".++@@@@@@@@@@@@@@@@@.++@. ",
	342	".++@@@@@.@@@@.@@@@@@.+++@. ",
	343	".++@@@@@@@@@@@@@@@@@.++++@. ",
	344	".++@@@@@@@@@@@@@@@@@.+++++@. ",
	345	".++@@.@@@@@@@@@@.@@@######## ",
	346	".++@@@@@@@@@@@@@@@@@@$$$$$$#.",
	347	".######@@@@@@@@@@@@@@@.....#.",
	348	" ###@@@@@@@@@@@@@@@++#.",
	349	" #####@@@@@@@@@@++#.",
	350	" #@.@@@@@@@@++#.",
	351	".. ###@@@@@@@++#.",
	352	".+.... #@@@@@@++#.",
	353	".++@@@... ####@@++#.",
	354	".++@@@@@@.. #####.",
	355	".++@@@@@@@@... ",
	356	".++@@@@@@%%%%@. ",
	357	".++@@@@@@%%%%@@.... ",
	358	".++@@@@@@%%%%@@@@@@.... ",
	359	".++@@@@@@%%%%@@@@@@@@@@.... ",
	360	".++@@@@@@@@@@@@@@@@@@@@@@++#.",
	361	".++@@@@@@@@@@@@@@@@@@@@@@++#.",
	362	".++@@@@@@@@@@@@@@@@@@@@@@++#.",
	363	".++@@@@@@@@@@@@@@@@@@@@@@++#.",
	364	".++@@@@@@@@@@@@@@@@@@@@@@++#.",
	365	".++++++++++++++++++++++++++#.",
	366	".++++++++++++++++++++++++++#.",
	367	"############################."};
	368
	369	wxHtmlImageCell::wxHtmlImageCell(wxWindow window, wxFSFile input,
	370	int w, int h, double scale, int align,
	371	const wxString& mapname) : wxHtmlCell()
	372	{
	373	m_window = window ? wxStaticCast(window, wxScrolledWindow) : NULL;
	374	m_scale = scale;
	375	m_showFrame = FALSE;
	376	m_bitmap = NULL;
	377	m_bmpW = w;
	378	m_bmpH = h;
	379	m_imageMap = NULL;
	380	m_mapName = mapname;
	381	SetCanLiveOnPagebreak(FALSE);
	382	#if wxUSE_GIF && wxUSE_TIMER
	383	m_gifDecoder = NULL;
	384	m_gifTimer = NULL;
	385	m_physX = m_physY = -1;
	386	#endif
	387
	388	if ( input )
	389	{
	390	wxInputStream *s = input->GetStream();
	391
	392	if ( s )
	393	{
	394	bool readImg = TRUE;
	395
	396	#if wxUSE_GIF && wxUSE_TIMER
	397	if ( (input->GetLocation().Matches(wxT("*.gif")) \|\|
	398	input->GetLocation().Matches(wxT("*.GIF"))) && m_window )
	399	{
	400	m_gifDecoder = new wxGIFDecoder(s, TRUE);
	401	if ( m_gifDecoder->ReadGIF() == wxGIF_OK )
	402	{
	403	wxImage img;
	404	if ( m_gifDecoder->ConvertToImage(&img) )
	405	SetImage(img);
	406
	407	readImg = FALSE;
	408
	409	if ( m_gifDecoder->IsAnimation() )
	410	{
	411	m_gifTimer = new wxGIFTimer(this);
	412	m_gifTimer->Start(m_gifDecoder->GetDelay(), TRUE);
	413	}
	414	else
	415	{
	416	wxDELETE(m_gifDecoder);
	417	}
	418	}
	419	else
	420	{
	421	wxDELETE(m_gifDecoder);
	422	}
	423	}
	424
	425	if ( readImg )
	426	#endif // wxUSE_GIF && wxUSE_TIMER
	427	{
	428	SetImage(wxImage(*s, wxBITMAP_TYPE_ANY));
	429	}
	430	}
	431	}
	432	else // input==NULL, use "broken image" bitmap
	433	{
	434	if ( m_bmpW == -1 && m_bmpH == -1 )
	435	{
	436	m_bmpW = 29;
	437	m_bmpH = 31;
	438	}
	439	else
	440	{
	441	m_showFrame = TRUE;
	442	if ( m_bmpW == -1 ) m_bmpW = 31;
	443	if ( m_bmpH == -1 ) m_bmpH = 33;
	444	}
	445	m_bitmap = new wxBitmap(broken_image_xpm);
	446	}
	447
	448	m_Width = (int)(scale * (double)m_bmpW);
	449	m_Height = (int)(scale * (double)m_bmpH);
	450
	451	switch (align)
	452	{
	453	case wxHTML_ALIGN_TOP :
	454	m_Descent = m_Height;
	455	break;
	456	case wxHTML_ALIGN_CENTER :
	457	m_Descent = m_Height / 2;
	458	break;
	459	case wxHTML_ALIGN_BOTTOM :
	460	default :
	461	m_Descent = 0;
	462	break;
	463	}
	464	}
	465
	466	void wxHtmlImageCell::SetImage(const wxImage& img)
	467	{
	468	if ( img.Ok() )
	469	{
	470	delete m_bitmap;
	471
	472	int ww, hh;
	473	ww = img.GetWidth();
	474	hh = img.GetHeight();
	475
	476	if ( m_bmpW == -1 )
	477	m_bmpW = ww;
	478	if ( m_bmpH == -1 )
	479	m_bmpH = hh;
	480
	481	if ((m_bmpW != ww) \|\| (m_bmpH != hh))
	482	{
	483	wxImage img2 = img.Scale(m_bmpW, m_bmpH);
	484	m_bitmap = new wxBitmap(img2);
	485	}
	486	else
	487	m_bitmap = new wxBitmap(img);
	488	}
	489	}
	490
	491	#if wxUSE_GIF && wxUSE_TIMER
	492	void wxHtmlImageCell::AdvanceAnimation(wxTimer *timer)
	493	{
	494	wxImage img;
	495
	496	m_gifDecoder->GoNextFrame(TRUE);
	497
	498	if ( m_physX == -1 )
	499	{
	500	m_physX = m_physY = 0;
	501	for (wxHtmlCell *cell = this; cell; cell = cell->GetParent())
	502	{
	503	m_physX += cell->GetPosX();
	504	m_physY += cell->GetPosY();
	505	}
	506	}
	507
	508	int x, y;
	509	m_window->CalcScrolledPosition(m_physX, m_physY, &x, &y);
	510	wxRect rect(x, y, m_Width, m_Height);
	511
	512	if ( m_window->GetClientRect().Intersects(rect) &&
	513	m_gifDecoder->ConvertToImage(&img) )
	514	{
	515	if ( (int)m_gifDecoder->GetWidth() != m_Width \|\|
	516	(int)m_gifDecoder->GetHeight() != m_Height \|\|
	517	m_gifDecoder->GetLeft() != 0 \|\| m_gifDecoder->GetTop() != 0 )
	518	{
	519	wxBitmap bmp(img);
	520	wxMemoryDC dc;
	521	dc.SelectObject(*m_bitmap);
	522	dc.DrawBitmap(bmp, m_gifDecoder->GetLeft(), m_gifDecoder->GetTop());
	523	}
	524	else
	525	SetImage(img);
	526	m_window->Refresh(img.HasMask(), &rect);
	527	}
	528
	529	timer->Start(m_gifDecoder->GetDelay(), TRUE);
	530	}
	531
	532	void wxHtmlImageCell::Layout(int w)
	533	{
	534	wxHtmlCell::Layout(w);
	535	m_physX = m_physY = -1;
	536	}
	537
	538	#endif
	539
	540	wxHtmlImageCell::~wxHtmlImageCell()
	541	{
	542	delete m_bitmap;
	543	#if wxUSE_GIF && wxUSE_TIMER
	544	delete m_gifTimer;
	545	delete m_gifDecoder;
	546	#endif
	547	}
	548
	549
	550	void wxHtmlImageCell::Draw(wxDC& dc, int x, int y, int WXUNUSED(view_y1), int WXUNUSED(view_y2))
	551	{
	552	if ( m_showFrame )
	553	{
	554	dc.SetBrush(*wxTRANSPARENT_BRUSH);
	555	dc.SetPen(*wxBLACK_PEN);
	556	dc.DrawRectangle(x + m_PosX, y + m_PosY, m_Width, m_Height);
	557	x++, y++;
	558	}
	559	if ( m_bitmap )
	560	{
	561	double us_x, us_y;
	562	dc.GetUserScale(&us_x, &us_y);
	563	dc.SetUserScale(us_x * m_scale, us_y * m_scale);
	564
	565	dc.DrawBitmap(*m_bitmap, (int) ((x + m_PosX) / m_scale),
	566	(int) ((y + m_PosY) / m_scale), TRUE);
	567	dc.SetUserScale(us_x, us_y);
	568	}
	569	}
	570
	571	wxHtmlLinkInfo *wxHtmlImageCell::GetLink( int x, int y ) const
	572	{
	573	if (m_mapName.IsEmpty())
	574	return wxHtmlCell::GetLink( x, y );
	575	if (!m_imageMap)
	576	{
	577	wxHtmlContainerCell p, op;
	578	op = p = GetParent();
	579	while (p)
	580	{
	581	op = p;
	582	p = p->GetParent();
	583	}
	584	p = op;
	585	wxHtmlCell cell = (wxHtmlCell)p->Find(wxHTML_COND_ISIMAGEMAP,
	586	(const void*)(&m_mapName));
	587	if (!cell)
	588	{
	589	((wxString&)m_mapName).Clear();
	590	return wxHtmlCell::GetLink( x, y );
	591	}
	592	{ // dirty hack, ask Joel why he fills m_ImageMap in this place
	593	// THE problem is that we're in const method and we can't modify m_ImageMap
	594	wxHtmlImageMapCell cx = (wxHtmlImageMapCell)(&m_imageMap);
	595	cx = (wxHtmlImageMapCell)cell;
	596	}
	597	}
	598	return m_imageMap->GetLink(x, y);
	599	}
	600
	601
	602
	603	//--------------------------------------------------------------------------------
	604	// tag handler
	605	//--------------------------------------------------------------------------------
	606
	607	TAG_HANDLER_BEGIN(IMG, "IMG,MAP,AREA")
	608
	609	TAG_HANDLER_PROC(tag)
	610	{
	611	if (tag.GetName() == wxT("IMG"))
	612	{
	613	if (tag.HasParam(wxT("SRC")))
	614	{
	615	int w = -1, h = -1;
	616	int al;
	617	wxFSFile *str;
	618	wxString tmp = tag.GetParam(wxT("SRC"));
	619	wxString mn = wxEmptyString;
	620
	621	str = m_WParser->OpenURL(wxHTML_URL_IMAGE, tmp);
	622
	623	if (tag.HasParam(wxT("WIDTH")))
	624	tag.GetParamAsInt(wxT("WIDTH"), &w);
	625	if (tag.HasParam(wxT("HEIGHT")))
	626	tag.GetParamAsInt(wxT("HEIGHT"), &h);
	627	al = wxHTML_ALIGN_BOTTOM;
	628	if (tag.HasParam(wxT("ALIGN")))
	629	{
	630	wxString alstr = tag.GetParam(wxT("ALIGN"));
	631	alstr.MakeUpper(); // for the case alignment was in ".."
	632	if (alstr == wxT("TEXTTOP"))
	633	al = wxHTML_ALIGN_TOP;
	634	else if ((alstr == wxT("CENTER")) \|\| (alstr == wxT("ABSCENTER")))
	635	al = wxHTML_ALIGN_CENTER;
	636	}
	637	if (tag.HasParam(wxT("USEMAP")))
	638	{
	639	mn = tag.GetParam( wxT("USEMAP") );
	640	if (mn.GetChar(0) == wxT('#'))
	641	{
	642	mn = mn.Mid( 1 );
	643	}
	644	}
	645	wxHtmlImageCell *cel = new wxHtmlImageCell(
	646	m_WParser->GetWindow(),
	647	str, w, h,
	648	m_WParser->GetPixelScale(),
	649	al, mn);
	650	cel->SetLink(m_WParser->GetLink());
	651	cel->SetId(tag.GetParam(wxT("id"))); // may be empty
	652	m_WParser->GetContainer()->InsertCell(cel);
	653	if (str)
	654	delete str;
	655	}
	656	}
	657	if (tag.GetName() == wxT("MAP"))
	658	{
	659	m_WParser->CloseContainer();
	660	m_WParser->OpenContainer();
	661	if (tag.HasParam(wxT("NAME")))
	662	{
	663	wxString tmp = tag.GetParam(wxT("NAME"));
	664	wxHtmlImageMapCell *cel = new wxHtmlImageMapCell( tmp );
	665	m_WParser->GetContainer()->InsertCell( cel );
	666	}
	667	ParseInner( tag );
	668	m_WParser->CloseContainer();
	669	m_WParser->OpenContainer();
	670	}
	671	if (tag.GetName() == wxT("AREA"))
	672	{
	673	if (tag.HasParam(wxT("SHAPE")))
	674	{
	675	wxString tmp = tag.GetParam(wxT("SHAPE"));
	676	wxString coords = wxEmptyString;
	677	tmp.MakeUpper();
	678	wxHtmlImageMapAreaCell *cel = NULL;
	679	if (tag.HasParam(wxT("COORDS")))
	680	{
	681	coords = tag.GetParam(wxT("COORDS"));
	682	}
	683	if (tmp == wxT("POLY"))
	684	{
	685	cel = new wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::POLY, coords, m_WParser->GetPixelScale() );
	686	}
	687	else if (tmp == wxT("CIRCLE"))
	688	{
	689	cel = new wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::CIRCLE, coords, m_WParser->GetPixelScale() );
	690	}
	691	else if (tmp == wxT("RECT"))
	692	{
	693	cel = new wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::RECT, coords, m_WParser->GetPixelScale() );
	694	}
	695	if (cel != NULL && tag.HasParam(wxT("HREF")))
	696	{
	697	wxString tmp = tag.GetParam(wxT("HREF"));
	698	wxString target = wxEmptyString;
	699	if (tag.HasParam(wxT("TARGET"))) target = tag.GetParam(wxT("TARGET"));
	700	cel->SetLink( wxHtmlLinkInfo(tmp, target));
	701	}
	702	if (cel != NULL) m_WParser->GetContainer()->InsertCell( cel );
	703	}
	704	}
	705
	706	return FALSE;
	707	}
	708
	709	TAG_HANDLER_END(IMG)
	710
	711
	712
	713	TAGS_MODULE_BEGIN(Image)
	714
	715	TAGS_MODULE_ADD(IMG)
	716
	717	TAGS_MODULE_END(Image)
	718
	719
	720	#endif