]> git.saurik.com Git - wxWidgets.git/blob - src/html/m_image.cpp
only use font/colours in SetWidgetStyle() if they're set
[wxWidgets.git] / src / html / m_image.cpp
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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
11 #pragma implementation
12 #endif
13
14 #include "wx/wxprec.h"
15
16 #include "wx/defs.h"
17 #if wxUSE_HTML && wxUSE_STREAMS
18
19 #ifdef __BORLANDC__
20 #pragma hdrstop
21 #endif
22
23 #ifndef WXPRECOMP
24 #include "wx/dc.h"
25 #include "wx/scrolwin.h"
26 #include "wx/timer.h"
27 #include "wx/dcmemory.h"
28 #endif
29
30 #include "wx/html/forcelnk.h"
31 #include "wx/html/m_templ.h"
32 #include "wx/html/htmlwin.h"
33
34 #include "wx/image.h"
35 #include "wx/gifdecod.h"
36 #include "wx/dynarray.h"
37 #include "wx/log.h"
38 #include "wx/artprov.h"
39
40 #include <math.h>
41 #include <float.h>
42
43 FORCE_LINK_ME(m_image)
44
45
46
47
48 WX_DECLARE_OBJARRAY(int, CoordArray);
49 #include "wx/arrimpl.cpp" // this is a magic incantation which must be done!
50 WX_DEFINE_OBJARRAY(CoordArray);
51
52
53 // ---------------------------------------------------------------------------
54 // wxHtmlImageMapAreaCell
55 // 0-width, 0-height cell that represents single area in
56 // imagemap (it's GetLink is called from wxHtmlImageCell's)
57 // ---------------------------------------------------------------------------
58
59 class wxHtmlImageMapAreaCell : public wxHtmlCell
60 {
61 public:
62 enum celltype { CIRCLE, RECT, POLY };
63 protected:
64 CoordArray coords;
65 celltype type;
66 int radius;
67 public:
68 wxHtmlImageMapAreaCell( celltype t, wxString &coords, double pixel_scale = 1.0);
69 virtual wxHtmlLinkInfo *GetLink( int x = 0, int y = 0 ) const;
70 void Draw(wxDC& WXUNUSED(dc),
71 int WXUNUSED(x), int WXUNUSED(y),
72 int WXUNUSED(view_y1), int WXUNUSED(view_y2),
73 wxHtmlRenderingInfo& WXUNUSED(info)) {}
74
75
76 DECLARE_NO_COPY_CLASS(wxHtmlImageMapAreaCell)
77 };
78
79
80
81
82
83 wxHtmlImageMapAreaCell::wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::celltype t, wxString &incoords, double pixel_scale )
84 {
85 int i;
86 wxString x = incoords, y;
87
88 type = t;
89 while ((i = x.Find( ',' )) != -1)
90 {
91 coords.Add( (int)(pixel_scale * (double)wxAtoi( x.Left( i ).c_str())) );
92 x = x.Mid( i + 1 );
93 }
94 coords.Add( (int)(pixel_scale * (double)wxAtoi( x.c_str())) );
95 }
96
97 wxHtmlLinkInfo *wxHtmlImageMapAreaCell::GetLink( int x, int y ) const
98 {
99 switch (type)
100 {
101 case RECT:
102 {
103 int l, t, r, b;
104
105 l = coords[ 0 ];
106 t = coords[ 1 ];
107 r = coords[ 2 ];
108 b = coords[ 3 ];
109 if (x >= l && x <= r && y >= t && y <= b)
110 {
111 return m_Link;
112 }
113 break;
114 }
115 case CIRCLE:
116 {
117 int l, t, r;
118 double d;
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))) );
124 if (d < (double)r)
125 {
126 return m_Link;
127 }
128 }
129 break;
130 case POLY:
131 {
132 if (coords.GetCount() >= 6)
133 {
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;
143
144 if ((yval >= wherey) != (coords[pointer] >= wherey))
145 {
146 if ((xval >= wherex) == (coords[0] >= wherex))
147 {
148 intersects += (xval >= wherex) ? 1 : 0;
149 }
150 else
151 {
152 intersects += ((xval - (yval - wherey) *
153 (coords[0] - xval) /
154 (coords[pointer] - yval)) >= wherex) ? 1 : 0;
155 }
156 }
157
158 while (pointer < end)
159 {
160 yval = coords[pointer];
161 pointer += 2;
162 if (yval >= wherey)
163 {
164 while ((pointer < end) && (coords[pointer] >= wherey))
165 {
166 pointer += 2;
167 }
168 if (pointer >= end)
169 {
170 break;
171 }
172 if ((coords[pointer - 3] >= wherex) ==
173 (coords[pointer - 1] >= wherex)) {
174 intersects += (coords[pointer - 3] >= wherex) ? 1 : 0;
175 }
176 else
177 {
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 }
183 }
184 else
185 {
186 while ((pointer < end) && (coords[pointer] < wherey))
187 {
188 pointer += 2;
189 }
190 if (pointer >= end)
191 {
192 break;
193 }
194 if ((coords[pointer - 3] >= wherex) ==
195 (coords[pointer - 1] >= wherex))
196 {
197 intersects += (coords[pointer - 3] >= wherex) ? 1 : 0;
198 }
199 else
200 {
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 }
208 if ((intersects & 1) != 0)
209 {
210 return m_Link;
211 }
212 }
213 }
214 break;
215 }
216
217 if (m_Next)
218 {
219 wxHtmlImageMapAreaCell *a = (wxHtmlImageMapAreaCell*)m_Next;
220 return a->GetLink( x, y );
221 }
222 return NULL;
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
236 // It responds to Find(wxHTML_COND_ISIMAGEMAP)
237 //--------------------------------------------------------------------------------
238
239
240 class wxHtmlImageMapCell : public wxHtmlCell
241 {
242 public:
243 wxHtmlImageMapCell( wxString &name );
244 protected:
245 wxString m_Name;
246 public:
247 virtual wxHtmlLinkInfo *GetLink( int x = 0, int y = 0 ) const;
248 virtual const wxHtmlCell *Find( int cond, const void *param ) const;
249 void Draw(wxDC& WXUNUSED(dc),
250 int WXUNUSED(x), int WXUNUSED(y),
251 int WXUNUSED(view_y1), int WXUNUSED(view_y2),
252 wxHtmlRenderingInfo& WXUNUSED(info)) {}
253
254 DECLARE_NO_COPY_CLASS(wxHtmlImageMapCell)
255 };
256
257
258 wxHtmlImageMapCell::wxHtmlImageMapCell( wxString &name )
259 {
260 m_Name = name ;
261 }
262
263 wxHtmlLinkInfo *wxHtmlImageMapCell::GetLink( int x, int y ) const
264 {
265 wxHtmlImageMapAreaCell *a = (wxHtmlImageMapAreaCell*)m_Next;
266 if (a)
267 return a->GetLink( x, y );
268 return wxHtmlCell::GetLink( x, y );
269 }
270
271 const wxHtmlCell *wxHtmlImageMapCell::Find( int cond, const void *param ) const
272 {
273 if (cond == wxHTML_COND_ISIMAGEMAP)
274 {
275 if (m_Name == *((wxString*)(param)))
276 return this;
277 }
278 return wxHtmlCell::Find(cond, param);
279 }
280
281
282
283
284
285 //--------------------------------------------------------------------------------
286 // wxHtmlImageCell
287 // Image/bitmap
288 //--------------------------------------------------------------------------------
289
290 class wxHtmlImageCell : public wxHtmlCell
291 {
292 public:
293 wxHtmlImageCell(wxWindow *window,
294 wxFSFile *input, int w = -1, int h = -1,
295 double scale = 1.0, int align = wxHTML_ALIGN_BOTTOM,
296 const wxString& mapname = wxEmptyString);
297 ~wxHtmlImageCell();
298 void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2,
299 wxHtmlRenderingInfo& info);
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;
311 bool m_showFrame:1;
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;
321
322 DECLARE_NO_COPY_CLASS(wxHtmlImageCell)
323 };
324
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 }
334
335 private:
336 wxHtmlImageCell *m_cell;
337
338 DECLARE_NO_COPY_CLASS(wxGIFTimer)
339 };
340 #endif
341
342
343 //----------------------------------------------------------------------------
344 // wxHtmlImageCell
345 //----------------------------------------------------------------------------
346
347
348 wxHtmlImageCell::wxHtmlImageCell(wxWindow *window, wxFSFile *input,
349 int w, int h, double scale, int align,
350 const wxString& mapname) : wxHtmlCell()
351 {
352 m_window = window ? wxStaticCast(window, wxScrolledWindow) : NULL;
353 m_scale = scale;
354 m_showFrame = FALSE;
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
366
367 if ( m_bmpW && m_bmpH )
368 {
369 if ( input )
370 {
371 wxInputStream *s = input->GetStream();
372
373 if ( s )
374 {
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 )
380 {
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);
387
388 readImg = FALSE;
389
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 }
399 }
400 else
401 {
402 wxDELETE(m_gifDecoder);
403 }
404 }
405
406 if ( readImg )
407 #endif // wxUSE_GIF && wxUSE_TIMER
408 {
409 wxImage image(*s, wxBITMAP_TYPE_ANY);
410 if ( image.Ok() )
411 SetImage(image);
412 }
413 }
414 }
415 else // input==NULL, use "broken image" bitmap
416 {
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 }
428 m_bitmap =
429 new wxBitmap(wxArtProvider::GetBitmap(wxART_MISSING_IMAGE));
430 }
431 }
432 //else: ignore the 0-sized images used sometimes on the Web pages
433
434 m_Width = (int)(scale * (double)m_bmpW);
435 m_Height = (int)(scale * (double)m_bmpH);
436
437 switch (align)
438 {
439 case wxHTML_ALIGN_TOP :
440 m_Descent = m_Height;
441 break;
442 case wxHTML_ALIGN_CENTER :
443 m_Descent = m_Height / 2;
444 break;
445 case wxHTML_ALIGN_BOTTOM :
446 default :
447 m_Descent = 0;
448 break;
449 }
450 }
451
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
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 }
480
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
502 if ( m_window->GetClientRect().Intersects(rect) &&
503 m_gifDecoder->ConvertToImage(&img) )
504 {
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);
512 dc.DrawBitmap(bmp, m_gifDecoder->GetLeft(), m_gifDecoder->GetTop(),
513 TRUE /* use mask */);
514 }
515 else
516 SetImage(img);
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 }
539
540
541 void wxHtmlImageCell::Draw(wxDC& dc, int x, int y,
542 int WXUNUSED(view_y1), int WXUNUSED(view_y2),
543 wxHtmlRenderingInfo& WXUNUSED(info))
544 {
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 )
553 {
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
563 double us_x, us_y;
564 dc.GetUserScale(&us_x, &us_y);
565 dc.SetUserScale(us_x * m_scale * imageScaleX, us_y * m_scale * imageScaleY);
566
567 dc.DrawBitmap(*m_bitmap, (int) ((x + m_PosX) / (m_scale*imageScaleX)),
568 (int) ((y + m_PosY) / (m_scale*imageScaleY)), TRUE);
569 dc.SetUserScale(us_x, us_y);
570 }
571 }
572
573 wxHtmlLinkInfo *wxHtmlImageCell::GetLink( int x, int y ) const
574 {
575 if (m_mapName.IsEmpty())
576 return wxHtmlCell::GetLink( x, y );
577 if (!m_imageMap)
578 {
579 wxHtmlContainerCell *p, *op;
580 op = p = GetParent();
581 while (p)
582 {
583 op = p;
584 p = p->GetParent();
585 }
586 p = op;
587 wxHtmlCell *cell = (wxHtmlCell*)p->Find(wxHTML_COND_ISIMAGEMAP,
588 (const void*)(&m_mapName));
589 if (!cell)
590 {
591 ((wxString&)m_mapName).Clear();
592 return wxHtmlCell::GetLink( x, y );
593 }
594 { // dirty hack, ask Joel why he fills m_ImageMap in this place
595 // THE problem is that we're in const method and we can't modify m_ImageMap
596 wxHtmlImageMapCell **cx = (wxHtmlImageMapCell**)(&m_imageMap);
597 *cx = (wxHtmlImageMapCell*)cell;
598 }
599 }
600 return m_imageMap->GetLink(x, y);
601 }
602
603
604
605 //--------------------------------------------------------------------------------
606 // tag handler
607 //--------------------------------------------------------------------------------
608
609 TAG_HANDLER_BEGIN(IMG, "IMG,MAP,AREA")
610 TAG_HANDLER_CONSTR(IMG) { }
611
612 TAG_HANDLER_PROC(tag)
613 {
614 if (tag.GetName() == wxT("IMG"))
615 {
616 if (tag.HasParam(wxT("SRC")))
617 {
618 int w = -1, h = -1;
619 int al;
620 wxFSFile *str;
621 wxString tmp = tag.GetParam(wxT("SRC"));
622 wxString mn = wxEmptyString;
623
624 str = m_WParser->OpenURL(wxHTML_URL_IMAGE, tmp);
625
626 if (tag.HasParam(wxT("WIDTH")))
627 tag.GetParamAsInt(wxT("WIDTH"), &w);
628 if (tag.HasParam(wxT("HEIGHT")))
629 tag.GetParamAsInt(wxT("HEIGHT"), &h);
630 al = wxHTML_ALIGN_BOTTOM;
631 if (tag.HasParam(wxT("ALIGN")))
632 {
633 wxString alstr = tag.GetParam(wxT("ALIGN"));
634 alstr.MakeUpper(); // for the case alignment was in ".."
635 if (alstr == wxT("TEXTTOP"))
636 al = wxHTML_ALIGN_TOP;
637 else if ((alstr == wxT("CENTER")) || (alstr == wxT("ABSCENTER")))
638 al = wxHTML_ALIGN_CENTER;
639 }
640 if (tag.HasParam(wxT("USEMAP")))
641 {
642 mn = tag.GetParam( wxT("USEMAP") );
643 if (mn.GetChar(0) == wxT('#'))
644 {
645 mn = mn.Mid( 1 );
646 }
647 }
648 wxHtmlImageCell *cel = new wxHtmlImageCell(
649 m_WParser->GetWindow(),
650 str, w, h,
651 m_WParser->GetPixelScale(),
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);
656 if (str)
657 delete str;
658 }
659 }
660 if (tag.GetName() == wxT("MAP"))
661 {
662 m_WParser->CloseContainer();
663 m_WParser->OpenContainer();
664 if (tag.HasParam(wxT("NAME")))
665 {
666 wxString tmp = tag.GetParam(wxT("NAME"));
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 }
674 if (tag.GetName() == wxT("AREA"))
675 {
676 if (tag.HasParam(wxT("SHAPE")))
677 {
678 wxString tmp = tag.GetParam(wxT("SHAPE"));
679 wxString coords = wxEmptyString;
680 tmp.MakeUpper();
681 wxHtmlImageMapAreaCell *cel = NULL;
682 if (tag.HasParam(wxT("COORDS")))
683 {
684 coords = tag.GetParam(wxT("COORDS"));
685 }
686 if (tmp == wxT("POLY"))
687 {
688 cel = new wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::POLY, coords, m_WParser->GetPixelScale() );
689 }
690 else if (tmp == wxT("CIRCLE"))
691 {
692 cel = new wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::CIRCLE, coords, m_WParser->GetPixelScale() );
693 }
694 else if (tmp == wxT("RECT"))
695 {
696 cel = new wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::RECT, coords, m_WParser->GetPixelScale() );
697 }
698 if (cel != NULL && tag.HasParam(wxT("HREF")))
699 {
700 wxString tmp = tag.GetParam(wxT("HREF"));
701 wxString target = wxEmptyString;
702 if (tag.HasParam(wxT("TARGET"))) target = tag.GetParam(wxT("TARGET"));
703 cel->SetLink( wxHtmlLinkInfo(tmp, target));
704 }
705 if (cel != NULL) m_WParser->GetContainer()->InsertCell( cel );
706 }
707 }
708
709 return FALSE;
710 }
711
712 TAG_HANDLER_END(IMG)
713
714
715
716 TAGS_MODULE_BEGIN(Image)
717
718 TAGS_MODULE_ADD(IMG)
719
720 TAGS_MODULE_END(Image)
721
722
723 #endif