#include "wx/colour.h"
#include "wx/image.h"
-#warning "move this to common"
-#include "wx/xpmdecod.h"
-
#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)
-{
-}
-
-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)
-{
- delete m_bitmap;
- m_bitmap = NULL;
-
- wxColour clr(wxQuantizeColour(colour, bitmap));
-
- 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();
-}
-
-#if wxUSE_PALETTE
-bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
-{
- unsigned char r,g,b;
- wxPalette *pal = bitmap.GetPalette();
-
- wxCHECK_MSG( pal, false, wxT("Cannot create mask from bitmap without palette") );
-
- pal->GetRGB(paletteIndex, &r, &g, &b);
-
- return Create(bitmap, wxColour(r, g, b));
-}
-#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( 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") );
- wxCHECK_MSG( bitmap.Ok(), false, wxT("Invalid bitmap") );
- wxCHECK_MSG( bitmap.GetDepth() == 1, false, wxT("Cannot create mask from colour bitmap") );
+ DFBSurfaceDescription desc;
+ desc.flags = (DFBSurfaceDescriptionFlags)
+ (DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT |
+ DSDESC_PREALLOCATED);
+ 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;
- m_bitmap = new wxBitmap(bitmap);
- return true;
+ return wxIDirectFB::Get()->CreateSurface(&desc);
}
-const wxBitmap& wxMask::GetBitmap() const
-{
- return m_bitmap ? *m_bitmap : wxNullBitmap;
-}
-
-
//-----------------------------------------------------------------------------
// wxBitmapRefData
//-----------------------------------------------------------------------------
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
}
- ~wxBitmapRefData()
+ virtual ~wxBitmapRefData()
{
delete m_mask;
#if wxUSE_PALETTE
#endif
}
- IDirectFBSurfacePtr m_surface;
- wxMask *m_mask;
+ wxIDirectFBSurfacePtr m_surface;
+ wxMask *m_mask;
#if wxUSE_PALETTE
- wxPalette *m_palette;
+ wxPalette *m_palette;
#endif
};
// wxBitmap
//-----------------------------------------------------------------------------
-IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxObject)
+IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)
IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxBitmapBase)
wxBitmap::wxBitmap(int width, int height, int 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") );
+ wxCHECK_MSG( depth == -1, false, wxT("only default depth supported now") );
DFBSurfaceDescription desc;
desc.flags = (DFBSurfaceDescriptionFlags)(
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 src(CreateSurfaceForImage(image));
+ 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->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") );
- return wxNullImage; // FIXME
+ wxImage img(GetWidth(), GetHeight());
+ wxIDirectFBSurfacePtr dst(CreateSurfaceForImage(img));
+ wxIDirectFBSurfacePtr src = M_BITMAP->m_surface;
+
+ if ( !dst->SetBlittingFlags(DSBLIT_NOFX) )
+ return wxNullImage;
+ if ( !dst->Blit(src->GetRaw(), NULL, 0, 0) )
+ return wxNullImage;
+
+ // FIXME: implement mask setting in the image
+ wxASSERT_MSG( GetMask() == NULL, _T("bitmap masks are ignored for now") );
+
+ return img;
}
#endif // wxUSE_IMAGE
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
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;
}
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;
}
{
wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
- return wxDfbGetSurfaceDepth(M_BITMAP->m_surface);
+ return M_BITMAP->m_surface->GetDepth();
}
wxMask *wxBitmap::GetMask() const
{
wxCHECK_RET( Ok(), wxT("invalid bitmap") );
+ AllocExclusive();
delete M_BITMAP->m_mask;
M_BITMAP->m_mask = mask;
}
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"
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;
void wxBitmap::SetHeight(int height)
{
AllocExclusive();
-#warning "todo"
+
+ wxFAIL_MSG( _T("SetHeight not implemented") );
}
void wxBitmap::SetWidth(int width)
{
AllocExclusive();
-#warning "todo"
+
+ wxFAIL_MSG( _T("SetWidth not implemented") );
}
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") );
projects / wxWidgets.git / blobdiff