moved c-runtime functions for CW to wxchar

[wxWidgets.git] / src / msw / bitmap.cpp

diff --git a/src/msw/bitmap.cpp b/src/msw/bitmap.cpp
index b34424a5fe1410cace71e3aa86fa0c28755b0f26..e6419cac7e3bf4cabbe49beec854dea486aa5ad9 100644 (file)
--- a/src/msw/bitmap.cpp
+++ b/src/msw/bitmap.cpp
@@ -50,7 +50,9 @@
 #include "wx/image.h"
 #include "wx/xpmdecod.h"
 
 #include "wx/image.h"
 #include "wx/xpmdecod.h"
 

+#ifdef wxHAVE_RAW_BITMAP

 #include "wx/rawbmp.h"
 #include "wx/rawbmp.h"

+#endif

 
 // missing from mingw32 header
 #ifndef CLR_INVALID
 
 // missing from mingw32 header
 #ifndef CLR_INVALID


@@ -788,7 +790,9 @@ bool wxBitmap::CreateFromImage(const wxImage& image, int depth, WXHDC hdc )
     HBITMAP hbitmap;
 
     // are we going to use DIB?
     HBITMAP hbitmap;
 
     // are we going to use DIB?

-    if ( wxShouldCreateDIB(w, h, depth, hdc) )
+    //
+    // NB: DDBs don't support alpha so if we have alpha channel we must use DIB
+    if ( image.HasAlpha() || wxShouldCreateDIB(w, h, depth, hdc) )

     {
         // don't delete the DIB section in dib object dtor
         hbitmap = dib.Detach();
     {
         // don't delete the DIB section in dib object dtor
         hbitmap = dib.Detach();


@@ -823,6 +827,13 @@ bool wxBitmap::CreateFromImage(const wxImage& image, int depth, WXHDC hdc )
 
 wxImage wxBitmap::ConvertToImage() const
 {
 
 wxImage wxBitmap::ConvertToImage() const
 {

+    // the colour used as transparent one in wxImage and the one it is replaced
+    // with when it really occurs in the bitmap
+    static const int MASK_RED = 1;
+    static const int MASK_GREEN = 2;
+    static const int MASK_BLUE = 3;
+    static const int MASK_BLUE_REPLACEMENT = 2;
+

     wxImage image;
 
     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
     wxImage image;
 
     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );


@@ -914,27 +925,37 @@ wxImage wxBitmap::ConvertToImage() const
         ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
         ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
         ::DeleteDC( memdc );
         ::SetBkColor( memdc, RGB( 255, 255, 255 ) );
         ::GetDIBits( memdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
         ::DeleteDC( memdc );

-        // background color set to RGB(16,16,16) in consistent with wxGTK
-        unsigned char r=16, g=16, b=16;

         ptdata = data;
         ptbits = lpBits;
         for( i=0; i<height; i++ )
         {
             for( j=0; j<width; j++ )
             {
         ptdata = data;
         ptbits = lpBits;
         for( i=0; i<height; i++ )
         {
             for( j=0; j<width; j++ )
             {

-                if( *ptbits != 0 )
+                // is this pixel transparent?
+                if ( *ptbits != 0 )
+                {
+                    if ( (ptdata[0] == MASK_RED) &&
+                            (ptdata[1] == MASK_GREEN) &&
+                                (ptdata[2] == MASK_BLUE) )
+                    {
+                        // we have to fudge the colour a bit to prevent this
+                        // pixel from appearing transparent
+                        ptdata[2] = MASK_BLUE_REPLACEMENT;
+                    }

                     ptdata += 3;
                     ptdata += 3;

-                else
+                }
+                else // masked pixel

                 {
                 {

-                    *(ptdata++)  = r;
-                    *(ptdata++)  = g;
-                    *(ptdata++)  = b;
+                    *(ptdata++)  = MASK_RED;
+                    *(ptdata++)  = MASK_GREEN;
+                    *(ptdata++)  = MASK_BLUE;

                 }
                 ptbits += 3;
             }
             ptbits += padding;
         }
                 }
                 ptbits += 3;
             }
             ptbits += padding;
         }

-        image.SetMaskColour( r, g, b );
+
+        image.SetMaskColour( MASK_RED, MASK_GREEN, MASK_BLUE );

         image.SetMask( TRUE );
     }
     else
         image.SetMask( TRUE );
     }
     else


@@ -1090,11 +1111,13 @@ wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
 // wxBitmap accessors
 // ----------------------------------------------------------------------------
 
 // wxBitmap accessors
 // ----------------------------------------------------------------------------
 

+#if wxUSE_PALETTE

 wxPalette* wxBitmap::GetPalette() const
 {
     return GetBitmapData() ? &GetBitmapData()->m_bitmapPalette
                            : (wxPalette *) NULL;
 }
 wxPalette* wxBitmap::GetPalette() const
 {
     return GetBitmapData() ? &GetBitmapData()->m_bitmapPalette
                            : (wxPalette *) NULL;
 }

+#endif

 
 wxMask *wxBitmap::GetMask() const
 {
 
 wxMask *wxBitmap::GetMask() const
 {


@@ -1185,14 +1208,13 @@ void wxBitmap::SetQuality(int WXUNUSED(quality))
 // raw bitmap access support
 // ----------------------------------------------------------------------------
 
 // raw bitmap access support
 // ----------------------------------------------------------------------------
 

-bool wxBitmap::GetRawData(wxRawBitmapData *data)
+#ifdef wxHAVE_RAW_BITMAP
+void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)

 {
 {

-    wxCHECK_MSG( data, FALSE, _T("NULL pointer in wxBitmap::GetRawData") );
-

     if ( !Ok() )
     {
         // no bitmap, no data (raw or otherwise)
     if ( !Ok() )
     {
         // no bitmap, no data (raw or otherwise)

-        return FALSE;
+        return NULL;

     }
 
     // if we're already a DIB we can access our data directly, but if not we
     }
 
     // if we're already a DIB we can access our data directly, but if not we


@@ -1209,7 +1231,7 @@ bool wxBitmap::GetRawData(wxRawBitmapData *data)
         {
             delete dib;
 
         {
             delete dib;
 

-            return FALSE;
+            return NULL;

         }
 
         // we'll free it in UngetRawData()
         }
 
         // we'll free it in UngetRawData()


@@ -1227,81 +1249,97 @@ bool wxBitmap::GetRawData(wxRawBitmapData *data)
     {
         wxFAIL_MSG( _T("failed to get DIBSECTION from a DIB?") );
 
     {
         wxFAIL_MSG( _T("failed to get DIBSECTION from a DIB?") );
 

-        return FALSE;
+        return NULL;
+    }
+
+    // check that the bitmap is in correct format
+    if ( ds.dsBm.bmBitsPixel != bpp )
+    {
+        wxFAIL_MSG( _T("incorrect bitmap type in wxBitmap::GetRawData()") );
+
+        return NULL;

     }
 
     }
 

-    // ok, store the relevant info in wxRawBitmapData
+    // ok, store the relevant info in wxPixelDataBase

     const LONG h = ds.dsBm.bmHeight;
 
     const LONG h = ds.dsBm.bmHeight;
 

-    data->m_width = ds.dsBm.bmWidth;
-    data->m_height = h;
-    data->m_bypp = ds.dsBm.bmBitsPixel / 8;
+    data.m_width = ds.dsBm.bmWidth;
+    data.m_height = h;

 
     // remember that DIBs are stored in top to bottom order!
     const LONG bytesPerRow = ds.dsBm.bmWidthBytes;
 
     // remember that DIBs are stored in top to bottom order!
     const LONG bytesPerRow = ds.dsBm.bmWidthBytes;

-    data->m_stride = -bytesPerRow;
-    data->m_pixels = (unsigned char *)ds.dsBm.bmBits;
+    data.m_stride = -bytesPerRow;
+
+    char *bits = (char *)ds.dsBm.bmBits;

     if ( h > 1 )
     {
     if ( h > 1 )
     {

-        data->m_pixels += (h - 1)*bytesPerRow;
+        bits += (h - 1)*bytesPerRow;

     }
 
     }
 

-    return TRUE;
+    return bits;

 }
 
 }
 

-void wxBitmap::UngetRawData(wxRawBitmapData *data)
+void wxBitmap::UngetRawData(wxPixelDataBase& dataBase)

 {
 {

-    wxCHECK_RET( data, _T("NULL pointer in wxBitmap::UngetRawData()") );
-

     if ( !Ok() )
         return;
 
     if ( !Ok() )
         return;
 

-    if ( !*data )
+    // the cast is ugly but we can't do without it and without making this
+    // function template (and hence inline) unfortunately
+    typedef wxPixelData<wxBitmap, wxAlphaPixelFormat> PixelData;
+    PixelData& data = (PixelData &)dataBase;
+
+    if ( !data )

     {
         // invalid data, don't crash -- but don't assert neither as we're
     {
         // invalid data, don't crash -- but don't assert neither as we're

-        // called automatically from wxRawBitmapData dtor and so there is no
+        // called automatically from wxPixelDataBase dtor and so there is no

         // way to prevent this from happening
         return;
     }
 
         // way to prevent this from happening
         return;
     }
 

-    // AlphaBlend() wants to have premultiplied source alpha but wxRawBitmap
-    // API uses normal, not premultiplied, colours, so adjust them here now
-    wxRawBitmapIterator p(*data);
-
-    const int w = data->GetWidth();
-    const int h = data->GetHeight();
-
-    for ( int y = 0; y < h; y++ )
+    if ( GetBitmapData()->m_hasAlpha )

     {
     {

-        wxRawBitmapIterator rowStart = p;
+        // AlphaBlend() wants to have premultiplied source alpha but
+        // wxRawBitmap API uses normal, not premultiplied, colours, so adjust
+        // them here now
+        PixelData::Iterator p(data);

 
 

-        for ( int x = 0; x < w; x++ )
+        const int w = data.GetWidth();
+        const int h = data.GetHeight();
+
+        for ( int y = 0; y < h; y++ )

         {
         {

-            const unsigned alpha = p.Alpha();
+            PixelData::Iterator rowStart = p;

 
 

-            p.Red() = (p.Red() * alpha + 127) / 255;
-            p.Blue() = (p.Blue() * alpha + 127) / 255;
-            p.Green() = (p.Green() * alpha + 127) / 255;
+            for ( int x = 0; x < w; x++ )
+            {
+                const unsigned alpha = p.Alpha();

 
 

-            ++p;
-        }
+                p.Red() = (p.Red() * alpha + 127) / 255;
+                p.Blue() = (p.Blue() * alpha + 127) / 255;
+                p.Green() = (p.Green() * alpha + 127) / 255;

 
 

-        p = rowStart;
-        p.OffsetY(1);
-    }
+                ++p;
+            }

 
 

-    // if we're a DDB we need to convert DIB back to DDB now to make the
-    // changes made via wxRawBitmapData effective
-    if ( !GetBitmapData()->m_isDIB )
-    {
-        wxDIB *dib = GetBitmapData()->m_dib;
-        GetBitmapData()->m_dib = NULL;
+            p = rowStart;
+            p.OffsetY(data, 1);
+        }

 
 

-        // TODO: convert
+        // if we're a DDB we need to convert DIB back to DDB now to make the
+        // changes made via raw bitmap access effective
+        if ( !GetBitmapData()->m_isDIB )
+        {
+            wxDIB *dib = GetBitmapData()->m_dib;
+            GetBitmapData()->m_dib = NULL;
+
+            // TODO: convert

 
 

-        delete dib;
+            delete dib;
+        }

     }
 }
     }
 }

+#endif // #ifdef wxHAVE_RAW_BITMAP

 
 // ----------------------------------------------------------------------------
 // wxMask
 
 // ----------------------------------------------------------------------------
 // wxMask