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     {
 270         return Check(
 271                 m_ptr->Blit(m_ptr, source->GetRaw(), source_rect, x, y));
 272     }
 273 };
 274
 275
 276 //-----------------------------------------------------------------------------
 277 // wxIDirectFBEventBuffer
 278 //-----------------------------------------------------------------------------
 279
 280 struct wxIDirectFBEventBuffer : public wxDfbWrapper<IDirectFBEventBuffer>
 281 {
 282     wxIDirectFBEventBuffer(IDirectFBEventBuffer *s) { Init(s); }
 283
 284     bool WakeUp()
 285     {
 286         return Check(m_ptr->WakeUp(m_ptr));
 287     }
 288
 289     bool HasEvent()
 290     {
 291         // returns DFB_OK if there is >=1 event, DFB_BUFFEREMPTY otherwise
 292         DFBResult r = m_ptr->HasEvent(m_ptr);
 293
 294         // NB: Check() also returns true for DFB_BUFFEREMPTY, so we can't just
 295         //     return it's return value:
 296         Check(r);
 297         return (r == DFB_OK);
 298     }
 299
 300     bool WaitForEventWithTimeout(unsigned secs, unsigned millisecs)
 301     {
 302         DFBResult r = m_ptr->WaitForEventWithTimeout(m_ptr, secs, millisecs);
 303
 304         // DFB_TIMEOUT is not an error in this function:
 305         if ( r == DFB_TIMEOUT )
 306         {
 307             m_lastResult = DFB_TIMEOUT;
 308             return true;
 309         }
 310
 311         return Check(r);
 312     }
 313
 314     bool GetEvent(wxDFBEvent& event)
 315     {
 316         return Check(m_ptr->GetEvent(m_ptr, &event));
 317     }
 318 };
 319
 320
 321 //-----------------------------------------------------------------------------
 322 // wxIDirectFBWindow
 323 //-----------------------------------------------------------------------------
 324
 325 struct wxIDirectFBWindow : public wxDfbWrapper<IDirectFBWindow>
 326 {
 327     wxIDirectFBWindow(IDirectFBWindow *s) { Init(s); }
 328
 329     bool GetID(DFBWindowID *id)
 330         { return Check(m_ptr->GetID(m_ptr, id)); }
 331
 332     bool GetPosition(int *x, int *y)
 333         { return Check(m_ptr->GetPosition(m_ptr, x, y)); }
 334
 335     bool GetSize(int *w, int *h)
 336         { return Check(m_ptr->GetSize(m_ptr, w, h)); }
 337
 338     bool MoveTo(int x, int y)
 339         { return Check(m_ptr->MoveTo(m_ptr, x, y)); }
 340
 341     bool Resize(int w, int h)
 342         { return Check(m_ptr->Resize(m_ptr, w, h)); }
 343
 344     bool SetOpacity(__u8 opacity)
 345         { return Check(m_ptr->SetOpacity(m_ptr, opacity)); }
 346
 347     bool SetStackingClass(DFBWindowStackingClass klass)
 348         { return Check(m_ptr->SetStackingClass(m_ptr, klass)); }
 349
 350     wxIDirectFBSurfacePtr GetSurface()
 351     {
 352         IDirectFBSurface *s;
 353         if ( Check(m_ptr->GetSurface(m_ptr, &s)) )
 354             return new wxIDirectFBSurface(s);
 355         else
 356             return NULL;
 357     }
 358
 359     bool AttachEventBuffer(const wxIDirectFBEventBufferPtr& buffer)
 360         { return Check(m_ptr->AttachEventBuffer(m_ptr, buffer->GetRaw())); }
 361
 362     bool RequestFocus()
 363         { return Check(m_ptr->RequestFocus(m_ptr)); }
 364 };
 365
 366
 367 //-----------------------------------------------------------------------------
 368 // wxIDirectFBDisplayLayer
 369 //-----------------------------------------------------------------------------
 370
 371 struct wxIDirectFBDisplayLayer : public wxDfbWrapper<IDirectFBDisplayLayer>
 372 {
 373     wxIDirectFBDisplayLayer(IDirectFBDisplayLayer *s) { Init(s); }
 374
 375     wxIDirectFBWindowPtr CreateWindow(const DFBWindowDescription *desc)
 376     {
 377         IDirectFBWindow *w;
 378         if ( Check(m_ptr->CreateWindow(m_ptr, desc, &w)) )
 379             return new wxIDirectFBWindow(w);
 380         else
 381             return NULL;
 382     }
 383
 384     wxIDirectFBSurfacePtr GetSurface()
 385     {
 386         IDirectFBSurface *s;
 387         if ( Check(m_ptr->GetSurface(m_ptr, &s)) )
 388             return new wxIDirectFBSurface(s);
 389         else
 390             return NULL;
 391     }
 392
 393     bool GetCursorPosition(int *x, int *y)
 394         { return Check(m_ptr->GetCursorPosition(m_ptr, x, y)); }
 395
 396     bool WarpCursor(int x, int y)
 397         { return Check(m_ptr->WarpCursor(m_ptr, x, y)); }
 398 };
 399
 400
 401 //-----------------------------------------------------------------------------
 402 // wxIDirectFB
 403 //-----------------------------------------------------------------------------
 404
 405 struct wxIDirectFB : public wxDfbWrapper<IDirectFB>
 406 {
 407     /**
 408         Returns pointer to DirectFB singleton object, it never returns NULL
 409         after wxApp was initialized. The object is cached, so calling this
 410         method is cheap.
 411      */
 412     static wxIDirectFBPtr Get()
 413     {
 414         if ( !ms_ptr ) CreateDirectFB();
 415         return ms_ptr;
 416     }
 417
 418     bool SetVideoMode(int w, int h, int bpp)
 419         { return Check(m_ptr->SetVideoMode(m_ptr, w, h, bpp)); }
 420
 421     wxIDirectFBSurfacePtr CreateSurface(const DFBSurfaceDescription *desc)
 422     {
 423         IDirectFBSurface *s;
 424         if ( Check(m_ptr->CreateSurface(m_ptr, desc, &s)) )
 425             return new wxIDirectFBSurface(s);
 426         else
 427             return NULL;
 428     }
 429
 430     wxIDirectFBEventBufferPtr CreateEventBuffer()
 431     {
 432         IDirectFBEventBuffer *b;
 433         if ( Check(m_ptr->CreateEventBuffer(m_ptr, &b)) )
 434             return new wxIDirectFBEventBuffer(b);
 435         else
 436             return NULL;
 437     }
 438
 439     wxIDirectFBFontPtr CreateFont(const char *filename,
 440                                   const DFBFontDescription *desc)
 441     {
 442         IDirectFBFont *f;
 443         if ( Check(m_ptr->CreateFont(m_ptr, filename, desc, &f)) )
 444             return new wxIDirectFBFont(f);
 445         else
 446             return NULL;
 447     }
 448
 449     wxIDirectFBDisplayLayerPtr GetDisplayLayer(DFBDisplayLayerID id)
 450     {
 451         IDirectFBDisplayLayer *l;
 452         if ( Check(m_ptr->GetDisplayLayer(m_ptr, id, &l)) )
 453             return new wxIDirectFBDisplayLayer(l);
 454         else
 455             return NULL;
 456     }
 457
 458 private:
 459     wxIDirectFB(IDirectFB *ptr) { Init(ptr); }
 460
 461     // creates ms_ptr instance
 462     static void CreateDirectFB();
 463
 464     static void CleanUp();
 465     friend class wxApp; // calls CleanUp
 466
 467     // pointer to the singleton IDirectFB object
 468     static wxIDirectFBPtr ms_ptr;
 469 };
 470
 471 #endif // _WX_DFB_WRAPDFB_H_