#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"
//-----------------------------------------------------------------------------
-// helpers
+// helpers for translating between wx and DFB pixel formats
//-----------------------------------------------------------------------------
-// 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)
+namespace
{
-#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
+// 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>
+void CopyPixelsAndSwapRGB(unsigned w, unsigned h,
+ const unsigned char *src,
+ unsigned src_pitch,
+ unsigned char *dst,
+ unsigned dst_pitch)
+{
+ 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];
+ }
+ }
}
+void CopySurfaceToImage(const wxIDirectFBSurfacePtr& surface, wxImage& image)
+{
+ wxIDirectFBSurface::Locked locked(surface, DSLF_READ);
+ wxCHECK_RET( locked.ptr, "failed to lock surface" );
-//-----------------------------------------------------------------------------
-// wxMask
-//-----------------------------------------------------------------------------
+ const unsigned width = image.GetWidth();
+ const unsigned height = image.GetHeight();
+ const DFBSurfacePixelFormat format = surface->GetPixelFormat();
-IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
+ // 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;
+ }
-wxMask::wxMask() : m_bitmap(NULL)
-{
+ // 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;
+ }
}
-wxMask::wxMask(const wxBitmap& bitmap)
- : m_bitmap(NULL)
+void CopyImageToSurface(const wxImage& image,
+ const wxIDirectFBSurfacePtr& surface)
{
- Create(bitmap);
-}
+ wxIDirectFBSurface::Locked locked(surface, DSLF_WRITE);
+ wxCHECK_RET( locked.ptr, "failed to lock surface" );
-wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour)
- : m_bitmap(NULL)
-{
- Create(bitmap, colour);
-}
+ const unsigned width = image.GetWidth();
+ const unsigned height = image.GetHeight();
+ const DFBSurfacePixelFormat format = surface->GetPixelFormat();
-#if wxUSE_PALETTE
-wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex)
- : m_bitmap(NULL)
-{
- Create(bitmap, paletteIndex);
+ // 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++);
+ }
}
-#endif // wxUSE_PALETTE
-wxMask::wxMask(const wxMask& mask)
+wxIDirectFBSurfacePtr
+CreateSurfaceWithFormat(int w, int h, DFBSurfacePixelFormat format)
{
- m_bitmap = mask.m_bitmap ? new wxBitmap(*mask.m_bitmap) : NULL;
+ DFBSurfaceDescription desc;
+ desc.flags = (DFBSurfaceDescriptionFlags)
+ (DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT);
+ desc.caps = DSCAPS_NONE;
+ 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);
}
-wxMask::~wxMask()
+// Creates a surface that will use wxImage's pixel data (RGB only)
+wxIDirectFBSurfacePtr CreateSurfaceForImage(const wxImage& image)
{
- delete m_bitmap;
+ 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);
}
-#warning "move this to common code"
-bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour)
+bool ConvertSurfaceToFormat(wxIDirectFBSurfacePtr& surface,
+ DFBSurfacePixelFormat format)
{
- delete m_bitmap;
- m_bitmap = NULL;
-
- wxColour clr(wxQuantizeColour(colour, bitmap));
+ if ( surface->GetPixelFormat() == format )
+ return true;
- wxImage imgSrc(bitmap.ConvertToImage());
- imgSrc.SetMask(false);
- wxImage image(imgSrc.ConvertToMono(clr.Red(), clr.Green(), clr.Blue()));
- if ( !image.Ok() )
+ int w, h;
+ surface->GetSize(&w, &h);
+ wxIDirectFBSurfacePtr s = CreateSurfaceWithFormat(w, h, format);
+ if ( !s )
return false;
- m_bitmap = new wxBitmap(image, 1);
+ if ( !s->SetBlittingFlags(DSBLIT_NOFX) )
+ return false;
+ if ( !s->Blit(surface->GetRaw(), NULL, 0, 0) )
+ return false;
- return m_bitmap->Ok();
+ surface = s;
+ return true;
}
-#if wxUSE_PALETTE
-bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex)
+DFBSurfacePixelFormat DepthToFormat(int depth)
{
- unsigned char r,g,b;
- wxPalette *pal = bitmap.GetPalette();
-
- wxCHECK_MSG( pal, false, wxT("Cannot create mask from bitmap without palette") );
+ 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;
+ }
+}
- pal->GetRGB(paletteIndex, &r, &g, &b);
+// ----------------------------------------------------------------------------
+// monochrome bitmap functions
+// ----------------------------------------------------------------------------
+
+// this function works with destination buffer of type T and not char (where T
+// is typically wxUint32 for RGB32, wxUint16 for RGB16 &c) as we don't need
+// access to the individual pixel components -- and so it's not suitable for
+// the pixel formats with pixel size not equal to 8, 16 or 32
+template <typename T, int White, int Black>
+void
+CopyBits(int width,
+ int height,
+ const unsigned char *src,
+ const wxIDirectFBSurface::Locked locked)
+{
+ static const int BITS_PER_BYTE = 8;
+
+ // extra padding to add to dst at the end of each row: this works on the
+ // assumption that all rows are aligned at multiples of T (and usually 4
+ // bytes) boundary so check for it (and change the code if this assert is
+ // ever triggered)
+ wxASSERT_MSG( !(locked.pitch % sizeof(T)), "image rows not aligned?" );
+ const int padDst = (locked.pitch - width*sizeof(T))/sizeof(T);
+
+ int x = 0; // position in the current bitmap row
+
+ // a single char in src corresponds to 8 destination pixels and the last
+ // char in the row contains padding if necessary, i.e. there is always an
+ // integer number of chars per row
+ const unsigned char * const
+ srcEnd = src + ((width + BITS_PER_BYTE - 1)/BITS_PER_BYTE)*height;
+
+ // we operate with sizeof(T), not 1, bytes at once
+ T *dst = static_cast<T *>(locked.ptr);
+ while ( src < srcEnd )
+ {
+ unsigned char val = *src++;
- return Create(bitmap, wxColour(r, g, b));
+ for ( int bit = 0; bit < BITS_PER_BYTE; bit++ )
+ {
+ *dst++ = val & 1 ? White : Black;
+ val >>= 1;
+ if ( ++x == width )
+ {
+ dst += padDst;
+ x = 0;
+ break;
+ }
+ }
+ }
}
-#endif // wxUSE_PALETTE
-bool wxMask::Create(const wxBitmap& bitmap)
+bool
+CopyBitsToSurface(const unsigned char *bits,
+ int width,
+ int height,
+ wxIDirectFBSurfacePtr& surface)
{
- delete m_bitmap;
- m_bitmap = NULL;
+ wxIDirectFBSurface::Locked locked(surface, DSLF_WRITE);
+ wxCHECK_MSG( locked.ptr, false, "failed to lock surface" );
- wxCHECK_MSG( bitmap.Ok(), false, wxT("Invalid bitmap") );
- wxCHECK_MSG( bitmap.GetDepth() == 1, false, wxT("Cannot create mask from colour bitmap") );
+ const DFBSurfacePixelFormat format = surface->GetPixelFormat();
- m_bitmap = new wxBitmap(bitmap);
- return true;
-}
+ switch ( format )
+ {
+ case DSPF_LUT8:
+ // we suppose that these indices correspond to the palette entries
+ // for white and black, respectively, but a better idea would be to
+ // use IDirectFBPalette::FindBestMatch() to determine them
+ CopyBits<wxUint8, 0xff, 0>(width, height, bits, locked);
+ break;
+
+ case DSPF_RGB16:
+ CopyBits<wxUint16, 0xffff, 0>(width, height, bits, locked);
+ break;
+
+ case DSPF_RGB32:
+ CopyBits<wxUint32, 0xffffffff, 0>(width, height, bits, locked);
+ break;
+
+ default:
+ // we don't really have time to implement efficient support for all
+ // the other formats so simply (and awfully slowly, of course...)
+ // convert everything else from RGB32
+ surface = CreateSurfaceWithFormat(width, height, DSPF_RGB32);
+ if ( !surface )
+ return false;
+
+ if ( !CopyBitsToSurface(bits, width, height, surface) )
+ return false;
+
+ if ( !ConvertSurfaceToFormat(surface, format) )
+ return false;
+ }
-const wxBitmap& wxMask::GetBitmap() const
-{
- return m_bitmap ? *m_bitmap : wxNullBitmap;
+ return true;
}
+} // anonymous namespace
//-----------------------------------------------------------------------------
// wxBitmapRefData
//-----------------------------------------------------------------------------
-class wxBitmapRefData: public wxObjectRefData
+class wxBitmapRefData: public wxGDIRefData
{
public:
wxBitmapRefData()
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
#endif
}
- ~wxBitmapRefData()
+ virtual ~wxBitmapRefData()
{
delete m_mask;
#if wxUSE_PALETTE
#endif
}
+ virtual bool IsOk() const { return m_surface; }
+
wxIDirectFBSurfacePtr m_surface;
wxMask *m_mask;
#if wxUSE_PALETTE
// wxBitmap
//-----------------------------------------------------------------------------
-IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxBitmapBase)
wxBitmap::wxBitmap(int width, int height, int depth)
{
UnRef();
- wxCHECK_MSG( surface, false, _T("invalid surface") );
+ wxCHECK_MSG( surface, false, "invalid surface" );
m_refData = new wxBitmapRefData();
M_BITMAP->m_surface = surface;
}
bool wxBitmap::Create(int width, int height, int depth)
+{
+ return CreateWithFormat(width, height, DepthToFormat(depth));
+}
+
+bool wxBitmap::CreateWithFormat(int width, int height, int dfbFormat)
{
UnRef();
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;
-
- return Create(wxIDirectFB::Get()->CreateSurface(&desc));
+ return Create(CreateSurfaceWithFormat(width, height,
+ DFBSurfacePixelFormat(dfbFormat)));
}
-#warning "FIXME: move this to common code"
-bool wxBitmap::CreateFromXpm(const char **bits)
+#if wxUSE_IMAGE
+wxBitmap::wxBitmap(const wxImage& imageOrig, int depth)
{
- wxCHECK_MSG( bits != NULL, false, wxT("invalid bitmap data") );
+ wxCHECK_RET( imageOrig.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") );
+ wxImage image(imageOrig);
- *this = wxBitmap(img);
+ // 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();
- return true;
-#else
- wxFAIL_MSG( _T("creating bitmaps from XPMs not supported") );
- return false;
-#endif // wxUSE_IMAGE && wxUSE_XPM
-}
+ DFBSurfacePixelFormat format = DepthToFormat(depth);
+ if ( format == DSPF_UNKNOWN && image.HasAlpha() )
+ format = DSPF_ARGB;
-#if wxUSE_IMAGE
-wxBitmap::wxBitmap(const wxImage& image, int depth)
-{
- wxCHECK_RET( image.Ok(), wxT("invalid image") );
+ // 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:
+ wxIDirectFBSurfacePtr dst = M_BITMAP->m_surface;
+
+ 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;
+ }
+ }
}
wxImage wxBitmap::ConvertToImage() const
{
wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
- return wxNullImage; // FIXME
+ wxImage img(GetWidth(), GetHeight());
+ wxIDirectFBSurfacePtr src = M_BITMAP->m_surface;
+
+ 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
+ wxASSERT_MSG( GetMask() == NULL, "bitmap masks are ignored for now" );
+
+ return img;
}
#endif // wxUSE_IMAGE
-wxBitmap::wxBitmap(const wxString &filename, wxBitmapType type)
+void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
{
- LoadFile(filename, type);
+ 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;
}
-wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
+void wxBitmap::UngetRawData(wxPixelDataBase& WXUNUSED(data))
{
- wxCHECK_RET( depth == 1, wxT("can only create mono bitmap from XBM data") );
+ M_BITMAP->m_surface->Unlock();
+}
+
+bool wxBitmap::HasAlpha() const
+{
+ wxCHECK_MSG( Ok(), false, "invalid bitmap" );
+
+ return M_BITMAP->m_surface->GetPixelFormat() == DSPF_ARGB;
}
-bool wxBitmap::Ok() const
+wxBitmap::wxBitmap(const wxString &filename, wxBitmapType type)
{
- return (m_refData != NULL && M_BITMAP->m_surface);
+ LoadFile(filename, type);
}
-bool wxBitmap::operator==(const wxBitmap& bmp) const
+wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
{
- // FIXME: is this the right way to compare bitmaps?
- return (m_refData == bmp.m_refData);
+ wxCHECK_RET( depth == 1, wxT("can only create mono bitmap from XBM data") );
+
+ // create bitmap in the device-dependent format
+ if ( !CreateWithFormat(width, height, DSPF_UNKNOWN) )
+ return;
+
+ if ( !CopyBitsToSurface((const unsigned char *)bits,
+ width, height, M_BITMAP->m_surface) )
+ UnRef();
}
int wxBitmap::GetHeight() const
{
wxCHECK_RET( Ok(), wxT("invalid bitmap") );
+ AllocExclusive();
delete M_BITMAP->m_mask;
M_BITMAP->m_mask = mask;
}
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 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;
}
}
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( "SetHeight not implemented" );
}
void wxBitmap::SetWidth(int width)
{
AllocExclusive();
-#warning "todo"
+
+ wxFAIL_MSG( "SetWidth not implemented" );
}
void wxBitmap::SetDepth(int depth)
{
+ DFBSurfacePixelFormat format = DepthToFormat(depth);
+ if ( M_BITMAP->m_surface->GetPixelFormat() == format )
+ return;
+
AllocExclusive();
-#warning "todo"
+
+ 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
return M_BITMAP->m_surface;
}
-wxObjectRefData *wxBitmap::CreateRefData() const
+wxGDIRefData *wxBitmap::CreateGDIRefData() const
{
return new wxBitmapRefData;
}
-wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxBitmap::CloneGDIRefData(const wxGDIRefData *data) const
{
return new wxBitmapRefData(*(wxBitmapRefData *)data);
}
projects / wxWidgets.git / blobdiff