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