use C++ compiler for va_copy test, at least under IRIX the C99 C compiler has it...

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

diff --git a/src/dfb/bitmap.cpp b/src/dfb/bitmap.cpp
index 691898dc8e656a5a67c670e47619c0e19bf8ddb4..c6ebc605955678f8df4edca489ea8f99b5bc5a1b 100644 (file)
--- a/src/dfb/bitmap.cpp
+++ b/src/dfb/bitmap.cpp
@@ -24,123 +24,83 @@
 #include "wx/colour.h"
 #include "wx/image.h"
 
 #include "wx/colour.h"
 #include "wx/image.h"
 

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

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

-// Convert wxColour into it's quantized value in lower-precision
-// pixel format (needed for masking by colour).
-static wxColour wxQuantizeColour(const wxColour& clr, const wxBitmap& bmp)
-{
-#if 0
-    pixel_format_t *pf = bmp.GetMGLbitmap_t()->pf;
-
-    if ( pf->redAdjust == 0 && pf->greenAdjust == 0 && pf->blueAdjust == 0 )
-        return clr;
-    else
-        return wxColour((unsigned char)((clr.Red() >> pf->redAdjust) << pf->redAdjust),
-                        (unsigned char)((clr.Green() >> pf->greenAdjust) << pf->greenAdjust),
-                        (unsigned char)((clr.Blue() >> pf->blueAdjust) << pf->blueAdjust));
-#endif
-}
-
-
-//-----------------------------------------------------------------------------
-// wxMask
-//-----------------------------------------------------------------------------
-
-IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
-
-wxMask::wxMask() : m_bitmap(NULL)
+// pitch = stride = # of bytes between the start of N-th line and (N+1)-th line
+static void CopyPixelsAndSwapRGB(unsigned w, unsigned h,
+                                 const unsigned char *src,
+                                 unsigned src_pitch,
+                                 unsigned char *dst,
+                                 unsigned dst_pitch)

 {
 {

+    unsigned src_advance = src_pitch - 3 * w;
+    unsigned dst_advance = dst_pitch - 3 * w;
+    for ( unsigned y = 0; y < h; y++, src += src_advance, dst += dst_advance )
+    {
+        for ( unsigned x = 0; x < w; x++, src += 3, dst += 3 )
+        {
+            // copy with RGB -> BGR translation:
+            dst[0] = src[2];
+            dst[1] = src[1];
+            dst[2] = src[0];
+        }
+    }

 }
 
 }
 

-wxMask::wxMask(const wxBitmap& bitmap)
-    : m_bitmap(NULL)
-{
-    Create(bitmap);
-}
-
-wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
-    : m_bitmap(NULL)
-{
-    Create(bitmap, colour);
-}
-
-#if wxUSE_PALETTE
-wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
-    : m_bitmap(NULL)
-{
-    Create(bitmap, paletteIndex);
-}
-#endif // wxUSE_PALETTE
-
-wxMask::wxMask(const wxMask& mask)
-{
-    m_bitmap = mask.m_bitmap ? new wxBitmap(*mask.m_bitmap) : NULL;
-}
-
-wxMask::~wxMask()
-{
-    delete m_bitmap;
-}
-
-#warning "move this to common code"
-bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
+static void CopySurfaceToImage(const wxIDirectFBSurfacePtr& surface,
+                               const wxImage& image)

 {
 {

-    delete m_bitmap;
-    m_bitmap = NULL;
+    wxCHECK_RET( surface->GetPixelFormat() == DSPF_RGB24,
+                 _T("unexpected pixel format") );

 
 

-    wxColour clr(wxQuantizeColour(colour, bitmap));
+    wxIDirectFBSurface::Locked locked(surface, DSLF_READ);
+    wxCHECK_RET( locked.ptr, _T("failed to lock surface") );

 
 

-    wxImage imgSrc(bitmap.ConvertToImage());
-    imgSrc.SetMask(false);
-    wxImage image(imgSrc.ConvertToMono(clr.Red(), clr.Green(), clr.Blue()));
-    if ( !image.Ok() )
-        return false;
-
-    m_bitmap = new wxBitmap(image, 1);
-
-    return m_bitmap->Ok();
+    CopyPixelsAndSwapRGB(image.GetWidth(), image.GetHeight(),
+                         (unsigned char*)locked.ptr, locked.pitch,
+                         image.GetData(), image.GetWidth() * 3);

 }
 
 }
 

-#if wxUSE_PALETTE
-bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
+static void CopyImageToSurface(const wxImage& image,
+                               const wxIDirectFBSurfacePtr& surface)

 {
 {

-    unsigned char r,g,b;
-    wxPalette *pal = bitmap.GetPalette();
+    wxCHECK_RET( surface->GetPixelFormat() == DSPF_RGB24,
+                 _T("unexpected pixel format") );

 
 

-    wxCHECK_MSG( pal, false, wxT("Cannot create mask from bitmap without palette") );
+    wxIDirectFBSurface::Locked locked(surface, DSLF_WRITE);
+    wxCHECK_RET( locked.ptr, _T("failed to lock surface") );

 
 

-    pal->GetRGB(paletteIndex, &r, &g, &b);
-
-    return Create(bitmap, wxColour(r, g, b));
+    CopyPixelsAndSwapRGB(image.GetWidth(), image.GetHeight(),
+                         image.GetData(), image.GetWidth() * 3,
+                         (unsigned char*)locked.ptr, locked.pitch);

 }
 }

-#endif // wxUSE_PALETTE

 
 

-bool wxMask::Create(const wxBitmap& bitmap)
+// Creates a surface that will use wxImage's pixel data (RGB only)
+static wxIDirectFBSurfacePtr CreateSurfaceForImage(const wxImage& image)

 {
 {

-    delete m_bitmap;
-    m_bitmap = NULL;
-
-    wxCHECK_MSG( bitmap.Ok(), false, wxT("Invalid bitmap") );
-    wxCHECK_MSG( bitmap.GetDepth() == 1, false, wxT("Cannot create mask from colour bitmap") );
+    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") );

 
 

-    m_bitmap = new wxBitmap(bitmap);
-    return true;
-}
+    // 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
+    DFBSurfaceDescription desc;
+    desc.flags = (DFBSurfaceDescriptionFlags)
+        (DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT);
+    desc.caps = DSCAPS_NONE;
+    desc.width = image.GetWidth();
+    desc.height = image.GetHeight();
+    desc.pixelformat = DSPF_RGB24;

 
 

-const wxBitmap& wxMask::GetBitmap() const
-{
-    return m_bitmap ? *m_bitmap : wxNullBitmap;
+    return wxIDirectFB::Get()->CreateSurface(&desc);

 }
 
 }
 

-

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


@@ -158,15 +118,15 @@ public:
 
     wxBitmapRefData(const wxBitmapRefData& data)
     {
 
     wxBitmapRefData(const wxBitmapRefData& data)
     {

-        m_surface = wxDfbCloneSurface(data.m_surface,
-                                      wxDfbCloneSurface_NoPixels);
+        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_palette = data.m_palette ? new wxPalette(*data.m_palette) : NULL;
 #endif
     }
 
         m_mask = data.m_mask ? new wxMask(*data.m_mask) : NULL;
 #if wxUSE_PALETTE
         m_palette = data.m_palette ? new wxPalette(*data.m_palette) : NULL;
 #endif
     }
 

-    ~wxBitmapRefData()
+    virtual ~wxBitmapRefData()

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


@@ -174,10 +134,10 @@ public:
 #endif
     }
 
 #endif
     }
 

-    IDirectFBSurfacePtr m_surface;
-    wxMask             *m_mask;
+    wxIDirectFBSurfacePtr m_surface;
+    wxMask               *m_mask;

 #if wxUSE_PALETTE
 #if wxUSE_PALETTE

-    wxPalette          *m_palette;
+    wxPalette            *m_palette;

 #endif
 };
 
 #endif
 };
 


@@ -187,7 +147,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)


@@ -195,11 +155,23 @@ wxBitmap::wxBitmap(int width, int height, int depth)
     Create(width, height, depth);
 }
 
     Create(width, height, depth);
 }
 

+bool wxBitmap::Create(const wxIDirectFBSurfacePtr& surface)
+{
+    UnRef();
+
+    wxCHECK_MSG( surface, false, _T("invalid surface") );
+
+    m_refData = new wxBitmapRefData();
+    M_BITMAP->m_surface = surface;
+    return true;
+}
+

 bool wxBitmap::Create(int width, int height, int depth)
 {
     UnRef();
 
     wxCHECK_MSG( width > 0 && height > 0, false, wxT("invalid bitmap size") );
 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)(
 
     DFBSurfaceDescription desc;
     desc.flags = (DFBSurfaceDescriptionFlags)(


@@ -208,47 +180,71 @@ bool wxBitmap::Create(int width, int height, int depth)
     desc.width = width;
     desc.height = height;
 
     desc.width = width;
     desc.height = height;
 

-    IDirectFBSurfacePtr surface;
-    IDirectFBPtr dfb(wxTheApp->GetDirectFBInterface());
-    if ( !DFB_CALL( dfb->CreateSurface(dfb, &desc, &surface) ) )
-        return false;
-
-    m_refData = new wxBitmapRefData();
-    M_BITMAP->m_surface = surface;
-
-    return true;
+    return Create(wxIDirectFB::Get()->CreateSurface(&desc));

 }
 
 }
 

-#warning "FIXME: move this to common code"
-bool wxBitmap::CreateFromXpm(const char **bits)
+#if wxUSE_IMAGE
+wxBitmap::wxBitmap(const wxImage& image, int depth)

 {
 {

-    wxCHECK_MSG( bits != NULL, false, wxT("invalid bitmap data") );
+    wxCHECK_RET( image.Ok(), wxT("invalid image") );

 
 

-#if wxUSE_IMAGE && wxUSE_XPM
-    wxXPMDecoder decoder;
-    wxImage img = decoder.ReadData(bits);
-    wxCHECK_MSG( img.Ok(), false, wxT("invalid bitmap data") );
+    // create surface in screen's format:
+    if ( !Create(image.GetWidth(), image.GetHeight(), depth) )
+        return;

 
 

-    *this = wxBitmap(img);
+    // then copy the image to it:
+    wxIDirectFBSurfacePtr dst = M_BITMAP->m_surface;

 
 

-    return true;
-#else
-    wxFAIL_MSG( _T("creating bitmaps from XPMs not supported") );
-    return false;
-#endif // wxUSE_IMAGE && wxUSE_XPM
-}
+    if ( dst->GetPixelFormat() == DSPF_RGB24 )
+    {
+        CopyImageToSurface(image, dst);
+    }
+    else
+    {
+        // 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;
+    }

 
 

-#if wxUSE_IMAGE
-wxBitmap::wxBitmap(const wxImage& image, int depth)
-{
-    wxCHECK_RET( image.Ok(), wxT("invalid image") );
+    // FIXME: implement mask creation from image's mask (or alpha channel?)
+    wxASSERT_MSG( !image.HasMask(), _T("image masks are ignored for now") );

 }
 
 wxImage wxBitmap::ConvertToImage() const
 {
     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 
 }
 
 wxImage wxBitmap::ConvertToImage() const
 {
     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 

-    return wxNullImage; // FIXME
+    wxImage img(GetWidth(), GetHeight());
+    wxIDirectFBSurfacePtr src = M_BITMAP->m_surface;
+
+    if ( src->GetPixelFormat() == DSPF_RGB24 )
+    {
+        CopySurfaceToImage(src, img);
+    }
+    else
+    {
+        // 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
+    wxASSERT_MSG( GetMask() == NULL, _T("bitmap masks are ignored for now") );
+
+    return img;

 }
 #endif // wxUSE_IMAGE
 
 }
 #endif // wxUSE_IMAGE
 


@@ -260,17 +256,13 @@ wxBitmap::wxBitmap(const wxString &filename, wxBitmapType type)
 wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
 {
     wxCHECK_RET( depth == 1, wxT("can only create mono bitmap from XBM data") );
 wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
 {
     wxCHECK_RET( depth == 1, wxT("can only create mono bitmap from XBM data") );

-}

 
 

-bool wxBitmap::Ok() const
-{
-    return (m_refData != NULL && M_BITMAP->m_surface);
+    wxFAIL_MSG( _T("not implemented") );

 }
 
 }
 

-bool wxBitmap::operator==(const wxBitmap& bmp) const
+bool wxBitmap::IsOk() const

 {
 {

-    // FIXME: is this the right way to compare bitmaps?
-    return (m_refData == bmp.m_refData);
+    return (m_refData != NULL && M_BITMAP->m_surface);

 }
 
 int wxBitmap::GetHeight() const
 }
 
 int wxBitmap::GetHeight() const


@@ -278,7 +270,7 @@ int wxBitmap::GetHeight() const
     wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 
     int h = -1;
     wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 
     int h = -1;

-    DFB_CALL( M_BITMAP->m_surface->GetSize(M_BITMAP->m_surface, NULL, &h) );
+    M_BITMAP->m_surface->GetSize(NULL, &h);

     return h;
 }
 
     return h;
 }
 


@@ -287,7 +279,7 @@ int wxBitmap::GetWidth() const
     wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 
     int w = -1;
     wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 
     int w = -1;

-    DFB_CALL( M_BITMAP->m_surface->GetSize(M_BITMAP->m_surface, &w, NULL) );
+    M_BITMAP->m_surface->GetSize(&w, NULL);

     return w;
 }
 
     return w;
 }
 


@@ -295,7 +287,7 @@ int wxBitmap::GetDepth() const
 {
     wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 
 {
     wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
 

-    return wxDfbGetSurfaceDepth(M_BITMAP->m_surface);
+    return M_BITMAP->m_surface->GetDepth();

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


@@ -309,6 +301,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;
 }


@@ -328,6 +321,10 @@ wxBitmap wxBitmap::GetSubBitmap(const wxRect& rect) const
                  wxNullBitmap,
                  wxT("invalid bitmap or bitmap region") );
 
                  wxNullBitmap,
                  wxT("invalid bitmap or bitmap region") );
 

+    // NB: DirectFB subsurfaces share the same pixels buffer, so we must
+    //     clone the obtained subsurface
+    DFBRectangle r = { rect.x, rect.y, rect.width, rect.height };
+    return wxBitmap(M_BITMAP->m_surface->GetSubSurface(&r)->Clone());

 }
 
 #warning "to common code"
 }
 
 #warning "to common code"


@@ -342,7 +339,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


@@ -376,7 +373,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;
         }
     }


@@ -397,6 +394,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;
 


@@ -409,22 +407,25 @@ void wxBitmap::SetPalette(const wxPalette& palette)
 void wxBitmap::SetHeight(int height)
 {
     AllocExclusive();
 void wxBitmap::SetHeight(int height)
 {
     AllocExclusive();

-#warning "todo"
+
+    wxFAIL_MSG( _T("SetHeight not implemented") );

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

-#warning "todo"
+
+    wxFAIL_MSG( _T("SetWidth not implemented") );

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

-#warning "todo"
+
+    wxFAIL_MSG( _T("SetDepth not implemented") );

 }
 
 }
 

-IDirectFBSurfacePtr wxBitmap::GetDirectFBSurface() const
+wxIDirectFBSurfacePtr wxBitmap::GetDirectFBSurface() const

 {
     wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
 
 {
     wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );