don't refresh the current cell in SetCellHighlightROPenWidth() if it's invalid (...

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

diff --git a/src/dfb/bitmap.cpp b/src/dfb/bitmap.cpp
index 6d4b5b0acb1819b304f44946472f1e6b7c77ec27..91684bdad393c0e1f60892cb54c06938ed91fb79 100644 (file)
--- a/src/dfb/bitmap.cpp
+++ b/src/dfb/bitmap.cpp
@@ -64,7 +64,7 @@ static void CopySurfaceToImage(const wxIDirectFBSurfacePtr& surface,
                                wxImage& image)
 {
     wxIDirectFBSurface::Locked locked(surface, DSLF_READ);
                                wxImage& image)
 {
     wxIDirectFBSurface::Locked locked(surface, DSLF_READ);

-    wxCHECK_RET( locked.ptr, _T("failed to lock surface") );
+    wxCHECK_RET( locked.ptr, "failed to lock surface" );

 
     const unsigned width = image.GetWidth();
     const unsigned height = image.GetHeight();
 
     const unsigned width = image.GetWidth();
     const unsigned height = image.GetHeight();


@@ -173,11 +173,17 @@ 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_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT);

     desc.caps = DSCAPS_NONE;
     desc.width = w;
     desc.height = h;
     desc.caps = DSCAPS_NONE;
     desc.width = w;
     desc.height = h;

-    desc.pixelformat = format;
+
+    if ( format != DSPF_UNKNOWN )
+    {
+        desc.flags = (DFBSurfaceDescriptionFlags)(
+                            desc.flags | DSDESC_PIXELFORMAT);
+        desc.pixelformat = format;
+    }

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


@@ -185,10 +191,10 @@ CreateSurfaceWithFormat(int w, int h, DFBSurfacePixelFormat format)
 // Creates a surface that will use wxImage's pixel data (RGB only)
 static wxIDirectFBSurfacePtr CreateSurfaceForImage(const wxImage& image)
 {
 // Creates a surface that will use wxImage's pixel data (RGB only)
 static wxIDirectFBSurfacePtr CreateSurfaceForImage(const wxImage& image)
 {

-    wxCHECK_MSG( image.Ok(), NULL, _T("invalid image") );
+    wxCHECK_MSG( image.Ok(), NULL, "invalid image" );

     // FIXME_DFB: implement alpha handling by merging alpha buffer with RGB
     //            into a temporary RGBA surface
     // 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") );
+    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
 
     // NB: wxImage uses RGB order of bytes while DirectFB uses BGR, so we
     //     cannot use preallocated surface that shares data with wxImage, we


@@ -197,11 +203,50 @@ static wxIDirectFBSurfacePtr CreateSurfaceForImage(const wxImage& image)
                                    DSPF_RGB24);
 }
 
                                    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
 //-----------------------------------------------------------------------------
 

-class wxBitmapRefData: public wxObjectRefData
+class wxBitmapRefData: public wxGDIRefData

 {
 public:
     wxBitmapRefData()
 {
 public:
     wxBitmapRefData()


@@ -230,6 +275,8 @@ public:
 #endif
     }
 
 #endif
     }
 

+    virtual bool IsOk() const { return m_surface; }
+

     wxIDirectFBSurfacePtr m_surface;
     wxMask               *m_mask;
 #if wxUSE_PALETTE
     wxIDirectFBSurfacePtr m_surface;
     wxMask               *m_mask;
 #if wxUSE_PALETTE


@@ -243,7 +290,6 @@ public:
 // wxBitmap
 //-----------------------------------------------------------------------------
 
 // wxBitmap
 //-----------------------------------------------------------------------------
 

-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)


@@ -255,7 +301,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;


@@ -264,9 +310,7 @@ bool wxBitmap::Create(const wxIDirectFBSurfacePtr& surface)
 
 bool wxBitmap::Create(int width, int height, int depth)
 {
 
 bool wxBitmap::Create(int width, int height, int depth)
 {

-    wxCHECK_MSG( depth == -1, false, wxT("only default depth supported now") );
-
-    return CreateWithFormat(width, height, -1);
+    return CreateWithFormat(width, height, DepthToFormat(depth));

 }
 
 bool wxBitmap::CreateWithFormat(int width, int height, int dfbFormat)
 }
 
 bool wxBitmap::CreateWithFormat(int width, int height, int dfbFormat)


@@ -275,33 +319,29 @@ bool wxBitmap::CreateWithFormat(int width, int height, int dfbFormat)
 
     wxCHECK_MSG( width > 0 && height > 0, false, wxT("invalid bitmap size") );
 
 
     wxCHECK_MSG( width > 0 && height > 0, false, wxT("invalid bitmap size") );
 

-    DFBSurfaceDescription desc;
-    desc.flags = (DFBSurfaceDescriptionFlags)(
-                        DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT);
-    desc.caps = DSCAPS_NONE;
-    desc.width = width;
-    desc.height = height;
-
-    if ( dfbFormat != -1 )
-    {
-        desc.flags = (DFBSurfaceDescriptionFlags)(
-                            desc.flags | DSDESC_PIXELFORMAT);
-        desc.pixelformat = (DFBSurfacePixelFormat)dfbFormat;
-    }
-
-    return Create(wxIDirectFB::Get()->CreateSurface(&desc));
+    return Create(CreateSurfaceWithFormat(width, height,
+                                          DFBSurfacePixelFormat(dfbFormat)));

 }
 
 #if wxUSE_IMAGE
 }
 
 #if wxUSE_IMAGE

-wxBitmap::wxBitmap(const wxImage& image, int depth)
+wxBitmap::wxBitmap(const wxImage& imageOrig, int depth)

 {
 {

-    wxCHECK_RET( image.Ok(), wxT("invalid image") );
-    wxCHECK_RET( depth == -1, wxT("only default depth supported now") );
+    wxCHECK_RET( imageOrig.Ok(), wxT("invalid image") );
+
+    wxImage image(imageOrig);
+
+    // convert mask to alpha channel, because wxMask isn't implemented yet
+    // FIXME: don't do this, implement proper wxMask support
+    if ( image.HasMask() )
+        image.InitAlpha();
+
+    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):
 
     // create surface in screen's format (unless we need alpha channel,
     // in which case use ARGB):

-    if ( !CreateWithFormat(image.GetWidth(), image.GetHeight(),
-                           image.HasAlpha() ? DSPF_ARGB : -1) )
+    if ( !CreateWithFormat(image.GetWidth(), image.GetHeight(), format) )

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


@@ -328,9 +368,6 @@ wxBitmap::wxBitmap(const wxImage& image, int depth)
                 return;
         }
     }
                 return;
         }
     }

-
-    // 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
 }
 
 wxImage wxBitmap::ConvertToImage() const


@@ -363,7 +400,7 @@ wxImage wxBitmap::ConvertToImage() const
     }
 
     // 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;
 }
 
     return img;
 }


@@ -381,8 +418,11 @@ void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
     else
         format = DSPF_RGB24;
 
     else
         format = DSPF_RGB24;
 

-    // requested format is not what this bitmap uses
-    if ( format != M_BITMAP->m_surface->GetPixelFormat() )
+    // 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;
         return NULL;
 
     void *bits = NULL;


@@ -420,12 +460,7 @@ 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") );
-}
-
-bool wxBitmap::IsOk() const
-{
-    return (m_refData != NULL && M_BITMAP->m_surface);
+    wxFAIL_MSG( "not implemented" );

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


@@ -571,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


@@ -595,12 +644,12 @@ wxIDirectFBSurfacePtr wxBitmap::GetDirectFBSurface() const
     return M_BITMAP->m_surface;
 }
 
     return M_BITMAP->m_surface;
 }
 

-wxObjectRefData *wxBitmap::CreateRefData() const
+wxGDIRefData *wxBitmap::CreateGDIRefData() const

 {
     return new wxBitmapRefData;
 }
 
 {
     return new wxBitmapRefData;
 }
 

-wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxBitmap::CloneGDIRefData(const wxGDIRefData *data) const

 {
     return new wxBitmapRefData(*(wxBitmapRefData *)data);
 }
 {
     return new wxBitmapRefData(*(wxBitmapRefData *)data);
 }