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

    bool Flip(const DFBRegion *region, int flags)
    {
        return Check(m_ptr->Flip(m_ptr, region, (DFBSurfaceFlipFlags)flags));
    }

    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 Check(
                m_ptr->Blit(m_ptr, source->GetRaw(), source_rect, x, y));
    }
};


//-----------------------------------------------------------------------------
// 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)
    {
        IDirectFBDisplayLayer *l;
        if ( Check(m_ptr->GetDisplayLayer(m_ptr, id, &l)) )
            return new wxIDirectFBDisplayLayer(l);
        else
            return NULL;
    }

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
234	bool Flip(const DFBRegion *region, int flags)
235	{
236	return Check(m_ptr->Flip(m_ptr, region, (DFBSurfaceFlipFlags)flags));
237	}
238
239	wxIDirectFBSurfacePtr GetSubSurface(const DFBRectangle *rect)
240	{
241	IDirectFBSurface *s;
242	if ( Check(m_ptr->GetSubSurface(m_ptr, rect, &s)) )
243	return new wxIDirectFBSurface(s);
244	else
245	return NULL;
246	}
247
248	wxIDirectFBPalettePtr GetPalette()
249	{
250	IDirectFBPalette *s;
251	if ( Check(m_ptr->GetPalette(m_ptr, &s)) )
252	return new wxIDirectFBPalette(s);
253	else
254	return NULL;
255	}
256
257	bool SetPalette(const wxIDirectFBPalettePtr& pal)
258	{ return Check(m_ptr->SetPalette(m_ptr, pal->GetRaw())); }
259
260	bool SetBlittingFlags(int flags)
261	{
262	return Check(
263	m_ptr->SetBlittingFlags(m_ptr, (DFBSurfaceBlittingFlags)flags));
264	}
265
266	bool Blit(const wxIDirectFBSurfacePtr& source,
267	const DFBRectangle *source_rect,
268	int x, int y)
269	{
270	return Check(
271	m_ptr->Blit(m_ptr, source->GetRaw(), source_rect, x, y));
272	}
273	};
274
275
276	//-----------------------------------------------------------------------------
277	// wxIDirectFBEventBuffer
278	//-----------------------------------------------------------------------------
279
280	struct wxIDirectFBEventBuffer : public wxDfbWrapper<IDirectFBEventBuffer>
281	{
282	wxIDirectFBEventBuffer(IDirectFBEventBuffer *s) { Init(s); }
283
284	bool WakeUp()
285	{
286	return Check(m_ptr->WakeUp(m_ptr));
287	}
288
289	bool HasEvent()
290	{
291	// returns DFB_OK if there is >=1 event, DFB_BUFFEREMPTY otherwise
292	DFBResult r = m_ptr->HasEvent(m_ptr);
293
294	// NB: Check() also returns true for DFB_BUFFEREMPTY, so we can't just
295	// return it's return value:
296	Check(r);
297	return (r == DFB_OK);
298	}
299
300	bool WaitForEventWithTimeout(unsigned secs, unsigned millisecs)
301	{
6a613ad6 VS	302	DFBResult r = m_ptr->WaitForEventWithTimeout(m_ptr, secs, millisecs);
	303
	304	// DFB_TIMEOUT is not an error in this function:
	305	if ( r == DFB_TIMEOUT )
	306	{
	307	m_lastResult = DFB_TIMEOUT;
	308	return true;
	309	}
	310
	311	return Check(r);
52c8d32a VS	312	}
	313
	314	bool GetEvent(wxDFBEvent& event)
	315	{
	316	return Check(m_ptr->GetEvent(m_ptr, &event));
	317	}
	318	};
	319
	320
	321	//-----------------------------------------------------------------------------
	322	// wxIDirectFBWindow
	323	//-----------------------------------------------------------------------------
	324
	325	struct wxIDirectFBWindow : public wxDfbWrapper<IDirectFBWindow>
	326	{
	327	wxIDirectFBWindow(IDirectFBWindow *s) { Init(s); }
	328
	329	bool GetID(DFBWindowID *id)
	330	{ return Check(m_ptr->GetID(m_ptr, id)); }
	331
	332	bool GetPosition(int x, int y)
	333	{ return Check(m_ptr->GetPosition(m_ptr, x, y)); }
	334
	335	bool GetSize(int w, int h)
	336	{ return Check(m_ptr->GetSize(m_ptr, w, h)); }
	337
	338	bool MoveTo(int x, int y)
	339	{ return Check(m_ptr->MoveTo(m_ptr, x, y)); }
	340
	341	bool Resize(int w, int h)
	342	{ return Check(m_ptr->Resize(m_ptr, w, h)); }
	343
	344	bool SetOpacity(__u8 opacity)
	345	{ return Check(m_ptr->SetOpacity(m_ptr, opacity)); }
	346
	347	bool SetStackingClass(DFBWindowStackingClass klass)
	348	{ return Check(m_ptr->SetStackingClass(m_ptr, klass)); }
	349
	350	wxIDirectFBSurfacePtr GetSurface()
	351	{
	352	IDirectFBSurface *s;
	353	if ( Check(m_ptr->GetSurface(m_ptr, &s)) )
	354	return new wxIDirectFBSurface(s);
	355	else
	356	return NULL;
	357	}
	358
	359	bool AttachEventBuffer(const wxIDirectFBEventBufferPtr& buffer)
	360	{ return Check(m_ptr->AttachEventBuffer(m_ptr, buffer->GetRaw())); }
	361
	362	bool RequestFocus()
	363	{ return Check(m_ptr->RequestFocus(m_ptr)); }
	364	};
	365
	366
	367	//-----------------------------------------------------------------------------
	368	// wxIDirectFBDisplayLayer
	369	//-----------------------------------------------------------------------------
	370
	371	struct wxIDirectFBDisplayLayer : public wxDfbWrapper<IDirectFBDisplayLayer>
	372	{
	373	wxIDirectFBDisplayLayer(IDirectFBDisplayLayer *s) { Init(s); }
	374
	375	wxIDirectFBWindowPtr CreateWindow(const DFBWindowDescription *desc)
376	{
377	IDirectFBWindow *w;
378	if ( Check(m_ptr->CreateWindow(m_ptr, desc, &w)) )
379	return new wxIDirectFBWindow(w);
380	else
381	return NULL;
382	}
383
384	wxIDirectFBSurfacePtr GetSurface()
385	{
386	IDirectFBSurface *s;
387	if ( Check(m_ptr->GetSurface(m_ptr, &s)) )
388	return new wxIDirectFBSurface(s);
389	else
390	return NULL;
391	}
392
393	bool GetCursorPosition(int x, int y)
394	{ return Check(m_ptr->GetCursorPosition(m_ptr, x, y)); }
395
396	bool WarpCursor(int x, int y)
397	{ return Check(m_ptr->WarpCursor(m_ptr, x, y)); }
398	};
399
400
401	//-----------------------------------------------------------------------------
402	// wxIDirectFB
403	//-----------------------------------------------------------------------------
404
405	struct wxIDirectFB : public wxDfbWrapper<IDirectFB>
406	{
407	/**
408	Returns pointer to DirectFB singleton object, it never returns NULL
409	after wxApp was initialized. The object is cached, so calling this
410	method is cheap.
411	*/
412	static wxIDirectFBPtr Get()
413	{
414	if ( !ms_ptr ) CreateDirectFB();
415	return ms_ptr;
416	}
417
418	bool SetVideoMode(int w, int h, int bpp)
419	{ return Check(m_ptr->SetVideoMode(m_ptr, w, h, bpp)); }
420
421	wxIDirectFBSurfacePtr CreateSurface(const DFBSurfaceDescription *desc)
422	{
423	IDirectFBSurface *s;
424	if ( Check(m_ptr->CreateSurface(m_ptr, desc, &s)) )
425	return new wxIDirectFBSurface(s);
426	else
427	return NULL;
428	}
429
430	wxIDirectFBEventBufferPtr CreateEventBuffer()
431	{
432	IDirectFBEventBuffer *b;
433	if ( Check(m_ptr->CreateEventBuffer(m_ptr, &b)) )
434	return new wxIDirectFBEventBuffer(b);
435	else
436	return NULL;
437	}
438
439	wxIDirectFBFontPtr CreateFont(const char *filename,
440	const DFBFontDescription *desc)
441	{
442	IDirectFBFont *f;
443	if ( Check(m_ptr->CreateFont(m_ptr, filename, desc, &f)) )
444	return new wxIDirectFBFont(f);
445	else
446	return NULL;
447	}
448
449	wxIDirectFBDisplayLayerPtr GetDisplayLayer(DFBDisplayLayerID id)
450	{
451	IDirectFBDisplayLayer *l;
452	if ( Check(m_ptr->GetDisplayLayer(m_ptr, id, &l)) )
453	return new wxIDirectFBDisplayLayer(l);
454	else
455	return NULL;
456	}
457
458	private:
459	wxIDirectFB(IDirectFB *ptr) { Init(ptr); }
460
461	// creates ms_ptr instance
462	static void CreateDirectFB();
463
464	static void CleanUp();
465	friend class wxApp; // calls CleanUp
466
467	// pointer to the singleton IDirectFB object
468	static wxIDirectFBPtr ms_ptr;
469	};
470
471	#endif // _WX_DFB_WRAPDFB_H_