src/dfb/bitmap.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/dfb/bitmap.cpp
// Purpose:     wxBitmap implementation
// Author:      Vaclav Slavik
// Created:     2006-08-04
// RCS-ID:      $Id$
// Copyright:   (c) 2006 REA Elektronik GmbH
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/app.h"
    #include "wx/log.h"
#endif

#include "wx/bitmap.h"
#include "wx/colour.h"
#include "wx/image.h"

#include "wx/dfb/private.h"

//-----------------------------------------------------------------------------
// helpers
//-----------------------------------------------------------------------------

// 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];
        }
    }
}

static void CopySurfaceToImage(const wxIDirectFBSurfacePtr& surface,
                               const wxImage& image)
{
    wxCHECK_RET( surface->GetPixelFormat() == DSPF_RGB24,
                 _T("unexpected pixel format") );

    wxIDirectFBSurface::Locked locked(surface, DSLF_READ);
    wxCHECK_RET( locked.ptr, _T("failed to lock surface") );

    CopyPixelsAndSwapRGB(image.GetWidth(), image.GetHeight(),
                         (unsigned char*)locked.ptr, locked.pitch,
                         image.GetData(), image.GetWidth() * 3);
}

static void CopyImageToSurface(const wxImage& image,
                               const wxIDirectFBSurfacePtr& surface)
{
    wxCHECK_RET( surface->GetPixelFormat() == DSPF_RGB24,
                 _T("unexpected pixel format") );

    wxIDirectFBSurface::Locked locked(surface, DSLF_WRITE);
    wxCHECK_RET( locked.ptr, _T("failed to lock surface") );

    CopyPixelsAndSwapRGB(image.GetWidth(), image.GetHeight(),
                         image.GetData(), image.GetWidth() * 3,
                         (unsigned char*)locked.ptr, locked.pitch);
}

// 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") );
    // 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") );

    // 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;

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

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

class wxBitmapRefData: public wxObjectRefData
{
public:
    wxBitmapRefData()
    {
        m_mask = NULL;
#if wxUSE_PALETTE
        m_palette = NULL;
#endif
    }

    wxBitmapRefData(const wxBitmapRefData& data)
    {
        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
    }

    virtual ~wxBitmapRefData()
    {
        delete m_mask;
#if wxUSE_PALETTE
        delete m_palette;
#endif
    }

    wxIDirectFBSurfacePtr m_surface;
    wxMask               *m_mask;
#if wxUSE_PALETTE
    wxPalette            *m_palette;
#endif
};

#define M_BITMAP ((wxBitmapRefData *)m_refData)

//-----------------------------------------------------------------------------
// wxBitmap
//-----------------------------------------------------------------------------

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)(
                        DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT);
    desc.caps = DSCAPS_NONE;
    desc.width = width;
    desc.height = height;

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

#if wxUSE_IMAGE
wxBitmap::wxBitmap(const wxImage& image, int depth)
{
    wxCHECK_RET( image.Ok(), wxT("invalid image") );

    // create surface in screen's format:
    if ( !Create(image.GetWidth(), image.GetHeight(), depth) )
        return;

    // then copy the image to it:
    wxIDirectFBSurfacePtr dst = M_BITMAP->m_surface;

    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;
    }

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

wxBitmap::wxBitmap(const wxString &filename, wxBitmapType type)
{
    LoadFile(filename, 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") );

    wxFAIL_MSG( _T("not implemented") );
}

bool wxBitmap::IsOk() const
{
    return (m_refData != NULL && M_BITMAP->m_surface);
}

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

    int h = -1;
    M_BITMAP->m_surface->GetSize(NULL, &h);
    return h;
}

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

    int w = -1;
    M_BITMAP->m_surface->GetSize(&w, NULL);
    return w;
}

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

    return M_BITMAP->m_surface->GetDepth();
}

wxMask *wxBitmap::GetMask() const
{
    wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );

    return M_BITMAP->m_mask;
}

void wxBitmap::SetMask(wxMask *mask)
{
    wxCHECK_RET( Ok(), wxT("invalid bitmap") );

    AllocExclusive();
    delete M_BITMAP->m_mask;
    M_BITMAP->m_mask = mask;
}

bool wxBitmap::CopyFromIcon(const wxIcon& icon)
{
    *this = *((wxBitmap*)(&icon));
    return true;
}

wxBitmap wxBitmap::GetSubBitmap(const wxRect& rect) const
{
    wxCHECK_MSG( Ok() &&
                 rect.x >= 0 && rect.y >= 0 &&
                 rect.x+rect.width <= GetWidth() &&
                 rect.y+rect.height <= GetHeight(),
                 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"
bool wxBitmap::LoadFile(const wxString &name, wxBitmapType type)
{
    UnRef();

    wxBitmapHandler *handler = FindHandler(type);

    if ( handler == NULL )
    {
        wxImage image;
        if ( !image.LoadFile(name, type) || !image.Ok() )
        {
            wxLogError(_("No bitmap handler for type %d defined."), type);
            return false;
        }
        else
        {
            *this = wxBitmap(image);
            return true;
        }
    }

    m_refData = new wxBitmapRefData();

    return handler->LoadFile(this, name, type, -1, -1);
}

#warning "to common code"
bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type, const wxPalette *palette) const
{
    wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );

    wxBitmapHandler *handler = FindHandler(type);

    if ( handler == NULL )
    {
        wxImage image = ConvertToImage();
#if wxUSE_PALETTE
        if ( palette )
            image.SetPalette(*palette);
#endif // wxUSE_PALETTE

        if ( image.Ok() )
            return image.SaveFile(filename, type);
        else
        {
            wxLogError(_("No bitmap handler for type %d defined."), type);
            return false;
        }
    }

    return handler->SaveFile(this, filename, type, palette);
}

#if wxUSE_PALETTE
wxPalette *wxBitmap::GetPalette() const
{
    wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );

    return M_BITMAP->m_palette;
}

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

    AllocExclusive();
    delete M_BITMAP->m_palette;
    M_BITMAP->m_palette = NULL;

    if ( !palette.Ok() ) return;

    M_BITMAP->m_palette = new wxPalette(palette);
}
#endif // wxUSE_PALETTE

void wxBitmap::SetHeight(int height)
{
    AllocExclusive();

    wxFAIL_MSG( _T("SetHeight not implemented") );
}

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

    wxFAIL_MSG( _T("SetWidth not implemented") );
}

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

    wxFAIL_MSG( _T("SetDepth not implemented") );
}

wxIDirectFBSurfacePtr wxBitmap::GetDirectFBSurface() const
{
    wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );

    return M_BITMAP->m_surface;
}

wxObjectRefData *wxBitmap::CreateRefData() const
{
    return new wxBitmapRefData;
}

wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *data) const
{
    return new wxBitmapRefData(*(wxBitmapRefData *)data);
}


/*static*/
void wxBitmap::InitStandardHandlers()
{
    // not wxBitmap handlers, we rely on wxImage
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/dfb/bitmap.cpp
	3	// Purpose: wxBitmap implementation
	4	// Author: Vaclav Slavik
	5	// Created: 2006-08-04
	6	// RCS-ID: $Id$
	7	// Copyright: (c) 2006 REA Elektronik GmbH
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	// For compilers that support precompilation, includes "wx.h".
	12	#include "wx/wxprec.h"
	13
	14	#ifdef __BORLANDC__
	15	#pragma hdrstop
	16	#endif
	17
	18	#ifndef WX_PRECOMP
	19	#include "wx/app.h"
	20	#include "wx/log.h"
	21	#endif
	22
	23	#include "wx/bitmap.h"
	24	#include "wx/colour.h"
	25	#include "wx/image.h"
	26
	27	#include "wx/dfb/private.h"
	28
	29	//-----------------------------------------------------------------------------
	30	// helpers
	31	//-----------------------------------------------------------------------------
	32
	33	// pitch = stride = # of bytes between the start of N-th line and (N+1)-th line
	34	static void CopyPixelsAndSwapRGB(unsigned w, unsigned h,
	35	const unsigned char *src,
	36	unsigned src_pitch,
	37	unsigned char *dst,
	38	unsigned dst_pitch)
	39	{
	40	unsigned src_advance = src_pitch - 3 * w;
	41	unsigned dst_advance = dst_pitch - 3 * w;
	42	for ( unsigned y = 0; y < h; y++, src += src_advance, dst += dst_advance )
	43	{
	44	for ( unsigned x = 0; x < w; x++, src += 3, dst += 3 )
	45	{
	46	// copy with RGB -> BGR translation:
	47	dst[0] = src[2];
	48	dst[1] = src[1];
	49	dst[2] = src[0];
	50	}
	51	}
	52	}
	53
	54	static void CopySurfaceToImage(const wxIDirectFBSurfacePtr& surface,
	55	const wxImage& image)
	56	{
	57	wxCHECK_RET( surface->GetPixelFormat() == DSPF_RGB24,
	58	_T("unexpected pixel format") );
	59
	60	wxIDirectFBSurface::Locked locked(surface, DSLF_READ);
	61	wxCHECK_RET( locked.ptr, _T("failed to lock surface") );
	62
	63	CopyPixelsAndSwapRGB(image.GetWidth(), image.GetHeight(),
	64	(unsigned char*)locked.ptr, locked.pitch,
	65	image.GetData(), image.GetWidth() * 3);
	66	}
	67
	68	static void CopyImageToSurface(const wxImage& image,
	69	const wxIDirectFBSurfacePtr& surface)
	70	{
	71	wxCHECK_RET( surface->GetPixelFormat() == DSPF_RGB24,
	72	_T("unexpected pixel format") );
	73
	74	wxIDirectFBSurface::Locked locked(surface, DSLF_WRITE);
	75	wxCHECK_RET( locked.ptr, _T("failed to lock surface") );
	76
	77	CopyPixelsAndSwapRGB(image.GetWidth(), image.GetHeight(),
	78	image.GetData(), image.GetWidth() * 3,
	79	(unsigned char*)locked.ptr, locked.pitch);
	80	}
	81
	82	// Creates a surface that will use wxImage's pixel data (RGB only)
	83	static wxIDirectFBSurfacePtr CreateSurfaceForImage(const wxImage& image)
	84	{
	85	wxCHECK_MSG( image.Ok(), NULL, _T("invalid image") );
	86	// FIXME_DFB: implement alpha handling by merging alpha buffer with RGB
	87	// into a temporary RGBA surface
	88	wxCHECK_MSG( !image.HasAlpha(), NULL, _T("alpha channel not supported") );
	89
	90	// NB: wxImage uses RGB order of bytes while DirectFB uses BGR, so we
	91	// cannot use preallocated surface that shares data with wxImage, we
	92	// have to copy the data to temporary surface instead
	93	DFBSurfaceDescription desc;
	94	desc.flags = (DFBSurfaceDescriptionFlags)
	95	(DSDESC_CAPS \| DSDESC_WIDTH \| DSDESC_HEIGHT \| DSDESC_PIXELFORMAT);
	96	desc.caps = DSCAPS_NONE;
	97	desc.width = image.GetWidth();
	98	desc.height = image.GetHeight();
	99	desc.pixelformat = DSPF_RGB24;
	100
	101	return wxIDirectFB::Get()->CreateSurface(&desc);
	102	}
	103
	104	//-----------------------------------------------------------------------------
	105	// wxBitmapRefData
	106	//-----------------------------------------------------------------------------
	107
	108	class wxBitmapRefData: public wxObjectRefData
	109	{
	110	public:
	111	wxBitmapRefData()
	112	{
	113	m_mask = NULL;
	114	#if wxUSE_PALETTE
	115	m_palette = NULL;
	116	#endif
	117	}
	118
	119	wxBitmapRefData(const wxBitmapRefData& data)
	120	{
	121	m_surface = data.m_surface ? data.m_surface->Clone() : NULL;
	122
	123	m_mask = data.m_mask ? new wxMask(*data.m_mask) : NULL;
	124	#if wxUSE_PALETTE
	125	m_palette = data.m_palette ? new wxPalette(*data.m_palette) : NULL;
	126	#endif
	127	}
	128
	129	virtual ~wxBitmapRefData()
	130	{
	131	delete m_mask;
	132	#if wxUSE_PALETTE
	133	delete m_palette;
	134	#endif
	135	}
	136
	137	wxIDirectFBSurfacePtr m_surface;
	138	wxMask *m_mask;
	139	#if wxUSE_PALETTE
	140	wxPalette *m_palette;
	141	#endif
	142	};
	143
	144	#define M_BITMAP ((wxBitmapRefData *)m_refData)
	145
	146	//-----------------------------------------------------------------------------
	147	// wxBitmap
	148	//-----------------------------------------------------------------------------
	149
	150	IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)
	151	IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxBitmapBase)
	152
	153	wxBitmap::wxBitmap(int width, int height, int depth)
	154	{
	155	Create(width, height, depth);
	156	}
	157
	158	bool wxBitmap::Create(const wxIDirectFBSurfacePtr& surface)
	159	{
	160	UnRef();
	161
	162	wxCHECK_MSG( surface, false, _T("invalid surface") );
	163
	164	m_refData = new wxBitmapRefData();
	165	M_BITMAP->m_surface = surface;
	166	return true;
	167	}
	168
	169	bool wxBitmap::Create(int width, int height, int depth)
	170	{
	171	UnRef();
	172
	173	wxCHECK_MSG( width > 0 && height > 0, false, wxT("invalid bitmap size") );
	174	wxCHECK_MSG( depth == -1, false, wxT("only default depth supported now") );
	175
	176	DFBSurfaceDescription desc;
	177	desc.flags = (DFBSurfaceDescriptionFlags)(
	178	DSDESC_CAPS \| DSDESC_WIDTH \| DSDESC_HEIGHT);
	179	desc.caps = DSCAPS_NONE;
	180	desc.width = width;
	181	desc.height = height;
	182
	183	return Create(wxIDirectFB::Get()->CreateSurface(&desc));
	184	}
	185
	186	#if wxUSE_IMAGE
	187	wxBitmap::wxBitmap(const wxImage& image, int depth)
	188	{
	189	wxCHECK_RET( image.Ok(), wxT("invalid image") );
	190
	191	// create surface in screen's format:
	192	if ( !Create(image.GetWidth(), image.GetHeight(), depth) )
	193	return;
	194
	195	// then copy the image to it:
	196	wxIDirectFBSurfacePtr dst = M_BITMAP->m_surface;
	197
	198	if ( dst->GetPixelFormat() == DSPF_RGB24 )
	199	{
	200	CopyImageToSurface(image, dst);
	201	}
	202	else
	203	{
	204	// wxBitmap uses different pixel format, so we have to use a temporary
	205	// surface and blit to the bitmap via it:
	206	wxIDirectFBSurfacePtr src(CreateSurfaceForImage(image));
	207	CopyImageToSurface(image, src);
	208
	209	if ( !dst->SetBlittingFlags(DSBLIT_NOFX) )
	210	return;
	211	if ( !dst->Blit(src->GetRaw(), NULL, 0, 0) )
	212	return;
	213	}
	214
	215	// FIXME: implement mask creation from image's mask (or alpha channel?)
	216	wxASSERT_MSG( !image.HasMask(), _T("image masks are ignored for now") );
	217	}
	218
	219	wxImage wxBitmap::ConvertToImage() const
	220	{
	221	wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
	222
	223	wxImage img(GetWidth(), GetHeight());
	224	wxIDirectFBSurfacePtr src = M_BITMAP->m_surface;
	225
	226	if ( src->GetPixelFormat() == DSPF_RGB24 )
	227	{
	228	CopySurfaceToImage(src, img);
	229	}
	230	else
	231	{
	232	// wxBitmap uses different pixel format, so we have to use a temporary
	233	// surface and blit to the bitmap via it:
	234	wxIDirectFBSurfacePtr dst(CreateSurfaceForImage(img));
	235
	236	if ( !dst->SetBlittingFlags(DSBLIT_NOFX) )
	237	return wxNullImage;
	238	if ( !dst->Blit(src->GetRaw(), NULL, 0, 0) )
	239	return wxNullImage;
	240
	241	CopySurfaceToImage(dst, img);
	242	}
	243
	244	// FIXME: implement mask setting in the image
	245	wxASSERT_MSG( GetMask() == NULL, _T("bitmap masks are ignored for now") );
	246
	247	return img;
	248	}
	249	#endif // wxUSE_IMAGE
	250
	251	wxBitmap::wxBitmap(const wxString &filename, wxBitmapType type)
	252	{
	253	LoadFile(filename, type);
	254	}
	255
	256	wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
	257	{
	258	wxCHECK_RET( depth == 1, wxT("can only create mono bitmap from XBM data") );
	259
	260	wxFAIL_MSG( _T("not implemented") );
	261	}
	262
	263	bool wxBitmap::IsOk() const
	264	{
	265	return (m_refData != NULL && M_BITMAP->m_surface);
	266	}
	267
	268	int wxBitmap::GetHeight() const
	269	{
	270	wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
	271
	272	int h = -1;
	273	M_BITMAP->m_surface->GetSize(NULL, &h);
	274	return h;
	275	}
	276
	277	int wxBitmap::GetWidth() const
	278	{
	279	wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
	280
	281	int w = -1;
	282	M_BITMAP->m_surface->GetSize(&w, NULL);
	283	return w;
	284	}
	285
	286	int wxBitmap::GetDepth() const
	287	{
	288	wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
	289
	290	return M_BITMAP->m_surface->GetDepth();
	291	}
	292
	293	wxMask *wxBitmap::GetMask() const
	294	{
	295	wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
	296
	297	return M_BITMAP->m_mask;
	298	}
	299
	300	void wxBitmap::SetMask(wxMask *mask)
	301	{
	302	wxCHECK_RET( Ok(), wxT("invalid bitmap") );
	303
	304	AllocExclusive();
	305	delete M_BITMAP->m_mask;
	306	M_BITMAP->m_mask = mask;
	307	}
	308
	309	bool wxBitmap::CopyFromIcon(const wxIcon& icon)
	310	{
	311	this = ((wxBitmap*)(&icon));
	312	return true;
	313	}
	314
	315	wxBitmap wxBitmap::GetSubBitmap(const wxRect& rect) const
	316	{
	317	wxCHECK_MSG( Ok() &&
	318	rect.x >= 0 && rect.y >= 0 &&
	319	rect.x+rect.width <= GetWidth() &&
	320	rect.y+rect.height <= GetHeight(),
	321	wxNullBitmap,
	322	wxT("invalid bitmap or bitmap region") );
	323
	324	// NB: DirectFB subsurfaces share the same pixels buffer, so we must
	325	// clone the obtained subsurface
	326	DFBRectangle r = { rect.x, rect.y, rect.width, rect.height };
	327	return wxBitmap(M_BITMAP->m_surface->GetSubSurface(&r)->Clone());
	328	}
	329
	330	#warning "to common code"
	331	bool wxBitmap::LoadFile(const wxString &name, wxBitmapType type)
	332	{
	333	UnRef();
	334
	335	wxBitmapHandler *handler = FindHandler(type);
	336
	337	if ( handler == NULL )
	338	{
	339	wxImage image;
	340	if ( !image.LoadFile(name, type) \|\| !image.Ok() )
	341	{
	342	wxLogError(_("No bitmap handler for type %d defined."), type);
	343	return false;
	344	}
	345	else
	346	{
	347	*this = wxBitmap(image);
	348	return true;
	349	}
	350	}
	351
	352	m_refData = new wxBitmapRefData();
	353
	354	return handler->LoadFile(this, name, type, -1, -1);
	355	}
	356
	357	#warning "to common code"
	358	bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type, const wxPalette *palette) const
	359	{
	360	wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
	361
	362	wxBitmapHandler *handler = FindHandler(type);
	363
	364	if ( handler == NULL )
	365	{
	366	wxImage image = ConvertToImage();
	367	#if wxUSE_PALETTE
	368	if ( palette )
	369	image.SetPalette(*palette);
	370	#endif // wxUSE_PALETTE
	371
	372	if ( image.Ok() )
	373	return image.SaveFile(filename, type);
	374	else
	375	{
	376	wxLogError(_("No bitmap handler for type %d defined."), type);
	377	return false;
	378	}
	379	}
	380
	381	return handler->SaveFile(this, filename, type, palette);
	382	}
	383
	384	#if wxUSE_PALETTE
	385	wxPalette *wxBitmap::GetPalette() const
	386	{
	387	wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
	388
	389	return M_BITMAP->m_palette;
	390	}
	391
	392	void wxBitmap::SetPalette(const wxPalette& palette)
	393	{
	394	wxCHECK_RET( Ok(), wxT("invalid bitmap") );
	395	wxCHECK_RET( GetDepth() > 1 && GetDepth() <= 8, wxT("cannot set palette for bitmap of this depth") );
	396
	397	AllocExclusive();
	398	delete M_BITMAP->m_palette;
	399	M_BITMAP->m_palette = NULL;
	400
	401	if ( !palette.Ok() ) return;
	402
	403	M_BITMAP->m_palette = new wxPalette(palette);
	404	}
	405	#endif // wxUSE_PALETTE
	406
	407	void wxBitmap::SetHeight(int height)
	408	{
	409	AllocExclusive();
	410
	411	wxFAIL_MSG( _T("SetHeight not implemented") );
	412	}
	413
	414	void wxBitmap::SetWidth(int width)
	415	{
	416	AllocExclusive();
	417
	418	wxFAIL_MSG( _T("SetWidth not implemented") );
	419	}
	420
	421	void wxBitmap::SetDepth(int depth)
	422	{
	423	AllocExclusive();
	424
	425	wxFAIL_MSG( _T("SetDepth not implemented") );
	426	}
	427
	428	wxIDirectFBSurfacePtr wxBitmap::GetDirectFBSurface() const
	429	{
	430	wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
	431
	432	return M_BITMAP->m_surface;
	433	}
	434
	435	wxObjectRefData *wxBitmap::CreateRefData() const
	436	{
	437	return new wxBitmapRefData;
	438	}
	439
	440	wxObjectRefData wxBitmap::CloneRefData(const wxObjectRefData data) const
	441	{
	442	return new wxBitmapRefData((wxBitmapRefData )data);
	443	}
	444
	445
	446	/static/
	447	void wxBitmap::InitStandardHandlers()
	448	{
	449	// not wxBitmap handlers, we rely on wxImage
	450	}