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

    bool GetConfiguration(DFBDisplayLayerConfig *config)
        { return Check(m_ptr->GetConfiguration(m_ptr, config)); }

    wxVideoMode GetVideoMode();

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