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

#ifdef __BORDLANDC__
#pragma hdrstop
#endif

#ifndef WXPRECOMP
#include "wx/wx.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;
        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;
    wxInputStream *s = input -> GetStream();

    img = new wxImage(*s, wxBITMAP_TYPE_ANY);

    m_Image = NULL;
    if (img && (img -> Ok())) {
        ww = img -> GetWidth();
        hh = img -> GetHeight();
        if (w != -1) m_Width = w; else m_Width = ww;
        if (h != -1) m_Height = h; else m_Height = hh;

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

        if ((m_Width != ww) || (m_Height != hh)) {
            wxImage img2 = img -> Scale(m_Width, m_Height);
            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 view_y1, int view_y2)
{
    if (m_Image)
//        dc.DrawBitmap(*m_Image, x + m_PosX, y + m_PosY, (m_Image->GetMask() != (wxMask*) 0));
        dc.DrawBitmap(*m_Image, x + m_PosX, y + m_PosY, TRUE);
    wxHtmlCell::Draw(dc, x, y, view_y1, view_y2);
}

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