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

#include "wx/wxprec.h"

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

#ifdef __BORLANDC__
#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 "wx/log.h"
#include "wx/artprov.h"
#include "wx/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;
        void Draw(wxDC& WXUNUSED(dc),
                  int WXUNUSED(x), int WXUNUSED(y),
                  int WXUNUSED(view_y1), int WXUNUSED(view_y2),
                  wxHtmlRenderingInfo& WXUNUSED(info)) {}


    DECLARE_NO_COPY_CLASS(wxHtmlImageMapAreaCell)
};


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

    type = t;
    while ((i = x.Find( ',' )) != wxNOT_FOUND)
    {
        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;
        void Draw(wxDC& WXUNUSED(dc),
                  int WXUNUSED(x), int WXUNUSED(y),
                  int WXUNUSED(view_y1), int WXUNUSED(view_y2),
                  wxHtmlRenderingInfo& WXUNUSED(info)) {}

    DECLARE_NO_COPY_CLASS(wxHtmlImageMapCell)
};


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 = wxDefaultCoord, int h = wxDefaultCoord,
                    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,
              wxHtmlRenderingInfo& info);
    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;

    DECLARE_NO_COPY_CLASS(wxHtmlImageCell)
};

#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;

    DECLARE_NO_COPY_CLASS(wxGIFTimer)
};
#endif


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


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 = wxDefaultCoord;
#endif

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

            if ( s )
            {
#if wxUSE_GIF && wxUSE_TIMER
                bool readImg = true;
                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
                {
                    wxImage image(*s, wxBITMAP_TYPE_ANY);
                    if ( image.Ok() )
                        SetImage(image);
                }
            }
        }
        else // input==NULL, use "broken image" bitmap
        {
            if ( m_bmpW == wxDefaultCoord && m_bmpH == wxDefaultCoord )
            {
                m_bmpW = 29;
                m_bmpH = 31;
            }
            else
            {
                m_showFrame = true;
                if ( m_bmpW == wxDefaultCoord ) m_bmpW = 31;
                if ( m_bmpH == wxDefaultCoord ) m_bmpH = 33;
            }
            m_bitmap =
                new wxBitmap(wxArtProvider::GetBitmap(wxART_MISSING_IMAGE));
        }
    }
    //else: ignore the 0-sized images used sometimes on the Web pages

    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 == wxDefaultCoord )
            m_bmpW = ww;
        if ( m_bmpH == wxDefaultCoord )
            m_bmpH = hh;

        // Only scale the bitmap at the rendering stage,
        // so we don't lose quality twice
/*
        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 == wxDefaultCoord )
    {
        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(),
                          true /* use mask */);
        }
        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 = wxDefaultCoord;
}

#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),
                           wxHtmlRenderingInfo& WXUNUSED(info))
{
    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 )
    {
        // We add in the scaling from the desired bitmap width
        // and height, so we only do the scaling once.
        double imageScaleX = 1.0;
        double imageScaleY = 1.0;
        if (m_bmpW != m_bitmap->GetWidth())
            imageScaleX = (double) m_bmpW / (double) m_bitmap->GetWidth();
        if (m_bmpH != m_bitmap->GetHeight())
            imageScaleY = (double) m_bmpH / (double) m_bitmap->GetHeight();

        double us_x, us_y;
        dc.GetUserScale(&us_x, &us_y);
        dc.SetUserScale(us_x * m_scale * imageScaleX, us_y * m_scale * imageScaleY);

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

wxHtmlLinkInfo *wxHtmlImageCell::GetLink( int x, int y ) const
{
    if (m_mapName.empty())
        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_CONSTR(IMG) { }

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