Use of blobs with a binding to a SQL_C_BINARY type column definition was not working...

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

diff --git a/src/html/m_image.cpp b/src/html/m_image.cpp
index 396edda93d32d60bbae637c8a447024d0eded04c..58aaa45e230843edf0f497a9724abc95a9300f8c 100644 (file)
--- a/src/html/m_image.cpp
+++ b/src/html/m_image.cpp
@@ -7,7 +7,7 @@
 // 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
 


@@ -24,14 +24,18 @@
     #include "wx/dc.h"
     #include "wx/scrolwin.h"
     #include "wx/timer.h"
     #include "wx/dc.h"
     #include "wx/scrolwin.h"
     #include "wx/timer.h"

+    #include "wx/dcmemory.h"

 #endif
 
 #include "wx/html/forcelnk.h"
 #include "wx/html/m_templ.h"
 #endif
 
 #include "wx/html/forcelnk.h"
 #include "wx/html/m_templ.h"

+#include "wx/html/htmlwin.h"

 
 #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 <math.h>
 #include <float.h>
 
 #include <math.h>
 #include <float.h>


@@ -46,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
 {


@@ -63,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)

 };
 
 
 };
 
 


@@ -235,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)

 };
 
 
 };
 
 


@@ -274,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 = -1, int h = -1,
+                    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);


@@ -290,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;


@@ -299,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


@@ -313,20 +334,24 @@ 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()
 {
                                  const wxString& mapname) : wxHtmlCell()
 {

-    m_window = wxStaticCast(window, wxScrolledWindow);
+    m_window = window ? wxStaticCast(window, wxScrolledWindow) : NULL;

     m_scale = scale;
     m_scale = scale;

+    m_showFrame = FALSE;

     m_bitmap = NULL;
     m_bmpW = w;
     m_bmpH = h;
     m_bitmap = NULL;
     m_bmpW = w;
     m_bmpH = h;


@@ -339,47 +364,72 @@ wxHtmlImageCell::wxHtmlImageCell(wxWindow *window, wxFSFile *input,
     m_physX = m_physY = -1;
 #endif
 
     m_physX = m_physY = -1;
 #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 == -1 && m_bmpH == -1 )
+            {
+                m_bmpW = 29;
+                m_bmpH = 31;
+            }

             else
             {
             else
             {

-                wxDELETE(m_gifDecoder);
+                m_showFrame = TRUE;
+                if ( m_bmpW == -1 ) m_bmpW = 31;
+                if ( m_bmpH == -1 ) 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);


@@ -414,12 +464,16 @@ void wxHtmlImageCell::SetImage(const wxImage& img)
         if ( m_bmpH == -1 )
             m_bmpH = hh;
 
         if ( m_bmpH == -1 )
             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);
     }
 }


@@ -445,10 +499,21 @@ 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) )
     {
          m_gifDecoder->ConvertToImage(&img) )
     {

-        SetImage(img);
+        if ( (int)m_gifDecoder->GetWidth() != m_Width ||
+             (int)m_gifDecoder->GetHeight() != m_Height ||
+             m_gifDecoder->GetLeft() != 0 || m_gifDecoder->GetTop() != 0 )
+        {
+            wxBitmap bmp(img);
+            wxMemoryDC dc;
+            dc.SelectObject(*m_bitmap);
+            dc.DrawBitmap(bmp, m_gifDecoder->GetLeft(), m_gifDecoder->GetTop(),
+                          TRUE /* use mask */);
+        }
+        else
+            SetImage(img);

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


@@ -473,16 +538,34 @@ 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);
     }
 }
         dc.SetUserScale(us_x, us_y);
     }
 }


@@ -501,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)
         {


@@ -524,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)
     {


@@ -537,7 +621,8 @@ TAG_HANDLER_BEGIN(IMG, "IMG,MAP,AREA")
                 wxString tmp = tag.GetParam(wxT("SRC"));
                 wxString mn = wxEmptyString;
 
                 wxString tmp = tag.GetParam(wxT("SRC"));
                 wxString mn = wxEmptyString;
 

-                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")))


@@ -560,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"))