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