]> git.saurik.com Git - wxWidgets.git/blob - src/html/m_image.cpp
projects / wxWidgets.git / blob
? search:


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