include/wx/dfb/wrapdfb.h

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