]>
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 | #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 |