Move wxCocoa's wxFontRefData from the header to the implementation file.

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

diff --git a/src/msw/bitmap.cpp b/src/msw/bitmap.cpp
index f6e6b1820f3030988f01fdf48360cb088b629677..f3221c6e73caaa8275e464ff1a1c7febb477b6d0 100644 (file)
--- a/src/msw/bitmap.cpp
+++ b/src/msw/bitmap.cpp
@@ -45,8 +45,6 @@
     #include "wx/msw/dib.h"
 #endif
 
     #include "wx/msw/dib.h"
 #endif
 

-#include "wx/xpmdecod.h"
-

 #ifdef wxHAVE_RAW_BITMAP
     #include "wx/rawbmp.h"
 #endif
 #ifdef wxHAVE_RAW_BITMAP
     #include "wx/rawbmp.h"
 #endif


@@ -207,8 +205,13 @@ wxBitmapRefData::wxBitmapRefData(const wxBitmapRefData& data)
     m_selectedInto = NULL;
 #endif
 
     m_selectedInto = NULL;
 #endif
 

-    // can't copy the mask as the other bitmap destroys it
+    // (deep) copy the mask if present

     m_bitmapMask = NULL;
     m_bitmapMask = NULL;

+    if (data.m_bitmapMask)
+        m_bitmapMask = new wxMask(*data.m_bitmapMask);
+
+    // FIXME: we don't copy m_hBitmap currently but we should, see wxBitmap::
+    //        CloneRefData()

 
     wxASSERT_MSG( !data.m_isDIB,
                     _T("can't copy bitmap locked for raw access!") );
 
     wxASSERT_MSG( !data.m_isDIB,
                     _T("can't copy bitmap locked for raw access!") );


@@ -254,6 +257,10 @@ wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *dataOrig) const
     if ( !data )
         return NULL;
 
     if ( !data )
         return NULL;
 

+    // FIXME: this method is backwards, it should just create a new
+    //        wxBitmapRefData using its copy ctor but instead it modifies this
+    //        bitmap itself and then returns its m_refData -- which works, of
+    //        course (except in !wxUSE_WXDIB), but is completely illogical

     wxBitmap *self = wx_const_cast(wxBitmap *, this);
 
 #if wxUSE_WXDIB
     wxBitmap *self = wx_const_cast(wxBitmap *, this);
 
 #if wxUSE_WXDIB


@@ -266,16 +273,24 @@ wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *dataOrig) const
     else
 #endif // wxUSE_WXDIB
     {
     else
 #endif // wxUSE_WXDIB
     {

-        // don't copy the bitmap data, but do copy the size, depth, ...
+        // copy the bitmap data

         self->m_refData = new wxBitmapRefData(*data);
     }
 
         self->m_refData = new wxBitmapRefData(*data);
     }
 

+    // copy also the mask
+    wxMask * const maskSrc = data->GetMask();
+    if ( maskSrc )
+    {
+        wxBitmapRefData *selfdata = wx_static_cast(wxBitmapRefData *, m_refData);
+
+        selfdata->SetMask(new wxMask(*maskSrc));
+    }
+

     return m_refData;
 }
 
     return m_refData;
 }
 

-#ifdef __WIN32__
-
-bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& icon)
+bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& icon,
+                                    wxBitmapTransparency transp)

 {
 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
     // it may be either HICON or HCURSOR
 {
 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
     // it may be either HICON or HCURSOR


@@ -301,31 +316,51 @@ bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& icon)
 
     refData->m_hBitmap = (WXHBITMAP)iconInfo.hbmColor;
 
 
     refData->m_hBitmap = (WXHBITMAP)iconInfo.hbmColor;
 

+    switch ( transp )
+    {
+        default:
+            wxFAIL_MSG( _T("unknown wxBitmapTransparency value") );
+
+        case wxBitmapTransparency_None:
+            // nothing to do, refData->m_hasAlpha is false by default
+            break;
+
+        case wxBitmapTransparency_Auto:

 #if wxUSE_WXDIB
 #if wxUSE_WXDIB

-    // If the icon is 32 bits per pixel then it may have alpha channel data,
-    // although there are some icons that are 32 bpp but have no alpha... So
-    // convert to a DIB and manually check the 4th byte for each pixel.
-    BITMAP bm;
-    if ( ::GetObject(iconInfo.hbmColor, sizeof(BITMAP), (LPVOID)&bm)
-         && bm.bmBitsPixel == 32)
-    {
-        wxDIB dib(iconInfo.hbmColor);
-        if (dib.IsOk())
-        {
-            unsigned char* pixels = dib.GetData();
-            for (int idx=0; idx<w*h*4; idx+=4)
+            // If the icon is 32 bits per pixel then it may have alpha channel
+            // data, although there are some icons that are 32 bpp but have no
+            // alpha... So convert to a DIB and manually check the 4th byte for
+            // each pixel.

             {
             {

-                if (pixels[idx+3] != 0)
+                BITMAP bm;
+                if ( ::GetObject(iconInfo.hbmColor, sizeof(bm), &bm) &&
+                        (bm.bmBitsPixel == 32) )

                 {
                 {

-                    // If there is an alpha byte that is non-zero then set the
-                    // alpha flag and bail out of the loop.
-                    refData->m_hasAlpha = true;
-                    break;
+                    wxDIB dib(iconInfo.hbmColor);
+                    if (dib.IsOk())
+                    {
+                        const unsigned char* pixels = dib.GetData();
+                        for (int idx = 0; idx < w*h*4; idx+=4)
+                        {
+                            if (pixels[idx+3] != 0)
+                            {
+                                // If there is an alpha byte that is non-zero
+                                // then set the alpha flag and stop checking
+                                refData->m_hasAlpha = true;
+                                break;
+                            }
+                        }
+                    }

                 }
             }
                 }
             }

-        }
+            break;
+#endif // wxUSE_WXDIB
+
+        case wxBitmapTransparency_Always:
+            refData->m_hasAlpha = true;
+            break;

     }
     }

-#endif
+

     if ( !refData->m_hasAlpha )
     {
         // the mask returned by GetIconInfo() is inverted compared to the usual
     if ( !refData->m_hasAlpha )
     {
         // the mask returned by GetIconInfo() is inverted compared to the usual


@@ -337,32 +372,32 @@ bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& icon)
     ::DeleteObject(iconInfo.hbmMask);
 
     return true;
     ::DeleteObject(iconInfo.hbmMask);
 
     return true;

-#else
+#else // __WXMICROWIN__ || __WXWINCE__

     wxUnusedVar(icon);
     wxUnusedVar(icon);

+    wxUnusedVar(transp);
+

     return false;
     return false;

-#endif
+#endif // !__WXWINCE__/__WXWINCE__

 }
 
 }
 

-#endif // Win32
-
-bool wxBitmap::CopyFromCursor(const wxCursor& cursor)
+bool wxBitmap::CopyFromCursor(const wxCursor& cursor, wxBitmapTransparency transp)

 {
     UnRef();
 
     if ( !cursor.Ok() )
         return false;
 
 {
     UnRef();
 
     if ( !cursor.Ok() )
         return false;
 

-    return CopyFromIconOrCursor(cursor);
+    return CopyFromIconOrCursor(cursor, transp);

 }
 
 }
 

-bool wxBitmap::CopyFromIcon(const wxIcon& icon)
+bool wxBitmap::CopyFromIcon(const wxIcon& icon, wxBitmapTransparency transp)

 {
     UnRef();
 
     if ( !icon.Ok() )
         return false;
 
 {
     UnRef();
 
     if ( !icon.Ok() )
         return false;
 

-    return CopyFromIconOrCursor(icon);
+    return CopyFromIconOrCursor(icon, transp);

 }
 
 #ifndef NEVER_USE_DIB
 }
 
 #ifndef NEVER_USE_DIB


@@ -1054,8 +1089,14 @@ bool wxBitmap::SaveFile(const wxString& filename,
 // ----------------------------------------------------------------------------
 // sub bitmap extraction
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // sub bitmap extraction
 // ----------------------------------------------------------------------------

+wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect ) const
+{
+        MemoryHDC dcSrc;
+        SelectInHDC selectSrc(dcSrc, GetHbitmap());
+        return GetSubBitmapOfHDC( rect, (WXHDC)dcSrc );
+}

 
 

-wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
+wxBitmap wxBitmap::GetSubBitmapOfHDC( const wxRect& rect, WXHDC hdc ) const

 {
     wxCHECK_MSG( Ok() &&
                  (rect.x >= 0) && (rect.y >= 0) &&
 {
     wxCHECK_MSG( Ok() &&
                  (rect.x >= 0) && (rect.y >= 0) &&


@@ -1076,16 +1117,15 @@ wxBitmap wxBitmap::GetSubBitmap( const wxRect& rect) const
               dcDst;
 
     {
               dcDst;
 
     {

-        SelectInHDC selectSrc(dcSrc, GetHbitmap()),
-                    selectDst(dcDst, GetHbitmapOf(ret));
-
-        if ( !selectSrc || !selectDst )
+        SelectInHDC selectDst(dcDst, GetHbitmapOf(ret));
+               
+        if ( !selectDst )

         {
         {

-            wxLogLastError(_T("SelectObjct(hBitmap)"));
+            wxLogLastError(_T("SelectObject(destBitmap)"));

         }
 
         if ( !::BitBlt(dcDst, 0, 0, rect.width, rect.height,
         }
 
         if ( !::BitBlt(dcDst, 0, 0, rect.width, rect.height,

-                       dcSrc, rect.x, rect.y, SRCCOPY) )
+                       (HDC)hdc, rect.x, rect.y, SRCCOPY) )

         {
             wxLogLastError(_T("BitBlt"));
         }
         {
             wxLogLastError(_T("BitBlt"));
         }


@@ -1148,15 +1188,6 @@ wxDC *wxBitmap::GetSelectedInto() const
 
 #endif
 
 
 #endif
 

-#if WXWIN_COMPATIBILITY_2_4
-
-int wxBitmap::GetQuality() const
-{
-    return 0;
-}
-
-#endif // WXWIN_COMPATIBILITY_2_4
-

 void wxBitmap::UseAlpha()
 {
     if ( GetBitmapData() )
 void wxBitmap::UseAlpha()
 {
     if ( GetBitmapData() )


@@ -1200,14 +1231,6 @@ void wxBitmap::SetMask(wxMask *mask)
     GetBitmapData()->SetMask(mask);
 }
 
     GetBitmapData()->SetMask(mask);
 }
 

-#if WXWIN_COMPATIBILITY_2_4
-
-void wxBitmap::SetQuality(int WXUNUSED(quality))
-{
-}
-
-#endif // WXWIN_COMPATIBILITY_2_4
-

 // ----------------------------------------------------------------------------
 // raw bitmap access support
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // raw bitmap access support
 // ----------------------------------------------------------------------------


@@ -1329,6 +1352,39 @@ wxMask::wxMask()
     m_maskBitmap = 0;
 }
 
     m_maskBitmap = 0;
 }
 

+// Copy constructor
+wxMask::wxMask(const wxMask &mask)
+      : wxObject()
+{
+    BITMAP bmp;
+
+    HDC srcDC = CreateCompatibleDC(0);
+    HDC destDC = CreateCompatibleDC(0);
+
+    // GetBitmapDimensionEx won't work if SetBitmapDimensionEx wasn't used
+    // so we'll use GetObject() API here:
+    if (::GetObject((HGDIOBJ)mask.m_maskBitmap, sizeof(bmp), &bmp) == 0)
+    {
+        wxFAIL_MSG(wxT("Cannot retrieve the dimensions of the wxMask to copy"));
+        return;
+    }
+
+    // create our HBITMAP
+    int w = bmp.bmWidth, h = bmp.bmHeight;
+    m_maskBitmap = (WXHBITMAP)CreateCompatibleBitmap(srcDC, w, h);
+
+    // copy the mask's HBITMAP into our HBITMAP
+    SelectObject(srcDC, (HBITMAP) mask.m_maskBitmap);
+    SelectObject(destDC, (HBITMAP) m_maskBitmap);
+
+    BitBlt(destDC, 0, 0, w, h, srcDC, 0, 0, SRCCOPY);
+
+    SelectObject(srcDC, 0);
+    DeleteDC(srcDC);
+    SelectObject(destDC, 0);
+    DeleteDC(destDC);
+}
+

 // Construct a mask from a bitmap and a colour indicating
 // the transparent area
 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
 // Construct a mask from a bitmap and a colour indicating
 // the transparent area
 wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)


@@ -1522,56 +1578,32 @@ bool wxBitmapHandler::Save(wxGDIImage *image,
     return bitmap && SaveFile(bitmap, name, type);
 }
 
     return bitmap && SaveFile(bitmap, name, type);
 }
 

-// ----------------------------------------------------------------------------
-// DIB functions
-// ----------------------------------------------------------------------------
-
-#ifndef __WXMICROWIN__
-bool wxCreateDIB(long xSize, long ySize, long bitsPerPixel,
-                 HPALETTE hPal, LPBITMAPINFO* lpDIBHeader)
+bool wxBitmapHandler::Create(wxBitmap *WXUNUSED(bitmap),
+                             const void* WXUNUSED(data),
+                             long WXUNUSED(type),
+                             int WXUNUSED(width),
+                             int WXUNUSED(height),
+                             int WXUNUSED(depth))

 {
 {

-   unsigned long   i, headerSize;
-
-   // Allocate space for a DIB header
-   headerSize = (sizeof(BITMAPINFOHEADER) + (256 * sizeof(PALETTEENTRY)));
-   LPBITMAPINFO lpDIBheader = (BITMAPINFO *) malloc(headerSize);
-   LPPALETTEENTRY lpPe = (PALETTEENTRY *)((BYTE*)lpDIBheader + sizeof(BITMAPINFOHEADER));
-
-   GetPaletteEntries(hPal, 0, 256, lpPe);
-
-   memset(lpDIBheader, 0x00, sizeof(BITMAPINFOHEADER));
-
-   // Fill in the static parts of the DIB header
-   lpDIBheader->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
-   lpDIBheader->bmiHeader.biWidth = xSize;
-   lpDIBheader->bmiHeader.biHeight = ySize;
-   lpDIBheader->bmiHeader.biPlanes = 1;
-
-   // this value must be 1, 4, 8 or 24 so PixelDepth can only be
-   lpDIBheader->bmiHeader.biBitCount = (WORD)(bitsPerPixel);
-   lpDIBheader->bmiHeader.biCompression = BI_RGB;
-   lpDIBheader->bmiHeader.biSizeImage = (xSize * abs(ySize) * bitsPerPixel) >> 3;
-   lpDIBheader->bmiHeader.biClrUsed = 256;
-
-
-   // Initialize the DIB palette
-   for (i = 0; i < 256; i++) {
-      lpDIBheader->bmiColors[i].rgbReserved = lpPe[i].peFlags;
-      lpDIBheader->bmiColors[i].rgbRed = lpPe[i].peRed;
-      lpDIBheader->bmiColors[i].rgbGreen = lpPe[i].peGreen;
-      lpDIBheader->bmiColors[i].rgbBlue = lpPe[i].peBlue;
-   }
-
-   *lpDIBHeader = lpDIBheader;
+    return false;
+}

 
 

-   return true;
+bool wxBitmapHandler::LoadFile(wxBitmap *WXUNUSED(bitmap),
+                               const wxString& WXUNUSED(name),
+                               long WXUNUSED(type),
+                               int WXUNUSED(desiredWidth),
+                               int WXUNUSED(desiredHeight))
+{
+    return false;

 }
 
 }
 

-void wxFreeDIB(LPBITMAPINFO lpDIBHeader)
+bool wxBitmapHandler::SaveFile(wxBitmap *WXUNUSED(bitmap),
+                               const wxString& WXUNUSED(name),
+                               int WXUNUSED(type),
+                               const wxPalette *WXUNUSED(palette))

 {
 {

-    free(lpDIBHeader);
+    return false;

 }
 }

-#endif

 
 // ----------------------------------------------------------------------------
 // global helper functions implemented here
 
 // ----------------------------------------------------------------------------
 // global helper functions implemented here