vcl/headless/svpgdi.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "headless/svpgdi.hxx"
  21 #include "headless/svpbmp.hxx"
  22
  23 #include <vcl/sysdata.hxx>
  24 #include <basegfx/range/b2drange.hxx>
  25 #include <basegfx/range/b2ibox.hxx>
  26 #include <basegfx/polygon/b2dpolypolygon.hxx>
  27 #include <basegfx/polygon/b2dpolygon.hxx>
  28 #include <basegfx/polygon/b2dpolygontools.hxx>
  29 #include <basebmp/scanlineformats.hxx>
  30
  31 #include <tools/debug.hxx>
  32
  33 #if OSL_DEBUG_LEVEL > 2
  34 #include <basebmp/debug.hxx>
  35 #include <fstream>
  36 #include <rtl/strbuf.hxx>
  37 #include <sys/stat.h>
  38 #endif
  39
  40 #include <region.h>
  41 #include <stdio.h>
  42
  43 inline void dbgOut( const basebmp::BitmapDeviceSharedPtr&
  44 #if OSL_DEBUG_LEVEL > 2
  45 rDevice
  46 #endif
  47 )
  48 {
  49     #if OSL_DEBUG_LEVEL > 2
  50     static int dbgStreamNum = 0;
  51     rtl::OStringBuffer aBuf( 256 );
  52     aBuf.append( "debug" );
  53     mkdir( aBuf.getStr(), 0777 );
  54     aBuf.append( "/" );
  55     aBuf.append( sal_Int64(reinterpret_cast<sal_IntPtr>(rDevice.get())), 16 );
  56     mkdir( aBuf.getStr(), 0777 );
  57     aBuf.append( "/bmp" );
  58     aBuf.append( sal_Int32(dbgStreamNum++) );
  59     std::fstream bmpstream( aBuf.getStr(), std::ios::out );
  60     debugDump( rDevice, bmpstream );
  61     #endif
  62 }
  63
  64 // ===========================================================================
  65
  66 bool SvpSalGraphics::drawAlphaBitmap( const SalTwoRect&, const SalBitmap& /*rSourceBitmap*/, const SalBitmap& /*rAlphaBitmap*/ )
  67 {
  68     // TODO(P3) implement alpha blending
  69     return false;
  70 }
  71
  72 bool SvpSalGraphics::drawAlphaRect( long /*nX*/, long /*nY*/, long /*nWidth*/, long /*nHeight*/, sal_uInt8 /*nTransparency*/ )
  73 {
  74     // TODO(P3) implement alpha blending
  75     return false;
  76 }
  77
  78 SvpSalGraphics::SvpSalGraphics() :
  79     m_bUseLineColor( true ),
  80     m_aLineColor( COL_BLACK ),
  81     m_bUseFillColor( false ),
  82     m_aFillColor( COL_WHITE ),
  83     m_aTextColor( COL_BLACK ),
  84     m_aDrawMode( basebmp::DrawMode_PAINT ),
  85     m_eTextFmt( basebmp::Format::EIGHT_BIT_GREY ),
  86     m_bClipSetup( false )
  87 {
  88     for( int i = 0; i < MAX_FALLBACK; ++i )
  89         m_pServerFont[i] = NULL;
  90 }
  91
  92 SvpSalGraphics::~SvpSalGraphics()
  93 {
  94 }
  95
  96 void SvpSalGraphics::setDevice( basebmp::BitmapDeviceSharedPtr& rDevice )
  97 {
  98     m_aOrigDevice = rDevice;
  99     ResetClipRegion();
 100
 101     // determine matching bitmap format for masks
 102     sal_uInt32 nDeviceFmt = m_aDevice->getScanlineFormat();
 103     DBG_ASSERT( (nDeviceFmt <= (sal_uInt32)basebmp::Format::MAX), "SVP::setDevice() with invalid bitmap format" );
 104     switch( nDeviceFmt )
 105     {
 106         case basebmp::Format::EIGHT_BIT_GREY:
 107         case basebmp::Format::SIXTEEN_BIT_LSB_TC_MASK:
 108         case basebmp::Format::SIXTEEN_BIT_MSB_TC_MASK:
 109         case basebmp::Format::TWENTYFOUR_BIT_TC_MASK:
 110         case basebmp::Format::THIRTYTWO_BIT_TC_MASK_BGRA:
 111         case basebmp::Format::THIRTYTWO_BIT_TC_MASK_ARGB:
 112         case basebmp::Format::THIRTYTWO_BIT_TC_MASK_ABGR:
 113         case basebmp::Format::THIRTYTWO_BIT_TC_MASK_RGBA:
 114             m_eTextFmt = basebmp::Format::EIGHT_BIT_GREY;
 115             break;
 116         default:
 117             m_eTextFmt = basebmp::Format::ONE_BIT_LSB_GREY;
 118             break;
 119     }
 120 }
 121
 122 void SvpSalGraphics::GetResolution( sal_Int32& rDPIX, sal_Int32& rDPIY )
 123 {
 124     rDPIX = rDPIY = 96;
 125 }
 126
 127 sal_uInt16 SvpSalGraphics::GetBitCount() const
 128 {
 129     return SvpElement::getBitCountFromScanlineFormat( m_aDevice->getScanlineFormat() );
 130 }
 131
 132 long SvpSalGraphics::GetGraphicsWidth() const
 133 {
 134     if( m_aDevice.get() )
 135     {
 136         basegfx::B2IVector aSize = m_aOrigDevice->getSize();
 137         return aSize.getX();
 138     }
 139     return 0;
 140 }
 141
 142 void SvpSalGraphics::ResetClipRegion()
 143 {
 144     m_aDevice = m_aOrigDevice;
 145     m_aClipMap.reset();
 146     m_bClipSetup = true;
 147     m_aClipRegion.SetNull();
 148 }
 149
 150
 151 // verify clip for the whole area is setup
 152 void SvpSalGraphics::ensureClip()
 153 {
 154     if (m_bClipSetup)
 155         return;
 156
 157     m_aDevice = m_aOrigDevice;
 158     basegfx::B2IVector aSize = m_aDevice->getSize();
 159     m_aClipMap = basebmp::createBitmapDevice( aSize, false, basebmp::Format::ONE_BIT_MSB_GREY );
 160     m_aClipMap->clear( basebmp::Color(0xFFFFFFFF) );
 161
 162     // fprintf( stderr, "non rect clip region set with %d rects:\n",
 163     //         (int)m_aClipRegion.GetRectCount() );
 164     ImplRegionInfo aInfo;
 165     long nX, nY, nW, nH;
 166     bool bRegionRect = m_aClipRegion.ImplGetFirstRect(aInfo, nX, nY, nW, nH );
 167     while( bRegionRect )
 168     {
 169         if ( nW && nH )
 170         {
 171             basegfx::B2DPolyPolygon aFull;
 172             aFull.append( basegfx::tools::createPolygonFromRect( basegfx::B2DRectangle( nX, nY, nX+nW, nY+nH ) ) );
 173             m_aClipMap->fillPolyPolygon( aFull, basebmp::Color(0), basebmp::DrawMode_PAINT );
 174         }
 175     //    fprintf( stderr, "\t %ld,%ld %ldx%ld\n", nX, nY, nW, nH );
 176         bRegionRect = m_aClipRegion.ImplGetNextRect( aInfo, nX, nY, nW, nH );
 177     }
 178     m_bClipSetup = true;
 179 }
 180
 181 SvpSalGraphics::ClipUndoHandle::~ClipUndoHandle()
 182 {
 183     if( m_aDevice.get() )
 184         m_rGfx.m_aDevice = m_aDevice;
 185 }
 186
 187 // setup a clip rectangle -only- iff we have to; if aRange
 188 // is entirely contained inside an existing clip frame, we
 189 // will avoid setting up the clip bitmap. Similarly if the
 190 // range doesn't appear at all we return true to avoid
 191 // rendering
 192 bool SvpSalGraphics::isClippedSetup( const basegfx::B2IBox &aRange, SvpSalGraphics::ClipUndoHandle &rUndo )
 193 {
 194     if( m_bClipSetup )
 195         return false;
 196
 197     if( m_aClipRegion.IsEmpty() ) // no clipping
 198         return false;
 199
 200     // fprintf( stderr, "ensureClipFor: %d, %d %dx%d\n",
 201     //         aRange.getMinX(), aRange.getMinY(),
 202     //         (int)aRange.getWidth(), (int)aRange.getHeight() );
 203
 204     // first see if aRange is purely internal to one of the clip regions
 205     Rectangle aRect( Point( aRange.getMinX(), aRange.getMinY() ),
 206                      Size( aRange.getWidth(), aRange.getHeight() ) );
 207
 208     // then see if we are overlapping with just one
 209     int nHit = 0;
 210     Rectangle aIterRect, aHitRect;
 211     RegionHandle aHnd = m_aClipRegion.BeginEnumRects();
 212     while( m_aClipRegion.GetNextEnumRect( aHnd, aIterRect ) )
 213     {
 214         if( aIterRect.IsOver( aRect ) )
 215         {
 216             aHitRect = aIterRect;
 217             nHit++;
 218         }
 219     }
 220     m_aClipRegion.EndEnumRects (aHnd);
 221
 222     if( nHit == 0 ) // rendering outside any clipping region
 223     {
 224 //        fprintf (stderr, "denegerate case detected ...\n");
 225         return true;
 226     }
 227     else if( nHit == 1 ) // common path: rendering against just one clipping region
 228     {
 229         if( aHitRect.IsInside( aRect ) )
 230         {
 231 //        fprintf (stderr, " is inside ! avoid deeper clip ...\n");
 232             return false;
 233         }
 234 //    fprintf (stderr, " operation only overlaps with a single clip zone\n" );
 235         rUndo.m_aDevice = m_aDevice;
 236         m_aDevice = basebmp::subsetBitmapDevice( m_aOrigDevice,
 237                                                  basegfx::B2IBox (aHitRect.Left(),
 238                                                                   aHitRect.Top(),
 239                                                                   aHitRect.Right(),
 240                                                                   aHitRect.Bottom()) );
 241         return false;
 242     }
 243 //    fprintf (stderr, "URK: complex & slow clipping case\n" );
 244     // horribly slow & complicated case ...
 245
 246     ensureClip();
 247     return false;
 248 }
 249
 250
 251 // Clipping by creating unconditional mask bitmaps is horribly
 252 // slow so defer it, as much as possible. It is common to get
 253 // 3 rectangles pushed, and have to create a vast off-screen
 254 // mask only to destroy it shortly afterwards. That is
 255 // particularly galling if we render only to a small,
 256 // well defined rectangular area inside one of these clip
 257 // rectangles.
 258 //
 259 // ensureClipFor() or ensureClip() need to be called before
 260 // real rendering. FIXME: we should prolly push this down to
 261 // bitmapdevice instead.
 262 bool SvpSalGraphics::setClipRegion( const Region& i_rClip )
 263 {
 264     m_aClipRegion = i_rClip;
 265     m_aClipMap.reset();
 266     if( i_rClip.IsEmpty() )
 267         m_bClipSetup = true;
 268
 269     else if( i_rClip.GetRectCount() == 1 )
 270     {
 271         m_aClipMap.reset();
 272         Rectangle aBoundRect( i_rClip.GetBoundRect() );
 273         m_aDevice = basebmp::subsetBitmapDevice( m_aOrigDevice,
 274                                                  basegfx::B2IBox(aBoundRect.Left(),aBoundRect.Top(),aBoundRect.Right(),aBoundRect.Bottom()) );
 275         m_bClipSetup = true;
 276     }
 277     else
 278         m_bClipSetup = false;
 279
 280     return true;
 281 }
 282
 283 void SvpSalGraphics::SetLineColor()
 284 {
 285     m_bUseLineColor = false;
 286 }
 287
 288 void SvpSalGraphics::SetLineColor( SalColor nSalColor )
 289 {
 290     m_bUseLineColor = true;
 291     m_aLineColor = basebmp::Color( nSalColor );
 292 }
 293
 294 void SvpSalGraphics::SetFillColor()
 295 {
 296     m_bUseFillColor = false;
 297 }
 298
 299 void SvpSalGraphics::SetFillColor( SalColor nSalColor )
 300 {
 301     m_bUseFillColor = true;
 302     m_aFillColor = basebmp::Color( nSalColor );
 303 }
 304
 305 void SvpSalGraphics::SetXORMode( bool bSet, bool )
 306 {
 307     m_aDrawMode = bSet ? basebmp::DrawMode_XOR : basebmp::DrawMode_PAINT;
 308 }
 309
 310 void SvpSalGraphics::SetROPLineColor( SalROPColor nROPColor )
 311 {
 312     m_bUseLineColor = true;
 313     switch( nROPColor )
 314     {
 315         case SAL_ROP_0:
 316             m_aLineColor = basebmp::Color( 0 );
 317             break;
 318         case SAL_ROP_1:
 319             m_aLineColor = basebmp::Color( 0xffffff );
 320             break;
 321         case SAL_ROP_INVERT:
 322             m_aLineColor = basebmp::Color( 0xffffff );
 323             break;
 324     }
 325 }
 326
 327 void SvpSalGraphics::SetROPFillColor( SalROPColor nROPColor )
 328 {
 329     m_bUseFillColor = true;
 330     switch( nROPColor )
 331     {
 332         case SAL_ROP_0:
 333             m_aFillColor = basebmp::Color( 0 );
 334             break;
 335         case SAL_ROP_1:
 336             m_aFillColor = basebmp::Color( 0xffffff );
 337             break;
 338         case SAL_ROP_INVERT:
 339             m_aFillColor = basebmp::Color( 0xffffff );
 340             break;
 341     }
 342 }
 343
 344 void SvpSalGraphics::SetTextColor( SalColor nSalColor )
 345 {
 346     m_aTextColor = basebmp::Color( nSalColor );
 347 }
 348
 349 void SvpSalGraphics::drawPixel( long nX, long nY )
 350 {
 351     if( m_bUseLineColor )
 352     {
 353         ensureClip();
 354         m_aDevice->setPixel( basegfx::B2IPoint( nX, nY ),
 355                              m_aLineColor,
 356                              m_aDrawMode,
 357                              m_aClipMap
 358                              );
 359     }
 360     dbgOut( m_aDevice );
 361 }
 362
 363 void SvpSalGraphics::drawPixel( long nX, long nY, SalColor nSalColor )
 364 {
 365     basebmp::Color aColor( nSalColor );
 366     ensureClip();
 367     m_aDevice->setPixel( basegfx::B2IPoint( nX, nY ),
 368                          aColor,
 369                          m_aDrawMode,
 370                          m_aClipMap
 371                          );
 372     dbgOut( m_aDevice );
 373 }
 374
 375 void SvpSalGraphics::drawLine( long nX1, long nY1, long nX2, long nY2 )
 376 {
 377     if( m_bUseLineColor )
 378     {
 379         ensureClip(); // FIXME: for ...
 380         m_aDevice->drawLine( basegfx::B2IPoint( nX1, nY1 ),
 381                              basegfx::B2IPoint( nX2, nY2 ),
 382                              m_aLineColor,
 383                              m_aDrawMode,
 384                              m_aClipMap );
 385     }
 386     dbgOut( m_aDevice );
 387 }
 388
 389 void SvpSalGraphics::drawRect( long nX, long nY, long nWidth, long nHeight )
 390 {
 391     if( m_bUseLineColor || m_bUseFillColor )
 392     {
 393         basegfx::B2DPolygon aRect = basegfx::tools::createPolygonFromRect( basegfx::B2DRectangle( nX, nY, nX+nWidth, nY+nHeight ) );
 394         ensureClip(); // FIXME: for ...
 395         if( m_bUseFillColor )
 396         {
 397             basegfx::B2DPolyPolygon aPolyPoly( aRect );
 398             m_aDevice->fillPolyPolygon( aPolyPoly, m_aFillColor, m_aDrawMode, m_aClipMap );
 399         }
 400         if( m_bUseLineColor )
 401             m_aDevice->drawPolygon( aRect, m_aLineColor, m_aDrawMode, m_aClipMap );
 402     }
 403     dbgOut( m_aDevice );
 404 }
 405
 406 void SvpSalGraphics::drawPolyLine( sal_uLong nPoints, const SalPoint* pPtAry )
 407 {
 408     if( m_bUseLineColor && nPoints )
 409     {
 410         basegfx::B2DPolygon aPoly;
 411         aPoly.append( basegfx::B2DPoint( pPtAry->mnX, pPtAry->mnY ), nPoints );
 412         for( sal_uLong i = 1; i < nPoints; i++ )
 413             aPoly.setB2DPoint( i, basegfx::B2DPoint( pPtAry[i].mnX, pPtAry[i].mnY ) );
 414         aPoly.setClosed( false );
 415         ensureClip(); // FIXME: for ...
 416         m_aDevice->drawPolygon( aPoly, m_aLineColor, m_aDrawMode, m_aClipMap );
 417     }
 418     dbgOut( m_aDevice );
 419 }
 420
 421 void SvpSalGraphics::drawPolygon( sal_uLong nPoints, const SalPoint* pPtAry )
 422 {
 423     if( ( m_bUseLineColor || m_bUseFillColor ) && nPoints )
 424     {
 425         basegfx::B2DPolygon aPoly;
 426         aPoly.append( basegfx::B2DPoint( pPtAry->mnX, pPtAry->mnY ), nPoints );
 427         for( sal_uLong i = 1; i < nPoints; i++ )
 428             aPoly.setB2DPoint( i, basegfx::B2DPoint( pPtAry[i].mnX, pPtAry[i].mnY ) );
 429         ensureClip(); // FIXME: for ...
 430         if( m_bUseFillColor )
 431         {
 432             aPoly.setClosed( true );
 433             m_aDevice->fillPolyPolygon( basegfx::B2DPolyPolygon(aPoly), m_aFillColor, m_aDrawMode, m_aClipMap );
 434         }
 435         if( m_bUseLineColor )
 436         {
 437             aPoly.setClosed( false );
 438             m_aDevice->drawPolygon( aPoly, m_aLineColor, m_aDrawMode, m_aClipMap );
 439         }
 440     }
 441     dbgOut( m_aDevice );
 442 }
 443
 444 void SvpSalGraphics::drawPolyPolygon( sal_uInt32        nPoly,
 445                                       const sal_uInt32* pPointCounts,
 446                                       PCONSTSALPOINT*   pPtAry )
 447 {
 448     if( ( m_bUseLineColor || m_bUseFillColor ) && nPoly )
 449     {
 450         basegfx::B2DPolyPolygon aPolyPoly;
 451         for( sal_uInt32 nPolygon = 0; nPolygon < nPoly; nPolygon++ )
 452         {
 453             sal_uInt32 nPoints = pPointCounts[nPolygon];
 454             if( nPoints )
 455             {
 456                 PCONSTSALPOINT pPoints = pPtAry[nPolygon];
 457                 basegfx::B2DPolygon aPoly;
 458                 aPoly.append( basegfx::B2DPoint( pPoints->mnX, pPoints->mnY ), nPoints );
 459                 for( sal_uInt32 i = 1; i < nPoints; i++ )
 460                     aPoly.setB2DPoint( i, basegfx::B2DPoint( pPoints[i].mnX, pPoints[i].mnY ) );
 461
 462                 aPolyPoly.append( aPoly );
 463             }
 464         }
 465         ensureClip(); // FIXME: for ...
 466         if( m_bUseFillColor )
 467         {
 468             aPolyPoly.setClosed( true );
 469             m_aDevice->fillPolyPolygon( aPolyPoly, m_aFillColor, m_aDrawMode, m_aClipMap );
 470         }
 471         if( m_bUseLineColor )
 472         {
 473             aPolyPoly.setClosed( false );
 474             nPoly = aPolyPoly.count();
 475             for( sal_uInt32 i = 0; i < nPoly; i++ )
 476                 m_aDevice->drawPolygon( aPolyPoly.getB2DPolygon(i), m_aLineColor, m_aDrawMode, m_aClipMap );
 477         }
 478     }
 479     dbgOut( m_aDevice );
 480 }
 481
 482 bool SvpSalGraphics::drawPolyLine(
 483     const ::basegfx::B2DPolygon&,
 484     double /*fTransparency*/,
 485     const ::basegfx::B2DVector& /*rLineWidths*/,
 486     basegfx::B2DLineJoin /*eJoin*/,
 487     com::sun::star::drawing::LineCap /*eLineCap*/)
 488 {
 489         // TODO: implement and advertise OutDevSupport_B2DDraw support
 490         return false;
 491 }
 492
 493 sal_Bool SvpSalGraphics::drawPolyLineBezier( sal_uLong,
 494                                              const SalPoint*,
 495                                              const sal_uInt8* )
 496 {
 497     return sal_False;
 498 }
 499
 500 sal_Bool SvpSalGraphics::drawPolygonBezier( sal_uLong,
 501                                             const SalPoint*,
 502                                             const sal_uInt8* )
 503 {
 504     return sal_False;
 505 }
 506
 507 sal_Bool SvpSalGraphics::drawPolyPolygonBezier( sal_uInt32,
 508                                                 const sal_uInt32*,
 509                                                 const SalPoint* const*,
 510                                                 const sal_uInt8* const* )
 511 {
 512     return sal_False;
 513 }
 514
 515 bool SvpSalGraphics::drawPolyPolygon( const basegfx::B2DPolyPolygon&, double /*fTransparency*/ )
 516 {
 517     // TODO: maybe BaseBmp can draw B2DPolyPolygons directly
 518     return false;
 519 }
 520
 521 void SvpSalGraphics::copyArea( long nDestX,
 522                                       long nDestY,
 523                                       long nSrcX,
 524                                       long nSrcY,
 525                                       long nSrcWidth,
 526                                       long nSrcHeight,
 527                                       sal_uInt16 /*nFlags*/ )
 528 {
 529     basegfx::B2IBox aSrcRect( nSrcX, nSrcY, nSrcX+nSrcWidth, nSrcY+nSrcHeight );
 530     basegfx::B2IBox aDestRect( nDestX, nDestY, nDestX+nSrcWidth, nDestY+nSrcHeight );
 531     // fprintf( stderr, "copyArea %ld pixels - clip region %d\n",
 532     //         (long)(nSrcWidth * nSrcHeight), m_aClipMap.get() != NULL );
 533     SvpSalGraphics::ClipUndoHandle aUndo( this );
 534     if( !isClippedSetup( aDestRect, aUndo ) )
 535         m_aDevice->drawBitmap( m_aOrigDevice, aSrcRect, aDestRect, basebmp::DrawMode_PAINT, m_aClipMap );
 536     dbgOut( m_aDevice );
 537 }
 538
 539 void SvpSalGraphics::copyBits( const SalTwoRect* pPosAry,
 540                                SalGraphics*      pSrcGraphics )
 541 {
 542     SvpSalGraphics* pSrc = pSrcGraphics ?
 543         static_cast<SvpSalGraphics*>(pSrcGraphics) : this;
 544     basegfx::B2IBox aSrcRect( pPosAry->mnSrcX, pPosAry->mnSrcY,
 545                      pPosAry->mnSrcX+pPosAry->mnSrcWidth,
 546                      pPosAry->mnSrcY+pPosAry->mnSrcHeight );
 547     basegfx::B2IBox aDestRect( pPosAry->mnDestX, pPosAry->mnDestY,
 548                       pPosAry->mnDestX+pPosAry->mnDestWidth,
 549                       pPosAry->mnDestY+pPosAry->mnDestHeight );
 550
 551     SvpSalGraphics::ClipUndoHandle aUndo( this );
 552     if( !isClippedSetup( aDestRect, aUndo ) )
 553         m_aDevice->drawBitmap( pSrc->m_aOrigDevice, aSrcRect, aDestRect, basebmp::DrawMode_PAINT, m_aClipMap );
 554     dbgOut( m_aDevice );
 555 }
 556
 557 void SvpSalGraphics::drawBitmap( const SalTwoRect* pPosAry,
 558                                  const SalBitmap& rSalBitmap )
 559 {
 560     const SvpSalBitmap& rSrc = static_cast<const SvpSalBitmap&>(rSalBitmap);
 561     basegfx::B2IBox aSrcRect( pPosAry->mnSrcX, pPosAry->mnSrcY,
 562                      pPosAry->mnSrcX+pPosAry->mnSrcWidth,
 563                      pPosAry->mnSrcY+pPosAry->mnSrcHeight );
 564     basegfx::B2IBox aDestRect( pPosAry->mnDestX, pPosAry->mnDestY,
 565                       pPosAry->mnDestX+pPosAry->mnDestWidth,
 566                       pPosAry->mnDestY+pPosAry->mnDestHeight );
 567
 568     SvpSalGraphics::ClipUndoHandle aUndo( this );
 569     if( !isClippedSetup( aDestRect, aUndo ) )
 570         m_aDevice->drawBitmap( rSrc.getBitmap(), aSrcRect, aDestRect, basebmp::DrawMode_PAINT, m_aClipMap );
 571     dbgOut( m_aDevice );
 572 }
 573
 574 void SvpSalGraphics::drawBitmap( const SalTwoRect*,
 575                                  const SalBitmap&,
 576                                  SalColor )
 577 {
 578     // SNI, as in X11 plugin
 579 }
 580
 581 void SvpSalGraphics::drawBitmap( const SalTwoRect* pPosAry,
 582                                  const SalBitmap& rSalBitmap,
 583                                  const SalBitmap& rTransparentBitmap )
 584 {
 585     const SvpSalBitmap& rSrc = static_cast<const SvpSalBitmap&>(rSalBitmap);
 586     const SvpSalBitmap& rSrcTrans = static_cast<const SvpSalBitmap&>(rTransparentBitmap);
 587     basegfx::B2IBox aSrcRect( pPosAry->mnSrcX, pPosAry->mnSrcY,
 588                      pPosAry->mnSrcX+pPosAry->mnSrcWidth,
 589                      pPosAry->mnSrcY+pPosAry->mnSrcHeight );
 590     basegfx::B2IBox aDestRect( pPosAry->mnDestX, pPosAry->mnDestY,
 591                       pPosAry->mnDestX+pPosAry->mnDestWidth,
 592                       pPosAry->mnDestY+pPosAry->mnDestHeight );
 593     SvpSalGraphics::ClipUndoHandle aUndo( this );
 594     if( !isClippedSetup( aDestRect, aUndo ) )
 595         m_aDevice->drawMaskedBitmap( rSrc.getBitmap(), rSrcTrans.getBitmap(),
 596                                      aSrcRect, aDestRect, basebmp::DrawMode_PAINT, m_aClipMap );
 597     dbgOut( m_aDevice );
 598 }
 599
 600 void SvpSalGraphics::drawMask( const SalTwoRect* pPosAry,
 601                                const SalBitmap& rSalBitmap,
 602                                SalColor nMaskColor )
 603 {
 604     const SvpSalBitmap& rSrc = static_cast<const SvpSalBitmap&>(rSalBitmap);
 605     basegfx::B2IBox aSrcRect( pPosAry->mnSrcX, pPosAry->mnSrcY,
 606                      pPosAry->mnSrcX+pPosAry->mnSrcWidth,
 607                      pPosAry->mnSrcY+pPosAry->mnSrcHeight );
 608     basegfx::B2IPoint aDestPoint( pPosAry->mnDestX, pPosAry->mnDestY );
 609
 610     // BitmapDevice::drawMaskedColor works with 0==transparent,
 611     // 255==opaque. drawMask() semantic is the other way
 612     // around. Therefore, invert mask.
 613     basebmp::BitmapDeviceSharedPtr aCopy =
 614         cloneBitmapDevice( basegfx::B2IVector( pPosAry->mnSrcWidth, pPosAry->mnSrcHeight ),
 615                            rSrc.getBitmap() );
 616     basebmp::Color aBgColor( COL_WHITE );
 617     aCopy->clear(aBgColor);
 618     basebmp::Color aFgColor( COL_BLACK );
 619     aCopy->drawMaskedColor( aFgColor, rSrc.getBitmap(), aSrcRect, basegfx::B2IPoint() );
 620
 621     basebmp::Color aColor( nMaskColor );
 622     basegfx::B2IBox aSrcRect2( 0, 0, pPosAry->mnSrcWidth, pPosAry->mnSrcHeight );
 623     const basegfx::B2IBox aClipRect( aDestPoint, basegfx::B2ITuple( aSrcRect.getWidth(), aSrcRect.getHeight() ) );
 624
 625     SvpSalGraphics::ClipUndoHandle aUndo( this );
 626     if( !isClippedSetup( aClipRect, aUndo ) )
 627         m_aDevice->drawMaskedColor( aColor, aCopy, aSrcRect, aDestPoint, m_aClipMap );
 628     dbgOut( m_aDevice );
 629 }
 630
 631 SalBitmap* SvpSalGraphics::getBitmap( long nX, long nY, long nWidth, long nHeight )
 632 {
 633     basebmp::BitmapDeviceSharedPtr aCopy =
 634         cloneBitmapDevice( basegfx::B2IVector( nWidth, nHeight ),
 635                            m_aDevice );
 636     basegfx::B2IBox aSrcRect( nX, nY, nX+nWidth, nY+nHeight );
 637     basegfx::B2IBox aDestRect( 0, 0, nWidth, nHeight );
 638
 639     SvpSalGraphics::ClipUndoHandle aUndo( this );
 640     if( !isClippedSetup( aDestRect, aUndo ) )
 641         aCopy->drawBitmap( m_aOrigDevice, aSrcRect, aDestRect, basebmp::DrawMode_PAINT );
 642
 643     SvpSalBitmap* pBitmap = new SvpSalBitmap();
 644     pBitmap->setBitmap( aCopy );
 645     return pBitmap;
 646 }
 647
 648 SalColor SvpSalGraphics::getPixel( long nX, long nY )
 649 {
 650     basebmp::Color aColor( m_aOrigDevice->getPixel( basegfx::B2IPoint( nX, nY ) ) );
 651     return aColor.toInt32();
 652 }
 653
 654 void SvpSalGraphics::invert( long nX, long nY, long nWidth, long nHeight, SalInvert /*nFlags*/ )
 655 {
 656     // FIXME: handle SAL_INVERT_50 and SAL_INVERT_TRACKFRAME
 657     basegfx::B2DPolygon aRect = basegfx::tools::createPolygonFromRect( basegfx::B2DRectangle( nX, nY, nX+nWidth, nY+nHeight ) );
 658     basegfx::B2DPolyPolygon aPolyPoly( aRect );
 659     basegfx::B2IBox aDestRange( nX, nY, nX + nWidth, nY + nHeight );
 660
 661     SvpSalGraphics::ClipUndoHandle aUndo( this );
 662     if( !isClippedSetup( aDestRange, aUndo ) )
 663         m_aDevice->fillPolyPolygon( aPolyPoly, basebmp::Color( 0xffffff ), basebmp::DrawMode_XOR, m_aClipMap );
 664     dbgOut( m_aDevice );
 665 }
 666
 667 void SvpSalGraphics::invert( sal_uLong nPoints, const SalPoint* pPtAry, SalInvert /*nFlags*/ )
 668 {
 669     // FIXME: handle SAL_INVERT_50 and SAL_INVERT_TRACKFRAME
 670     basegfx::B2DPolygon aPoly;
 671     aPoly.append( basegfx::B2DPoint( pPtAry->mnX, pPtAry->mnY ), nPoints );
 672     for( sal_uLong i = 1; i < nPoints; i++ )
 673         aPoly.setB2DPoint( i, basegfx::B2DPoint( pPtAry[i].mnX, pPtAry[i].mnY ) );
 674     aPoly.setClosed( true );
 675     ensureClip(); // FIXME for ...
 676     m_aDevice->fillPolyPolygon( basegfx::B2DPolyPolygon(aPoly), basebmp::Color( 0xffffff ), basebmp::DrawMode_XOR, m_aClipMap );
 677     dbgOut( m_aDevice );
 678 }
 679
 680 sal_Bool SvpSalGraphics::drawEPS( long, long, long, long, void*, sal_uLong )
 681 {
 682     return sal_False;
 683 }
 684
 685 SystemFontData SvpSalGraphics::GetSysFontData( int nFallbacklevel ) const
 686 {
 687     SystemFontData aSysFontData;
 688
 689     if (nFallbacklevel >= MAX_FALLBACK) nFallbacklevel = MAX_FALLBACK - 1;
 690     if (nFallbacklevel < 0 ) nFallbacklevel = 0;
 691
 692     aSysFontData.nSize = sizeof( SystemFontData );
 693     aSysFontData.nFontId = 0;
 694     aSysFontData.nFontFlags = 0;
 695     aSysFontData.bFakeBold = false;
 696     aSysFontData.bFakeItalic = false;
 697     aSysFontData.bAntialias = true;
 698     return aSysFontData;
 699 }
 700
 701 SystemGraphicsData SvpSalGraphics::GetGraphicsData() const
 702 {
 703     return SystemGraphicsData();
 704 }
 705
 706 bool SvpSalGraphics::supportsOperation( OutDevSupportType ) const
 707 {
 708     return false;
 709 }
 710
 711 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */