[wxWidgets.git] / include / wx / dfb / wrapdfb.h

/////////////////////////////////////////////////////////////////////////////
// Name:        wx/dfb/wrapdfb.h
// Purpose:     wx wrappers for DirectFB interfaces
// Author:      Vaclav Slavik
// Created:     2006-08-23
// RCS-ID:      $Id$
// Copyright:   (c) 2006 REA Elektronik GmbH
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifndef _WX_DFB_WRAPDFB_H_
#define _WX_DFB_WRAPDFB_H_

#include "wx/dfb/dfbptr.h"

#include <directfb.h>

wxDFB_DECLARE_INTERFACE(IDirectFB);
wxDFB_DECLARE_INTERFACE(IDirectFBDisplayLayer);
wxDFB_DECLARE_INTERFACE(IDirectFBWindow);
wxDFB_DECLARE_INTERFACE(IDirectFBSurface);
wxDFB_DECLARE_INTERFACE(IDirectFBPalette);
wxDFB_DECLARE_INTERFACE(IDirectFBEventBuffer);


/**
    Checks the @a code of a DirectFB call and returns true if it was
    successful and false if it failed, logging the errors as appropriate
    (asserts for programming errors, wxLogError for runtime failures).
 */
bool wxDfbCheckReturn(DFBResult code);

//-----------------------------------------------------------------------------
// wxDfbEvent
//-----------------------------------------------------------------------------

/**
    The struct defined by this macro is a thin wrapper around DFB*Event type.
    It is needed because DFB*Event are typedefs and so we can't forward declare
    them, but we need to pass them to methods declared in public headers where
    <directfb.h> cannot be included. So this struct just holds the event value,
    it's sole purpose is that it can be forward declared.
 */
#define WXDFB_DEFINE_EVENT_WRAPPER(T)                                       \
    struct wx##T                                                            \
    {                                                                       \
        wx##T() {}                                                          \
        wx##T(const T& event) : m_event(event) {}                           \
                                                                            \
        operator T&() { return m_event; }                                   \
        operator const T&() const { return m_event; }                       \
        T* operator&() { return &m_event; }                                 \
                                                                            \
        DFBEventClass GetClass() const { return m_event.clazz; }            \
                                                                            \
    private:                                                                \
        T m_event;                                                          \
    };

WXDFB_DEFINE_EVENT_WRAPPER(DFBEvent)
WXDFB_DEFINE_EVENT_WRAPPER(DFBWindowEvent)


//-----------------------------------------------------------------------------
// wxDfbWrapper<T>
//-----------------------------------------------------------------------------

/// Base class for wxDfbWrapper<T>
class wxDfbWrapperBase
{
public:
    /// Increases reference count of the object
    void AddRef()
    {
        m_refCnt++;
    }

    /// Decreases reference count and if it reaches zero, deletes the object
    void Release()
    {
        if ( --m_refCnt == 0 )
            delete this;
    }

    /// Returns result code of the last call
    DFBResult GetLastResult() const { return m_lastResult; }

protected:
    wxDfbWrapperBase() : m_refCnt(1), m_lastResult(DFB_OK) {}

    /// Dtor may only be called from Release()
    virtual ~wxDfbWrapperBase() {}

    /**
        Checks the @a result of a DirectFB call and returns true if it was
        successful and false if it failed. Also stores result of the call
        so that it can be obtained by calling GetLastResult().
     */
    bool Check(DFBResult result)
    {
        m_lastResult = result;
        return wxDfbCheckReturn(result);
    }

protected:
    /// Reference count
    unsigned m_refCnt;

    /// Result of the last DirectFB call
    DFBResult m_lastResult;
};

/**
    This template is base class for friendly C++ wrapper around DirectFB
    interface T.

    The wrapper provides same API as DirectFB, with a few exceptions:
     - methods return true/false instead of error code
     - methods that return or create another interface return pointer to the
       interface (or NULL on failure) instead of storing it in the last
       argument
     - interface arguments use wxFooPtr type instead of raw DirectFB pointer
     - methods taking flags use int type instead of an enum when the flags
       can be or-combination of enum elements (this is workaround for
       C++-unfriendly DirectFB API)
 */
template<typename T>
class wxDfbWrapper : public wxDfbWrapperBase
{
public:
    /// "Raw" DirectFB interface type
    typedef T DirectFBIface;

    /// Returns raw DirectFB pointer
    T *GetRaw() const { return m_ptr; }

protected:
    /// To be called from ctor. Takes ownership of raw object.
    void Init(T *ptr) { m_ptr = ptr; }

    /// Dtor may only be used from Release
    ~wxDfbWrapper()
    {
        if ( m_ptr )
            m_ptr->Release(m_ptr);
    }

protected:
    // pointer to DirectFB object
    T *m_ptr;
};


//-----------------------------------------------------------------------------
// wxIDirectFBFont
//-----------------------------------------------------------------------------

struct wxIDirectFBFont : public wxDfbWrapper<IDirectFBFont>
{
    wxIDirectFBFont(IDirectFBFont *s) { Init(s); }

    bool GetStringWidth(const char *text, int bytes, int *w)
        { return Check(m_ptr->GetStringWidth(m_ptr, text, bytes, w)); }

    bool GetStringExtents(const char *text, int bytes,
                          DFBRectangle *logicalRect, DFBRectangle *inkRect)
    {
        return Check(m_ptr->GetStringExtents(m_ptr, text, bytes,
                                               logicalRect, inkRect));
    }

    bool GetHeight(int *h)
        { return Check(m_ptr->GetHeight(m_ptr, h)); }

    bool GetDescender(int *descender)
        { return Check(m_ptr->GetDescender(m_ptr, descender)); }
};


//-----------------------------------------------------------------------------
// wxIDirectFBPalette
//-----------------------------------------------------------------------------

struct wxIDirectFBPalette : public wxDfbWrapper<IDirectFBPalette>
{
    wxIDirectFBPalette(IDirectFBPalette *s) { Init(s); }
};


//-----------------------------------------------------------------------------
// wxIDirectFBSurface
//-----------------------------------------------------------------------------

struct wxIDirectFBSurface : public wxDfbWrapper<IDirectFBSurface>
{
    wxIDirectFBSurface(IDirectFBSurface *s) { Init(s); }

    bool GetSize(int *w, int *h)
        { return Check(m_ptr->GetSize(m_ptr, w, h)); }

    bool GetCapabilities(DFBSurfaceCapabilities *caps)
        { return Check(m_ptr->GetCapabilities(m_ptr, caps)); }

    bool GetPixelFormat(DFBSurfacePixelFormat *caps)
        { return Check(m_ptr->GetPixelFormat(m_ptr, caps)); }

    bool SetClip(const DFBRegion *clip)
        { return Check(m_ptr->SetClip(m_ptr, clip)); }

    bool SetColor(__u8 r, __u8 g, __u8 b, __u8 a)
        { return Check(m_ptr->SetColor(m_ptr, r, g, b, a)); }

    bool Clear(__u8 r, __u8 g, __u8 b, __u8 a)
        { return Check(m_ptr->Clear(m_ptr, r, g, b, a)); }

    bool DrawLine(int x1, int y1, int x2, int y2)
        { return Check(m_ptr->DrawLine(m_ptr, x1, y1, x2, y2)); }

    bool DrawRectangle(int x, int y, int w, int h)
        { return Check(m_ptr->DrawRectangle(m_ptr, x, y, w, h)); }

    bool FillRectangle(int x, int y, int w, int h)
        { return Check(m_ptr->FillRectangle(m_ptr, x, y, w, h)); }

    bool SetFont(const wxIDirectFBFontPtr& font)
        { return Check(m_ptr->SetFont(m_ptr, font->GetRaw())); }

    bool DrawString(const char *text, int bytes, int x, int y, int flags)
    {
        return Check(m_ptr->DrawString(m_ptr, text, bytes, x, y,
                                         (DFBSurfaceTextFlags)flags));
    }

    /**
        Updates the front buffer from the back buffer. If @a region is not
        NULL, only given rectangle is updated.
     */
    bool FlipToFront(const DFBRegion *region = NULL);

    wxIDirectFBSurfacePtr GetSubSurface(const DFBRectangle *rect)
    {
        IDirectFBSurface *s;
        if ( Check(m_ptr->GetSubSurface(m_ptr, rect, &s)) )
            return new wxIDirectFBSurface(s);
        else
            return NULL;
    }

    wxIDirectFBPalettePtr GetPalette()
    {
        IDirectFBPalette *s;
        if ( Check(m_ptr->GetPalette(m_ptr, &s)) )
            return new wxIDirectFBPalette(s);
        else
            return NULL;
    }

    bool SetPalette(const wxIDirectFBPalettePtr& pal)
        { return Check(m_ptr->SetPalette(m_ptr, pal->GetRaw())); }

    bool SetBlittingFlags(int flags)
    {
        return Check(
            m_ptr->SetBlittingFlags(m_ptr, (DFBSurfaceBlittingFlags)flags));
    }

    bool Blit(const wxIDirectFBSurfacePtr& source,
              const DFBRectangle *source_rect,
              int x, int y)
        { return Blit(source->GetRaw(), source_rect, x, y); }

    bool Blit(IDirectFBSurface *source,
              const DFBRectangle *source_rect,
              int x, int y)
        { return Check(m_ptr->Blit(m_ptr, source, source_rect, x, y)); }

    bool StretchBlit(const wxIDirectFBSurfacePtr& source,
              const DFBRectangle *source_rect,
              const DFBRectangle *dest_rect)
    {
        return Check(m_ptr->StretchBlit(m_ptr, source->GetRaw(),
                                        source_rect, dest_rect));
    }


    /// Returns bit depth used by the surface or -1 on error
    int GetDepth();

    /**
        Creates a new surface by cloning this one. New surface will have same
        capabilities, pixel format and pixel data as the existing one.

        @see CreateCompatible
     */
    wxIDirectFBSurfacePtr Clone();

    /// Flags for CreateCompatible()
    enum CreateCompatibleFlags
    {
        /// Don't create double-buffered surface
        CreateCompatible_NoBackBuffer = 1
    };

    /**
        Creates a surface compatible with this one, i.e. surface with the same
        capabilities and pixel format, but with different and size.

        @param size  Size of the surface to create. If wxDefaultSize, use the
                     size of this surface.
        @param flags Or-combination of CreateCompatibleFlags values
     */
    wxIDirectFBSurfacePtr CreateCompatible(const wxSize& size = wxDefaultSize,
                                           int flags = 0);

private:
    // this is private because we want user code to use FlipToFront()
    bool Flip(const DFBRegion *region, int flags);
};


//-----------------------------------------------------------------------------
// wxIDirectFBEventBuffer
//-----------------------------------------------------------------------------

struct wxIDirectFBEventBuffer : public wxDfbWrapper<IDirectFBEventBuffer>
{
    wxIDirectFBEventBuffer(IDirectFBEventBuffer *s) { Init(s); }

    bool WakeUp()
    {
        return Check(m_ptr->WakeUp(m_ptr));
    }

    bool HasEvent()
    {
        // returns DFB_OK if there is >=1 event, DFB_BUFFEREMPTY otherwise
        DFBResult r = m_ptr->HasEvent(m_ptr);

        // NB: Check() also returns true for DFB_BUFFEREMPTY, so we can't just
        //     return it's return value:
        Check(r);
        return (r == DFB_OK);
    }

    bool WaitForEventWithTimeout(unsigned secs, unsigned millisecs)
    {
        DFBResult r = m_ptr->WaitForEventWithTimeout(m_ptr, secs, millisecs);

        // DFB_TIMEOUT is not an error in this function:
        if ( r == DFB_TIMEOUT )
        {
            m_lastResult = DFB_TIMEOUT;
            return true;
        }

        return Check(r);
    }

    bool GetEvent(wxDFBEvent& event)
    {
        return Check(m_ptr->GetEvent(m_ptr, &event));
    }
};


//-----------------------------------------------------------------------------
// wxIDirectFBWindow
//-----------------------------------------------------------------------------

struct wxIDirectFBWindow : public wxDfbWrapper<IDirectFBWindow>
{
    wxIDirectFBWindow(IDirectFBWindow *s) { Init(s); }

    bool GetID(DFBWindowID *id)
        { return Check(m_ptr->GetID(m_ptr, id)); }

    bool GetPosition(int *x, int *y)
        { return Check(m_ptr->GetPosition(m_ptr, x, y)); }

    bool GetSize(int *w, int *h)
        { return Check(m_ptr->GetSize(m_ptr, w, h)); }

    bool MoveTo(int x, int y)
        { return Check(m_ptr->MoveTo(m_ptr, x, y)); }

    bool Resize(int w, int h)
        { return Check(m_ptr->Resize(m_ptr, w, h)); }

    bool SetOpacity(__u8 opacity)
        { return Check(m_ptr->SetOpacity(m_ptr, opacity)); }

    bool SetStackingClass(DFBWindowStackingClass klass)
        { return Check(m_ptr->SetStackingClass(m_ptr, klass)); }

    wxIDirectFBSurfacePtr GetSurface()
    {
        IDirectFBSurface *s;
        if ( Check(m_ptr->GetSurface(m_ptr, &s)) )
            return new wxIDirectFBSurface(s);
        else
            return NULL;
    }

    bool AttachEventBuffer(const wxIDirectFBEventBufferPtr& buffer)
        { return Check(m_ptr->AttachEventBuffer(m_ptr, buffer->GetRaw())); }

    bool RequestFocus()
        { return Check(m_ptr->RequestFocus(m_ptr)); }
};


//-----------------------------------------------------------------------------
// wxIDirectFBDisplayLayer
//-----------------------------------------------------------------------------

struct wxIDirectFBDisplayLayer : public wxDfbWrapper<IDirectFBDisplayLayer>
{
    wxIDirectFBDisplayLayer(IDirectFBDisplayLayer *s) { Init(s); }

    wxIDirectFBWindowPtr CreateWindow(const DFBWindowDescription *desc)
    {
        IDirectFBWindow *w;
        if ( Check(m_ptr->CreateWindow(m_ptr, desc, &w)) )
            return new wxIDirectFBWindow(w);
        else
            return NULL;
    }

    wxIDirectFBSurfacePtr GetSurface()
    {
        IDirectFBSurface *s;
        if ( Check(m_ptr->GetSurface(m_ptr, &s)) )
            return new wxIDirectFBSurface(s);
        else
            return NULL;
    }

    bool GetCursorPosition(int *x, int *y)
        { return Check(m_ptr->GetCursorPosition(m_ptr, x, y)); }

    bool WarpCursor(int x, int y)
        { return Check(m_ptr->WarpCursor(m_ptr, x, y)); }
};


//-----------------------------------------------------------------------------
// wxIDirectFB
//-----------------------------------------------------------------------------

struct wxIDirectFB : public wxDfbWrapper<IDirectFB>
{
    /**
        Returns pointer to DirectFB singleton object, it never returns NULL
        after wxApp was initialized. The object is cached, so calling this
        method is cheap.
     */
    static wxIDirectFBPtr Get()
    {
        if ( !ms_ptr ) CreateDirectFB();
        return ms_ptr;
    }

    bool SetVideoMode(int w, int h, int bpp)
        { return Check(m_ptr->SetVideoMode(m_ptr, w, h, bpp)); }

    wxIDirectFBSurfacePtr CreateSurface(const DFBSurfaceDescription *desc)
    {
        IDirectFBSurface *s;
        if ( Check(m_ptr->CreateSurface(m_ptr, desc, &s)) )
            return new wxIDirectFBSurface(s);
        else
            return NULL;
    }

    wxIDirectFBEventBufferPtr CreateEventBuffer()
    {
        IDirectFBEventBuffer *b;
        if ( Check(m_ptr->CreateEventBuffer(m_ptr, &b)) )
            return new wxIDirectFBEventBuffer(b);
        else
            return NULL;
    }

    wxIDirectFBFontPtr CreateFont(const char *filename,
                                  const DFBFontDescription *desc)
    {
        IDirectFBFont *f;
        if ( Check(m_ptr->CreateFont(m_ptr, filename, desc, &f)) )
            return new wxIDirectFBFont(f);
        else
            return NULL;
    }

    wxIDirectFBDisplayLayerPtr
    GetDisplayLayer(DFBDisplayLayerID id = DLID_PRIMARY)
    {
        IDirectFBDisplayLayer *l;
        if ( Check(m_ptr->GetDisplayLayer(m_ptr, id, &l)) )
            return new wxIDirectFBDisplayLayer(l);
        else
            return NULL;
    }

    /// Returns primary surface
    wxIDirectFBSurfacePtr GetPrimarySurface();

private:
    wxIDirectFB(IDirectFB *ptr) { Init(ptr); }

    // creates ms_ptr instance
    static void CreateDirectFB();

    static void CleanUp();
    friend class wxApp; // calls CleanUp

    // pointer to the singleton IDirectFB object
    static wxIDirectFBPtr ms_ptr;
};

#endif // _WX_DFB_WRAPDFB_H_
Commit	Line	Data
52c8d32a VS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: wx/dfb/wrapdfb.h
	3	// Purpose: wx wrappers for DirectFB interfaces
	4	// Author: Vaclav Slavik
	5	// Created: 2006-08-23
	6	// RCS-ID: $Id$
	7	// Copyright: (c) 2006 REA Elektronik GmbH
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	#ifndef _WX_DFB_WRAPDFB_H_
	12	#define _WX_DFB_WRAPDFB_H_
	13
	14	#include "wx/dfb/dfbptr.h"
	15
	16	#include <directfb.h>
	17
	18	wxDFB_DECLARE_INTERFACE(IDirectFB);
	19	wxDFB_DECLARE_INTERFACE(IDirectFBDisplayLayer);
	20	wxDFB_DECLARE_INTERFACE(IDirectFBWindow);
	21	wxDFB_DECLARE_INTERFACE(IDirectFBSurface);
	22	wxDFB_DECLARE_INTERFACE(IDirectFBPalette);
	23	wxDFB_DECLARE_INTERFACE(IDirectFBEventBuffer);
	24
	25
	26	/**
	27	Checks the @a code of a DirectFB call and returns true if it was
	28	successful and false if it failed, logging the errors as appropriate
	29	(asserts for programming errors, wxLogError for runtime failures).
	30	*/
	31	bool wxDfbCheckReturn(DFBResult code);
	32
	33	//-----------------------------------------------------------------------------
	34	// wxDfbEvent
	35	//-----------------------------------------------------------------------------
	36
	37	/**
	38	The struct defined by this macro is a thin wrapper around DFB*Event type.
	39	It is needed because DFB*Event are typedefs and so we can't forward declare
	40	them, but we need to pass them to methods declared in public headers where
	41	<directfb.h> cannot be included. So this struct just holds the event value,
	42	it's sole purpose is that it can be forward declared.
	43	*/
	44	#define WXDFB_DEFINE_EVENT_WRAPPER(T) \
	45	struct wx##T \
	46	{ \
	47	wx##T() {} \
	48	wx##T(const T& event) : m_event(event) {} \
	49	\
	50	operator T&() { return m_event; } \
	51	operator const T&() const { return m_event; } \
	52	T* operator&() { return &m_event; } \
	53	\
	54	DFBEventClass GetClass() const { return m_event.clazz; } \
	55	\
	56	private: \
	57	T m_event; \
	58	};
	59
	60	WXDFB_DEFINE_EVENT_WRAPPER(DFBEvent)
	61	WXDFB_DEFINE_EVENT_WRAPPER(DFBWindowEvent)
	62
	63
	64	//-----------------------------------------------------------------------------
65	// wxDfbWrapper<T>
66	//-----------------------------------------------------------------------------
67
68	/// Base class for wxDfbWrapper<T>
69	class wxDfbWrapperBase
70	{
71	public:
72	/// Increases reference count of the object
73	void AddRef()
74	{
75	m_refCnt++;
76	}
77
78	/// Decreases reference count and if it reaches zero, deletes the object
79	void Release()
80	{
81	if ( --m_refCnt == 0 )
82	delete this;
83	}
84
85	/// Returns result code of the last call
86	DFBResult GetLastResult() const { return m_lastResult; }
87
88	protected:
89	wxDfbWrapperBase() : m_refCnt(1), m_lastResult(DFB_OK) {}
90
91	/// Dtor may only be called from Release()
92	virtual ~wxDfbWrapperBase() {}
93
94	/**
95	Checks the @a result of a DirectFB call and returns true if it was
96	successful and false if it failed. Also stores result of the call
97	so that it can be obtained by calling GetLastResult().
98	*/
99	bool Check(DFBResult result)
100	{
101	m_lastResult = result;
102	return wxDfbCheckReturn(result);
103	}
104
105	protected:
106	/// Reference count
107	unsigned m_refCnt;
108
109	/// Result of the last DirectFB call
110	DFBResult m_lastResult;
111	};
112
113	/**
114	This template is base class for friendly C++ wrapper around DirectFB
115	interface T.
116
117	The wrapper provides same API as DirectFB, with a few exceptions:
118	- methods return true/false instead of error code
119	- methods that return or create another interface return pointer to the
120	interface (or NULL on failure) instead of storing it in the last
121	argument
122	- interface arguments use wxFooPtr type instead of raw DirectFB pointer
123	- methods taking flags use int type instead of an enum when the flags
124	can be or-combination of enum elements (this is workaround for
125	C++-unfriendly DirectFB API)
126	*/
127	template<typename T>
128	class wxDfbWrapper : public wxDfbWrapperBase
129	{
130	public:
131	/// "Raw" DirectFB interface type
132	typedef T DirectFBIface;
133
134	/// Returns raw DirectFB pointer
135	T *GetRaw() const { return m_ptr; }
136
137	protected:
138	/// To be called from ctor. Takes ownership of raw object.
139	void Init(T *ptr) { m_ptr = ptr; }
140
141	/// Dtor may only be used from Release
142	~wxDfbWrapper()
143	{
144	if ( m_ptr )
145	m_ptr->Release(m_ptr);
146	}
147
148	protected:
149	// pointer to DirectFB object
150	T *m_ptr;
151	};
152
153
154	//-----------------------------------------------------------------------------
155	// wxIDirectFBFont
156	//-----------------------------------------------------------------------------
157
158	struct wxIDirectFBFont : public wxDfbWrapper<IDirectFBFont>
159	{
160	wxIDirectFBFont(IDirectFBFont *s) { Init(s); }
161
162	bool GetStringWidth(const char text, int bytes, int w)
163	{ return Check(m_ptr->GetStringWidth(m_ptr, text, bytes, w)); }
164
165	bool GetStringExtents(const char *text, int bytes,
166	DFBRectangle logicalRect, DFBRectangle inkRect)
167	{
168	return Check(m_ptr->GetStringExtents(m_ptr, text, bytes,
169	logicalRect, inkRect));
170	}
171
172	bool GetHeight(int *h)
173	{ return Check(m_ptr->GetHeight(m_ptr, h)); }
174
175	bool GetDescender(int *descender)
176	{ return Check(m_ptr->GetDescender(m_ptr, descender)); }
177	};
178
179
180	//-----------------------------------------------------------------------------
181	// wxIDirectFBPalette
182	//-----------------------------------------------------------------------------
183
184	struct wxIDirectFBPalette : public wxDfbWrapper<IDirectFBPalette>
185	{
186	wxIDirectFBPalette(IDirectFBPalette *s) { Init(s); }
187	};
188
189
190	//-----------------------------------------------------------------------------
191	// wxIDirectFBSurface
192	//-----------------------------------------------------------------------------
193
194	struct wxIDirectFBSurface : public wxDfbWrapper<IDirectFBSurface>
195	{
196	wxIDirectFBSurface(IDirectFBSurface *s) { Init(s); }
197
198	bool GetSize(int w, int h)
199	{ return Check(m_ptr->GetSize(m_ptr, w, h)); }
200
201	bool GetCapabilities(DFBSurfaceCapabilities *caps)
202	{ return Check(m_ptr->GetCapabilities(m_ptr, caps)); }
203
204	bool GetPixelFormat(DFBSurfacePixelFormat *caps)
205	{ return Check(m_ptr->GetPixelFormat(m_ptr, caps)); }
206
207	bool SetClip(const DFBRegion *clip)
208	{ return Check(m_ptr->SetClip(m_ptr, clip)); }
209
210	bool SetColor(__u8 r, __u8 g, __u8 b, __u8 a)
211	{ return Check(m_ptr->SetColor(m_ptr, r, g, b, a)); }
212
213	bool Clear(__u8 r, __u8 g, __u8 b, __u8 a)
214	{ return Check(m_ptr->Clear(m_ptr, r, g, b, a)); }
215
216	bool DrawLine(int x1, int y1, int x2, int y2)
217	{ return Check(m_ptr->DrawLine(m_ptr, x1, y1, x2, y2)); }
218
219	bool DrawRectangle(int x, int y, int w, int h)
220	{ return Check(m_ptr->DrawRectangle(m_ptr, x, y, w, h)); }
221
222	bool FillRectangle(int x, int y, int w, int h)
223	{ return Check(m_ptr->FillRectangle(m_ptr, x, y, w, h)); }
224
225	bool SetFont(const wxIDirectFBFontPtr& font)
226	{ return Check(m_ptr->SetFont(m_ptr, font->GetRaw())); }
227
228	bool DrawString(const char *text, int bytes, int x, int y, int flags)
229	{
230	return Check(m_ptr->DrawString(m_ptr, text, bytes, x, y,
231	(DFBSurfaceTextFlags)flags));
232	}
233
20671963 VS	234	/**
	235	Updates the front buffer from the back buffer. If @a region is not
	236	NULL, only given rectangle is updated.
	237	*/
	238	bool FlipToFront(const DFBRegion *region = NULL);
52c8d32a VS	239
	240	wxIDirectFBSurfacePtr GetSubSurface(const DFBRectangle *rect)
	241	{
	242	IDirectFBSurface *s;
	243	if ( Check(m_ptr->GetSubSurface(m_ptr, rect, &s)) )
	244	return new wxIDirectFBSurface(s);
	245	else
	246	return NULL;
	247	}
	248
	249	wxIDirectFBPalettePtr GetPalette()
	250	{
	251	IDirectFBPalette *s;
	252	if ( Check(m_ptr->GetPalette(m_ptr, &s)) )
	253	return new wxIDirectFBPalette(s);
	254	else
	255	return NULL;
	256	}
	257
	258	bool SetPalette(const wxIDirectFBPalettePtr& pal)
	259	{ return Check(m_ptr->SetPalette(m_ptr, pal->GetRaw())); }
	260
	261	bool SetBlittingFlags(int flags)
	262	{
	263	return Check(
	264	m_ptr->SetBlittingFlags(m_ptr, (DFBSurfaceBlittingFlags)flags));
	265	}
	266
	267	bool Blit(const wxIDirectFBSurfacePtr& source,
	268	const DFBRectangle *source_rect,
	269	int x, int y)
a5b31f4e VS	270	{ return Blit(source->GetRaw(), source_rect, x, y); }
	271
	272	bool Blit(IDirectFBSurface *source,
	273	const DFBRectangle *source_rect,
	274	int x, int y)
	275	{ return Check(m_ptr->Blit(m_ptr, source, source_rect, x, y)); }
	276
5942996c VS	277	bool StretchBlit(const wxIDirectFBSurfacePtr& source,
	278	const DFBRectangle *source_rect,
	279	const DFBRectangle *dest_rect)
	280	{
	281	return Check(m_ptr->StretchBlit(m_ptr, source->GetRaw(),
	282	source_rect, dest_rect));
	283	}
	284
a5b31f4e VS	285
	286	/// Returns bit depth used by the surface or -1 on error
	287	int GetDepth();
	288
	289	/**
	290	Creates a new surface by cloning this one. New surface will have same
	291	capabilities, pixel format and pixel data as the existing one.
	292
	293	@see CreateCompatible
	294	*/
	295	wxIDirectFBSurfacePtr Clone();
	296
7e2baeb4 VS	297	/// Flags for CreateCompatible()
	298	enum CreateCompatibleFlags
	299	{
	300	/// Don't create double-buffered surface
	301	CreateCompatible_NoBackBuffer = 1
	302	};
	303
a5b31f4e VS	304	/**
	305	Creates a surface compatible with this one, i.e. surface with the same
	306	capabilities and pixel format, but with different and size.
	307
7e2baeb4 VS	308	@param size Size of the surface to create. If wxDefaultSize, use the
	309	size of this surface.
	310	@param flags Or-combination of CreateCompatibleFlags values
a5b31f4e	311	*/
7e2baeb4 VS	312	wxIDirectFBSurfacePtr CreateCompatible(const wxSize& size = wxDefaultSize,
7e2baeb4 VS	313	int flags = 0);
20671963 VS	314
	315	private:
	316	// this is private because we want user code to use FlipToFront()
	317	bool Flip(const DFBRegion *region, int flags);
52c8d32a VS	318	};
	319
	320
	321	//-----------------------------------------------------------------------------
	322	// wxIDirectFBEventBuffer
	323	//-----------------------------------------------------------------------------
	324
	325	struct wxIDirectFBEventBuffer : public wxDfbWrapper<IDirectFBEventBuffer>
	326	{
	327	wxIDirectFBEventBuffer(IDirectFBEventBuffer *s) { Init(s); }
	328
	329	bool WakeUp()
	330	{
	331	return Check(m_ptr->WakeUp(m_ptr));
	332	}
	333
	334	bool HasEvent()
	335	{
	336	// returns DFB_OK if there is >=1 event, DFB_BUFFEREMPTY otherwise
	337	DFBResult r = m_ptr->HasEvent(m_ptr);
	338
	339	// NB: Check() also returns true for DFB_BUFFEREMPTY, so we can't just
	340	// return it's return value:
	341	Check(r);
	342	return (r == DFB_OK);
	343	}
	344
	345	bool WaitForEventWithTimeout(unsigned secs, unsigned millisecs)
	346	{
6a613ad6 VS	347	DFBResult r = m_ptr->WaitForEventWithTimeout(m_ptr, secs, millisecs);
	348
	349	// DFB_TIMEOUT is not an error in this function:
	350	if ( r == DFB_TIMEOUT )
	351	{
	352	m_lastResult = DFB_TIMEOUT;
	353	return true;
	354	}
	355
	356	return Check(r);
52c8d32a VS	357	}
	358
	359	bool GetEvent(wxDFBEvent& event)
	360	{
	361	return Check(m_ptr->GetEvent(m_ptr, &event));
	362	}
	363	};
	364
	365
	366	//-----------------------------------------------------------------------------
	367	// wxIDirectFBWindow
	368	//-----------------------------------------------------------------------------
	369
	370	struct wxIDirectFBWindow : public wxDfbWrapper<IDirectFBWindow>
	371	{
	372	wxIDirectFBWindow(IDirectFBWindow *s) { Init(s); }
	373
	374	bool GetID(DFBWindowID *id)
	375	{ return Check(m_ptr->GetID(m_ptr, id)); }
	376
	377	bool GetPosition(int x, int y)
	378	{ return Check(m_ptr->GetPosition(m_ptr, x, y)); }
	379
	380	bool GetSize(int w, int h)
	381	{ return Check(m_ptr->GetSize(m_ptr, w, h)); }
	382
	383	bool MoveTo(int x, int y)
	384	{ return Check(m_ptr->MoveTo(m_ptr, x, y)); }
	385
	386	bool Resize(int w, int h)
	387	{ return Check(m_ptr->Resize(m_ptr, w, h)); }
	388
	389	bool SetOpacity(__u8 opacity)
	390	{ return Check(m_ptr->SetOpacity(m_ptr, opacity)); }
	391
	392	bool SetStackingClass(DFBWindowStackingClass klass)
	393	{ return Check(m_ptr->SetStackingClass(m_ptr, klass)); }
	394
	395	wxIDirectFBSurfacePtr GetSurface()
	396	{
	397	IDirectFBSurface *s;
	398	if ( Check(m_ptr->GetSurface(m_ptr, &s)) )
	399	return new wxIDirectFBSurface(s);
	400	else
	401	return NULL;
	402	}
	403
	404	bool AttachEventBuffer(const wxIDirectFBEventBufferPtr& buffer)
	405	{ return Check(m_ptr->AttachEventBuffer(m_ptr, buffer->GetRaw())); }
	406
	407	bool RequestFocus()
	408	{ return Check(m_ptr->RequestFocus(m_ptr)); }
	409	};
	410
	411
	412	//-----------------------------------------------------------------------------
	413	// wxIDirectFBDisplayLayer
	414	//-----------------------------------------------------------------------------
	415
	416	struct wxIDirectFBDisplayLayer : public wxDfbWrapper<IDirectFBDisplayLayer>
	417	{
	418	wxIDirectFBDisplayLayer(IDirectFBDisplayLayer *s) { Init(s); }
	419
	420	wxIDirectFBWindowPtr CreateWindow(const DFBWindowDescription *desc)
421	{
422	IDirectFBWindow *w;
423	if ( Check(m_ptr->CreateWindow(m_ptr, desc, &w)) )
424	return new wxIDirectFBWindow(w);
425	else
426	return NULL;
427	}
428
429	wxIDirectFBSurfacePtr GetSurface()
430	{
431	IDirectFBSurface *s;
432	if ( Check(m_ptr->GetSurface(m_ptr, &s)) )
433	return new wxIDirectFBSurface(s);
434	else
435	return NULL;
436	}
437
438	bool GetCursorPosition(int x, int y)
439	{ return Check(m_ptr->GetCursorPosition(m_ptr, x, y)); }
440
441	bool WarpCursor(int x, int y)
442	{ return Check(m_ptr->WarpCursor(m_ptr, x, y)); }
443	};
444
445
446	//-----------------------------------------------------------------------------
447	// wxIDirectFB
448	//-----------------------------------------------------------------------------
449
450	struct wxIDirectFB : public wxDfbWrapper<IDirectFB>
451	{
452	/**
453	Returns pointer to DirectFB singleton object, it never returns NULL
454	after wxApp was initialized. The object is cached, so calling this
455	method is cheap.
456	*/
457	static wxIDirectFBPtr Get()
458	{
459	if ( !ms_ptr ) CreateDirectFB();
460	return ms_ptr;
461	}
462
463	bool SetVideoMode(int w, int h, int bpp)
464	{ return Check(m_ptr->SetVideoMode(m_ptr, w, h, bpp)); }
465
466	wxIDirectFBSurfacePtr CreateSurface(const DFBSurfaceDescription *desc)
467	{
468	IDirectFBSurface *s;
469	if ( Check(m_ptr->CreateSurface(m_ptr, desc, &s)) )
470	return new wxIDirectFBSurface(s);
471	else
472	return NULL;
473	}
474
475	wxIDirectFBEventBufferPtr CreateEventBuffer()
476	{
477	IDirectFBEventBuffer *b;
478	if ( Check(m_ptr->CreateEventBuffer(m_ptr, &b)) )
479	return new wxIDirectFBEventBuffer(b);
480	else
481	return NULL;
482	}
483
484	wxIDirectFBFontPtr CreateFont(const char *filename,
485	const DFBFontDescription *desc)
486	{
487	IDirectFBFont *f;
488	if ( Check(m_ptr->CreateFont(m_ptr, filename, desc, &f)) )
489	return new wxIDirectFBFont(f);
490	else
491	return NULL;
492	}
493
a5b31f4e VS	494	wxIDirectFBDisplayLayerPtr
a5b31f4e VS	495	GetDisplayLayer(DFBDisplayLayerID id = DLID_PRIMARY)
52c8d32a VS	496	{
	497	IDirectFBDisplayLayer *l;
	498	if ( Check(m_ptr->GetDisplayLayer(m_ptr, id, &l)) )
	499	return new wxIDirectFBDisplayLayer(l);
	500	else
	501	return NULL;
	502	}
	503
a5b31f4e VS	504	/// Returns primary surface
	505	wxIDirectFBSurfacePtr GetPrimarySurface();
	506
52c8d32a VS	507	private:
	508	wxIDirectFB(IDirectFB *ptr) { Init(ptr); }
	509
	510	// creates ms_ptr instance
	511	static void CreateDirectFB();
	512
	513	static void CleanUp();
	514	friend class wxApp; // calls CleanUp
	515
	516	// pointer to the singleton IDirectFB object
	517	static wxIDirectFBPtr ms_ptr;
	518	};
	519
	520	#endif // _WX_DFB_WRAPDFB_H_