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

#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"
#endif

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

#include "wx/image.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:
        wxBitmap *m_Image;
        double m_Scale;
        wxHtmlImageMapCell *m_ImageMap;
        wxString m_MapName;

        wxHtmlImageCell(wxFSFile *input, int w = -1, int h = -1, double scale = 1.0, int align = wxHTML_ALIGN_BOTTOM, wxString mapname = wxEmptyString);
        ~wxHtmlImageCell() {if (m_Image) delete m_Image; }
        void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2);
        virtual wxHtmlLinkInfo *GetLink( int x = 0, int y = 0 ) const;
};


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

wxHtmlImageCell::wxHtmlImageCell(wxFSFile *input, int w, int h, double scale, int align, wxString mapname) : wxHtmlCell()
{
    wxImage *img;
    int ww, hh, bw, bh;
    wxInputStream *s = input->GetStream();

    m_Scale = scale;
    img = new wxImage(*s, wxBITMAP_TYPE_ANY);
    m_Image = NULL;
    if (img && (img->Ok()))
    {
        ww = img->GetWidth();
        hh = img->GetHeight();
        if (w != -1) bw = w; else bw = ww;
        if (h != -1) bh = h; else bh = hh;

        m_Width = (int)(scale * (double)bw);
        m_Height = (int)(scale * (double)bh);

        if ((bw != ww) || (bh != hh))
        {
            wxImage img2 = img->Scale(bw, bh);
            m_Image = new wxBitmap(img2.ConvertToBitmap());
        }
        else
            m_Image = new wxBitmap(img->ConvertToBitmap());
        delete img;
    }
    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;
    }

    m_ImageMap = NULL;
    m_MapName = mapname;
    SetCanLiveOnPagebreak(FALSE);
}


void wxHtmlImageCell::Draw(wxDC& dc, int x, int y, int WXUNUSED(view_y1), int WXUNUSED(view_y2))
{
    if (m_Image)
    {
        double us_x, us_y;
        dc.GetUserScale(&us_x, &us_y);
        dc.SetUserScale(us_x * m_Scale, us_y * m_Scale);

//      dc.DrawBitmap(*m_Image, x + m_PosX, y + m_PosY, (m_Image->GetMask() != (wxMask*) 0));
        dc.DrawBitmap(*m_Image, (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->GetFS()->OpenFile(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 = NULL;
                if (str)
                {
                    cel = new wxHtmlImageCell(str, w, h, m_WParser->GetPixelScale(), al, mn);
                    cel->SetLink(m_WParser->GetLink());
                    m_WParser->GetContainer()->InsertCell(cel);
                    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
5526e819 VS	7	// Licence: wxWindows Licence
	8	/////////////////////////////////////////////////////////////////////////////
	9
3364ab79 RS	10	#ifdef __GNUG__
	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
3364ab79 RS	19	#ifdef __BORDLANDC__
	20	#pragma hdrstop
	21	#endif
	22
	23	#ifndef WXPRECOMP
04dbb646	24	#include "wx/dc.h"
3364ab79 RS	25	#endif
3364ab79 RS	26
69941f05 VS	27	#include "wx/html/forcelnk.h"
69941f05 VS	28	#include "wx/html/m_templ.h"
5526e819	29
25082126 VS	30	#include "wx/image.h"
	31	#include "wx/dynarray.h"
	32
	33	#include <math.h>
	34	#include <float.h>
5526e819	35
c88293a4	36	FORCE_LINK_ME(m_image)
5526e819 VS	37
5526e819 VS	38
25082126 VS	39
	40
	41	WX_DECLARE_OBJARRAY(int, CoordArray);
3096bd2f	42	#include "wx/arrimpl.cpp" // this is a magic incantation which must be done!
25082126 VS	43	WX_DEFINE_OBJARRAY(CoordArray);
	44
	45
	46	//--------------------------------------------------------------------------------
	47	// wxHtmlImageMapAreaCell
	48	// 0-width, 0-height cell that represents single area in imagemap
	49	// (it's GetLink is called from wxHtmlImageCell's)
	50	//--------------------------------------------------------------------------------
	51
	52	class wxHtmlImageMapAreaCell : public wxHtmlCell
	53	{
01325161 VS	54	public:
	55	enum celltype { CIRCLE, RECT, POLY };
	56	protected:
	57	CoordArray coords;
	58	celltype type;
edbd0635	59	int radius;
01325161	60	public:
edbd0635	61	wxHtmlImageMapAreaCell( celltype t, wxString &coords, double pixel_scale = 1.0);
846914d1	62	virtual wxHtmlLinkInfo *GetLink( int x = 0, int y = 0 ) const;
25082126 VS	63	};
	64
	65
	66
	67
	68
edbd0635	69	wxHtmlImageMapAreaCell::wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::celltype t, wxString &incoords, double pixel_scale )
25082126	70	{
edbd0635	71	int i;
01325161 VS	72	wxString x = incoords, y;
	73
	74	type = t;
04dbb646	75	while ((i = x.Find( ',' )) != -1)
4f9297b0	76	{
edbd0635	77	coords.Add( (int)(pixel_scale * (double)wxAtoi( x.Left( i ).c_str())) );
01325161 VS	78	x = x.Mid( i + 1 );
01325161 VS	79	}
edbd0635	80	coords.Add( (int)(pixel_scale * (double)wxAtoi( x.c_str())) );
25082126 VS	81	}
25082126 VS	82
846914d1	83	wxHtmlLinkInfo *wxHtmlImageMapAreaCell::GetLink( int x, int y ) const
25082126	84	{
04dbb646	85	switch (type)
4f9297b0	86	{
01325161 VS	87	case RECT:
01325161 VS	88	{
edbd0635	89	int l, t, r, b;
01325161 VS	90
	91	l = coords[ 0 ];
	92	t = coords[ 1 ];
	93	r = coords[ 2 ];
	94	b = coords[ 3 ];
04dbb646 VZ	95	if (x >= l && x <= r && y >= t && y <= b)
04dbb646 VZ	96	{
01325161 VS	97	return m_Link;
	98	}
	99	break;
	100	}
	101	case CIRCLE:
	102	{
edbd0635 VS	103	int l, t, r;
edbd0635 VS	104	double d;
01325161 VS	105
	106	l = coords[ 0 ];
	107	t = coords[ 1 ];
	108	r = coords[ 2 ];
	109	d = sqrt( (double) (((x - l) * (x - l)) + ((y - t) * (y - t))) );
04dbb646 VZ	110	if (d < (double)r)
04dbb646 VZ	111	{
01325161 VS	112	return m_Link;
	113	}
	114	}
	115	break;
	116	case POLY:
	117	{
04dbb646 VZ	118	if (coords.GetCount() >= 6)
04dbb646 VZ	119	{
edbd0635 VS	120	int intersects = 0;
	121	int wherex = x;
	122	int wherey = y;
	123	int totalv = coords.GetCount() / 2;
	124	int totalc = totalv * 2;
	125	int xval = coords[totalc - 2];
	126	int yval = coords[totalc - 1];
	127	int end = totalc;
	128	int pointer = 1;
01325161	129
04dbb646 VZ	130	if ((yval >= wherey) != (coords[pointer] >= wherey))
	131	{
	132	if ((xval >= wherex) == (coords[0] >= wherex))
	133	{
01325161	134	intersects += (xval >= wherex) ? 1 : 0;
04dbb646 VZ	135	}
	136	else
	137	{
01325161 VS	138	intersects += ((xval - (yval - wherey) *
	139	(coords[0] - xval) /
	140	(coords[pointer] - yval)) >= wherex) ? 1 : 0;
	141	}
	142	}
	143
04dbb646 VZ	144	while (pointer < end)
04dbb646 VZ	145	{
01325161 VS	146	yval = coords[pointer];
01325161 VS	147	pointer += 2;
04dbb646 VZ	148	if (yval >= wherey)
	149	{
	150	while ((pointer < end) && (coords[pointer] >= wherey))
	151	{
01325161 VS	152	pointer += 2;
01325161 VS	153	}
04dbb646 VZ	154	if (pointer >= end)
04dbb646 VZ	155	{
01325161 VS	156	break;
	157	}
	158	if ((coords[pointer - 3] >= wherex) ==
	159	(coords[pointer - 1] >= wherex)) {
	160	intersects += (coords[pointer - 3] >= wherex) ? 1 : 0;
04dbb646 VZ	161	}
	162	else
	163	{
01325161 VS	164	intersects +=
	165	((coords[pointer - 3] - (coords[pointer - 2] - wherey) *
	166	(coords[pointer - 1] - coords[pointer - 3]) /
	167	(coords[pointer] - coords[pointer - 2])) >= wherex) ? 1 : 0;
	168	}
04dbb646 VZ	169	}
	170	else
	171	{
	172	while ((pointer < end) && (coords[pointer] < wherey))
	173	{
01325161 VS	174	pointer += 2;
01325161 VS	175	}
04dbb646 VZ	176	if (pointer >= end)
04dbb646 VZ	177	{
01325161 VS	178	break;
	179	}
	180	if ((coords[pointer - 3] >= wherex) ==
04dbb646 VZ	181	(coords[pointer - 1] >= wherex))
04dbb646 VZ	182	{
01325161	183	intersects += (coords[pointer - 3] >= wherex) ? 1 : 0;
04dbb646 VZ	184	}
	185	else
	186	{
01325161 VS	187	intersects +=
	188	((coords[pointer - 3] - (coords[pointer - 2] - wherey) *
	189	(coords[pointer - 1] - coords[pointer - 3]) /
	190	(coords[pointer] - coords[pointer - 2])) >= wherex) ? 1 : 0;
	191	}
	192	}
	193	}
04dbb646 VZ	194	if ((intersects & 1) != 0)
04dbb646 VZ	195	{
01325161 VS	196	return m_Link;
	197	}
	198	}
	199	}
	200	break;
	201	}
4f9297b0	202
04dbb646	203	if (m_Next)
4f9297b0	204	{
edbd0635	205	wxHtmlImageMapAreaCell a = (wxHtmlImageMapAreaCell)m_Next;
01325161 VS	206	return a->GetLink( x, y );
01325161 VS	207	}
846914d1	208	return NULL;
25082126 VS	209	}
	210
	211
	212
	213
	214
	215
	216
	217
	218	//--------------------------------------------------------------------------------
	219	// wxHtmlImageMapCell
	220	// 0-width, 0-height cell that represents map from imagemaps
	221	// it is always placed before wxHtmlImageMapAreaCells
efba2b89	222	// It responds to Find(wxHTML_COND_ISIMAGEMAP)
25082126 VS	223	//--------------------------------------------------------------------------------
	224
	225
	226	class wxHtmlImageMapCell : public wxHtmlCell
	227	{
01325161 VS	228	public:
	229	wxHtmlImageMapCell( wxString &name );
	230	protected:
	231	wxString m_Name;
	232	public:
846914d1	233	virtual wxHtmlLinkInfo *GetLink( int x = 0, int y = 0 ) const;
01325161	234	virtual const wxHtmlCell Find( int cond, const void param ) const;
25082126 VS	235	};
	236
	237
	238	wxHtmlImageMapCell::wxHtmlImageMapCell( wxString &name )
	239	{
01325161	240	m_Name = name ;
25082126 VS	241	}
25082126 VS	242
846914d1	243	wxHtmlLinkInfo *wxHtmlImageMapCell::GetLink( int x, int y ) const
25082126	244	{
edbd0635	245	wxHtmlImageMapAreaCell a = (wxHtmlImageMapAreaCell)m_Next;
01325161 VS	246	if (a)
	247	return a->GetLink( x, y );
	248	return wxHtmlCell::GetLink( x, y );
25082126 VS	249	}
	250
	251	const wxHtmlCell wxHtmlImageMapCell::Find( int cond, const void param ) const
	252	{
04dbb646	253	if (cond == wxHTML_COND_ISIMAGEMAP)
4f9297b0	254	{
01325161 VS	255	if (m_Name == ((wxString)(param)))
	256	return this;
	257	}
	258	return wxHtmlCell::Find(cond, param);
25082126 VS	259	}
	260
	261
	262
	263
	264
5526e819 VS	265	//--------------------------------------------------------------------------------
	266	// wxHtmlImageCell
	267	// Image/bitmap
	268	//--------------------------------------------------------------------------------
	269
	270	class wxHtmlImageCell : public wxHtmlCell
	271	{
	272	public:
	273	wxBitmap *m_Image;
b5c01940	274	double m_Scale;
01325161 VS	275	wxHtmlImageMapCell *m_ImageMap;
01325161 VS	276	wxString m_MapName;
5526e819	277
37a1f3f6	278	wxHtmlImageCell(wxFSFile *input, int w = -1, int h = -1, double scale = 1.0, int align = wxHTML_ALIGN_BOTTOM, wxString mapname = wxEmptyString);
01325161	279	~wxHtmlImageCell() {if (m_Image) delete m_Image; }
5526e819	280	void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2);
846914d1	281	virtual wxHtmlLinkInfo *GetLink( int x = 0, int y = 0 ) const;
5526e819 VS	282	};
	283
	284
	285
25082126	286
5526e819 VS	287	//--------------------------------------------------------------------------------
	288	// wxHtmlImageCell
	289	//--------------------------------------------------------------------------------
	290
37a1f3f6	291	wxHtmlImageCell::wxHtmlImageCell(wxFSFile *input, int w, int h, double scale, int align, wxString mapname) : wxHtmlCell()
5526e819 VS	292	{
5526e819 VS	293	wxImage *img;
b5c01940	294	int ww, hh, bw, bh;
4f9297b0	295	wxInputStream *s = input->GetStream();
04dbb646	296
b5c01940	297	m_Scale = scale;
72aa4a98	298	img = new wxImage(*s, wxBITMAP_TYPE_ANY);
5526e819	299	m_Image = NULL;
04dbb646	300	if (img && (img->Ok()))
4f9297b0 VS	301	{
	302	ww = img->GetWidth();
	303	hh = img->GetHeight();
b5c01940 VS	304	if (w != -1) bw = w; else bw = ww;
b5c01940 VS	305	if (h != -1) bh = h; else bh = hh;
37a1f3f6	306
b5c01940 VS	307	m_Width = (int)(scale * (double)bw);
b5c01940 VS	308	m_Height = (int)(scale * (double)bh);
37a1f3f6	309
04dbb646 VZ	310	if ((bw != ww) \|\| (bh != hh))
04dbb646 VZ	311	{
b5c01940	312	wxImage img2 = img->Scale(bw, bh);
5526e819	313	m_Image = new wxBitmap(img2.ConvertToBitmap());
04dbb646 VZ	314	}
04dbb646 VZ	315	else
4f9297b0	316	m_Image = new wxBitmap(img->ConvertToBitmap());
5526e819 VS	317	delete img;
5526e819 VS	318	}
04dbb646	319	switch (align)
4f9297b0	320	{
efba2b89	321	case wxHTML_ALIGN_TOP :
01325161 VS	322	m_Descent = m_Height;
01325161 VS	323	break;
efba2b89	324	case wxHTML_ALIGN_CENTER :
01325161 VS	325	m_Descent = m_Height / 2;
	326	break;
	327	case wxHTML_ALIGN_BOTTOM :
	328	default :
	329	m_Descent = 0;
	330	break;
5526e819	331	}
25082126 VS	332
	333	m_ImageMap = NULL;
	334	m_MapName = mapname;
db98870d	335	SetCanLiveOnPagebreak(FALSE);
5526e819 VS	336	}
	337
	338
	339
d699f48b	340	void wxHtmlImageCell::Draw(wxDC& dc, int x, int y, int WXUNUSED(view_y1), int WXUNUSED(view_y2))
5526e819 VS	341	{
5526e819 VS	342	if (m_Image)
b5c01940 VS	343	{
	344	double us_x, us_y;
	345	dc.GetUserScale(&us_x, &us_y);
	346	dc.SetUserScale(us_x * m_Scale, us_y * m_Scale);
04dbb646	347
b5c01940	348	// dc.DrawBitmap(m_Image, x + m_PosX, y + m_PosY, (m_Image->GetMask() != (wxMask) 0));
04dbb646	349	dc.DrawBitmap(*m_Image, (int) ((x + m_PosX) / m_Scale),
7a5e6267	350	(int) ((y + m_PosY) / m_Scale), TRUE);
b5c01940 VS	351	dc.SetUserScale(us_x, us_y);
b5c01940 VS	352	}
5526e819 VS	353	}
5526e819 VS	354
846914d1	355	wxHtmlLinkInfo *wxHtmlImageCell::GetLink( int x, int y ) const
25082126	356	{
01325161 VS	357	if (m_MapName.IsEmpty())
01325161 VS	358	return wxHtmlCell::GetLink( x, y );
04dbb646	359	if (!m_ImageMap)
4f9297b0	360	{
edbd0635	361	wxHtmlContainerCell p, op;
01325161	362	op = p = GetParent();
04dbb646 VZ	363	while (p)
04dbb646 VZ	364	{
01325161 VS	365	op = p;
	366	p = p->GetParent();
	367	}
	368	p = op;
	369	wxHtmlCell cell = (wxHtmlCell)p->Find( wxHTML_COND_ISIMAGEMAP, (const void*)(&m_MapName));
04dbb646 VZ	370	if (!cell)
04dbb646 VZ	371	{
01325161 VS	372	((wxString&)m_MapName).Clear();
	373	return wxHtmlCell::GetLink( x, y );
	374	}
4f9297b0	375	{ // dirty hack, ask Joel why he fills m_ImageMap in this place
01325161	376	// THE problem is that we're in const method and we can't modify m_ImageMap
25082126	377	wxHtmlImageMapCell cx = (wxHtmlImageMapCell)(&m_ImageMap);
01325161	378	cx = (wxHtmlImageMapCell)cell;
25082126	379	}
01325161 VS	380	}
01325161 VS	381	return m_ImageMap->GetLink( x, y );
25082126	382	}
5526e819 VS	383
	384
	385
	386	//--------------------------------------------------------------------------------
	387	// tag handler
	388	//--------------------------------------------------------------------------------
	389
01325161	390	TAG_HANDLER_BEGIN(IMG, "IMG,MAP,AREA")
5526e819 VS	391
	392	TAG_HANDLER_PROC(tag)
	393	{
04dbb646 VZ	394	if (tag.GetName() == wxT("IMG"))
	395	{
	396	if (tag.HasParam(wxT("SRC")))
	397	{
01325161 VS	398	int w = -1, h = -1;
	399	int al;
	400	wxFSFile *str;
0413cec5	401	wxString tmp = tag.GetParam(wxT("SRC"));
01325161 VS	402	wxString mn = wxEmptyString;
01325161 VS	403
4f9297b0	404	str = m_WParser->GetFS()->OpenFile(tmp);
04dbb646	405	if (tag.HasParam(wxT("WIDTH")))
8bd72d90	406	tag.GetParamAsInt(wxT("WIDTH"), &w);
04dbb646	407	if (tag.HasParam(wxT("HEIGHT")))
8bd72d90	408	tag.GetParamAsInt(wxT("HEIGHT"), &h);
01325161	409	al = wxHTML_ALIGN_BOTTOM;
04dbb646 VZ	410	if (tag.HasParam(wxT("ALIGN")))
04dbb646 VZ	411	{
0413cec5	412	wxString alstr = tag.GetParam(wxT("ALIGN"));
01325161	413	alstr.MakeUpper(); // for the case alignment was in ".."
04dbb646	414	if (alstr == wxT("TEXTTOP"))
8bd72d90	415	al = wxHTML_ALIGN_TOP;
04dbb646	416	else if ((alstr == wxT("CENTER")) \|\| (alstr == wxT("ABSCENTER")))
8bd72d90	417	al = wxHTML_ALIGN_CENTER;
01325161	418	}
04dbb646 VZ	419	if (tag.HasParam(wxT("USEMAP")))
04dbb646 VZ	420	{
0413cec5	421	mn = tag.GetParam( wxT("USEMAP") );
04dbb646 VZ	422	if (mn.GetChar(0) == wxT('#'))
04dbb646 VZ	423	{
01325161 VS	424	mn = mn.Mid( 1 );
	425	}
	426	}
	427	wxHtmlImageCell *cel = NULL;
04dbb646 VZ	428	if (str)
04dbb646 VZ	429	{
4f9297b0 VS	430	cel = new wxHtmlImageCell(str, w, h, m_WParser->GetPixelScale(), al, mn);
	431	cel->SetLink(m_WParser->GetLink());
	432	m_WParser->GetContainer()->InsertCell(cel);
01325161 VS	433	delete str;
	434	}
	435	}
	436	}
04dbb646 VZ	437	if (tag.GetName() == wxT("MAP"))
04dbb646 VZ	438	{
01325161 VS	439	m_WParser->CloseContainer();
01325161 VS	440	m_WParser->OpenContainer();
04dbb646 VZ	441	if (tag.HasParam(wxT("NAME")))
04dbb646 VZ	442	{
0413cec5	443	wxString tmp = tag.GetParam(wxT("NAME"));
01325161 VS	444	wxHtmlImageMapCell *cel = new wxHtmlImageMapCell( tmp );
	445	m_WParser->GetContainer()->InsertCell( cel );
	446	}
	447	ParseInner( tag );
	448	m_WParser->CloseContainer();
	449	m_WParser->OpenContainer();
	450	}
04dbb646 VZ	451	if (tag.GetName() == wxT("AREA"))
	452	{
	453	if (tag.HasParam(wxT("SHAPE")))
	454	{
0413cec5	455	wxString tmp = tag.GetParam(wxT("SHAPE"));
edbd0635	456	wxString coords = wxEmptyString;
01325161 VS	457	tmp.MakeUpper();
01325161 VS	458	wxHtmlImageMapAreaCell *cel = NULL;
04dbb646 VZ	459	if (tag.HasParam(wxT("COORDS")))
04dbb646 VZ	460	{
0413cec5	461	coords = tag.GetParam(wxT("COORDS"));
01325161	462	}
04dbb646 VZ	463	if (tmp == wxT("POLY"))
04dbb646 VZ	464	{
4f9297b0	465	cel = new wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::POLY, coords, m_WParser->GetPixelScale() );
04dbb646 VZ	466	}
	467	else if (tmp == wxT("CIRCLE"))
	468	{
4f9297b0	469	cel = new wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::CIRCLE, coords, m_WParser->GetPixelScale() );
04dbb646 VZ	470	}
	471	else if (tmp == wxT("RECT"))
	472	{
4f9297b0	473	cel = new wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::RECT, coords, m_WParser->GetPixelScale() );
01325161	474	}
04dbb646 VZ	475	if (cel != NULL && tag.HasParam(wxT("HREF")))
04dbb646 VZ	476	{
0413cec5	477	wxString tmp = tag.GetParam(wxT("HREF"));
846914d1	478	wxString target = wxEmptyString;
0413cec5	479	if (tag.HasParam(wxT("TARGET"))) target = tag.GetParam(wxT("TARGET"));
846914d1	480	cel->SetLink( wxHtmlLinkInfo(tmp, target));
01325161 VS	481	}
	482	if (cel != NULL) m_WParser->GetContainer()->InsertCell( cel );
	483	}
	484	}
5526e819 VS	485
	486	return FALSE;
	487	}
	488
01325161	489	TAG_HANDLER_END(IMG)
5526e819 VS	490
	491
	492
	493	TAGS_MODULE_BEGIN(Image)
	494
	495	TAGS_MODULE_ADD(IMG)
	496
	497	TAGS_MODULE_END(Image)
	498
	499
3364ab79	500	#endif