| 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( ',' )) != wxNOT_FOUND) |
| 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 = wxDefaultCoord, int h = wxDefaultCoord, |
| 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 = wxDefaultCoord; |
| 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 == wxDefaultCoord && m_bmpH == wxDefaultCoord ) |
| 418 | { |
| 419 | m_bmpW = 29; |
| 420 | m_bmpH = 31; |
| 421 | } |
| 422 | else |
| 423 | { |
| 424 | m_showFrame = true; |
| 425 | if ( m_bmpW == wxDefaultCoord ) m_bmpW = 31; |
| 426 | if ( m_bmpH == wxDefaultCoord ) 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 == 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 | } |
| 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 == wxDefaultCoord ) |
| 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 = wxDefaultCoord; |
| 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 = wxDefaultCoord, h = wxDefaultCoord; |
| 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 |