Set/GetExpanderColumn() should use wxDataViewColumn, not unsigned int

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

diff --git a/src/dfb/bitmap.cpp b/src/dfb/bitmap.cpp
index 60e0a9e861f8c497ef3737a881c385fdf69b243f..0c245df509ce2db061cff161e81292c0ab9f417f 100644 (file)
--- a/src/dfb/bitmap.cpp
+++ b/src/dfb/bitmap.cpp
@@ -23,9 +23,7 @@
 #include "wx/bitmap.h"
 #include "wx/colour.h"
 #include "wx/image.h"
 #include "wx/bitmap.h"
 #include "wx/colour.h"
 #include "wx/image.h"

-
-#warning "move this to common"
-#include "wx/xpmdecod.h"
+#include "wx/rawbmp.h"

 
 #include "wx/dfb/private.h"
 
 
 #include "wx/dfb/private.h"
 


@@ -33,28 +31,217 @@
 // helpers
 //-----------------------------------------------------------------------------
 
 // helpers
 //-----------------------------------------------------------------------------
 

-// Creates a surface that will use wxImage's pixel data (RGB only)
-static wxIDirectFBSurfacePtr CreateSurfaceForImage(const wxImage& image)
+// NB: Most of this conversion code is needed because of differences between
+//     wxImage and wxDFB's wxBitmap representations:
+//     (1) wxImage uses RGB order, while DirectFB uses BGR
+//     (2) wxImage has alpha channel in a separate plane, while DirectFB puts
+//         all components into single BGRA plane
+
+// pitch = stride = # of bytes between the start of N-th line and (N+1)-th line
+// {Src,Dst}PixSize = # of bytes used to represent one pixel
+template<int SrcPixSize, int DstPixSize>
+static void CopyPixelsAndSwapRGB(unsigned w, unsigned h,
+                                 const unsigned char *src,
+                                 unsigned src_pitch,
+                                 unsigned char *dst,
+                                 unsigned dst_pitch)

 {
 {

-    wxCHECK_MSG( image.Ok(), NULL, _T("invalid image") );
-    // FIXME_DFB: implement alpha handling by merging alpha buffer with RGB
-    //            into a temporary RGBA surface
-    wxCHECK_MSG( !image.HasAlpha(), NULL, _T("alpha channel not supported") );
+    unsigned src_advance = src_pitch - SrcPixSize * w;
+    unsigned dst_advance = dst_pitch - DstPixSize * w;
+    for ( unsigned y = 0; y < h; y++, src += src_advance, dst += dst_advance )
+    {
+        for ( unsigned x = 0; x < w; x++, src += SrcPixSize, dst += DstPixSize )
+        {
+            // copy with RGB -> BGR translation:
+            dst[0] = src[2];
+            dst[1] = src[1];
+            dst[2] = src[0];
+        }
+    }
+}

 
 

+static void CopySurfaceToImage(const wxIDirectFBSurfacePtr& surface,
+                               wxImage& image)
+{
+    wxIDirectFBSurface::Locked locked(surface, DSLF_READ);
+    wxCHECK_RET( locked.ptr, "failed to lock surface" );
+
+    const unsigned width = image.GetWidth();
+    const unsigned height = image.GetHeight();
+    const DFBSurfacePixelFormat format = surface->GetPixelFormat();
+
+    // copy RGB data from the surface:
+    switch ( format )
+    {
+        case DSPF_RGB24:
+            CopyPixelsAndSwapRGB<3,3>
+            (
+                width, height,
+                (unsigned char*)locked.ptr, locked.pitch,
+                image.GetData(), width * 3
+            );
+            break;
+
+        case DSPF_RGB32:
+        case DSPF_ARGB:
+            CopyPixelsAndSwapRGB<4,3>
+            (
+                width, height,
+                (unsigned char*)locked.ptr, locked.pitch,
+                image.GetData(), width * 3
+            );
+            break;
+
+        default:
+            wxFAIL_MSG( "unexpected pixel format" );
+            return;
+    }
+
+    // extract alpha channel if the bitmap has it:
+    if ( format == DSPF_ARGB )
+    {
+        // create alpha plane:
+        image.SetAlpha();
+
+        // and copy alpha data to it:
+        const unsigned advance = locked.pitch - 4 * width;
+        unsigned char *alpha = image.GetAlpha();
+        // NB: "+3" is to get pointer to alpha component
+        const unsigned char *src = ((unsigned char*)locked.ptr) + 3;
+
+        for ( unsigned y = 0; y < height; y++, src += advance )
+            for ( unsigned x = 0; x < width; x++, src += 4 )
+                *(alpha++) = *src;
+    }
+}
+
+static void CopyImageToSurface(const wxImage& image,
+                               const wxIDirectFBSurfacePtr& surface)
+{
+    wxIDirectFBSurface::Locked locked(surface, DSLF_WRITE);
+    wxCHECK_RET( locked.ptr, "failed to lock surface" );
+
+    const unsigned width = image.GetWidth();
+    const unsigned height = image.GetHeight();
+    const DFBSurfacePixelFormat format = surface->GetPixelFormat();
+
+    // copy RGB data to the surface:
+    switch ( format )
+    {
+        case DSPF_RGB24:
+            CopyPixelsAndSwapRGB<3,3>
+            (
+               width, height,
+               image.GetData(), width * 3,
+               (unsigned char*)locked.ptr, locked.pitch
+            );
+            break;
+
+        case DSPF_RGB32:
+        case DSPF_ARGB:
+            CopyPixelsAndSwapRGB<3,4>
+            (
+               width, height,
+               image.GetData(), width * 3,
+               (unsigned char*)locked.ptr, locked.pitch
+            );
+            break;
+
+        default:
+            wxFAIL_MSG( "unexpected pixel format" );
+            return;
+    }
+
+    // if the image has alpha channel, merge it in:
+    if ( format == DSPF_ARGB )
+    {
+        wxCHECK_RET( image.HasAlpha(), "logic error - ARGB, but no alpha" );
+
+        const unsigned advance = locked.pitch - 4 * width;
+        const unsigned char *alpha = image.GetAlpha();
+        // NB: "+3" is to get pointer to alpha component
+        unsigned char *dest = ((unsigned char*)locked.ptr) + 3;
+
+        for ( unsigned y = 0; y < height; y++, dest += advance )
+            for ( unsigned x = 0; x < width; x++, dest += 4 )
+                *dest = *(alpha++);
+    }
+}
+
+static wxIDirectFBSurfacePtr
+CreateSurfaceWithFormat(int w, int h, DFBSurfacePixelFormat format)
+{

     DFBSurfaceDescription desc;
     desc.flags = (DFBSurfaceDescriptionFlags)
     DFBSurfaceDescription desc;
     desc.flags = (DFBSurfaceDescriptionFlags)

-        (DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT |
-         DSDESC_PREALLOCATED);
+        (DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT);

     desc.caps = DSCAPS_NONE;
     desc.caps = DSCAPS_NONE;

-    desc.width = image.GetWidth();
-    desc.height = image.GetHeight();
-    desc.pixelformat = DSPF_RGB24;
-    desc.preallocated[0].data = image.GetData();
-    desc.preallocated[0].pitch = 3 * desc.width;
+    desc.width = w;
+    desc.height = h;
+
+    if ( format != DSPF_UNKNOWN )
+    {
+        desc.flags = (DFBSurfaceDescriptionFlags)(
+                            desc.flags | DSDESC_PIXELFORMAT);
+        desc.pixelformat = format;
+    }

 
     return wxIDirectFB::Get()->CreateSurface(&desc);
 }
 
 
     return wxIDirectFB::Get()->CreateSurface(&desc);
 }
 

+// Creates a surface that will use wxImage's pixel data (RGB only)
+static wxIDirectFBSurfacePtr CreateSurfaceForImage(const wxImage& image)
+{
+    wxCHECK_MSG( image.Ok(), NULL, "invalid image" );
+    // FIXME_DFB: implement alpha handling by merging alpha buffer with RGB
+    //            into a temporary RGBA surface
+    wxCHECK_MSG( !image.HasAlpha(), NULL, "alpha channel not supported" );
+
+    // NB: wxImage uses RGB order of bytes while DirectFB uses BGR, so we
+    //     cannot use preallocated surface that shares data with wxImage, we
+    //     have to copy the data to temporary surface instead
+    return CreateSurfaceWithFormat(image.GetWidth(), image.GetHeight(),
+                                   DSPF_RGB24);
+}
+
+static bool ConvertSurfaceToFormat(wxIDirectFBSurfacePtr& surface,
+                                   DFBSurfacePixelFormat format)
+{
+    if ( surface->GetPixelFormat() == format )
+        return true;
+
+    int w, h;
+    surface->GetSize(&w, &h);
+    wxIDirectFBSurfacePtr s = CreateSurfaceWithFormat(w, h, format);
+    if ( !s )
+        return false;
+
+    if ( !s->SetBlittingFlags(DSBLIT_NOFX) )
+        return false;
+    if ( !s->Blit(surface->GetRaw(), NULL, 0, 0) )
+        return false;
+
+    surface = s;
+    return true;
+}
+
+static DFBSurfacePixelFormat DepthToFormat(int depth)
+{
+    switch ( depth )
+    {
+        case 24:
+            return DSPF_RGB24;
+        case 32:
+            // NB: we treat depth=32 as requesting ARGB for consistency with
+            //     other ports
+            return DSPF_ARGB;
+        default:
+            wxFAIL_MSG( "unsupported depth requested" );
+            // fall through
+        case -1:
+            return DSPF_UNKNOWN;
+    }
+}
+

 //-----------------------------------------------------------------------------
 // wxBitmapRefData
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // wxBitmapRefData
 //-----------------------------------------------------------------------------


@@ -72,8 +259,7 @@ public:
 
     wxBitmapRefData(const wxBitmapRefData& data)
     {
 
     wxBitmapRefData(const wxBitmapRefData& data)
     {

-        if ( data.m_surface )
-            m_surface = data.m_surface->Clone();
+        m_surface = data.m_surface ? data.m_surface->Clone() : NULL;

 
         m_mask = data.m_mask ? new wxMask(*data.m_mask) : NULL;
 #if wxUSE_PALETTE
 
         m_mask = data.m_mask ? new wxMask(*data.m_mask) : NULL;
 #if wxUSE_PALETTE


@@ -81,7 +267,7 @@ public:
 #endif
     }
 
 #endif
     }
 

-    ~wxBitmapRefData()
+    virtual ~wxBitmapRefData()

     {
         delete m_mask;
 #if wxUSE_PALETTE
     {
         delete m_mask;
 #if wxUSE_PALETTE


@@ -102,7 +288,7 @@ public:
 // wxBitmap
 //-----------------------------------------------------------------------------
 
 // wxBitmap
 //-----------------------------------------------------------------------------
 

-IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxObject)
+IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)

 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxBitmapBase)
 
 wxBitmap::wxBitmap(int width, int height, int depth)
 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxBitmapBase)
 
 wxBitmap::wxBitmap(int width, int height, int depth)


@@ -114,7 +300,7 @@ bool wxBitmap::Create(const wxIDirectFBSurfacePtr& surface)
 {
     UnRef();
 
 {
     UnRef();
 

-    wxCHECK_MSG( surface, false, _T("invalid surface") );
+    wxCHECK_MSG( surface, false, "invalid surface" );

 
     m_refData = new wxBitmapRefData();
     M_BITMAP->m_surface = surface;
 
     m_refData = new wxBitmapRefData();
     M_BITMAP->m_surface = surface;


@@ -123,38 +309,17 @@ bool wxBitmap::Create(const wxIDirectFBSurfacePtr& surface)
 
 bool wxBitmap::Create(int width, int height, int depth)
 {
 
 bool wxBitmap::Create(int width, int height, int depth)
 {

-    UnRef();
-
-    wxCHECK_MSG( width > 0 && height > 0, false, wxT("invalid bitmap size") );
-    wxCHECK_MSG( depth == -1, false, wxT("only default depth supported now") );
-
-    DFBSurfaceDescription desc;
-    desc.flags = (DFBSurfaceDescriptionFlags)(
-                        DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT);
-    desc.caps = DSCAPS_NONE;
-    desc.width = width;
-    desc.height = height;
-
-    return Create(wxIDirectFB::Get()->CreateSurface(&desc));
+    return CreateWithFormat(width, height, DepthToFormat(depth));

 }
 
 }
 

-#warning "FIXME: move this to common code"
-bool wxBitmap::CreateFromXpm(const char **bits)
+bool wxBitmap::CreateWithFormat(int width, int height, int dfbFormat)

 {
 {

-    wxCHECK_MSG( bits != NULL, false, wxT("invalid bitmap data") );
-
-#if wxUSE_IMAGE && wxUSE_XPM
-    wxXPMDecoder decoder;
-    wxImage img = decoder.ReadData(bits);
-    wxCHECK_MSG( img.Ok(), false, wxT("invalid bitmap data") );
+    UnRef();

 
 

-    *this = wxBitmap(img);
+    wxCHECK_MSG( width > 0 && height > 0, false, wxT("invalid bitmap size") );

 
 

-    return true;
-#else
-    wxFAIL_MSG( _T("creating bitmaps from XPMs not supported") );
-    return false;
-#endif // wxUSE_IMAGE && wxUSE_XPM
+    return Create(CreateSurfaceWithFormat(width, height,
+                                          DFBSurfacePixelFormat(dfbFormat)));

 }
 
 #if wxUSE_IMAGE
 }
 
 #if wxUSE_IMAGE


@@ -162,21 +327,42 @@ wxBitmap::wxBitmap(const wxImage& image, int depth)
 {
     wxCHECK_RET( image.Ok(), wxT("invalid image") );
 
 {
     wxCHECK_RET( image.Ok(), wxT("invalid image") );
 

-    // create surface in screen's format:
-    if ( !Create(image.GetWidth(), image.GetHeight(), depth) )
+    DFBSurfacePixelFormat format = DepthToFormat(depth);
+    if ( format == DSPF_UNKNOWN && image.HasAlpha() )
+        format = DSPF_ARGB;
+
+    // create surface in screen's format (unless we need alpha channel,
+    // in which case use ARGB):
+    if ( !CreateWithFormat(image.GetWidth(), image.GetHeight(), format) )

         return;
 
     // then copy the image to it:
         return;
 
     // then copy the image to it:

-    wxIDirectFBSurfacePtr src(CreateSurfaceForImage(image));

     wxIDirectFBSurfacePtr dst = M_BITMAP->m_surface;
 
     wxIDirectFBSurfacePtr dst = M_BITMAP->m_surface;
 

-    if ( !dst->SetBlittingFlags(DSBLIT_NOFX) )
-        return;
-    if ( !dst->Blit(src->GetRaw(), NULL, 0, 0) )
-        return;
+    switch ( dst->GetPixelFormat() )
+    {
+        case DSPF_RGB24:
+        case DSPF_RGB32:
+        case DSPF_ARGB:
+            CopyImageToSurface(image, dst);
+            break;
+
+        default:
+        {
+            // wxBitmap uses different pixel format, so we have to use a
+            // temporary surface and blit to the bitmap via it:
+            wxIDirectFBSurfacePtr src(CreateSurfaceForImage(image));
+            CopyImageToSurface(image, src);
+
+            if ( !dst->SetBlittingFlags(DSBLIT_NOFX) )
+                return;
+            if ( !dst->Blit(src->GetRaw(), NULL, 0, 0) )
+                return;
+        }
+    }

 
     // FIXME: implement mask creation from image's mask (or alpha channel?)
 
     // FIXME: implement mask creation from image's mask (or alpha channel?)

-    wxASSERT_MSG( !image.HasMask(), _T("image masks are ignored for now") );
+    wxASSERT_MSG( !image.HasMask(), "image masks are ignored for now" );

 }
 
 wxImage wxBitmap::ConvertToImage() const
 }
 
 wxImage wxBitmap::ConvertToImage() const


@@ -184,21 +370,82 @@ wxImage wxBitmap::ConvertToImage() const
     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 
     wxImage img(GetWidth(), GetHeight());
     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 
     wxImage img(GetWidth(), GetHeight());

-    wxIDirectFBSurfacePtr dst(CreateSurfaceForImage(img));

     wxIDirectFBSurfacePtr src = M_BITMAP->m_surface;
 
     wxIDirectFBSurfacePtr src = M_BITMAP->m_surface;
 

-    if ( !dst->SetBlittingFlags(DSBLIT_NOFX) )
-        return wxNullImage;
-    if ( !dst->Blit(src->GetRaw(), NULL, 0, 0) )
-        return wxNullImage;
+    switch ( src->GetPixelFormat() )
+    {
+        case DSPF_RGB24:
+        case DSPF_RGB32:
+        case DSPF_ARGB:
+            CopySurfaceToImage(src, img);
+            break;
+        default:
+        {
+            // wxBitmap uses different pixel format, so we have to use a
+            // temporary surface and blit to the bitmap via it:
+            wxIDirectFBSurfacePtr dst(CreateSurfaceForImage(img));
+
+            if ( !dst->SetBlittingFlags(DSBLIT_NOFX) )
+                return wxNullImage;
+            if ( !dst->Blit(src->GetRaw(), NULL, 0, 0) )
+                return wxNullImage;
+
+            CopySurfaceToImage(dst, img);
+        }
+    }

 
     // FIXME: implement mask setting in the image
 
     // FIXME: implement mask setting in the image

-    wxASSERT_MSG( GetMask() == NULL, _T("bitmap masks are ignored for now") );
+    wxASSERT_MSG( GetMask() == NULL, "bitmap masks are ignored for now" );

 
     return img;
 }
 #endif // wxUSE_IMAGE
 
 
     return img;
 }
 #endif // wxUSE_IMAGE
 

+void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
+{
+    wxCHECK_MSG( Ok(), NULL, "invalid bitmap" );
+
+    AllocExclusive();
+
+    DFBSurfacePixelFormat format;
+    if ( bpp == 32 )
+        format = DSPF_ARGB;
+    else
+        format = DSPF_RGB24;
+
+    // convert the bitmap into format compatible with requested raw access;
+    // note that we don't bother converting the bitmap back in UngetRawData(),
+    // as unpacked formats (RGB24, RGB32) are the common case and converting
+    // between them while blitting is fast enough (FIXME?)
+    if ( !ConvertSurfaceToFormat(M_BITMAP->m_surface, format) )
+        return NULL;
+
+    void *bits = NULL;
+    if ( !M_BITMAP->m_surface->Lock
+                               (
+                                 (DFBSurfaceLockFlags)(DSLF_READ | DSLF_WRITE),
+                                 &bits,
+                                 &data.m_stride
+                               ) )
+        return NULL;
+
+    M_BITMAP->m_surface->GetSize(&data.m_width, &data.m_height);
+
+    return bits;
+}
+
+void wxBitmap::UngetRawData(wxPixelDataBase& WXUNUSED(data))
+{
+    M_BITMAP->m_surface->Unlock();
+}
+
+bool wxBitmap::HasAlpha() const
+{
+    wxCHECK_MSG( Ok(), false, "invalid bitmap" );
+
+    return M_BITMAP->m_surface->GetPixelFormat() == DSPF_ARGB;
+}
+

 wxBitmap::wxBitmap(const wxString &filename, wxBitmapType type)
 {
     LoadFile(filename, type);
 wxBitmap::wxBitmap(const wxString &filename, wxBitmapType type)
 {
     LoadFile(filename, type);


@@ -208,20 +455,14 @@ wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
 {
     wxCHECK_RET( depth == 1, wxT("can only create mono bitmap from XBM data") );
 
 {
     wxCHECK_RET( depth == 1, wxT("can only create mono bitmap from XBM data") );
 

-    wxFAIL_MSG( _T("not implemented") );
+    wxFAIL_MSG( "not implemented" );

 }
 
 }
 

-bool wxBitmap::Ok() const
+bool wxBitmap::IsOk() const

 {
     return (m_refData != NULL && M_BITMAP->m_surface);
 }
 
 {
     return (m_refData != NULL && M_BITMAP->m_surface);
 }
 

-bool wxBitmap::operator==(const wxBitmap& bmp) const
-{
-    // FIXME: is this the right way to compare bitmaps?
-    return (m_refData == bmp.m_refData);
-}
-

 int wxBitmap::GetHeight() const
 {
     wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 int wxBitmap::GetHeight() const
 {
     wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );


@@ -258,6 +499,7 @@ void wxBitmap::SetMask(wxMask *mask)
 {
     wxCHECK_RET( Ok(), wxT("invalid bitmap") );
 
 {
     wxCHECK_RET( Ok(), wxT("invalid bitmap") );
 

+    AllocExclusive();

     delete M_BITMAP->m_mask;
     M_BITMAP->m_mask = mask;
 }
     delete M_BITMAP->m_mask;
     M_BITMAP->m_mask = mask;
 }


@@ -295,7 +537,7 @@ bool wxBitmap::LoadFile(const wxString &name, wxBitmapType type)
         wxImage image;
         if ( !image.LoadFile(name, type) || !image.Ok() )
         {
         wxImage image;
         if ( !image.LoadFile(name, type) || !image.Ok() )
         {

-            wxLogError("no bitmap handler for type %d defined.", type);
+            wxLogError(_("No bitmap handler for type %d defined."), type);

             return false;
         }
         else
             return false;
         }
         else


@@ -329,7 +571,7 @@ bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type, const wxPal
             return image.SaveFile(filename, type);
         else
         {
             return image.SaveFile(filename, type);
         else
         {

-            wxLogError("no bitmap handler for type %d defined.", type);
+            wxLogError(_("No bitmap handler for type %d defined."), type);

             return false;
         }
     }
             return false;
         }
     }


@@ -350,6 +592,7 @@ void wxBitmap::SetPalette(const wxPalette& palette)
     wxCHECK_RET( Ok(), wxT("invalid bitmap") );
     wxCHECK_RET( GetDepth() > 1 && GetDepth() <= 8, wxT("cannot set palette for bitmap of this depth") );
 
     wxCHECK_RET( Ok(), wxT("invalid bitmap") );
     wxCHECK_RET( GetDepth() > 1 && GetDepth() <= 8, wxT("cannot set palette for bitmap of this depth") );
 

+    AllocExclusive();

     delete M_BITMAP->m_palette;
     M_BITMAP->m_palette = NULL;
 
     delete M_BITMAP->m_palette;
     M_BITMAP->m_palette = NULL;
 


@@ -363,21 +606,35 @@ void wxBitmap::SetHeight(int height)
 {
     AllocExclusive();
 
 {
     AllocExclusive();
 

-    wxFAIL_MSG( _T("SetHeight not implemented") );
+    wxFAIL_MSG( "SetHeight not implemented" );

 }
 
 void wxBitmap::SetWidth(int width)
 {
     AllocExclusive();
 
 }
 
 void wxBitmap::SetWidth(int width)
 {
     AllocExclusive();
 

-    wxFAIL_MSG( _T("SetWidth not implemented") );
+    wxFAIL_MSG( "SetWidth not implemented" );

 }
 
 void wxBitmap::SetDepth(int depth)
 {
 }
 
 void wxBitmap::SetDepth(int depth)
 {

+    DFBSurfacePixelFormat format = DepthToFormat(depth);
+    if ( M_BITMAP->m_surface->GetPixelFormat() == format )
+        return;
+

     AllocExclusive();
 
     AllocExclusive();
 

-    wxFAIL_MSG( _T("SetDepth not implemented") );
+    int w, h;
+    M_BITMAP->m_surface->GetSize(&w, &h);
+    wxIDirectFBSurfacePtr s = CreateSurfaceWithFormat(w, h, format);
+    if ( !s )
+        return;
+    if ( !s->SetBlittingFlags(DSBLIT_NOFX) )
+        return;
+    if ( !s->Blit(M_BITMAP->m_surface->GetRaw(), NULL, 0, 0) )
+        return;
+
+    M_BITMAP->m_surface = s;

 }
 
 wxIDirectFBSurfacePtr wxBitmap::GetDirectFBSurface() const
 }
 
 wxIDirectFBSurfacePtr wxBitmap::GetDirectFBSurface() const