[wxWidgets.git] / 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
/////////////////////////////////////////////////////////////////////////////

#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation
#endif

#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 <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( ',' )) != -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;
        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 = -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,
              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 = -1;
#endif

    if ( m_bmpW && m_bmpH )
    {
        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
                {
                    wxImage image(*s, wxBITMAP_TYPE_ANY);
                    if ( image.Ok() )
                        SetImage(image);
                }
            }
        }
        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(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 == -1 )
            m_bmpW = ww;
        if ( m_bmpH == -1 )
            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 == -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(),
                          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 = -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),
                           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.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_CONSTR(IMG) { }

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