X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/52c8d32a71bb7553dd89324fa6d56faac95eb5d0..64ea838d8f4d1853b7d850db93ee565e901d099a:/src/dfb/dc.cpp

diff --git a/src/dfb/dc.cpp b/src/dfb/dc.cpp
index 60afcaa00e..c4006994df 100644
--- a/src/dfb/dc.cpp
+++ b/src/dfb/dc.cpp
@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        src/dfb/dc.cpp
-// Purpose:     wxDC class
+// Purpose:     wxDFBDCImpl class
 // Author:      Vaclav Slavik
 // Created:     2006-08-07
 // RCS-ID:      $Id$
@@ -24,48 +24,42 @@
 #endif
 
 #ifndef WX_PRECOMP
-    #include "wx/dc.h"
+    #include "wx/dcmemory.h"
     #include "wx/log.h"
 #endif
 
+#include "wx/dfb/dc.h"
 #include "wx/dfb/private.h"
 
+// these values are used to initialize newly created DC
+#define DEFAULT_FONT      (*wxNORMAL_FONT)
+#define DEFAULT_PEN       (*wxBLACK_PEN)
+#define DEFAULT_BRUSH     (*wxWHITE_BRUSH)
+
 // ===========================================================================
 // implementation
 // ===========================================================================
 
 //-----------------------------------------------------------------------------
-// wxDC
+// wxDFBDCImpl
 //-----------------------------------------------------------------------------
 
-IMPLEMENT_ABSTRACT_CLASS(wxDC, wxDCBase)
-
-// Default constructor
-wxDC::wxDC()
-{
-    m_ok = false;
-}
-
-wxDC::wxDC(const wxIDirectFBSurfacePtr& surface)
-{
-    Init(surface);
-}
+IMPLEMENT_ABSTRACT_CLASS(wxDFBDCImpl, wxDCImpl)
 
-void wxDC::Init(const wxIDirectFBSurfacePtr& surface)
+void wxDFBDCImpl::DFBInit(const wxIDirectFBSurfacePtr& surface)
 {
-    m_ok = (surface != NULL);
-    wxCHECK_RET( surface != NULL, _T("invalid surface") );
-
     m_surface = surface;
 
+    wxCHECK_RET( surface != NULL, "invalid surface" );
+
     m_mm_to_pix_x = (double)wxGetDisplaySize().GetWidth() /
                     (double)wxGetDisplaySizeMM().GetWidth();
     m_mm_to_pix_y = (double)wxGetDisplaySize().GetHeight() /
                     (double)wxGetDisplaySizeMM().GetHeight();
 
-    SetFont(*wxNORMAL_FONT);
-    SetPen(*wxBLACK_PEN);
-    SetBrush(*wxWHITE_BRUSH);
+    SetFont(DEFAULT_FONT);
+    SetPen(DEFAULT_PEN);
+    SetBrush(DEFAULT_BRUSH);
 }
 
 
@@ -73,25 +67,23 @@ void wxDC::Init(const wxIDirectFBSurfacePtr& surface)
 // clipping
 // ---------------------------------------------------------------------------
 
+void wxDFBDCImpl::DoSetClippingRegion(wxCoord cx, wxCoord cy, wxCoord cw, wxCoord ch)
+{
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
 
-#define DO_SET_CLIPPING_BOX(rg)                      \
-{                                                    \
-    wxRect rect = rg.GetBox();                       \
-    m_clipX1 = (wxCoord) XDEV2LOG(rect.GetLeft());   \
-    m_clipY1 = (wxCoord) YDEV2LOG(rect.GetTop());    \
-    m_clipX2 = (wxCoord) XDEV2LOG(rect.GetRight());  \
-    m_clipY2 = (wxCoord) YDEV2LOG(rect.GetBottom()); \
-}
+    wxSize size(GetSize());
 
-void wxDC::DoSetClippingRegion(wxCoord cx, wxCoord cy, wxCoord cw, wxCoord ch)
-{
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxASSERT_MSG( !m_clipping,
+                  "narrowing clipping region not implemented yet" );
 
+    // NB: We intersect the clipping rectangle with surface's area here because
+    //     DirectFB will return an error if you try to set clipping rectangle
+    //     that is partially outside of the surface.
     DFBRegion r;
-    r.x1 = XLOG2DEV(cx);
-    r.y1 = YLOG2DEV(cy);
-    r.x2 = r.x1 + XLOG2DEVREL(cw) - 1;
-    r.y2 = r.y1 + XLOG2DEVREL(ch) - 1;
+    r.x1 = wxMax(0, XLOG2DEV(cx));
+    r.y1 = wxMax(0, YLOG2DEV(cy));
+    r.x2 = wxMin(r.x1 + XLOG2DEVREL(cw), size.x) - 1;
+    r.y2 = wxMin(r.y1 + YLOG2DEVREL(ch), size.y) - 1;
 
     if ( !m_surface->SetClip(&r) )
         return;
@@ -103,16 +95,24 @@ void wxDC::DoSetClippingRegion(wxCoord cx, wxCoord cy, wxCoord cw, wxCoord ch)
     m_clipping = true;
 }
 
-void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)
+void wxDFBDCImpl::DoSetDeviceClippingRegion(const wxRegion& region)
 {
-    // NB: this can be done because wxDFB only supports
-    //     rectangular regions
-    SetClippingRegion(region.AsRect());
+    // NB: this can be done because wxDFB only supports rectangular regions
+    wxRect rect = region.AsRect();
+
+    // our parameter is in physical coordinates while DoSetClippingRegion()
+    // takes logical ones
+    rect.x = XDEV2LOG(rect.x);
+    rect.y = YDEV2LOG(rect.y);
+    rect.width = XDEV2LOG(rect.width);
+    rect.height = YDEV2LOG(rect.height);
+
+    DoSetClippingRegion(rect.x, rect.y, rect.width, rect.height);
 }
 
-void wxDC::DestroyClippingRegion()
+void wxDFBDCImpl::DestroyClippingRegion()
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
 
     m_surface->SetClip(NULL);
 
@@ -123,59 +123,94 @@ void wxDC::DestroyClippingRegion()
 // query capabilities
 // ---------------------------------------------------------------------------
 
-int wxDC::GetDepth() const
+int wxDFBDCImpl::GetDepth() const
 {
-    return wxDfbGetSurfaceDepth(m_surface);
+    return m_surface->GetDepth();
 }
 
 // ---------------------------------------------------------------------------
 // drawing
 // ---------------------------------------------------------------------------
 
-void wxDC::Clear()
+void wxDFBDCImpl::Clear()
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
 
     if ( m_backgroundBrush.GetStyle() == wxTRANSPARENT )
         return;
 
     wxColour clr = m_backgroundBrush.GetColour();
     m_surface->Clear(clr.Red(), clr.Green(), clr.Blue(), clr.Alpha());
+
+    wxSize size(GetSize());
+    CalcBoundingBox(XDEV2LOG(0), YDEV2LOG(0));
+    CalcBoundingBox(XDEV2LOG(size.x), YDEV2LOG(size.y));
 }
 
 extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
-                          const wxColour & col, int style);
+                          const wxColour & col, wxFloodFillStyle style);
 
-bool wxDC::DoFloodFill(wxCoord x, wxCoord y,
-                       const wxColour& col, int style)
+bool wxDFBDCImpl::DoFloodFill(wxCoord x, wxCoord y,
+                       const wxColour& col, wxFloodFillStyle style)
 {
-    return wxDoFloodFill(this, x, y, col, style);
+    return wxDoFloodFill(GetOwner(), x, y, col, style);
 }
 
-bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
+bool wxDFBDCImpl::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
 {
-    wxCHECK_MSG( col, false, _T("NULL colour parameter in wxDC::GetPixel"));
+    wxCHECK_MSG( col, false, "NULL colour parameter in wxDFBDCImpl::GetPixel");
+
+    wxFAIL_MSG( "GetPixel not implemented" );
+
+    wxUnusedVar(x);
+    wxUnusedVar(y);
 
-    wxFAIL_MSG( _T("GetPixel not implemented") );
     return false;
 }
 
-void wxDC::DoCrossHair(wxCoord x, wxCoord y)
+void wxDFBDCImpl::DoCrossHair(wxCoord x, wxCoord y)
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
+
+    wxFAIL_MSG( "CrossHair not implemented" );
 
-    wxFAIL_MSG( _T("CrossHair not implemented") );
+    wxUnusedVar(x);
+    wxUnusedVar(y);
 }
 
-void wxDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
+void wxDFBDCImpl::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
 
     if ( m_pen.GetStyle() == wxTRANSPARENT )
         return;
 
-    m_surface->DrawLine(XLOG2DEV(x1), YLOG2DEV(y1),
-                        XLOG2DEV(x2), YLOG2DEV(y2));
+    wxCoord xx1 = XLOG2DEV(x1);
+    wxCoord yy1 = YLOG2DEV(y1);
+    wxCoord xx2 = XLOG2DEV(x2);
+    wxCoord yy2 = YLOG2DEV(y2);
+
+    // FIXME: DrawLine() shouldn't draw the last pixel, but DFB's DrawLine()
+    //        does draw it. We should undo any change to the last pixel by
+    //        using GetPixel() and PutPixel(), but until they are implemented,
+    //        handle at least the special case of vertical and horizontal
+    //        lines correctly:
+    if ( xx1 == xx2 )
+    {
+        if ( yy1 < yy2 )
+            yy2--;
+        else if ( yy1 > yy2 )
+            yy2++;
+    }
+    if ( yy1 == yy2 )
+    {
+        if ( xx1 < xx2 )
+            xx2--;
+        else if ( xx1 > xx2 )
+            xx2++;
+    }
+
+    m_surface->DrawLine(xx1, yy1, xx2, yy2);
 
     CalcBoundingBox(x1, y1);
     CalcBoundingBox(x2, y2);
@@ -183,40 +218,48 @@ void wxDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
 
 // Draws an arc of a circle, centred on (xc, yc), with starting point (x1, y1)
 // and ending at (x2, y2)
-void wxDC::DoDrawArc(wxCoord x1, wxCoord y1,
-                     wxCoord x2, wxCoord y2,
-                     wxCoord xc, wxCoord yc)
+void wxDFBDCImpl::DoDrawArc(wxCoord WXUNUSED(x1), wxCoord WXUNUSED(y1),
+                            wxCoord WXUNUSED(x2), wxCoord WXUNUSED(y2),
+                            wxCoord WXUNUSED(xc), wxCoord WXUNUSED(yc))
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
 
-    wxFAIL_MSG( _T("DrawArc not implemented") );
+    wxFAIL_MSG( "DrawArc not implemented" );
 }
 
-void wxDC::DoDrawPoint(wxCoord x, wxCoord y)
+void wxDFBDCImpl::DoDrawPoint(wxCoord x, wxCoord y)
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
+
+    // NB: DirectFB API doesn't provide a function for drawing points, so
+    //     implement it as 1px long line. This is inefficient, but then, so is
+    //     using DrawPoint() for drawing more than a few points.
+    DoDrawLine(x, y, x, y);
 
-    wxFAIL_MSG( _T("DrawPoint not implemented") );
+    // FIXME_DFB: implement special cases for common formats (RGB24,RGBA/RGB32)
 }
 
-void wxDC::DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset,int WXUNUSED(fillStyle))
+void wxDFBDCImpl::DoDrawPolygon(int WXUNUSED(n), wxPoint WXUNUSED(points)[],
+                                wxCoord WXUNUSED(xoffset), wxCoord WXUNUSED(yoffset),
+                                wxPolygonFillMode WXUNUSED(fillStyle))
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
 
-    wxFAIL_MSG( _T("DrawPolygon not implemented") );
+    wxFAIL_MSG( "DrawPolygon not implemented" );
 }
 
-void wxDC::DoDrawLines(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset)
+void wxDFBDCImpl::DoDrawLines(int WXUNUSED(n), wxPoint WXUNUSED(points)[],
+                              wxCoord WXUNUSED(xoffset), wxCoord WXUNUSED(yoffset))
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
 
     // TODO: impl. using DirectDB's DrawLines
-    wxFAIL_MSG( _T("DrawLines not implemented") );
+    wxFAIL_MSG( "DrawLines not implemented" );
 }
 
-void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
+void wxDFBDCImpl::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
 
     wxCoord xx = XLOG2DEV(x);
     wxCoord yy = YLOG2DEV(y);
@@ -240,7 +283,8 @@ void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
     {
         SelectColour(m_brush.GetColour());
         m_surface->FillRectangle(xx, yy, ww, hh);
-        // restore pen's colour
+        // restore pen's colour, because other drawing functions expect the
+        // colour to be set to the pen:
         SelectColour(m_pen.GetColour());
     }
 
@@ -253,148 +297,177 @@ void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
     CalcBoundingBox(x + width, y + height);
 }
 
-void wxDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius)
+void wxDFBDCImpl::DoDrawRoundedRectangle(wxCoord WXUNUSED(x),
+                                         wxCoord WXUNUSED(y),
+                                         wxCoord WXUNUSED(width),
+                                         wxCoord WXUNUSED(height),
+                                         double WXUNUSED(radius))
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
 
-    wxFAIL_MSG( _T("DrawRoundedRectangle not implemented") );
+    wxFAIL_MSG( "DrawRoundedRectangle not implemented" );
 }
 
-void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
+void wxDFBDCImpl::DoDrawEllipse(wxCoord WXUNUSED(x),
+                                wxCoord WXUNUSED(y),
+                                wxCoord WXUNUSED(width),
+                                wxCoord WXUNUSED(height))
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
 
-    wxFAIL_MSG( _T("DrawElipse not implemented") );
+    wxFAIL_MSG( "DrawElipse not implemented" );
 }
 
-void wxDC::DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,double ea)
+void wxDFBDCImpl::DoDrawEllipticArc(wxCoord WXUNUSED(x),
+                                    wxCoord WXUNUSED(y),
+                                    wxCoord WXUNUSED(w),
+                                    wxCoord WXUNUSED(h),
+                                    double WXUNUSED(sa),
+                                    double WXUNUSED(ea))
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
 
-    wxFAIL_MSG( _T("DrawElipticArc not implemented") );
+    wxFAIL_MSG( "DrawElipticArc not implemented" );
 }
 
-void wxDC::DoDrawText(const wxString& text, wxCoord x, wxCoord y)
+void wxDFBDCImpl::DoDrawText(const wxString& text, wxCoord x, wxCoord y)
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
 
     wxCoord xx = XLOG2DEV(x);
-    wxCoord yy = XLOG2DEV(y);
+    wxCoord yy = YLOG2DEV(y);
 
     // update the bounding box
     wxCoord w, h;
     CalcBoundingBox(x, y);
-    GetTextExtent(text, &w, &h);
+    DoGetTextExtent(text, &w, &h);
     CalcBoundingBox(x + w, y + h);
 
     // if background mode is solid, DrawText must paint text's background:
     if ( m_backgroundMode == wxSOLID )
     {
-        wxCHECK_RET( m_backgroundBrush.Ok(), wxT("invalid background brush") );
+        wxCHECK_RET( m_textBackgroundColour.IsOk(),
+                     wxT("invalid background color") );
 
-        SelectColour(m_backgroundBrush.GetColour());
+        SelectColour(m_textBackgroundColour);
         m_surface->FillRectangle(xx, yy, XLOG2DEVREL(w), YLOG2DEVREL(h));
-        // restore pen's colour
-        SelectColour(m_pen.GetColour());
     }
 
     // finally draw the text itself:
-    m_surface->DrawString(wxSTR_TO_DFB(text), -1, xx, yy, DSTF_LEFT | DSTF_TOP);
+    wxCHECK_RET( m_textForegroundColour.IsOk(),
+                 wxT("invalid foreground color") );
+    SelectColour(m_textForegroundColour);
+    m_surface->DrawString(text.utf8_str(), -1, xx, yy, DSTF_LEFT | DSTF_TOP);
+
+    // restore pen's colour, because other drawing functions expect the colour
+    // to be set to the pen:
+    SelectColour(m_pen.GetColour());
 }
 
-void wxDC::DoDrawRotatedText(const wxString& text,
-                             wxCoord x, wxCoord y,
-                             double angle)
+void wxDFBDCImpl::DoDrawRotatedText(const wxString& WXUNUSED(text),
+                                    wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
+                                    double WXUNUSED(angle))
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
 
-    wxFAIL_MSG( _T("DrawRotatedText not implemented") );
+    wxFAIL_MSG( "DrawRotatedText not implemented" );
 }
 
 // ---------------------------------------------------------------------------
 // set GDI objects
 // ---------------------------------------------------------------------------
 
-void wxDC::SetPen(const wxPen& pen)
+void wxDFBDCImpl::SetPen(const wxPen& pen)
 {
-    if ( !pen.Ok() ) return;
-    m_pen = pen;
+    m_pen = pen.IsOk() ? pen : DEFAULT_PEN;
 
     SelectColour(m_pen.GetColour());
 }
 
-void wxDC::SetBrush(const wxBrush& brush)
+void wxDFBDCImpl::SetBrush(const wxBrush& brush)
 {
-    if ( !brush.Ok() ) return;
-    m_brush = brush;
+    m_brush = brush.IsOk() ? brush : DEFAULT_BRUSH;
 }
 
-void wxDC::SelectColour(const wxColour& clr)
+void wxDFBDCImpl::SelectColour(const wxColour& clr)
 {
     m_surface->SetColor(clr.Red(), clr.Green(), clr.Blue(), clr.Alpha());
     #warning "use SetColorIndex?"
 }
 
 #if wxUSE_PALETTE
-void wxDC::SetPalette(const wxPalette& WXUNUSED(palette))
+void wxDFBDCImpl::SetPalette(const wxPalette& WXUNUSED(palette))
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
 
-    wxFAIL_MSG( _T("SetPalette not implemented") );
+    wxFAIL_MSG( "SetPalette not implemented" );
 }
 #endif // wxUSE_PALETTE
 
-void wxDC::SetFont(const wxFont& font)
+void wxDFBDCImpl::SetFont(const wxFont& font)
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
 
-    if ( !font.Ok() )
-        return;
+    wxFont f(font.IsOk() ? font : DEFAULT_FONT);
+
+    wxFont oldfont(m_font);
+
+    m_font = f;
 
-    if ( !m_surface->SetFont(font.GetDirectFBFont()) )
+    if ( !m_surface->SetFont(GetCurrentFont()) )
+    {
+        m_font = oldfont;
         return;
+    }
+}
 
-    m_font = font;
+wxIDirectFBFontPtr wxDFBDCImpl::GetCurrentFont() const
+{
+    bool aa = (GetDepth() > 8);
+    return m_font.GetDirectFBFont(aa);
 }
 
-void wxDC::SetBackground(const wxBrush& brush)
+void wxDFBDCImpl::SetBackground(const wxBrush& brush)
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
 
-    if (!brush.Ok()) return;
+    if (!brush.IsOk()) return;
 
     m_backgroundBrush = brush;
 }
 
-void wxDC::SetBackgroundMode(int mode)
+void wxDFBDCImpl::SetBackgroundMode(int mode)
 {
     m_backgroundMode = mode;
 }
 
-void wxDC::SetLogicalFunction(int function)
+void wxDFBDCImpl::SetLogicalFunction(wxRasterOperationMode function)
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
 
-    wxFAIL_MSG( _T("SetLogicalFunction not implemented") );
+    // NB: we could also support XOR, but for blitting only (via DSBLIT_XOR);
+    //     and possibly others via SetSrc/DstBlendFunction()
+    wxASSERT_MSG( function == wxCOPY,
+                  "only wxCOPY logical function supported" );
 
     m_logicalFunction = function;
 }
 
-bool wxDC::StartDoc(const wxString& WXUNUSED(message))
+bool wxDFBDCImpl::StartDoc(const wxString& WXUNUSED(message))
 {
     // We might be previewing, so return true to let it continue.
     return true;
 }
 
-void wxDC::EndDoc()
+void wxDFBDCImpl::EndDoc()
 {
 }
 
-void wxDC::StartPage()
+void wxDFBDCImpl::StartPage()
 {
 }
 
-void wxDC::EndPage()
+void wxDFBDCImpl::EndPage()
 {
 }
 
@@ -402,48 +475,48 @@ void wxDC::EndPage()
 // text metrics
 // ---------------------------------------------------------------------------
 
-wxCoord wxDC::GetCharHeight() const
+wxCoord wxDFBDCImpl::GetCharHeight() const
 {
-    wxCHECK_MSG( Ok(), -1, wxT("invalid dc") );
-    wxCHECK_MSG( m_font.Ok(), -1, wxT("no font selected") );
+    wxCHECK_MSG( IsOk(), -1, wxT("invalid dc") );
+    wxCHECK_MSG( m_font.IsOk(), -1, wxT("no font selected") );
 
     int h = -1;
-    m_font.GetDirectFBFont()->GetHeight(&h);
+    GetCurrentFont()->GetHeight(&h);
     return YDEV2LOGREL(h);
 }
 
-wxCoord wxDC::GetCharWidth() const
+wxCoord wxDFBDCImpl::GetCharWidth() const
 {
-    wxCHECK_MSG( Ok(), -1, wxT("invalid dc") );
-    wxCHECK_MSG( m_font.Ok(), -1, wxT("no font selected") );
+    wxCHECK_MSG( IsOk(), -1, wxT("invalid dc") );
+    wxCHECK_MSG( m_font.IsOk(), -1, wxT("no font selected") );
 
     int w = -1;
-    m_font.GetDirectFBFont()->GetStringWidth("H", 1, &w);
+    GetCurrentFont()->GetStringWidth("H", 1, &w);
     // VS: YDEV is corrent, it should *not* be XDEV, because font's are only
     //     scaled according to m_scaleY
     return YDEV2LOGREL(w);
 }
 
-void wxDC::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,
+void wxDFBDCImpl::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,
                            wxCoord *descent, wxCoord *externalLeading,
-                           wxFont *theFont) const
+                           const wxFont *theFont) const
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
-    wxCHECK_RET( m_font.Ok(), wxT("no font selected") );
-    wxCHECK_RET( !theFont || theFont->Ok(), wxT("invalid font") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
+    wxCHECK_RET( m_font.IsOk(), wxT("no font selected") );
+    wxCHECK_RET( !theFont || theFont->IsOk(), wxT("invalid font") );
 
     wxFont oldFont;
     if ( theFont != NULL )
     {
         oldFont = m_font;
-        wxConstCast(this, wxDC)->SetFont(*theFont);
+        wxConstCast(this, wxDFBDCImpl)->SetFont(*theFont);
     }
 
     wxCoord xx = 0, yy = 0;
     DFBRectangle rect;
-    wxIDirectFBFontPtr f = m_font.GetDirectFBFont();
+    wxIDirectFBFontPtr f = GetCurrentFont();
 
-    if ( f->GetStringExtents(wxSTR_TO_DFB(string), -1, &rect, NULL) )
+    if ( f->GetStringExtents(string.utf8_str(), -1, &rect, NULL) )
     {
         // VS: YDEV is corrent, it should *not* be XDEV, because font's are
         //     only scaled according to m_scaleY
@@ -465,7 +538,7 @@ void wxDC::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,
     if ( externalLeading ) *externalLeading = 0;
 
     if ( theFont != NULL )
-        wxConstCast(this, wxDC)->SetFont(oldFont);
+        wxConstCast(this, wxDFBDCImpl)->SetFont(oldFont);
 }
 
 
@@ -474,140 +547,18 @@ void wxDC::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,
 // mapping modes
 // ---------------------------------------------------------------------------
 
-void wxDC::ComputeScaleAndOrigin()
-{
-    m_scaleX = m_logicalScaleX * m_userScaleX;
-    m_scaleY = m_logicalScaleY * m_userScaleY;
-
-    // FIXME_DFB: scaling affects pixel size of font, pens, brushes, which
-    //            is not currently implemented here; probably makes sense to
-    //            switch to Cairo instead of implementing everything for DFB
-    wxASSERT_MSG( m_scaleX == 1.0 && m_scaleY == 1.0,
-                  _T("scaling is not implemented in wxDFB") );
-}
-
-void wxDC::SetMapMode(int mode)
-{
-    #warning "move this to common code, it's shared by almost all ports!"
-    switch (mode)
-    {
-        case wxMM_TWIPS:
-          SetLogicalScale(twips2mm*m_mm_to_pix_x, twips2mm*m_mm_to_pix_y);
-          break;
-        case wxMM_POINTS:
-          SetLogicalScale(pt2mm*m_mm_to_pix_x, pt2mm*m_mm_to_pix_y);
-          break;
-        case wxMM_METRIC:
-          SetLogicalScale(m_mm_to_pix_x, m_mm_to_pix_y);
-          break;
-        case wxMM_LOMETRIC:
-          SetLogicalScale(m_mm_to_pix_x/10.0, m_mm_to_pix_y/10.0);
-          break;
-        default:
-        case wxMM_TEXT:
-          SetLogicalScale(1.0, 1.0);
-          break;
-    }
-    m_mappingMode = mode;
-}
+// FIXME_DFB: scaling affects pixel size of font, pens, brushes, which
+//            is not currently implemented here; probably makes sense to
+//            switch to Cairo instead of implementing everything for DFB
 
-void wxDC::SetUserScale(double x, double y)
+void wxDFBDCImpl::DoGetSize(int *w, int *h) const
 {
-    #warning "move this to common code?"
-    // allow negative ? -> no
-    m_userScaleX = x;
-    m_userScaleY = y;
-    ComputeScaleAndOrigin();
-}
-
-void wxDC::SetLogicalScale(double x, double y)
-{
-    #warning "move this to common code?"
-    // allow negative ?
-    m_logicalScaleX = x;
-    m_logicalScaleY = y;
-    ComputeScaleAndOrigin();
-}
-
-void wxDC::SetLogicalOrigin( wxCoord x, wxCoord y )
-{
-    #warning "move this to common code?"
-    m_logicalOriginX = x * m_signX;   // is this still correct ?
-    m_logicalOriginY = y * m_signY;
-    ComputeScaleAndOrigin();
-}
-
-void wxDC::SetDeviceOrigin( wxCoord x, wxCoord y )
-{
-    #warning "move this to common code?"
-    // only wxPostScripDC has m_signX = -1, we override SetDeviceOrigin there
-    m_deviceOriginX = x;
-    m_deviceOriginY = y;
-    ComputeScaleAndOrigin();
-}
-
-void wxDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp )
-{
-    #warning "move this to common code?"
-    // only wxPostScripDC has m_signX = -1, we override SetAxisOrientation there
-    m_signX = (xLeftRight ?  1 : -1);
-    m_signY = (yBottomUp  ? -1 :  1);
-    ComputeScaleAndOrigin();
-}
-
-// ---------------------------------------------------------------------------
-// coordinates transformations
-// ---------------------------------------------------------------------------
-
-wxCoord wxDCBase::DeviceToLogicalX(wxCoord x) const
-{
-    return ((wxDC *)this)->XDEV2LOG(x);
-}
-
-wxCoord wxDCBase::DeviceToLogicalY(wxCoord y) const
-{
-    return ((wxDC *)this)->YDEV2LOG(y);
-}
-
-wxCoord wxDCBase::DeviceToLogicalXRel(wxCoord x) const
-{
-    return ((wxDC *)this)->XDEV2LOGREL(x);
-}
-
-wxCoord wxDCBase::DeviceToLogicalYRel(wxCoord y) const
-{
-    return ((wxDC *)this)->YDEV2LOGREL(y);
-}
-
-wxCoord wxDCBase::LogicalToDeviceX(wxCoord x) const
-{
-    return ((wxDC *)this)->XLOG2DEV(x);
-}
-
-wxCoord wxDCBase::LogicalToDeviceY(wxCoord y) const
-{
-    return ((wxDC *)this)->YLOG2DEV(y);
-}
-
-wxCoord wxDCBase::LogicalToDeviceXRel(wxCoord x) const
-{
-    return ((wxDC *)this)->XLOG2DEVREL(x);
-}
-
-wxCoord wxDCBase::LogicalToDeviceYRel(wxCoord y) const
-{
-    return ((wxDC *)this)->YLOG2DEVREL(y);
-}
-
-
-void wxDC::DoGetSize(int *w, int *h) const
-{
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
 
     m_surface->GetSize(w, h);
 }
 
-void wxDC::DoGetSizeMM(int *width, int *height) const
+void wxDFBDCImpl::DoGetSizeMM(int *width, int *height) const
 {
     #warning "move this to common code?"
     int w = 0;
@@ -617,7 +568,7 @@ void wxDC::DoGetSizeMM(int *width, int *height) const
     if ( height ) *height = int(double(h) / (m_userScaleY*m_mm_to_pix_y));
 }
 
-wxSize wxDC::GetPPI() const
+wxSize wxDFBDCImpl::GetPPI() const
 {
     #warning "move this to common code?"
     return wxSize(int(double(m_mm_to_pix_x) * inches2mm),
@@ -629,23 +580,27 @@ wxSize wxDC::GetPPI() const
 // Blitting
 // ---------------------------------------------------------------------------
 
-bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
-                  wxCoord width, wxCoord height,
-                  wxDC *source, wxCoord xsrc, wxCoord ysrc,
-                  int rop, bool useMask,
-                  wxCoord xsrcMask, wxCoord ysrcMask)
+bool wxDFBDCImpl::DoBlit(wxCoord xdest, wxCoord ydest,
+                         wxCoord width, wxCoord height,
+                         wxDC *source, wxCoord xsrc, wxCoord ysrc,
+                         wxRasterOperationMode rop, bool useMask,
+                         wxCoord xsrcMask, wxCoord ysrcMask)
 {
-#warning "FIXME"
-    return false; 
-#if 0
-    wxCHECK_MSG( Ok(), false, wxT("invalid dc") );
-    wxCHECK_MSG( source, false, wxT("invalid source dc") );
+    wxCHECK_MSG( IsOk(), false, "invalid dc" );
+    wxCHECK_MSG( source, false, "invalid source dc" );
+
+    // NB: we could also support XOR here (via DSBLIT_XOR)
+    //     and possibly others via SetSrc/DstBlendFunction()
+    wxCHECK_MSG( rop == wxCOPY, false, "only wxCOPY function supported" );
 
     // transform the source DC coords to the device ones
     xsrc = source->LogicalToDeviceX(xsrc);
     ysrc = source->LogicalToDeviceY(ysrc);
 
-    /* FIXME_MGL: use the mask origin when drawing transparently */
+    // FIXME_DFB: use the mask origin when drawing transparently
+    wxASSERT_MSG( xsrcMask == -1 && ysrcMask == -1,
+                  "non-default source mask offset not implemented" );
+#if 0
     if (xsrcMask == -1 && ysrcMask == -1)
     {
         xsrcMask = xsrc; ysrcMask = ysrc;
@@ -655,143 +610,124 @@ bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
         xsrcMask = source->LogicalToDeviceX(xsrcMask);
         ysrcMask = source->LogicalToDeviceY(ysrcMask);
     }
+#endif
 
-    CalcBoundingBox(xdest, ydest);
-    CalcBoundingBox(xdest + width, ydest + height);
-
-    /* scale/translate size and position */
-    wxCoord xx = XLOG2DEV(xdest);
-    wxCoord yy = YLOG2DEV(ydest);
-    wxCoord ww = XLOG2DEVREL(width);
-    wxCoord hh = YLOG2DEVREL(height);
-
-    if ( source->m_isMemDC )
+    wxMemoryDC *sourceAsMemDC = wxDynamicCast(source, wxMemoryDC);
+    if ( sourceAsMemDC )
     {
-        wxMemoryDC *memDC = (wxMemoryDC*) source;
-        DoDrawSubBitmap(memDC->GetSelectedObject(), xsrc, ysrc, ww, hh,
-                        xdest, ydest, rop, useMask);
+        DoDrawSubBitmap(sourceAsMemDC->GetSelectedBitmap(),
+                        xsrc, ysrc,
+                        width, height,
+                        xdest, ydest,
+                        rop,
+                        useMask);
     }
     else
     {
-        m_MGLDC->makeCurrent(); // will go away with MGL6.0
-        m_MGLDC->bitBlt(*source->GetMGLDC(),
-                        xsrc, ysrc, xsrc + ww, ysrc + hh,
-                        xx, yy, LogicalFunctionToMGLRop(rop));
+        return DoBlitFromSurface
+               (
+                 static_cast<wxDFBDCImpl *>(source->GetImpl())
+                    ->GetDirectFBSurface(),
+                 xsrc, ysrc,
+                 width, height,
+                 xdest, ydest
+               );
     }
 
     return true;
-#endif
 }
 
-void wxDC::DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask)
+void wxDFBDCImpl::DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask)
 {
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
-    wxCHECK_RET( bmp.Ok(), wxT("invalid bitmap") );
-
-    wxCoord w = bmp.GetWidth();
-    wxCoord h = bmp.GetHeight();
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
+    wxCHECK_RET( bmp.IsOk(), wxT("invalid bitmap") );
 
-    DoDrawSubBitmap(bmp, 0, 0, w, h, x, y, m_logicalFunction, useMask);
+    DoDrawSubBitmap(bmp,
+                    0, 0, bmp.GetWidth(), bmp.GetHeight(),
+                    x, y,
+                    m_logicalFunction, useMask);
 }
 
-void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
+void wxDFBDCImpl::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
 {
     // VZ: egcs 1.0.3 refuses to compile this without cast, no idea why
     DoDrawBitmap((const wxBitmap&)icon, x, y, true);
 }
 
-void wxDC::DoDrawSubBitmap(const wxBitmap &bmp,
+void wxDFBDCImpl::DoDrawSubBitmap(const wxBitmap &bmp,
                            wxCoord x, wxCoord y, wxCoord w, wxCoord h,
                            wxCoord destx, wxCoord desty, int rop, bool useMask)
 {
-#if 0
-    wxCHECK_RET( Ok(), wxT("invalid dc") );
-    wxCHECK_RET( bmp.Ok(), wxT("invalid bitmap") );
+    wxCHECK_RET( IsOk(), wxT("invalid dc") );
+    wxCHECK_RET( bmp.IsOk(), wxT("invalid bitmap") );
 
-    CalcBoundingBox(x, y);
-    CalcBoundingBox(x + w, y + h);
-
-    wxCoord dx = XLOG2DEV(destx);
-    wxCoord dy = YLOG2DEV(desty);
-    wxCoord dw = XLOG2DEVREL(w);
-    wxCoord dh = YLOG2DEVREL(h);
-
-    m_MGLDC->makeCurrent(); // will go away with MGL6.0
-
-    bool useStretching = ((w != dw) || (h != dh));
-    bool putSection = (w != bmp.GetWidth() || h != bmp.GetHeight());
-    MGL_writeModeType mglRop = (MGL_writeModeType)LogicalFunctionToMGLRop(rop);
+    // NB: we could also support XOR here (via DSBLIT_XOR)
+    //     and possibly others via SetSrc/DstBlendFunction()
+    wxCHECK_RET( rop == wxCOPY, "only wxCOPY function supported" );
 
     if ( bmp.GetDepth() == 1 )
     {
         // Mono bitmaps are handled in special way -- all 1s are drawn in
         // foreground colours, all 0s in background colour.
-
-        ((wxBitmap&)bmp).SetMonoPalette(m_textForegroundColour, m_textBackgroundColour);
+        wxFAIL_MSG( "drawing mono bitmaps not implemented" );
+        return;
     }
 
     if ( useMask && bmp.GetMask() )
     {
-        // Since MGL does not support masks directly (in MGL, mask is handled
-        // in same way as in wxImage, i.e. there is one "key" color), we
-        // simulate masked bitblt in 6 steps (same as in MSW):
-        //
-        // 1. Create a temporary bitmap and copy the destination area into it.
-        // 2. Copy the source area into the temporary bitmap using the
-        //    specified logical function.
-        // 3. Set the masked area in the temporary bitmap to BLACK by ANDing
-        //    the mask bitmap with the temp bitmap with the foreground colour
-        //    set to WHITE and the bg colour set to BLACK.
-        // 4. Set the unmasked area in the destination area to BLACK by
-        //    ANDing the mask bitmap with the destination area with the
-        //    foreground colour set to BLACK and the background colour set
-        //    to WHITE.
-        // 5. OR the temporary bitmap with the destination area.
-        // 6. Delete the temporary bitmap.
-        //
-        // This sequence of operations ensures that the source's transparent
-        // area need not be black, and logical functions are supported.
-
-        wxBitmap *mask = bmp.GetMask()->GetBitmap();
-
-        MGLMemoryDC *temp;
-
-        if ( GetDepth() <= 8 )
-        {
-            temp = new MGLMemoryDC(dw, dh, GetDepth(), NULL);
-            wxDC tempdc;
-            tempdc.SetMGLDC(temp, false);
-            tempdc.SetPalette(m_palette);
-        }
-        else
-        {
-            pixel_format_t pf;
-            m_MGLDC->getPixelFormat(pf);
-            temp = new MGLMemoryDC(dw, dh, GetDepth(), &pf);
-        }
+        // FIXME_DFB: Could use blitting modes for this; also see
+        //            DFB's SetSrcBlendFunction() and SetSrcColorKey()
+        wxFAIL_MSG( "drawing bitmaps with masks not implemented" );
+        return;
+    }
 
-        wxCHECK_RET( temp->isValid(), wxT("cannot create temporary dc") );
+    DoBlitFromSurface(bmp.GetDirectFBSurface(),
+                      x, y,
+                      w, h,
+                      destx, desty);
+}
 
-        temp->bitBlt(*m_MGLDC, dx, dy, dx + dw, dy + dh, 0, 0, MGL_REPLACE_MODE);
+bool wxDFBDCImpl::DoBlitFromSurface(const wxIDirectFBSurfacePtr& src,
+                                    wxCoord srcx, wxCoord srcy,
+                                    wxCoord w, wxCoord h,
+                                    wxCoord dstx, wxCoord dsty)
+{
+    // don't do anything if the source rectangle is outside of source surface,
+    // DirectFB would assert in that case:
+    wxSize srcsize;
+    src->GetSize(&srcsize.x, &srcsize.y);
+    if ( !wxRect(srcx, srcy, w, h).Intersects(wxRect(srcsize)) )
+    {
+        wxLogDebug("Blitting from area outside of the source surface, caller code needs fixing.");
+        return false;
+    }
 
-        DoBitBlt(bmp, temp, x, y, w, h, 0, 0, dw, dh, mglRop,
-                 useStretching, putSection);
+    CalcBoundingBox(dstx, dsty);
+    CalcBoundingBox(dstx + w, dsty + h);
 
-        mask->SetMonoPalette(wxColour(0,0,0), wxColour(255,255,255));
-        DoBitBlt(*mask, temp, x, y, w, h, 0, 0, dw, dh, MGL_R2_MASKSRC,
-                 useStretching, putSection);
-        DoBitBlt(*mask, m_MGLDC, x, y, w, h, dx, dy, dw, dh, MGL_R2_MASKNOTSRC,
-                 useStretching, putSection);
+    DFBRectangle srcRect = { srcx, srcy, w, h };
+    DFBRectangle dstRect = { XLOG2DEV(dstx), YLOG2DEV(dsty),
+                             XLOG2DEVREL(w), YLOG2DEVREL(h) };
 
-        m_MGLDC->bitBlt(*temp, 0, 0, dw, dh, dx, dy, MGL_OR_MODE);
+    wxIDirectFBSurfacePtr dst(m_surface);
 
-        delete temp;
-    }
+    // FIXME: this will have to be different in useMask case, see above
+    DFBSurfaceBlittingFlags blitFlag = (src->GetPixelFormat() == DSPF_ARGB)
+                                       ? DSBLIT_BLEND_ALPHACHANNEL
+                                       : DSBLIT_NOFX;
+    if ( !dst->SetBlittingFlags(blitFlag) )
+        return false;
 
+    if ( srcRect.w != dstRect.w || srcRect.h != dstRect.h )
+    {
+        // the bitmap is drawn stretched:
+        dst->StretchBlit(src, &srcRect, &dstRect);
+    }
     else
     {
-        DoBitBlt(bmp, m_MGLDC, x, y, w, h, dx, dy, dw, dh, mglRop,
-                 useStretching, putSection);
+        // no stretching, size is preserved:
+        dst->Blit(src, &srcRect, dstRect.x, dstRect.y);
     }
-#endif
+
+    return true;
 }