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