]> git.saurik.com Git - wxWidgets.git/blame - include/wx/dfb/wrapdfb.h
Get/Set LayoutDirection
[wxWidgets.git] / include / wx / dfb / wrapdfb.h
CommitLineData
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
18wxDFB_DECLARE_INTERFACE(IDirectFB);
19wxDFB_DECLARE_INTERFACE(IDirectFBDisplayLayer);
d7ae4a62 20wxDFB_DECLARE_INTERFACE(IDirectFBFont);
52c8d32a
VS
21wxDFB_DECLARE_INTERFACE(IDirectFBWindow);
22wxDFB_DECLARE_INTERFACE(IDirectFBSurface);
23wxDFB_DECLARE_INTERFACE(IDirectFBPalette);
24wxDFB_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 */
32bool 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
61WXDFB_DEFINE_EVENT_WRAPPER(DFBEvent)
62WXDFB_DEFINE_EVENT_WRAPPER(DFBWindowEvent)
63
64
65//-----------------------------------------------------------------------------
66// wxDfbWrapper<T>
67//-----------------------------------------------------------------------------
68
69/// Base class for wxDfbWrapper<T>
70class wxDfbWrapperBase
71{
72public:
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
89protected:
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
106protected:
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 */
128template<typename T>
129class wxDfbWrapper : public wxDfbWrapperBase
130{
131public:
132 /// "Raw" DirectFB interface type
133 typedef T DirectFBIface;
134
135 /// Returns raw DirectFB pointer
136 T *GetRaw() const { return m_ptr; }
137
138protected:
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
149protected:
150 // pointer to DirectFB object
151 T *m_ptr;
152};
153
154
155//-----------------------------------------------------------------------------
156// wxIDirectFBFont
157//-----------------------------------------------------------------------------
158
159struct 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
185struct wxIDirectFBPalette : public wxDfbWrapper<IDirectFBPalette>
186{
187 wxIDirectFBPalette(IDirectFBPalette *s) { Init(s); }
188};
189
190
191//-----------------------------------------------------------------------------
192// wxIDirectFBSurface
193//-----------------------------------------------------------------------------
194
195struct 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,
314 int flags = 0);
20671963
VS
315
316private:
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
326struct 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
371struct 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
417struct 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
447struct 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
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
504private:
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_