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