X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/4b7f2165565bb33b149baf1272e28f9a61d579d3..803c55373484d1e2bfed85b46cbbfff8bfad1276:/src/msw/bitmap.cpp

diff --git a/src/msw/bitmap.cpp b/src/msw/bitmap.cpp
index 015b00e732..4c21494fcb 100644
--- a/src/msw/bitmap.cpp
+++ b/src/msw/bitmap.cpp
@@ -45,6 +45,12 @@
 
 #include "wx/msw/dib.h"
 #include "wx/image.h"
+#include "wx/xpmdecod.h"
+
+// missing from mingw32 header
+#ifndef CLR_INVALID
+    #define CLR_INVALID ((COLORREF)-1)
+#endif // no CLR_INVALID
 
 // ----------------------------------------------------------------------------
 // macros
@@ -81,7 +87,7 @@ void wxBitmapRefData::Free()
     {
         if ( !::DeleteObject((HBITMAP)m_hBitmap) )
         {
-            wxLogLastError("DeleteObject(hbitmap)");
+            wxLogLastError(wxT("DeleteObject(hbitmap)"));
         }
     }
 
@@ -112,7 +118,7 @@ bool wxBitmap::CopyFromIconOrCursor(const wxGDIImage& icon)
     ICONINFO iconInfo;
     if ( !::GetIconInfo(hicon, &iconInfo) )
     {
-        wxLogLastError("GetIconInfo");
+        wxLogLastError(wxT("GetIconInfo"));
 
         return FALSE;
     }
@@ -264,7 +270,7 @@ wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
     HBITMAP hbmp = ::CreateBitmap(width, height, 1, depth, data);
     if ( !hbmp )
     {
-        wxLogLastError("CreateBitmap");
+        wxLogLastError(wxT("CreateBitmap"));
     }
 
     if ( data != bits )
@@ -278,9 +284,20 @@ wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
 // Create from XPM data
 bool wxBitmap::CreateFromXpm(const char **data)
 {
+#if wxUSE_IMAGE && wxUSE_XPM
     Init();
 
-    return Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0);
+    wxCHECK_MSG( data != NULL, FALSE, wxT("invalid bitmap data") )
+    
+    wxXPMDecoder decoder;
+    wxImage img = decoder.ReadData(data);
+    wxCHECK_MSG( img.Ok(), FALSE, wxT("invalid bitmap data") )
+    
+    *this = wxBitmap(img);
+    return TRUE;
+#else
+	return FALSE;
+#endif
 }
 
 wxBitmap::wxBitmap(int w, int h, int d)
@@ -297,7 +314,7 @@ wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth)
     (void)Create(data, type, width, height, depth);
 }
 
-wxBitmap::wxBitmap(const wxString& filename, long type)
+wxBitmap::wxBitmap(const wxString& filename, wxBitmapType type)
 {
     Init();
 
@@ -321,7 +338,7 @@ bool wxBitmap::Create(int w, int h, int d)
         hbmp = ::CreateBitmap(w, h, 1, d, NULL);
         if ( !hbmp )
         {
-            wxLogLastError("CreateBitmap");
+            wxLogLastError(wxT("CreateBitmap"));
         }
     }
     else
@@ -330,7 +347,7 @@ bool wxBitmap::Create(int w, int h, int d)
         hbmp = ::CreateCompatibleBitmap(dc, w, h);
         if ( !hbmp )
         {
-            wxLogLastError("CreateCompatibleBitmap");
+            wxLogLastError(wxT("CreateCompatibleBitmap"));
         }
 
         GetBitmapData()->m_depth = wxDisplayDepth();
@@ -345,6 +362,368 @@ bool wxBitmap::Create(int w, int h, int d)
     return Ok();
 }
 
+// ----------------------------------------------------------------------------
+// wxImage to/from conversions
+// ----------------------------------------------------------------------------
+
+#if wxUSE_IMAGE
+
+bool wxBitmap::CreateFromImage( const wxImage& image, int depth )
+{
+    wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") )
+
+    m_refData = new wxBitmapRefData();
+
+    // sizeLimit is the MS upper limit for the DIB size
+#ifdef  WIN32
+    int sizeLimit = 1024*768*3;
+#else
+    int sizeLimit = 0x7fff ;
+#endif
+
+    // width and height of the device-dependent bitmap
+    int width = image.GetWidth();
+    int bmpHeight = image.GetHeight();
+
+    // calc the number of bytes per scanline and padding
+    int bytePerLine = width*3;
+    int sizeDWORD = sizeof( DWORD );
+    int lineBoundary = bytePerLine % sizeDWORD;
+    int padding = 0;
+    if( lineBoundary > 0 )
+    {
+        padding = sizeDWORD - lineBoundary;
+        bytePerLine += padding;
+    }
+    // calc the number of DIBs and heights of DIBs
+    int numDIB = 1;
+    int hRemain = 0;
+    int height = sizeLimit/bytePerLine;
+    if( height >= bmpHeight )
+        height = bmpHeight;
+    else
+    {
+        numDIB =  bmpHeight / height;
+        hRemain = bmpHeight % height;
+        if( hRemain >0 )  numDIB++;
+    }
+
+    // set bitmap parameters
+    wxCHECK_MSG( image.Ok(), FALSE, wxT("invalid image") );
+    SetWidth( width );
+    SetHeight( bmpHeight );
+    if (depth == -1) depth = wxDisplayDepth();
+    SetDepth( depth );
+
+    // create a DIB header
+    int headersize = sizeof(BITMAPINFOHEADER);
+    BITMAPINFO *lpDIBh = (BITMAPINFO *) malloc( headersize );
+    wxCHECK_MSG( lpDIBh, FALSE, wxT("could not allocate memory for DIB header") );
+    // Fill in the DIB header
+    lpDIBh->bmiHeader.biSize = headersize;
+    lpDIBh->bmiHeader.biWidth = (DWORD)width;
+    lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
+    lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
+    //   the general formula for biSizeImage:
+    //      ( ( ( ((DWORD)width*24) +31 ) & ~31 ) >> 3 ) * height;
+    lpDIBh->bmiHeader.biPlanes = 1;
+    lpDIBh->bmiHeader.biBitCount = 24;
+    lpDIBh->bmiHeader.biCompression = BI_RGB;
+    lpDIBh->bmiHeader.biClrUsed = 0;
+    // These seem not really needed for our purpose here.
+    lpDIBh->bmiHeader.biClrImportant = 0;
+    lpDIBh->bmiHeader.biXPelsPerMeter = 0;
+    lpDIBh->bmiHeader.biYPelsPerMeter = 0;
+    // memory for DIB data
+    unsigned char *lpBits;
+    lpBits = (unsigned char *)malloc( lpDIBh->bmiHeader.biSizeImage );
+    if( !lpBits )
+    {
+        wxFAIL_MSG( wxT("could not allocate memory for DIB") );
+        free( lpDIBh );
+        return FALSE;
+    }
+
+    // create and set the device-dependent bitmap
+    HDC hdc = ::GetDC(NULL);
+    HDC memdc = ::CreateCompatibleDC( hdc );
+    HBITMAP hbitmap;
+    hbitmap = ::CreateCompatibleBitmap( hdc, width, bmpHeight );
+    ::SelectObject( memdc, hbitmap);
+
+    HPALETTE hOldPalette = 0;
+    if (image.GetPalette().Ok())
+    {
+        hOldPalette = ::SelectPalette(memdc, (HPALETTE) image.GetPalette().GetHPALETTE(), FALSE);
+        ::RealizePalette(memdc);
+    }
+
+    // copy image data into DIB data and then into DDB (in a loop)
+    unsigned char *data = image.GetData();
+    int i, j, n;
+    int origin = 0;
+    unsigned char *ptdata = data;
+    unsigned char *ptbits;
+
+    for( n=0; n<numDIB; n++ )
+    {
+        if( numDIB > 1 && n == numDIB-1 && hRemain > 0 )
+        {
+            // redefine height and size of the (possibly) last smaller DIB
+            // memory is not reallocated
+            height = hRemain;
+            lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
+            lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
+        }
+        ptbits = lpBits;
+
+        for( j=0; j<height; j++ )
+        {
+            for( i=0; i<width; i++ )
+            {
+                *(ptbits++) = *(ptdata+2);
+                *(ptbits++) = *(ptdata+1);
+                *(ptbits++) = *(ptdata  );
+                ptdata += 3;
+            }
+            for( i=0; i< padding; i++ )   *(ptbits++) = 0;
+        }
+        ::StretchDIBits( memdc, 0, origin, width, height,\
+            0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
+        origin += height;
+        // if numDIB = 1,  lines below can also be used
+        //    hbitmap = CreateDIBitmap( hdc, &(lpDIBh->bmiHeader), CBM_INIT, lpBits, lpDIBh, DIB_RGB_COLORS );
+        // The above line is equivalent to the following two lines.
+        //    hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
+        //    ::SetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS);
+        // or the following lines
+        //    hbitmap = ::CreateCompatibleBitmap( hdc, width, height );
+        //    HDC memdc = ::CreateCompatibleDC( hdc );
+        //    ::SelectObject( memdc, hbitmap);
+        //    ::SetDIBitsToDevice( memdc, 0, 0, width, height,
+        //            0, 0, 0, height, (void *)lpBits, lpDIBh, DIB_RGB_COLORS);
+        //    ::SelectObject( memdc, 0 );
+        //    ::DeleteDC( memdc );
+    }
+    SetHBITMAP( (WXHBITMAP) hbitmap );
+
+    if (hOldPalette)
+        SelectPalette(memdc, hOldPalette, FALSE);
+
+    // similarly, created an mono-bitmap for the possible mask
+    if( image.HasMask() )
+    {
+        hbitmap = ::CreateBitmap( (WORD)width, (WORD)bmpHeight, 1, 1, NULL );
+        HGDIOBJ hbmpOld = ::SelectObject( memdc, hbitmap);
+        if( numDIB == 1 )   height = bmpHeight;
+        else                height = sizeLimit/bytePerLine;
+        lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
+        lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
+        origin = 0;
+        unsigned char r = image.GetMaskRed();
+        unsigned char g = image.GetMaskGreen();
+        unsigned char b = image.GetMaskBlue();
+        unsigned char zero = 0, one = 255;
+        ptdata = data;
+        for( n=0; n<numDIB; n++ )
+        {
+            if( numDIB > 1 && n == numDIB - 1 && hRemain > 0 )
+            {
+                // redefine height and size of the (possibly) last smaller DIB
+                // memory is not reallocated
+                height = hRemain;
+                lpDIBh->bmiHeader.biHeight = (DWORD)(-height);
+                lpDIBh->bmiHeader.biSizeImage = bytePerLine*height;
+            }
+            ptbits = lpBits;
+            for( int j=0; j<height; j++ )
+            {
+                for(i=0; i<width; i++ )
+                {
+                    // was causing a code gen bug in cw : if( ( cr !=r) || (cg!=g) || (cb!=b) )
+                    unsigned char cr = (*(ptdata++)) ;
+                    unsigned char cg = (*(ptdata++)) ;
+                    unsigned char cb = (*(ptdata++)) ;
+
+                    if( ( cr !=r) || (cg!=g) || (cb!=b) )
+                    {
+                        *(ptbits++) = one;
+                        *(ptbits++) = one;
+                        *(ptbits++) = one;
+                    }
+                    else
+                    {
+                        *(ptbits++) = zero;
+                        *(ptbits++) = zero;
+                        *(ptbits++) = zero;
+                    }
+                }
+                for( i=0; i< padding; i++ )   *(ptbits++) = zero;
+            }
+            ::StretchDIBits( memdc, 0, origin, width, height,\
+                0, 0, width, height, lpBits, lpDIBh, DIB_RGB_COLORS, SRCCOPY);
+            origin += height;
+        }
+        // create a wxMask object
+        wxMask *mask = new wxMask();
+        mask->SetMaskBitmap( (WXHBITMAP) hbitmap );
+        SetMask( mask );
+        // It will be deleted when the wxBitmap object is deleted (as of 01/1999)
+        /* The following can also be used but is slow to run
+        wxColour colour( GetMaskRed(), GetMaskGreen(), GetMaskBlue());
+        wxMask *mask = new wxMask( *this, colour );
+        SetMask( mask );
+        */
+
+        ::SelectObject( memdc, hbmpOld );
+    }
+
+    // free allocated resources
+    ::DeleteDC( memdc );
+    ::ReleaseDC(NULL, hdc);
+    free(lpDIBh);
+    free(lpBits);
+
+#if WXWIN_COMPATIBILITY_2
+    // check the wxBitmap object
+    GetBitmapData()->SetOk();
+#endif // WXWIN_COMPATIBILITY_2
+
+    if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
+
+    return TRUE;
+}
+
+wxImage wxBitmap::ConvertToImage() const
+{
+    wxImage image;
+
+    wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
+
+    // create an wxImage object
+    int width = GetWidth();
+    int height = GetHeight();
+    image.Create( width, height );
+    unsigned char *data = image.GetData();
+    if( !data )
+    {
+        wxFAIL_MSG( wxT("could not allocate data for image") );
+        return wxNullImage;
+    }
+
+    // calc the number of bytes per scanline and padding in the DIB
+    int bytePerLine = width*3;
+    int sizeDWORD = sizeof( DWORD );
+    int lineBoundary =  bytePerLine % sizeDWORD;
+    int padding = 0;
+    if( lineBoundary > 0 )
+    {
+        padding = sizeDWORD - lineBoundary;
+        bytePerLine += padding;
+    }
+
+    // create a DIB header
+    int headersize = sizeof(BITMAPINFOHEADER);
+    BITMAPINFO *lpDIBh = (BITMAPINFO *) malloc( headersize );
+    if( !lpDIBh )
+    {
+        wxFAIL_MSG( wxT("could not allocate data for DIB header") );
+        free( data );
+        return wxNullImage;
+    }
+    // Fill in the DIB header
+    lpDIBh->bmiHeader.biSize = headersize;
+    lpDIBh->bmiHeader.biWidth = width;
+    lpDIBh->bmiHeader.biHeight = -height;
+    lpDIBh->bmiHeader.biSizeImage = bytePerLine * height;
+    lpDIBh->bmiHeader.biPlanes = 1;
+    lpDIBh->bmiHeader.biBitCount = 24;
+    lpDIBh->bmiHeader.biCompression = BI_RGB;
+    lpDIBh->bmiHeader.biClrUsed = 0;
+    // These seem not really needed for our purpose here.
+    lpDIBh->bmiHeader.biClrImportant = 0;
+    lpDIBh->bmiHeader.biXPelsPerMeter = 0;
+    lpDIBh->bmiHeader.biYPelsPerMeter = 0;
+    // memory for DIB data
+    unsigned char *lpBits;
+    lpBits = (unsigned char *) malloc( lpDIBh->bmiHeader.biSizeImage );
+    if( !lpBits )
+    {
+        wxFAIL_MSG( wxT("could not allocate data for DIB") );
+        free( data );
+        free( lpDIBh );
+        return wxNullImage;
+    }
+
+    // copy data from the device-dependent bitmap to the DIB
+    HDC hdc = ::GetDC(NULL);
+    HBITMAP hbitmap;
+    hbitmap = (HBITMAP) GetHBITMAP();
+    ::GetDIBits( hdc, hbitmap, 0, height, lpBits, lpDIBh, DIB_RGB_COLORS );
+
+    // copy DIB data into the wxImage object
+    int i, j;
+    unsigned char *ptdata = data;
+    unsigned char *ptbits = lpBits;
+    for( i=0; i<height; i++ )
+    {
+        for( j=0; j<width; j++ )
+        {
+            *(ptdata++) = *(ptbits+2);
+            *(ptdata++) = *(ptbits+1);
+            *(ptdata++) = *(ptbits  );
+            ptbits += 3;
+        }
+        ptbits += padding;
+    }
+
+    // similarly, set data according to the possible mask bitmap
+    if( GetMask() && GetMask()->GetMaskBitmap() )
+    {
+        hbitmap = (HBITMAP) GetMask()->GetMaskBitmap();
+        // memory DC created, color set, data copied, and memory DC deleted
+        HDC memdc = ::CreateCompatibleDC( hdc );
+        ::SetTextColor( memdc, RGB( 0, 0, 0 ) );
+        ::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++ )
+            {
+                if( *ptbits != 0 )
+                    ptdata += 3;
+                else
+                {
+                    *(ptdata++)  = r;
+                    *(ptdata++)  = g;
+                    *(ptdata++)  = b;
+                }
+                ptbits += 3;
+            }
+            ptbits += padding;
+        }
+        image.SetMaskColour( r, g, b );
+        image.SetMask( TRUE );
+    }
+    else
+    {
+        image.SetMask( FALSE );
+    }
+    // free allocated resources
+    ::ReleaseDC(NULL, hdc);
+    free(lpDIBh);
+    free(lpBits);
+
+    return image;
+}
+
+#endif // wxUSE_IMAGE
+
 bool wxBitmap::LoadFile(const wxString& filename, long type)
 {
     UnRef();
@@ -357,16 +736,20 @@ bool wxBitmap::LoadFile(const wxString& filename, long type)
 
         return handler->LoadFile(this, filename, type, -1, -1);
     }
+#if wxUSE_IMAGE
     else
     {
         wxImage image;
-        if ( !image.LoadFile( filename, type ) || !image.Ok() )
-            return FALSE;
-
-        *this = image.ConvertToBitmap();
+        if ( image.LoadFile( filename, type ) && image.Ok() )
+        {
+            *this = image.ConvertToBitmap();
 
-        return TRUE;
+            return TRUE;
+        }
     }
+#endif // wxUSE_IMAGE
+
+    return FALSE;
 }
 
 bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
@@ -377,8 +760,7 @@ bool wxBitmap::Create(void *data, long type, int width, int height, int depth)
 
     if ( !handler )
     {
-        wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for "
-                       "type %d defined."), type);
+        wxLogDebug(wxT("Failed to create bitmap: no bitmap handler for type %d defined."), type);
 
         return FALSE;
     }
@@ -396,15 +778,19 @@ bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *pal
     {
         return handler->SaveFile(this, filename, type, palette);
     }
+#if wxUSE_IMAGE
     else
     {
         // FIXME what about palette? shouldn't we use it?
         wxImage image( *this );
-        if (!image.Ok())
-            return FALSE;
-
-        return image.SaveFile( filename, type );
+        if ( image.Ok() )
+        {
+            return image.SaveFile(filename, type);
+        }
     }
+#endif // wxUSE_IMAGE
+
+    return FALSE;
 }
 
 // ----------------------------------------------------------------------------
@@ -577,15 +963,15 @@ wxMask::~wxMask()
 // Create a mask from a mono bitmap (copies the bitmap).
 bool wxMask::Create(const wxBitmap& bitmap)
 {
+    wxCHECK_MSG( bitmap.Ok() && bitmap.GetDepth() == 1, FALSE,
+                 _T("can't create mask from invalid or not monochrome bitmap") );
+
     if ( m_maskBitmap )
     {
         ::DeleteObject((HBITMAP) m_maskBitmap);
         m_maskBitmap = 0;
     }
-    if (!bitmap.Ok() || bitmap.GetDepth() != 1)
-    {
-        return FALSE;
-    }
+
     m_maskBitmap = (WXHBITMAP) CreateBitmap(
                                             bitmap.GetWidth(),
                                             bitmap.GetHeight(),
@@ -648,36 +1034,42 @@ bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
     HDC destDC = ::CreateCompatibleDC(NULL);
     if ( !srcDC || !destDC )
     {
-        wxLogLastError("CreateCompatibleDC");
+        wxLogLastError(wxT("CreateCompatibleDC"));
     }
 
-    if ( !::SelectObject(srcDC, GetHbitmapOf(bitmap)) )
+    bool ok = TRUE;
+
+    HGDIOBJ hbmpSrcOld = ::SelectObject(srcDC, GetHbitmapOf(bitmap));
+    if ( !hbmpSrcOld )
     {
-        wxLogLastError("SelectObject");
+        wxLogLastError(wxT("SelectObject"));
+
+        ok = FALSE;
     }
-    if ( !::SelectObject(destDC, (HBITMAP)m_maskBitmap) )
+
+    HGDIOBJ hbmpDstOld = ::SelectObject(destDC, (HBITMAP)m_maskBitmap);
+    if ( !hbmpDstOld )
     {
-        wxLogLastError("SelectObject");
+        wxLogLastError(wxT("SelectObject"));
+
+        ok = FALSE;
     }
 
     // this is not very efficient, but I can't think of a better way of doing
     // it
-    for ( int w = 0; w < width; w++ )
+    for ( int w = 0; ok && (w < width); w++ )
     {
-        for ( int h = 0; h < height; h++ )
+        for ( int h = 0; ok && (h < height); h++ )
         {
             COLORREF col = GetPixel(srcDC, w, h);
             if ( col == CLR_INVALID )
             {
-                wxLogLastError("GetPixel");
+                wxLogLastError(wxT("GetPixel"));
 
                 // doesn't make sense to continue
-                ::SelectObject(srcDC, 0);
-                ::DeleteDC(srcDC);
-                ::SelectObject(destDC, 0);
-                ::DeleteDC(destDC);
+                ok = FALSE;
 
-                return FALSE;
+                break;
             }
 
             if ( col == maskColour )
@@ -691,12 +1083,12 @@ bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
         }
     }
 
-    ::SelectObject(srcDC, 0);
+    ::SelectObject(srcDC, hbmpSrcOld);
     ::DeleteDC(srcDC);
-    ::SelectObject(destDC, 0);
+    ::SelectObject(destDC, hbmpDstOld);
     ::DeleteDC(destDC);
 
-    return TRUE;
+    return ok;
 }
 
 // ----------------------------------------------------------------------------
@@ -710,7 +1102,7 @@ bool wxBitmapHandler::Create(wxGDIImage *image,
 {
     wxBitmap *bitmap = wxDynamicCast(image, wxBitmap);
 
-    return bitmap ? Create(bitmap, data, width, height, depth) : FALSE;
+    return bitmap ? Create(bitmap, data, flags, width, height, depth) : FALSE;
 }
 
 bool wxBitmapHandler::Load(wxGDIImage *image,
@@ -832,13 +1224,13 @@ extern HBITMAP wxInvertMask(HBITMAP hbmpMask, int w, int h)
     HDC hdcDst = ::CreateCompatibleDC(NULL);
     if ( !hdcSrc || !hdcDst )
     {
-        wxLogLastError("CreateCompatibleDC");
+        wxLogLastError(wxT("CreateCompatibleDC"));
     }
 
     HBITMAP hbmpInvMask = ::CreateBitmap(w, h, 1, 1, 0);
     if ( !hbmpInvMask )
     {
-        wxLogLastError("CreateBitmap");
+        wxLogLastError(wxT("CreateBitmap"));
     }
 
     ::SelectObject(hdcSrc, hbmpMask);
@@ -847,7 +1239,7 @@ extern HBITMAP wxInvertMask(HBITMAP hbmpMask, int w, int h)
                    hdcSrc, 0, 0,
                    NOTSRCCOPY) )
     {
-        wxLogLastError("BitBlt");
+        wxLogLastError(wxT("BitBlt"));
     }
 
     ::DeleteDC(hdcSrc);