going private for m_peer to give a foundation for better encapsulation

[wxWidgets.git] / include / wx / dfb / wrapdfb.h

diff --git a/include/wx/dfb/wrapdfb.h b/include/wx/dfb/wrapdfb.h
index 970c6ebf96d9fe82f461639778e49f6a3b8cc4d2..602dd7c5fb7b14e9ba6e54bc6ffec914c6c2ff79 100644 (file)
--- a/include/wx/dfb/wrapdfb.h
+++ b/include/wx/dfb/wrapdfb.h
@@ -12,11 +12,21 @@
 #define _WX_DFB_WRAPDFB_H_
 
 #include "wx/dfb/dfbptr.h"
 #define _WX_DFB_WRAPDFB_H_
 
 #include "wx/dfb/dfbptr.h"

+#include "wx/gdicmn.h"
+#include "wx/vidmode.h"

 
 #include <directfb.h>
 
 #include <directfb.h>

+#include <directfb_version.h>
+
+// DFB < 1.0 didn't have u8 type, only __u8
+#if DIRECTFB_MAJOR_VERSION == 0
+typedef __u8 u8;
+#endif
+

 
 wxDFB_DECLARE_INTERFACE(IDirectFB);
 wxDFB_DECLARE_INTERFACE(IDirectFBDisplayLayer);
 
 wxDFB_DECLARE_INTERFACE(IDirectFB);
 wxDFB_DECLARE_INTERFACE(IDirectFBDisplayLayer);

+wxDFB_DECLARE_INTERFACE(IDirectFBFont);

 wxDFB_DECLARE_INTERFACE(IDirectFBWindow);
 wxDFB_DECLARE_INTERFACE(IDirectFBSurface);
 wxDFB_DECLARE_INTERFACE(IDirectFBPalette);
 wxDFB_DECLARE_INTERFACE(IDirectFBWindow);
 wxDFB_DECLARE_INTERFACE(IDirectFBSurface);
 wxDFB_DECLARE_INTERFACE(IDirectFBPalette);


@@ -204,13 +214,16 @@ struct wxIDirectFBSurface : public wxDfbWrapper<IDirectFBSurface>
     bool GetPixelFormat(DFBSurfacePixelFormat *caps)
         { return Check(m_ptr->GetPixelFormat(m_ptr, caps)); }
 
     bool GetPixelFormat(DFBSurfacePixelFormat *caps)
         { return Check(m_ptr->GetPixelFormat(m_ptr, caps)); }
 

+    // convenience version of GetPixelFormat, returns DSPF_UNKNOWN if fails
+    DFBSurfacePixelFormat GetPixelFormat();
+

     bool SetClip(const DFBRegion *clip)
         { return Check(m_ptr->SetClip(m_ptr, clip)); }
 
     bool SetClip(const DFBRegion *clip)
         { return Check(m_ptr->SetClip(m_ptr, clip)); }
 

-    bool SetColor(__u8 r, __u8 g, __u8 b, __u8 a)
+    bool SetColor(u8 r, u8 g, u8 b, u8 a)

         { return Check(m_ptr->SetColor(m_ptr, r, g, b, a)); }
 
         { return Check(m_ptr->SetColor(m_ptr, r, g, b, a)); }
 

-    bool Clear(__u8 r, __u8 g, __u8 b, __u8 a)
+    bool Clear(u8 r, u8 g, u8 b, u8 a)

         { return Check(m_ptr->Clear(m_ptr, r, g, b, a)); }
 
     bool DrawLine(int x1, int y1, int x2, int y2)
         { return Check(m_ptr->Clear(m_ptr, r, g, b, a)); }
 
     bool DrawLine(int x1, int y1, int x2, int y2)


@@ -231,10 +244,11 @@ struct wxIDirectFBSurface : public wxDfbWrapper<IDirectFBSurface>
                                          (DFBSurfaceTextFlags)flags));
     }
 
                                          (DFBSurfaceTextFlags)flags));
     }
 

-    bool Flip(const DFBRegion *region, int flags)
-    {
-        return Check(m_ptr->Flip(m_ptr, region, (DFBSurfaceFlipFlags)flags));
-    }
+    /**
+        Updates the front buffer from the back buffer. If @a region is not
+        NULL, only given rectangle is updated.
+     */
+    bool FlipToFront(const DFBRegion *region = NULL);

 
     wxIDirectFBSurfacePtr GetSubSurface(const DFBRectangle *rect)
     {
 
     wxIDirectFBSurfacePtr GetSubSurface(const DFBRectangle *rect)
     {


@@ -266,54 +280,97 @@ struct wxIDirectFBSurface : public wxDfbWrapper<IDirectFBSurface>
     bool Blit(const wxIDirectFBSurfacePtr& source,
               const DFBRectangle *source_rect,
               int x, int y)
     bool Blit(const wxIDirectFBSurfacePtr& source,
               const DFBRectangle *source_rect,
               int x, int y)

+        { return Blit(source->GetRaw(), source_rect, x, y); }
+
+    bool Blit(IDirectFBSurface *source,
+              const DFBRectangle *source_rect,
+              int x, int y)
+        { return Check(m_ptr->Blit(m_ptr, source, source_rect, x, y)); }
+
+    bool StretchBlit(const wxIDirectFBSurfacePtr& source,
+              const DFBRectangle *source_rect,
+              const DFBRectangle *dest_rect)

     {
     {

-        return Check(
-                m_ptr->Blit(m_ptr, source->GetRaw(), source_rect, x, y));
+        return Check(m_ptr->StretchBlit(m_ptr, source->GetRaw(),
+                                        source_rect, dest_rect));

     }
     }

-};

 
 

+    /// Returns bit depth used by the surface or -1 on error
+    int GetDepth();

 
 

-//-----------------------------------------------------------------------------
-// wxIDirectFBEventBuffer
-//-----------------------------------------------------------------------------
+    /**
+        Creates a new surface by cloning this one. New surface will have same
+        capabilities, pixel format and pixel data as the existing one.

 
 

-struct wxIDirectFBEventBuffer : public wxDfbWrapper<IDirectFBEventBuffer>
-{
-    wxIDirectFBEventBuffer(IDirectFBEventBuffer *s) { Init(s); }
+        @see CreateCompatible
+     */
+    wxIDirectFBSurfacePtr Clone();

 
 

-    bool WakeUp()
+    /// Flags for CreateCompatible()
+    enum CreateCompatibleFlags

     {
     {

-        return Check(m_ptr->WakeUp(m_ptr));
-    }
+        /// Don't create double-buffered surface
+        CreateCompatible_NoBackBuffer = 1
+    };

 
 

-    bool HasEvent()
-    {
-        // returns DFB_OK if there is >=1 event, DFB_BUFFEREMPTY otherwise
-        DFBResult r = m_ptr->HasEvent(m_ptr);
+    /**
+        Creates a surface compatible with this one, i.e. surface with the same
+        capabilities and pixel format, but with different and size.

 
 

-        // NB: Check() also returns true for DFB_BUFFEREMPTY, so we can't just
-        //     return it's return value:
-        Check(r);
-        return (r == DFB_OK);
-    }
+        @param size  Size of the surface to create. If wxDefaultSize, use the
+                     size of this surface.
+        @param flags Or-combination of CreateCompatibleFlags values
+     */
+    wxIDirectFBSurfacePtr CreateCompatible(const wxSize& size = wxDefaultSize,
+                                           int flags = 0);

 
 

-    bool WaitForEventWithTimeout(unsigned secs, unsigned millisecs)
+    bool Lock(DFBSurfaceLockFlags flags, void **ret_ptr, int *ret_pitch)
+        { return Check(m_ptr->Lock(m_ptr, flags, ret_ptr, ret_pitch)); }
+
+    bool Unlock()
+        { return Check(m_ptr->Unlock(m_ptr)); }
+
+    /// Helper struct for safe locking & unlocking of surfaces
+    struct Locked

     {
     {

-        DFBResult r = m_ptr->WaitForEventWithTimeout(m_ptr, secs, millisecs);
+        Locked(const wxIDirectFBSurfacePtr& surface, DFBSurfaceLockFlags flags)
+            : m_surface(surface)
+        {
+            if ( !surface->Lock(flags, &ptr, &pitch) )
+                ptr = NULL;
+        }

 
 

-        // DFB_TIMEOUT is not an error in this function:
-        if ( r == DFB_TIMEOUT )
+        ~Locked()

         {
         {

-            m_lastResult = DFB_TIMEOUT;
-            return true;
+            if ( ptr )
+                m_surface->Unlock();

         }
 
         }
 

-        return Check(r);
-    }
+        void *ptr;
+        int pitch;
+
+    private:
+        wxIDirectFBSurfacePtr m_surface;
+    };
+
+
+private:
+    // this is private because we want user code to use FlipToFront()
+    bool Flip(const DFBRegion *region, int flags);
+};
+
+
+//-----------------------------------------------------------------------------
+// wxIDirectFBEventBuffer
+//-----------------------------------------------------------------------------
+
+struct wxIDirectFBEventBuffer : public wxDfbWrapper<IDirectFBEventBuffer>
+{
+    wxIDirectFBEventBuffer(IDirectFBEventBuffer *s) { Init(s); }

 
 

-    bool GetEvent(wxDFBEvent& event)
+    bool CreateFileDescriptor(int *ret_fd)

     {
     {

-        return Check(m_ptr->GetEvent(m_ptr, &event));
+        return Check(m_ptr->CreateFileDescriptor(m_ptr, ret_fd));

     }
 };
 
     }
 };
 


@@ -341,12 +398,18 @@ struct wxIDirectFBWindow : public wxDfbWrapper<IDirectFBWindow>
     bool Resize(int w, int h)
         { return Check(m_ptr->Resize(m_ptr, w, h)); }
 
     bool Resize(int w, int h)
         { return Check(m_ptr->Resize(m_ptr, w, h)); }
 

-    bool SetOpacity(__u8 opacity)
+    bool SetOpacity(u8 opacity)

         { return Check(m_ptr->SetOpacity(m_ptr, opacity)); }
 
     bool SetStackingClass(DFBWindowStackingClass klass)
         { return Check(m_ptr->SetStackingClass(m_ptr, klass)); }
 
         { return Check(m_ptr->SetOpacity(m_ptr, opacity)); }
 
     bool SetStackingClass(DFBWindowStackingClass klass)
         { return Check(m_ptr->SetStackingClass(m_ptr, klass)); }
 

+    bool RaiseToTop()
+        { return Check(m_ptr->RaiseToTop(m_ptr)); }
+
+    bool LowerToBottom()
+        { return Check(m_ptr->LowerToBottom(m_ptr)); }
+

     wxIDirectFBSurfacePtr GetSurface()
     {
         IDirectFBSurface *s;
     wxIDirectFBSurfacePtr GetSurface()
     {
         IDirectFBSurface *s;


@@ -361,6 +424,9 @@ struct wxIDirectFBWindow : public wxDfbWrapper<IDirectFBWindow>
 
     bool RequestFocus()
         { return Check(m_ptr->RequestFocus(m_ptr)); }
 
     bool RequestFocus()
         { return Check(m_ptr->RequestFocus(m_ptr)); }

+
+    bool Destroy()
+        { return Check(m_ptr->Destroy(m_ptr)); }

 };
 
 
 };
 
 


@@ -381,14 +447,10 @@ struct wxIDirectFBDisplayLayer : public wxDfbWrapper<IDirectFBDisplayLayer>
             return NULL;
     }
 
             return NULL;
     }
 

-    wxIDirectFBSurfacePtr GetSurface()
-    {
-        IDirectFBSurface *s;
-        if ( Check(m_ptr->GetSurface(m_ptr, &s)) )
-            return new wxIDirectFBSurface(s);
-        else
-            return NULL;
-    }
+    bool GetConfiguration(DFBDisplayLayerConfig *config)
+        { return Check(m_ptr->GetConfiguration(m_ptr, config)); }
+
+    wxVideoMode GetVideoMode();

 
     bool GetCursorPosition(int *x, int *y)
         { return Check(m_ptr->GetCursorPosition(m_ptr, x, y)); }
 
     bool GetCursorPosition(int *x, int *y)
         { return Check(m_ptr->GetCursorPosition(m_ptr, x, y)); }


@@ -446,7 +508,8 @@ struct wxIDirectFB : public wxDfbWrapper<IDirectFB>
             return NULL;
     }
 
             return NULL;
     }
 

-    wxIDirectFBDisplayLayerPtr GetDisplayLayer(DFBDisplayLayerID id)
+    wxIDirectFBDisplayLayerPtr
+    GetDisplayLayer(DFBDisplayLayerID id = DLID_PRIMARY)

     {
         IDirectFBDisplayLayer *l;
         if ( Check(m_ptr->GetDisplayLayer(m_ptr, id, &l)) )
     {
         IDirectFBDisplayLayer *l;
         if ( Check(m_ptr->GetDisplayLayer(m_ptr, id, &l)) )


@@ -455,6 +518,9 @@ struct wxIDirectFB : public wxDfbWrapper<IDirectFB>
             return NULL;
     }
 
             return NULL;
     }
 

+    /// Returns primary surface
+    wxIDirectFBSurfacePtr GetPrimarySurface();
+

 private:
     wxIDirectFB(IDirectFB *ptr) { Init(ptr); }
 
 private:
     wxIDirectFB(IDirectFB *ptr) { Init(ptr); }