src/dfb/dc.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/dfb/dc.cpp
   3 // Purpose:     wxDC class
   4 // Author:      Vaclav Slavik
   5 // Created:     2006-08-07
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2006 REA Elektronik GmbH
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 // ===========================================================================
  12 // declarations
  13 // ===========================================================================
  14
  15 // ---------------------------------------------------------------------------
  16 // headers
  17 // ---------------------------------------------------------------------------
  18
  19 // For compilers that support precompilation, includes "wx.h".
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23     #pragma hdrstop
  24 #endif
  25
  26 #ifndef WX_PRECOMP
  27     #include "wx/dc.h"
  28     #include "wx/dcmemory.h"
  29     #include "wx/log.h"
  30 #endif
  31
  32 #include "wx/dfb/private.h"
  33
  34 // these values are used to initialize newly created DC
  35 #define DEFAULT_FONT      (*wxNORMAL_FONT)
  36 #define DEFAULT_PEN       (*wxBLACK_PEN)
  37 #define DEFAULT_BRUSH     (*wxWHITE_BRUSH)
  38
  39 // ===========================================================================
  40 // implementation
  41 // ===========================================================================
  42
  43 //-----------------------------------------------------------------------------
  44 // wxDC
  45 //-----------------------------------------------------------------------------
  46
  47 IMPLEMENT_ABSTRACT_CLASS(wxDC, wxDCBase)
  48
  49 // Default constructor
  50 wxDC::wxDC()
  51 {
  52     m_ok = false;
  53 }
  54
  55 wxDC::wxDC(const wxIDirectFBSurfacePtr& surface)
  56 {
  57     DFBInit(surface);
  58 }
  59
  60 void wxDC::DFBInit(const wxIDirectFBSurfacePtr& surface)
  61 {
  62     m_ok = (surface != NULL);
  63     wxCHECK_RET( surface != NULL, _T("invalid surface") );
  64
  65     m_surface = surface;
  66
  67     m_mm_to_pix_x = (double)wxGetDisplaySize().GetWidth() /
  68                     (double)wxGetDisplaySizeMM().GetWidth();
  69     m_mm_to_pix_y = (double)wxGetDisplaySize().GetHeight() /
  70                     (double)wxGetDisplaySizeMM().GetHeight();
  71
  72     SetFont(DEFAULT_FONT);
  73     SetPen(DEFAULT_PEN);
  74     SetBrush(DEFAULT_BRUSH);
  75 }
  76
  77
  78 // ---------------------------------------------------------------------------
  79 // clipping
  80 // ---------------------------------------------------------------------------
  81
  82 void wxDC::DoSetClippingRegion(wxCoord cx, wxCoord cy, wxCoord cw, wxCoord ch)
  83 {
  84     wxCHECK_RET( Ok(), wxT("invalid dc") );
  85
  86     wxSize size(GetSize());
  87
  88     wxASSERT_MSG( !m_clipping,
  89                   _T("narrowing clipping region not implemented yet") );
  90
  91     // NB: We intersect the clipping rectangle with surface's area here because
  92     //     DirectFB will return an error if you try to set clipping rectangle
  93     //     that is partially outside of the surface.
  94     DFBRegion r;
  95     r.x1 = wxMax(0, XLOG2DEV(cx));
  96     r.y1 = wxMax(0, YLOG2DEV(cy));
  97     r.x2 = wxMin(r.x1 + XLOG2DEVREL(cw), size.x) - 1;
  98     r.y2 = wxMin(r.y1 + YLOG2DEVREL(ch), size.y) - 1;
  99
 100     if ( !m_surface->SetClip(&r) )
 101         return;
 102
 103     m_clipX1 = cx;
 104     m_clipY1 = cy;
 105     m_clipX2 = cx + cw - 1;
 106     m_clipY2 = cy + ch -1;
 107     m_clipping = true;
 108 }
 109
 110 void wxDC::DoSetClippingRegionAsRegion(const wxRegion& region)
 111 {
 112     // NB: this can be done because wxDFB only supports rectangular regions
 113     SetClippingRegion(region.AsRect());
 114 }
 115
 116 void wxDC::DestroyClippingRegion()
 117 {
 118     wxCHECK_RET( Ok(), wxT("invalid dc") );
 119
 120     m_surface->SetClip(NULL);
 121
 122     ResetClipping();
 123 }
 124
 125 // ---------------------------------------------------------------------------
 126 // query capabilities
 127 // ---------------------------------------------------------------------------
 128
 129 int wxDC::GetDepth() const
 130 {
 131     return m_surface->GetDepth();
 132 }
 133
 134 // ---------------------------------------------------------------------------
 135 // drawing
 136 // ---------------------------------------------------------------------------
 137
 138 void wxDC::Clear()
 139 {
 140     wxCHECK_RET( Ok(), wxT("invalid dc") );
 141
 142     if ( m_backgroundBrush.GetStyle() == wxTRANSPARENT )
 143         return;
 144
 145     wxColour clr = m_backgroundBrush.GetColour();
 146     m_surface->Clear(clr.Red(), clr.Green(), clr.Blue(), clr.Alpha());
 147
 148     wxSize size(GetSize());
 149     CalcBoundingBox(XDEV2LOG(0), YDEV2LOG(0));
 150     CalcBoundingBox(XDEV2LOG(size.x), YDEV2LOG(size.y));
 151 }
 152
 153 extern bool wxDoFloodFill(wxDC *dc, wxCoord x, wxCoord y,
 154                           const wxColour & col, int style);
 155
 156 bool wxDC::DoFloodFill(wxCoord x, wxCoord y,
 157                        const wxColour& col, int style)
 158 {
 159     return wxDoFloodFill(this, x, y, col, style);
 160 }
 161
 162 bool wxDC::DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
 163 {
 164     wxCHECK_MSG( col, false, _T("NULL colour parameter in wxDC::GetPixel"));
 165
 166     wxFAIL_MSG( _T("GetPixel not implemented") );
 167     return false;
 168 }
 169
 170 void wxDC::DoCrossHair(wxCoord x, wxCoord y)
 171 {
 172     wxCHECK_RET( Ok(), wxT("invalid dc") );
 173
 174     wxFAIL_MSG( _T("CrossHair not implemented") );
 175 }
 176
 177 void wxDC::DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
 178 {
 179     wxCHECK_RET( Ok(), wxT("invalid dc") );
 180
 181     if ( m_pen.GetStyle() == wxTRANSPARENT )
 182         return;
 183
 184     wxCoord xx1 = XLOG2DEV(x1);
 185     wxCoord yy1 = YLOG2DEV(y1);
 186     wxCoord xx2 = XLOG2DEV(x2);
 187     wxCoord yy2 = YLOG2DEV(y2);
 188
 189     // FIXME: DrawLine() shouldn't draw the last pixel, but DFB's DrawLine()
 190     //        does draw it. We should undo any change to the last pixel by
 191     //        using GetPixel() and PutPixel(), but until they are implemented,
 192     //        handle at least the special case of vertical and horizontal
 193     //        lines correctly:
 194     if ( xx1 == xx2 )
 195     {
 196         if ( yy1 < yy2 )
 197             yy2--;
 198         else if ( yy1 > yy2 )
 199             yy2++;
 200     }
 201     if ( yy1 == yy2 )
 202     {
 203         if ( xx1 < xx2 )
 204             xx2--;
 205         else if ( xx1 > xx2 )
 206             xx2++;
 207     }
 208
 209     m_surface->DrawLine(xx1, yy1, xx2, yy2);
 210
 211     CalcBoundingBox(x1, y1);
 212     CalcBoundingBox(x2, y2);
 213 }
 214
 215 // Draws an arc of a circle, centred on (xc, yc), with starting point (x1, y1)
 216 // and ending at (x2, y2)
 217 void wxDC::DoDrawArc(wxCoord x1, wxCoord y1,
 218                      wxCoord x2, wxCoord y2,
 219                      wxCoord xc, wxCoord yc)
 220 {
 221     wxCHECK_RET( Ok(), wxT("invalid dc") );
 222
 223     wxFAIL_MSG( _T("DrawArc not implemented") );
 224 }
 225
 226 void wxDC::DoDrawPoint(wxCoord x, wxCoord y)
 227 {
 228     wxCHECK_RET( Ok(), wxT("invalid dc") );
 229
 230     // NB: DirectFB API doesn't provide a function for drawing points, so
 231     //     implement it as 1px long line. This is inefficient, but then, so is
 232     //     using DrawPoint() for drawing more than a few points.
 233     DoDrawLine(x, y, x, y);
 234
 235     // FIXME_DFB: implement special cases for common formats (RGB24,RGBA/RGB32)
 236 }
 237
 238 void wxDC::DoDrawPolygon(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset,int WXUNUSED(fillStyle))
 239 {
 240     wxCHECK_RET( Ok(), wxT("invalid dc") );
 241
 242     wxFAIL_MSG( _T("DrawPolygon not implemented") );
 243 }
 244
 245 void wxDC::DoDrawLines(int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset)
 246 {
 247     wxCHECK_RET( Ok(), wxT("invalid dc") );
 248
 249     // TODO: impl. using DirectDB's DrawLines
 250     wxFAIL_MSG( _T("DrawLines not implemented") );
 251 }
 252
 253 void wxDC::DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 254 {
 255     wxCHECK_RET( Ok(), wxT("invalid dc") );
 256
 257     wxCoord xx = XLOG2DEV(x);
 258     wxCoord yy = YLOG2DEV(y);
 259     wxCoord ww = m_signX * XLOG2DEVREL(width);
 260     wxCoord hh = m_signY * YLOG2DEVREL(height);
 261
 262     if ( ww == 0 || hh == 0 ) return;
 263
 264     if ( ww < 0 )
 265     {
 266         ww = -ww;
 267         xx = xx - ww;
 268     }
 269     if ( hh < 0 )
 270     {
 271         hh = -hh;
 272         yy = yy - hh;
 273     }
 274
 275     if ( m_brush.GetStyle() != wxTRANSPARENT )
 276     {
 277         SelectColour(m_brush.GetColour());
 278         m_surface->FillRectangle(xx, yy, ww, hh);
 279         // restore pen's colour, because other drawing functions expect the
 280         // colour to be set to the pen:
 281         SelectColour(m_pen.GetColour());
 282     }
 283
 284     if ( m_pen.GetStyle() != wxTRANSPARENT )
 285     {
 286         m_surface->DrawRectangle(xx, yy, ww, hh);
 287     }
 288
 289     CalcBoundingBox(x, y);
 290     CalcBoundingBox(x + width, y + height);
 291 }
 292
 293 void wxDC::DoDrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height, double radius)
 294 {
 295     wxCHECK_RET( Ok(), wxT("invalid dc") );
 296
 297     wxFAIL_MSG( _T("DrawRoundedRectangle not implemented") );
 298 }
 299
 300 void wxDC::DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
 301 {
 302     wxCHECK_RET( Ok(), wxT("invalid dc") );
 303
 304     wxFAIL_MSG( _T("DrawElipse not implemented") );
 305 }
 306
 307 void wxDC::DoDrawEllipticArc(wxCoord x,wxCoord y,wxCoord w,wxCoord h,double sa,double ea)
 308 {
 309     wxCHECK_RET( Ok(), wxT("invalid dc") );
 310
 311     wxFAIL_MSG( _T("DrawElipticArc not implemented") );
 312 }
 313
 314 void wxDC::DoDrawText(const wxString& text, wxCoord x, wxCoord y)
 315 {
 316     wxCHECK_RET( Ok(), wxT("invalid dc") );
 317
 318     wxCoord xx = XLOG2DEV(x);
 319     wxCoord yy = YLOG2DEV(y);
 320
 321     // update the bounding box
 322     wxCoord w, h;
 323     CalcBoundingBox(x, y);
 324     GetTextExtent(text, &w, &h);
 325     CalcBoundingBox(x + w, y + h);
 326
 327     // if background mode is solid, DrawText must paint text's background:
 328     if ( m_backgroundMode == wxSOLID )
 329     {
 330         wxCHECK_RET( m_textBackgroundColour.Ok(),
 331                      wxT("invalid background color") );
 332
 333         SelectColour(m_textBackgroundColour);
 334         m_surface->FillRectangle(xx, yy, XLOG2DEVREL(w), YLOG2DEVREL(h));
 335     }
 336
 337     // finally draw the text itself:
 338     wxCHECK_RET( m_textForegroundColour.Ok(),
 339                  wxT("invalid foreground color") );
 340     SelectColour(m_textForegroundColour);
 341     m_surface->DrawString(text.utf8_str(), -1, xx, yy, DSTF_LEFT | DSTF_TOP);
 342
 343     // restore pen's colour, because other drawing functions expect the colour
 344     // to be set to the pen:
 345     SelectColour(m_pen.GetColour());
 346 }
 347
 348 void wxDC::DoDrawRotatedText(const wxString& text,
 349                              wxCoord x, wxCoord y,
 350                              double angle)
 351 {
 352     wxCHECK_RET( Ok(), wxT("invalid dc") );
 353
 354     wxFAIL_MSG( _T("DrawRotatedText not implemented") );
 355 }
 356
 357 // ---------------------------------------------------------------------------
 358 // set GDI objects
 359 // ---------------------------------------------------------------------------
 360
 361 void wxDC::SetPen(const wxPen& pen)
 362 {
 363     m_pen = pen.Ok() ? pen : DEFAULT_PEN;
 364
 365     SelectColour(m_pen.GetColour());
 366 }
 367
 368 void wxDC::SetBrush(const wxBrush& brush)
 369 {
 370     m_brush = brush.Ok() ? brush : DEFAULT_BRUSH;
 371 }
 372
 373 void wxDC::SelectColour(const wxColour& clr)
 374 {
 375     m_surface->SetColor(clr.Red(), clr.Green(), clr.Blue(), clr.Alpha());
 376     #warning "use SetColorIndex?"
 377 }
 378
 379 #if wxUSE_PALETTE
 380 void wxDC::SetPalette(const wxPalette& WXUNUSED(palette))
 381 {
 382     wxCHECK_RET( Ok(), wxT("invalid dc") );
 383
 384     wxFAIL_MSG( _T("SetPalette not implemented") );
 385 }
 386 #endif // wxUSE_PALETTE
 387
 388 void wxDC::SetFont(const wxFont& font)
 389 {
 390     wxCHECK_RET( Ok(), wxT("invalid dc") );
 391
 392     wxFont f(font.Ok() ? font : DEFAULT_FONT);
 393
 394     wxFont oldfont(m_font);
 395
 396     m_font = f;
 397
 398     if ( !m_surface->SetFont(GetCurrentFont()) )
 399     {
 400         m_font = oldfont;
 401         return;
 402     }
 403 }
 404
 405 wxIDirectFBFontPtr wxDC::GetCurrentFont() const
 406 {
 407     bool aa = (GetDepth() > 8);
 408     return m_font.GetDirectFBFont(aa);
 409 }
 410
 411 void wxDC::SetBackground(const wxBrush& brush)
 412 {
 413     wxCHECK_RET( Ok(), wxT("invalid dc") );
 414
 415     if (!brush.Ok()) return;
 416
 417     m_backgroundBrush = brush;
 418 }
 419
 420 void wxDC::SetBackgroundMode(int mode)
 421 {
 422     m_backgroundMode = mode;
 423 }
 424
 425 void wxDC::SetLogicalFunction(int function)
 426 {
 427     wxCHECK_RET( Ok(), wxT("invalid dc") );
 428
 429     // NB: we could also support XOR, but for blitting only (via DSBLIT_XOR);
 430     //     and possibly others via SetSrc/DstBlendFunction()
 431     wxASSERT_MSG( function == wxCOPY,
 432                   _T("only wxCOPY logical function supported") );
 433
 434     m_logicalFunction = function;
 435 }
 436
 437 bool wxDC::StartDoc(const wxString& WXUNUSED(message))
 438 {
 439     // We might be previewing, so return true to let it continue.
 440     return true;
 441 }
 442
 443 void wxDC::EndDoc()
 444 {
 445 }
 446
 447 void wxDC::StartPage()
 448 {
 449 }
 450
 451 void wxDC::EndPage()
 452 {
 453 }
 454
 455 // ---------------------------------------------------------------------------
 456 // text metrics
 457 // ---------------------------------------------------------------------------
 458
 459 wxCoord wxDC::GetCharHeight() const
 460 {
 461     wxCHECK_MSG( Ok(), -1, wxT("invalid dc") );
 462     wxCHECK_MSG( m_font.Ok(), -1, wxT("no font selected") );
 463
 464     int h = -1;
 465     GetCurrentFont()->GetHeight(&h);
 466     return YDEV2LOGREL(h);
 467 }
 468
 469 wxCoord wxDC::GetCharWidth() const
 470 {
 471     wxCHECK_MSG( Ok(), -1, wxT("invalid dc") );
 472     wxCHECK_MSG( m_font.Ok(), -1, wxT("no font selected") );
 473
 474     int w = -1;
 475     GetCurrentFont()->GetStringWidth("H", 1, &w);
 476     // VS: YDEV is corrent, it should *not* be XDEV, because font's are only
 477     //     scaled according to m_scaleY
 478     return YDEV2LOGREL(w);
 479 }
 480
 481 void wxDC::DoGetTextExtent(const wxString& string, wxCoord *x, wxCoord *y,
 482                            wxCoord *descent, wxCoord *externalLeading,
 483                            const wxFont *theFont) const
 484 {
 485     wxCHECK_RET( Ok(), wxT("invalid dc") );
 486     wxCHECK_RET( m_font.Ok(), wxT("no font selected") );
 487     wxCHECK_RET( !theFont || theFont->Ok(), wxT("invalid font") );
 488
 489     wxFont oldFont;
 490     if ( theFont != NULL )
 491     {
 492         oldFont = m_font;
 493         wxConstCast(this, wxDC)->SetFont(*theFont);
 494     }
 495
 496     wxCoord xx = 0, yy = 0;
 497     DFBRectangle rect;
 498     wxIDirectFBFontPtr f = GetCurrentFont();
 499
 500     if ( f->GetStringExtents(string.utf8_str(), -1, &rect, NULL) )
 501     {
 502         // VS: YDEV is corrent, it should *not* be XDEV, because font's are
 503         //     only scaled according to m_scaleY
 504         xx = YDEV2LOGREL(rect.w);
 505         yy = YDEV2LOGREL(rect.h);
 506
 507         if ( descent )
 508         {
 509             int d;
 510             if ( f->GetDescender(&d) )
 511                 *descent = YDEV2LOGREL(-d);
 512             else
 513                 *descent = 0;
 514         }
 515     }
 516
 517     if ( x ) *x = xx;
 518     if ( y ) *y = yy;
 519     if ( externalLeading ) *externalLeading = 0;
 520
 521     if ( theFont != NULL )
 522         wxConstCast(this, wxDC)->SetFont(oldFont);
 523 }
 524
 525
 526
 527 // ---------------------------------------------------------------------------
 528 // mapping modes
 529 // ---------------------------------------------------------------------------
 530
 531 // FIXME_DFB: scaling affects pixel size of font, pens, brushes, which
 532 //            is not currently implemented here; probably makes sense to
 533 //            switch to Cairo instead of implementing everything for DFB
 534
 535 void wxDC::DoGetSize(int *w, int *h) const
 536 {
 537     wxCHECK_RET( Ok(), wxT("invalid dc") );
 538
 539     m_surface->GetSize(w, h);
 540 }
 541
 542 void wxDC::DoGetSizeMM(int *width, int *height) const
 543 {
 544     #warning "move this to common code?"
 545     int w = 0;
 546     int h = 0;
 547     GetSize(&w, &h);
 548     if ( width ) *width = int(double(w) / (m_userScaleX*m_mm_to_pix_x));
 549     if ( height ) *height = int(double(h) / (m_userScaleY*m_mm_to_pix_y));
 550 }
 551
 552 wxSize wxDC::GetPPI() const
 553 {
 554     #warning "move this to common code?"
 555     return wxSize(int(double(m_mm_to_pix_x) * inches2mm),
 556                   int(double(m_mm_to_pix_y) * inches2mm));
 557 }
 558
 559
 560 // ---------------------------------------------------------------------------
 561 // Blitting
 562 // ---------------------------------------------------------------------------
 563
 564 bool wxDC::DoBlit(wxCoord xdest, wxCoord ydest,
 565                   wxCoord width, wxCoord height,
 566                   wxDC *source, wxCoord xsrc, wxCoord ysrc,
 567                   int rop, bool useMask,
 568                   wxCoord xsrcMask, wxCoord ysrcMask)
 569 {
 570     wxCHECK_MSG( Ok(), false, _T("invalid dc") );
 571     wxCHECK_MSG( source, false, _T("invalid source dc") );
 572
 573     // NB: we could also support XOR here (via DSBLIT_XOR)
 574     //     and possibly others via SetSrc/DstBlendFunction()
 575     wxCHECK_MSG( rop == wxCOPY, false, _T("only wxCOPY function supported") );
 576
 577     // transform the source DC coords to the device ones
 578     xsrc = source->LogicalToDeviceX(xsrc);
 579     ysrc = source->LogicalToDeviceY(ysrc);
 580
 581     // FIXME_DFB: use the mask origin when drawing transparently
 582     wxASSERT_MSG( xsrcMask == -1 && ysrcMask == -1,
 583                   _T("non-default source mask offset not implemented") );
 584 #if 0
 585     if (xsrcMask == -1 && ysrcMask == -1)
 586     {
 587         xsrcMask = xsrc; ysrcMask = ysrc;
 588     }
 589     else
 590     {
 591         xsrcMask = source->LogicalToDeviceX(xsrcMask);
 592         ysrcMask = source->LogicalToDeviceY(ysrcMask);
 593     }
 594 #endif
 595
 596     wxMemoryDC *sourceAsMemDC = wxDynamicCast(source, wxMemoryDC);
 597     if ( sourceAsMemDC )
 598     {
 599         DoDrawSubBitmap(sourceAsMemDC->GetSelectedObject(),
 600                         xsrc, ysrc,
 601                         width, height,
 602                         xdest, ydest,
 603                         rop,
 604                         useMask);
 605     }
 606     else
 607     {
 608         return DoBlitFromSurface(source->GetDirectFBSurface(),
 609                                  xsrc, ysrc,
 610                                  width, height,
 611                                  xdest, ydest);
 612     }
 613
 614     return true;
 615 }
 616
 617 void wxDC::DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y, bool useMask)
 618 {
 619     wxCHECK_RET( Ok(), wxT("invalid dc") );
 620     wxCHECK_RET( bmp.Ok(), wxT("invalid bitmap") );
 621
 622     DoDrawSubBitmap(bmp,
 623                     0, 0, bmp.GetWidth(), bmp.GetHeight(),
 624                     x, y,
 625                     m_logicalFunction, useMask);
 626 }
 627
 628 void wxDC::DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
 629 {
 630     // VZ: egcs 1.0.3 refuses to compile this without cast, no idea why
 631     DoDrawBitmap((const wxBitmap&)icon, x, y, true);
 632 }
 633
 634 void wxDC::DoDrawSubBitmap(const wxBitmap &bmp,
 635                            wxCoord x, wxCoord y, wxCoord w, wxCoord h,
 636                            wxCoord destx, wxCoord desty, int rop, bool useMask)
 637 {
 638     wxCHECK_RET( Ok(), wxT("invalid dc") );
 639     wxCHECK_RET( bmp.Ok(), wxT("invalid bitmap") );
 640
 641     // NB: we could also support XOR here (via DSBLIT_XOR)
 642     //     and possibly others via SetSrc/DstBlendFunction()
 643     wxCHECK_RET( rop == wxCOPY, _T("only wxCOPY function supported") );
 644
 645     if ( bmp.GetDepth() == 1 )
 646     {
 647         // Mono bitmaps are handled in special way -- all 1s are drawn in
 648         // foreground colours, all 0s in background colour.
 649         wxFAIL_MSG( _T("drawing mono bitmaps not implemented") );
 650         return;
 651     }
 652
 653     if ( useMask && bmp.GetMask() )
 654     {
 655         // FIXME_DFB: see MGL sources for a way to do it, but it's not directly
 656         //            applicable because DirectFB doesn't implement ROPs; OTOH,
 657         //            it has blitting modes that can be useful; finally, see
 658         //            DFB's SetSrcBlendFunction() and SetSrcColorKey()
 659         wxFAIL_MSG( _T("drawing bitmaps with masks not implemented") );
 660         return;
 661     }
 662
 663     DoBlitFromSurface(bmp.GetDirectFBSurface(),
 664                       x, y,
 665                       w, h,
 666                       destx, desty);
 667 }
 668
 669 bool wxDC::DoBlitFromSurface(const wxIDirectFBSurfacePtr& src,
 670                              wxCoord srcx, wxCoord srcy,
 671                              wxCoord w, wxCoord h,
 672                              wxCoord dstx, wxCoord dsty)
 673 {
 674     // don't do anything if the source rectangle is outside of source surface,
 675     // DirectFB would assert in that case:
 676     wxSize srcsize;
 677     src->GetSize(&srcsize.x, &srcsize.y);
 678     if ( !wxRect(srcx, srcy, w, h).Intersects(wxRect(srcsize)) )
 679     {
 680         wxLogDebug(_T("Blitting from area outside of the source surface, caller code needs fixing."));
 681         return false;
 682     }
 683
 684     CalcBoundingBox(dstx, dsty);
 685     CalcBoundingBox(dstx + w, dsty + h);
 686
 687     DFBRectangle srcRect = { srcx, srcy, w, h };
 688     DFBRectangle dstRect = { XLOG2DEV(dstx), YLOG2DEV(dsty),
 689                              XLOG2DEVREL(w), YLOG2DEVREL(h) };
 690
 691     wxIDirectFBSurfacePtr dst(m_surface);
 692
 693     // FIXME: this will have to be different in useMask case, see above
 694     if ( !dst->SetBlittingFlags(DSBLIT_NOFX) )
 695         return false;
 696
 697     if ( srcRect.w != dstRect.w || srcRect.h != dstRect.h )
 698     {
 699         // the bitmap is drawn stretched:
 700         dst->StretchBlit(src, &srcRect, &dstRect);
 701     }
 702     else
 703     {
 704         // no stretching, size is preserved:
 705         dst->Blit(src, &srcRect, dstRect.x, dstRect.y);
 706     }
 707
 708     return true;
 709 }