wxVariant is in wxBase so should be forward declared using WXDLLIMPEXP_BASE and not...

[wxWidgets.git] / src / html / m_image.cpp

diff --git a/src/html/m_image.cpp b/src/html/m_image.cpp
index 5f5cc37d911bfbcbf49bd4249c0f01c3ad287351..fd4ff2485563b930d07dcd0c9886412223ab5744 100644 (file)
--- a/src/html/m_image.cpp
+++ b/src/html/m_image.cpp
@@ -4,10 +4,10 @@
 // Author:      Vaclav Slavik
 // RCS-ID:      $Id$
 // Copyright:   (c) 1999 Vaclav Slavik, Joel Lucsy
 // Author:      Vaclav Slavik
 // RCS-ID:      $Id$
 // Copyright:   (c) 1999 Vaclav Slavik, Joel Lucsy

-// Licence:     wxWindows Licence
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)

 #pragma implementation
 #endif
 
 #pragma implementation
 #endif
 


@@ -16,7 +16,7 @@
 #include "wx/defs.h"
 #if wxUSE_HTML && wxUSE_STREAMS
 
 #include "wx/defs.h"
 #if wxUSE_HTML && wxUSE_STREAMS
 

-#ifdef __BORDLANDC__
+#ifdef __BORLANDC__

 #pragma hdrstop
 #endif
 
 #pragma hdrstop
 #endif
 


@@ -34,8 +34,10 @@
 #include "wx/image.h"
 #include "wx/gifdecod.h"
 #include "wx/dynarray.h"
 #include "wx/image.h"
 #include "wx/gifdecod.h"
 #include "wx/dynarray.h"

+#include "wx/log.h"
+#include "wx/artprov.h"
+#include "wx/math.h"

 
 

-#include <math.h>

 #include <float.h>
 
 FORCE_LINK_ME(m_image)
 #include <float.h>
 
 FORCE_LINK_ME(m_image)


@@ -48,11 +50,11 @@ WX_DECLARE_OBJARRAY(int, CoordArray);
 WX_DEFINE_OBJARRAY(CoordArray);
 
 
 WX_DEFINE_OBJARRAY(CoordArray);
 
 

-//--------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------

 // wxHtmlImageMapAreaCell
 // wxHtmlImageMapAreaCell

-//                  0-width, 0-height cell that represents single area in imagemap
-//                  (it's GetLink is called from wxHtmlImageCell's)
-//--------------------------------------------------------------------------------
+//                  0-width, 0-height cell that represents single area in
+//                  imagemap (it's GetLink is called from wxHtmlImageCell's)
+// ---------------------------------------------------------------------------

 
 class wxHtmlImageMapAreaCell : public wxHtmlCell
 {
 
 class wxHtmlImageMapAreaCell : public wxHtmlCell
 {


@@ -65,6 +67,13 @@ class wxHtmlImageMapAreaCell : public wxHtmlCell
     public:
         wxHtmlImageMapAreaCell( celltype t, wxString &coords, double pixel_scale = 1.0);
         virtual wxHtmlLinkInfo *GetLink( int x = 0, int y = 0 ) const;
     public:
         wxHtmlImageMapAreaCell( celltype t, wxString &coords, double pixel_scale = 1.0);
         virtual wxHtmlLinkInfo *GetLink( int x = 0, int y = 0 ) const;

+        void Draw(wxDC& WXUNUSED(dc),
+                  int WXUNUSED(x), int WXUNUSED(y),
+                  int WXUNUSED(view_y1), int WXUNUSED(view_y2),
+                  wxHtmlRenderingInfo& WXUNUSED(info)) {}
+
+
+    DECLARE_NO_COPY_CLASS(wxHtmlImageMapAreaCell)

 };
 
 
 };
 
 


@@ -77,7 +86,7 @@ wxHtmlImageMapAreaCell::wxHtmlImageMapAreaCell( wxHtmlImageMapAreaCell::celltype
     wxString x = incoords, y;
 
     type = t;
     wxString x = incoords, y;
 
     type = t;

-    while ((i = x.Find( ',' )) != -1)
+    while ((i = x.Find( ',' )) != wxNOT_FOUND)

     {
         coords.Add( (int)(pixel_scale * (double)wxAtoi( x.Left( i ).c_str())) );
         x = x.Mid( i + 1 );
     {
         coords.Add( (int)(pixel_scale * (double)wxAtoi( x.Left( i ).c_str())) );
         x = x.Mid( i + 1 );


@@ -237,6 +246,12 @@ class wxHtmlImageMapCell : public wxHtmlCell
     public:
         virtual wxHtmlLinkInfo *GetLink( int x = 0, int y = 0 ) const;
         virtual const wxHtmlCell *Find( int cond, const void *param ) const;
     public:
         virtual wxHtmlLinkInfo *GetLink( int x = 0, int y = 0 ) const;
         virtual const wxHtmlCell *Find( int cond, const void *param ) const;

+        void Draw(wxDC& WXUNUSED(dc),
+                  int WXUNUSED(x), int WXUNUSED(y),
+                  int WXUNUSED(view_y1), int WXUNUSED(view_y2),
+                  wxHtmlRenderingInfo& WXUNUSED(info)) {}
+
+    DECLARE_NO_COPY_CLASS(wxHtmlImageMapCell)

 };
 
 
 };
 
 


@@ -276,11 +291,12 @@ class wxHtmlImageCell : public wxHtmlCell
 {
 public:
     wxHtmlImageCell(wxWindow *window,
 {
 public:
     wxHtmlImageCell(wxWindow *window,

-                    wxFSFile *input, int w = -1, int h = -1, 
-                    double scale = 1.0, int align = wxHTML_ALIGN_BOTTOM, 
+                    wxFSFile *input, int w = wxDefaultCoord, int h = wxDefaultCoord,
+                    double scale = 1.0, int align = wxHTML_ALIGN_BOTTOM,

                     const wxString& mapname = wxEmptyString);
     ~wxHtmlImageCell();
                     const wxString& mapname = wxEmptyString);
     ~wxHtmlImageCell();

-    void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2);
+    void Draw(wxDC& dc, int x, int y, int view_y1, int view_y2,
+              wxHtmlRenderingInfo& info);

     virtual wxHtmlLinkInfo *GetLink(int x = 0, int y = 0) const;
 
     void SetImage(const wxImage& img);
     virtual wxHtmlLinkInfo *GetLink(int x = 0, int y = 0) const;
 
     void SetImage(const wxImage& img);


@@ -292,6 +308,7 @@ public:
 private:
     wxBitmap           *m_bitmap;
     int                 m_bmpW, m_bmpH;
 private:
     wxBitmap           *m_bitmap;
     int                 m_bmpW, m_bmpH;

+    bool                m_showFrame:1;

     wxScrolledWindow   *m_window;
 #if wxUSE_GIF && wxUSE_TIMER
     wxGIFDecoder       *m_gifDecoder;
     wxScrolledWindow   *m_window;
 #if wxUSE_GIF && wxUSE_TIMER
     wxGIFDecoder       *m_gifDecoder;


@@ -301,6 +318,8 @@ private:
     double              m_scale;
     wxHtmlImageMapCell *m_imageMap;
     wxString            m_mapName;
     double              m_scale;
     wxHtmlImageMapCell *m_imageMap;
     wxString            m_mapName;

+
+    DECLARE_NO_COPY_CLASS(wxHtmlImageCell)

 };
 
 #if wxUSE_GIF && wxUSE_TIMER
 };
 
 #if wxUSE_GIF && wxUSE_TIMER


@@ -315,73 +334,102 @@ class wxGIFTimer : public wxTimer
 
     private:
         wxHtmlImageCell *m_cell;
 
     private:
         wxHtmlImageCell *m_cell;

+
+    DECLARE_NO_COPY_CLASS(wxGIFTimer)

 };
 #endif
 
 
 };
 #endif
 
 

-//--------------------------------------------------------------------------------
+//----------------------------------------------------------------------------

 // wxHtmlImageCell
 // wxHtmlImageCell

-//--------------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+

 
 

-wxHtmlImageCell::wxHtmlImageCell(wxWindow *window, wxFSFile *input, 
-                                 int w, int h, double scale, int align, 
+wxHtmlImageCell::wxHtmlImageCell(wxWindow *window, wxFSFile *input,
+                                 int w, int h, double scale, int align,

                                  const wxString& mapname) : wxHtmlCell()
 {
     m_window = window ? wxStaticCast(window, wxScrolledWindow) : NULL;
     m_scale = scale;
                                  const wxString& mapname) : wxHtmlCell()
 {
     m_window = window ? wxStaticCast(window, wxScrolledWindow) : NULL;
     m_scale = scale;

+    m_showFrame = false;

     m_bitmap = NULL;
     m_bmpW = w;
     m_bmpH = h;
     m_imageMap = NULL;
     m_mapName = mapname;
     m_bitmap = NULL;
     m_bmpW = w;
     m_bmpH = h;
     m_imageMap = NULL;
     m_mapName = mapname;

-    SetCanLiveOnPagebreak(FALSE);
+    SetCanLiveOnPagebreak(false);

 #if wxUSE_GIF && wxUSE_TIMER
     m_gifDecoder = NULL;
     m_gifTimer = NULL;
 #if wxUSE_GIF && wxUSE_TIMER
     m_gifDecoder = NULL;
     m_gifTimer = NULL;

-    m_physX = m_physY = -1;
+    m_physX = m_physY = wxDefaultCoord;

 #endif
 
 #endif
 

-    wxInputStream *s = input->GetStream();
-    
-    if ( s )
+    if ( m_bmpW && m_bmpH )

     {
     {

-        bool readImg = TRUE;
-        
-#if wxUSE_GIF && wxUSE_TIMER
-        if ( (input->GetLocation().Matches(wxT("*.gif")) ||
-              input->GetLocation().Matches(wxT("*.GIF"))) && m_window )
+        if ( input )

         {
         {

-            m_gifDecoder = new wxGIFDecoder(s, TRUE);
-            if ( m_gifDecoder->ReadGIF() == wxGIF_OK )
-            {
-                wxImage img;
-                if ( m_gifDecoder->ConvertToImage(&img) )
-                    SetImage(img);
+            wxInputStream *s = input->GetStream();

 
 

-                readImg = FALSE;
+            if ( s )
+            {
+                bool readImg = true;

 
 

-                if ( m_gifDecoder->IsAnimation() )
+#if wxUSE_GIF && wxUSE_TIMER
+                if ( (input->GetLocation().Matches(wxT("*.gif")) ||
+                      input->GetLocation().Matches(wxT("*.GIF"))) && m_window )

                 {
                 {

-                    m_gifTimer = new wxGIFTimer(this);
-                    m_gifTimer->Start(m_gifDecoder->GetDelay(), TRUE);
+                    m_gifDecoder = new wxGIFDecoder(s, true);
+                    if ( m_gifDecoder->ReadGIF() == wxGIF_OK )
+                    {
+                        wxImage img;
+                        if ( m_gifDecoder->ConvertToImage(&img) )
+                            SetImage(img);
+
+                        readImg = false;
+
+                        if ( m_gifDecoder->IsAnimation() )
+                        {
+                            m_gifTimer = new wxGIFTimer(this);
+                            m_gifTimer->Start(m_gifDecoder->GetDelay(), true);
+                        }
+                        else
+                        {
+                            wxDELETE(m_gifDecoder);
+                        }
+                    }
+                    else
+                    {
+                        wxDELETE(m_gifDecoder);
+                    }

                 }
                 }

-                else
+
+                if ( readImg )
+#endif // wxUSE_GIF && wxUSE_TIMER

                 {
                 {

-                    wxDELETE(m_gifDecoder);
+                    wxImage image(*s, wxBITMAP_TYPE_ANY);
+                    if ( image.Ok() )
+                        SetImage(image);

                 }
             }
                 }
             }

+        }
+        else // input==NULL, use "broken image" bitmap
+        {
+            if ( m_bmpW == wxDefaultCoord && m_bmpH == wxDefaultCoord )
+            {
+                m_bmpW = 29;
+                m_bmpH = 31;
+            }

             else
             {
             else
             {

-                wxDELETE(m_gifDecoder);
+                m_showFrame = true;
+                if ( m_bmpW == wxDefaultCoord ) m_bmpW = 31;
+                if ( m_bmpH == wxDefaultCoord ) m_bmpH = 33;

             }
             }

-        }
-
-        if ( readImg )
-#endif
-        {
-            SetImage(wxImage(*s, wxBITMAP_TYPE_ANY));
+            m_bitmap =
+                new wxBitmap(wxArtProvider::GetBitmap(wxART_MISSING_IMAGE));

         }
     }
         }
     }

+    //else: ignore the 0-sized images used sometimes on the Web pages

 
     m_Width = (int)(scale * (double)m_bmpW);
     m_Height = (int)(scale * (double)m_bmpH);
 
     m_Width = (int)(scale * (double)m_bmpW);
     m_Height = (int)(scale * (double)m_bmpH);


@@ -411,17 +459,21 @@ void wxHtmlImageCell::SetImage(const wxImage& img)
         ww = img.GetWidth();
         hh = img.GetHeight();
 
         ww = img.GetWidth();
         hh = img.GetHeight();
 

-        if ( m_bmpW == -1 )
+        if ( m_bmpW == wxDefaultCoord )

             m_bmpW = ww;
             m_bmpW = ww;

-        if ( m_bmpH == -1 )
+        if ( m_bmpH == wxDefaultCoord )

             m_bmpH = hh;
 
             m_bmpH = hh;
 

+        // Only scale the bitmap at the rendering stage,
+        // so we don't lose quality twice
+/*

         if ((m_bmpW != ww) || (m_bmpH != hh))
         {
             wxImage img2 = img.Scale(m_bmpW, m_bmpH);
             m_bitmap = new wxBitmap(img2);
         }
         else
         if ((m_bmpW != ww) || (m_bmpH != hh))
         {
             wxImage img2 = img.Scale(m_bmpW, m_bmpH);
             m_bitmap = new wxBitmap(img2);
         }
         else

+*/

             m_bitmap = new wxBitmap(img);
     }
 }
             m_bitmap = new wxBitmap(img);
     }
 }


@@ -431,9 +483,9 @@ void wxHtmlImageCell::AdvanceAnimation(wxTimer *timer)
 {
     wxImage img;
 
 {
     wxImage img;
 

-    m_gifDecoder->GoNextFrame(TRUE);
+    m_gifDecoder->GoNextFrame(true);

 
 

-    if ( m_physX == -1 )
+    if ( m_physX == wxDefaultCoord )

     {
         m_physX = m_physY = 0;
         for (wxHtmlCell *cell = this; cell; cell = cell->GetParent())
     {
         m_physX = m_physY = 0;
         for (wxHtmlCell *cell = this; cell; cell = cell->GetParent())


@@ -447,7 +499,7 @@ void wxHtmlImageCell::AdvanceAnimation(wxTimer *timer)
     m_window->CalcScrolledPosition(m_physX, m_physY, &x, &y);
     wxRect rect(x, y, m_Width, m_Height);
 
     m_window->CalcScrolledPosition(m_physX, m_physY, &x, &y);
     wxRect rect(x, y, m_Width, m_Height);
 

-    if ( m_window->GetClientRect().Intersects(rect) && 
+    if ( m_window->GetClientRect().Intersects(rect) &&

          m_gifDecoder->ConvertToImage(&img) )
     {
         if ( (int)m_gifDecoder->GetWidth() != m_Width ||
          m_gifDecoder->ConvertToImage(&img) )
     {
         if ( (int)m_gifDecoder->GetWidth() != m_Width ||


@@ -457,20 +509,21 @@ void wxHtmlImageCell::AdvanceAnimation(wxTimer *timer)
             wxBitmap bmp(img);
             wxMemoryDC dc;
             dc.SelectObject(*m_bitmap);
             wxBitmap bmp(img);
             wxMemoryDC dc;
             dc.SelectObject(*m_bitmap);

-            dc.DrawBitmap(bmp, m_gifDecoder->GetLeft(), m_gifDecoder->GetTop());
+            dc.DrawBitmap(bmp, m_gifDecoder->GetLeft(), m_gifDecoder->GetTop(),
+                          true /* use mask */);

         }
         else
             SetImage(img);
         m_window->Refresh(img.HasMask(), &rect);
     }
 
         }
         else
             SetImage(img);
         m_window->Refresh(img.HasMask(), &rect);
     }
 

-    timer->Start(m_gifDecoder->GetDelay(), TRUE);
+    timer->Start(m_gifDecoder->GetDelay(), true);

 }
 
 void wxHtmlImageCell::Layout(int w)
 {
     wxHtmlCell::Layout(w);
 }
 
 void wxHtmlImageCell::Layout(int w)
 {
     wxHtmlCell::Layout(w);

-    m_physX = m_physY = -1;
+    m_physX = m_physY = wxDefaultCoord;

 }
 
 #endif
 }
 
 #endif


@@ -485,23 +538,41 @@ wxHtmlImageCell::~wxHtmlImageCell()
 }
 
 
 }
 
 

-void wxHtmlImageCell::Draw(wxDC& dc, int x, int y, int WXUNUSED(view_y1), int WXUNUSED(view_y2))
+void wxHtmlImageCell::Draw(wxDC& dc, int x, int y,
+                           int WXUNUSED(view_y1), int WXUNUSED(view_y2),
+                           wxHtmlRenderingInfo& WXUNUSED(info))

 {
 {

-    if (m_bitmap)
+    if ( m_showFrame )
+    {
+        dc.SetBrush(*wxTRANSPARENT_BRUSH);
+        dc.SetPen(*wxBLACK_PEN);
+        dc.DrawRectangle(x + m_PosX, y + m_PosY, m_Width, m_Height);
+        x++, y++;
+    }
+    if ( m_bitmap )

     {
     {

+        // We add in the scaling from the desired bitmap width
+        // and height, so we only do the scaling once.
+        double imageScaleX = 1.0;
+        double imageScaleY = 1.0;
+        if (m_bmpW != m_bitmap->GetWidth())
+            imageScaleX = (double) m_bmpW / (double) m_bitmap->GetWidth();
+        if (m_bmpH != m_bitmap->GetHeight())
+            imageScaleY = (double) m_bmpH / (double) m_bitmap->GetHeight();
+

         double us_x, us_y;
         dc.GetUserScale(&us_x, &us_y);
         double us_x, us_y;
         dc.GetUserScale(&us_x, &us_y);

-        dc.SetUserScale(us_x * m_scale, us_y * m_scale);
+        dc.SetUserScale(us_x * m_scale * imageScaleX, us_y * m_scale * imageScaleY);

 
 

-        dc.DrawBitmap(*m_bitmap, (int) ((x + m_PosX) / m_scale),
-                                 (int) ((y + m_PosY) / m_scale), TRUE);
+        dc.DrawBitmap(*m_bitmap, (int) ((x + m_PosX) / (m_scale*imageScaleX)),
+                                 (int) ((y + m_PosY) / (m_scale*imageScaleY)), true);

         dc.SetUserScale(us_x, us_y);
     }
 }
 
 wxHtmlLinkInfo *wxHtmlImageCell::GetLink( int x, int y ) const
 {
         dc.SetUserScale(us_x, us_y);
     }
 }
 
 wxHtmlLinkInfo *wxHtmlImageCell::GetLink( int x, int y ) const
 {

-    if (m_mapName.IsEmpty())
+    if (m_mapName.empty())

         return wxHtmlCell::GetLink( x, y );
     if (!m_imageMap)
     {
         return wxHtmlCell::GetLink( x, y );
     if (!m_imageMap)
     {


@@ -513,7 +584,7 @@ wxHtmlLinkInfo *wxHtmlImageCell::GetLink( int x, int y ) const
             p = p->GetParent();
         }
         p = op;
             p = p->GetParent();
         }
         p = op;

-        wxHtmlCell *cell = (wxHtmlCell*)p->Find(wxHTML_COND_ISIMAGEMAP, 
+        wxHtmlCell *cell = (wxHtmlCell*)p->Find(wxHTML_COND_ISIMAGEMAP,

                                                 (const void*)(&m_mapName));
         if (!cell)
         {
                                                 (const void*)(&m_mapName));
         if (!cell)
         {


@@ -536,6 +607,7 @@ wxHtmlLinkInfo *wxHtmlImageCell::GetLink( int x, int y ) const
 //--------------------------------------------------------------------------------
 
 TAG_HANDLER_BEGIN(IMG, "IMG,MAP,AREA")
 //--------------------------------------------------------------------------------
 
 TAG_HANDLER_BEGIN(IMG, "IMG,MAP,AREA")

+    TAG_HANDLER_CONSTR(IMG) { }

 
     TAG_HANDLER_PROC(tag)
     {
 
     TAG_HANDLER_PROC(tag)
     {


@@ -543,16 +615,14 @@ TAG_HANDLER_BEGIN(IMG, "IMG,MAP,AREA")
         {
             if (tag.HasParam(wxT("SRC")))
             {
         {
             if (tag.HasParam(wxT("SRC")))
             {

-                int w = -1, h = -1;
+                int w = wxDefaultCoord, h = wxDefaultCoord;

                 int al;
                 wxFSFile *str;
                 wxString tmp = tag.GetParam(wxT("SRC"));
                 wxString mn = wxEmptyString;
                 int al;
                 wxFSFile *str;
                 wxString tmp = tag.GetParam(wxT("SRC"));
                 wxString mn = wxEmptyString;

-                
-                if ( !m_WParser->CanOpenURL(tmp) )
-                    return FALSE;

 
 

-                str = m_WParser->GetFS()->OpenFile(tmp);
+                str = m_WParser->OpenURL(wxHTML_URL_IMAGE, tmp);
+

                 if (tag.HasParam(wxT("WIDTH")))
                     tag.GetParamAsInt(wxT("WIDTH"), &w);
                 if (tag.HasParam(wxT("HEIGHT")))
                 if (tag.HasParam(wxT("WIDTH")))
                     tag.GetParamAsInt(wxT("WIDTH"), &w);
                 if (tag.HasParam(wxT("HEIGHT")))


@@ -575,18 +645,16 @@ TAG_HANDLER_BEGIN(IMG, "IMG,MAP,AREA")
                         mn = mn.Mid( 1 );
                     }
                 }
                         mn = mn.Mid( 1 );
                     }
                 }

-                wxHtmlImageCell *cel = NULL;
+                wxHtmlImageCell *cel = new wxHtmlImageCell(
+                                          m_WParser->GetWindow(),
+                                          str, w, h,
+                                          m_WParser->GetPixelScale(),
+                                          al, mn);
+                cel->SetLink(m_WParser->GetLink());
+                cel->SetId(tag.GetParam(wxT("id"))); // may be empty
+                m_WParser->GetContainer()->InsertCell(cel);

                 if (str)
                 if (str)

-                {
-                    cel = new wxHtmlImageCell(m_WParser->GetWindow(),
-                                              str, w, h, 
-                                              m_WParser->GetPixelScale(), 
-                                              al, mn);
-                    cel->SetLink(m_WParser->GetLink());
-                    cel->SetId(tag.GetParam(wxT("id"))); // may be empty
-                    m_WParser->GetContainer()->InsertCell(cel);

                     delete str;
                     delete str;

-                }

             }
         }
         if (tag.GetName() == wxT("MAP"))
             }
         }
         if (tag.GetName() == wxT("MAP"))


@@ -638,7 +706,7 @@ TAG_HANDLER_BEGIN(IMG, "IMG,MAP,AREA")
             }
         }
 
             }
         }
 

-        return FALSE;
+        return false;

     }
 
 TAG_HANDLER_END(IMG)
     }
 
 TAG_HANDLER_END(IMG)