vcl/unx/headless/svpgdi.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: svpgdi.cxx,v $
  10  * $Revision: 1.8 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "svpgdi.hxx"
  32 #include "svpbmp.hxx"
  33
  34 #include <vcl/sysdata.hxx>
  35 #include <basegfx/range/b2drange.hxx>
  36 #include <basegfx/range/b2irange.hxx>
  37 #include <basegfx/polygon/b2dpolypolygon.hxx>
  38 #include <basegfx/polygon/b2dpolygon.hxx>
  39 #include <basegfx/polygon/b2dpolygontools.hxx>
  40 #include <basebmp/scanlineformats.hxx>
  41
  42 #include <tools/debug.hxx>
  43
  44 #if OSL_DEBUG_LEVEL > 2
  45 #include <basebmp/debug.hxx>
  46 #include <fstream>
  47 #include <rtl/strbuf.hxx>
  48 #include <sys/stat.h>
  49 #endif
  50
  51 #include <svppspgraphics.hxx>
  52
  53 using namespace basegfx;
  54 using namespace basebmp;
  55
  56 inline void dbgOut( const BitmapDeviceSharedPtr&
  57 #if OSL_DEBUG_LEVEL > 2
  58 rDevice
  59 #endif
  60 )
  61 {
  62     #if OSL_DEBUG_LEVEL > 2
  63     static int dbgStreamNum = 0;
  64     rtl::OStringBuffer aBuf( 256 );
  65     aBuf.append( "debug" );
  66     mkdir( aBuf.getStr(), 0777 );
  67     aBuf.append( "/" );
  68     aBuf.append( sal_Int64(reinterpret_cast<sal_uInt32>(rDevice.get())), 16 );
  69     mkdir( aBuf.getStr(), 0777 );
  70     aBuf.append( "/bmp" );
  71     aBuf.append( sal_Int32(dbgStreamNum++) );
  72     std::fstream bmpstream( aBuf.getStr(), std::ios::out );
  73     debugDump( rDevice, bmpstream );
  74     #endif
  75 }
  76
  77 // ===========================================================================
  78
  79 bool SvpSalGraphics::drawAlphaBitmap( const SalTwoRect&, const SalBitmap& /*rSourceBitmap*/, const SalBitmap& /*rAlphaBitmap*/ )
  80 {
  81     // TODO(P3) implement alpha blending
  82     return false;
  83 }
  84
  85 bool SvpSalGraphics::drawAlphaRect( long /*nX*/, long /*nY*/, long /*nWidth*/, long /*nHeight*/, sal_uInt8 /*nTransparency*/ )
  86 {
  87     // TODO(P3) implement alpha blending
  88     return false;
  89 }
  90
  91 SvpSalGraphics::SvpSalGraphics() :
  92     m_bUseLineColor( true ),
  93     m_aLineColor( COL_BLACK ),
  94     m_bUseFillColor( false ),
  95     m_aFillColor( COL_WHITE ),
  96     m_aTextColor( COL_BLACK ),
  97     m_aDrawMode( DrawMode_PAINT ),
  98     m_eTextFmt( Format::EIGHT_BIT_GREY )
  99 {
 100     for( int i = 0; i < MAX_FALLBACK; ++i )
 101         m_pServerFont[i] = NULL;
 102 }
 103
 104 SvpSalGraphics::~SvpSalGraphics()
 105 {
 106 }
 107
 108 void SvpSalGraphics::setDevice( BitmapDeviceSharedPtr& rDevice )
 109 {
 110     m_aDevice = rDevice;
 111     m_aOrigDevice = rDevice;
 112     m_aClipMap.reset();
 113
 114     // determine matching bitmap format for masks
 115     sal_uInt32 nDeviceFmt = m_aDevice->getScanlineFormat();
 116     DBG_ASSERT( (nDeviceFmt <= (sal_uInt32)Format::MAX), "SVP::setDevice() with invalid bitmap format" );
 117     switch( nDeviceFmt )
 118     {
 119         case Format::EIGHT_BIT_GREY:
 120         case Format::SIXTEEN_BIT_LSB_TC_MASK:
 121         case Format::SIXTEEN_BIT_MSB_TC_MASK:
 122         case Format::TWENTYFOUR_BIT_TC_MASK:
 123         case Format::THIRTYTWO_BIT_TC_MASK:
 124             m_eTextFmt = Format::EIGHT_BIT_GREY;
 125             break;
 126         default:
 127             m_eTextFmt = Format::ONE_BIT_LSB_GREY;
 128             break;
 129     }
 130 }
 131
 132 void SvpSalGraphics::GetResolution( sal_Int32& rDPIX, sal_Int32& rDPIY )
 133 {
 134     rDPIX = rDPIY = 96;
 135 }
 136
 137 USHORT SvpSalGraphics::GetBitCount()
 138 {
 139     return SvpElement::getBitCountFromScanlineFormat( m_aDevice->getScanlineFormat() );
 140 }
 141
 142 long SvpSalGraphics::GetGraphicsWidth() const
 143 {
 144     if( m_aDevice.get() )
 145     {
 146         B2IVector aSize = m_aDevice->getSize();
 147         return aSize.getX();
 148     }
 149     return 0;
 150 }
 151
 152 void SvpSalGraphics::ResetClipRegion()
 153 {
 154     m_aDevice = m_aOrigDevice;
 155     m_aClipMap.reset();
 156 }
 157
 158 void SvpSalGraphics::BeginSetClipRegion( ULONG n )
 159 {
 160     if( n <= 1 )
 161     {
 162         m_aClipMap.reset();
 163     }
 164     else
 165     {
 166         m_aDevice = m_aOrigDevice;
 167         B2IVector aSize = m_aDevice->getSize();
 168         m_aClipMap = createBitmapDevice( aSize, false, Format::ONE_BIT_MSB_GREY );
 169         m_aClipMap->clear( basebmp::Color(0xFFFFFFFF) );
 170     }
 171 }
 172
 173 BOOL SvpSalGraphics::unionClipRegion( long nX, long nY, long nWidth, long nHeight )
 174 {
 175     if( m_aClipMap )
 176     {
 177         B2DPolyPolygon aFull;
 178         aFull.append( tools::createPolygonFromRect( B2DRectangle( nX, nY, nX+nWidth, nY+nHeight ) ) );
 179         m_aClipMap->fillPolyPolygon( aFull, basebmp::Color(0), DrawMode_PAINT );
 180     }
 181     else
 182     {
 183         m_aDevice = basebmp::subsetBitmapDevice( m_aOrigDevice,
 184                                                  basegfx::B2IRange(nX,nY,nX+nWidth,nY+nHeight) );
 185     }
 186
 187     return TRUE;
 188 }
 189
 190 bool SvpSalGraphics::unionClipRegion( const ::basegfx::B2DPolyPolygon& )
 191 {
 192         // TODO: implement and advertise OutDevSupport_B2DClip support
 193         return false;
 194 }
 195
 196 void SvpSalGraphics::EndSetClipRegion()
 197 {
 198 }
 199
 200 void SvpSalGraphics::SetLineColor()
 201 {
 202     m_bUseLineColor = false;
 203 }
 204
 205 void SvpSalGraphics::SetLineColor( SalColor nSalColor )
 206 {
 207     m_bUseLineColor = true;
 208     m_aLineColor = basebmp::Color( nSalColor );
 209 }
 210
 211 void SvpSalGraphics::SetFillColor()
 212 {
 213     m_bUseFillColor = false;
 214 }
 215
 216 void SvpSalGraphics::SetFillColor( SalColor nSalColor )
 217 {
 218     m_bUseFillColor = true;
 219     m_aFillColor = basebmp::Color( nSalColor );
 220 }
 221
 222 void SvpSalGraphics::SetXORMode( bool bSet, bool )
 223 {
 224     m_aDrawMode = bSet ? DrawMode_XOR : DrawMode_PAINT;
 225 }
 226
 227 void SvpSalGraphics::SetROPLineColor( SalROPColor nROPColor )
 228 {
 229     m_bUseLineColor = true;
 230     switch( nROPColor )
 231     {
 232         case SAL_ROP_0:
 233             m_aLineColor = basebmp::Color( 0 );
 234             break;
 235         case SAL_ROP_1:
 236             m_aLineColor = basebmp::Color( 0xffffff );
 237             break;
 238         case SAL_ROP_INVERT:
 239             m_aLineColor = basebmp::Color( 0xffffff );
 240             break;
 241     }
 242 }
 243
 244 void SvpSalGraphics::SetROPFillColor( SalROPColor nROPColor )
 245 {
 246     m_bUseFillColor = true;
 247     switch( nROPColor )
 248     {
 249         case SAL_ROP_0:
 250             m_aFillColor = basebmp::Color( 0 );
 251             break;
 252         case SAL_ROP_1:
 253             m_aFillColor = basebmp::Color( 0xffffff );
 254             break;
 255         case SAL_ROP_INVERT:
 256             m_aFillColor = basebmp::Color( 0xffffff );
 257             break;
 258     }
 259 }
 260
 261 void SvpSalGraphics::SetTextColor( SalColor nSalColor )
 262 {
 263     m_aTextColor = basebmp::Color( nSalColor );
 264 }
 265
 266 void SvpSalGraphics::drawPixel( long nX, long nY )
 267 {
 268     if( m_bUseLineColor )
 269         m_aDevice->setPixel( B2IPoint( nX, nY ),
 270                              m_aLineColor,
 271                              m_aDrawMode,
 272                              m_aClipMap
 273                              );
 274     dbgOut( m_aDevice );
 275 }
 276
 277 void SvpSalGraphics::drawPixel( long nX, long nY, SalColor nSalColor )
 278 {
 279     basebmp::Color aColor( nSalColor );
 280     m_aDevice->setPixel( B2IPoint( nX, nY ),
 281                          aColor,
 282                          m_aDrawMode,
 283                          m_aClipMap
 284                          );
 285     dbgOut( m_aDevice );
 286 }
 287
 288 void SvpSalGraphics::drawLine( long nX1, long nY1, long nX2, long nY2 )
 289 {
 290     if( m_bUseLineColor )
 291         m_aDevice->drawLine( B2IPoint( nX1, nY1 ),
 292                              B2IPoint( nX2, nY2 ),
 293                              m_aLineColor,
 294                              m_aDrawMode,
 295                              m_aClipMap );
 296     dbgOut( m_aDevice );
 297 }
 298
 299 void SvpSalGraphics::drawRect( long nX, long nY, long nWidth, long nHeight )
 300 {
 301     if( m_bUseLineColor || m_bUseFillColor )
 302     {
 303         B2DPolygon aRect = tools::createPolygonFromRect( B2DRectangle( nX, nY, nX+nWidth, nY+nHeight ) );
 304         if( m_bUseFillColor )
 305         {
 306             B2DPolyPolygon aPolyPoly( aRect );
 307             m_aDevice->fillPolyPolygon( aPolyPoly, m_aFillColor, m_aDrawMode, m_aClipMap );
 308         }
 309         if( m_bUseLineColor )
 310             m_aDevice->drawPolygon( aRect, m_aLineColor, m_aDrawMode, m_aClipMap );
 311     }
 312     dbgOut( m_aDevice );
 313 }
 314
 315 void SvpSalGraphics::drawPolyLine( ULONG nPoints, const SalPoint* pPtAry )
 316 {
 317     if( m_bUseLineColor && nPoints )
 318     {
 319         B2DPolygon aPoly;
 320         aPoly.append( B2DPoint( pPtAry->mnX, pPtAry->mnY ), nPoints );
 321         for( ULONG i = 1; i < nPoints; i++ )
 322             aPoly.setB2DPoint( i, B2DPoint( pPtAry[i].mnX, pPtAry[i].mnY ) );
 323         aPoly.setClosed( false );
 324         m_aDevice->drawPolygon( aPoly, m_aLineColor, m_aDrawMode, m_aClipMap );
 325     }
 326     dbgOut( m_aDevice );
 327 }
 328
 329 void SvpSalGraphics::drawPolygon( ULONG nPoints, const SalPoint* pPtAry )
 330 {
 331     if( ( m_bUseLineColor || m_bUseFillColor ) && nPoints )
 332     {
 333         B2DPolygon aPoly;
 334         aPoly.append( B2DPoint( pPtAry->mnX, pPtAry->mnY ), nPoints );
 335         for( ULONG i = 1; i < nPoints; i++ )
 336             aPoly.setB2DPoint( i, B2DPoint( pPtAry[i].mnX, pPtAry[i].mnY ) );
 337         if( m_bUseFillColor )
 338         {
 339             aPoly.setClosed( true );
 340             m_aDevice->fillPolyPolygon( B2DPolyPolygon(aPoly), m_aFillColor, m_aDrawMode, m_aClipMap );
 341         }
 342         if( m_bUseLineColor )
 343         {
 344             aPoly.setClosed( false );
 345             m_aDevice->drawPolygon( aPoly, m_aLineColor, m_aDrawMode, m_aClipMap );
 346         }
 347     }
 348     dbgOut( m_aDevice );
 349 }
 350
 351 void SvpSalGraphics::drawPolyPolygon( sal_uInt32        nPoly,
 352                                       const sal_uInt32* pPointCounts,
 353                                       PCONSTSALPOINT*   pPtAry )
 354 {
 355     if( ( m_bUseLineColor || m_bUseFillColor ) && nPoly )
 356     {
 357         B2DPolyPolygon aPolyPoly;
 358         for( sal_uInt32 nPolygon = 0; nPolygon < nPoly; nPolygon++ )
 359         {
 360             sal_uInt32 nPoints = pPointCounts[nPolygon];
 361             if( nPoints )
 362             {
 363                 PCONSTSALPOINT pPoints = pPtAry[nPolygon];
 364                 B2DPolygon aPoly;
 365                 aPoly.append( B2DPoint( pPoints->mnX, pPoints->mnY ), nPoints );
 366                 for( ULONG i = 1; i < nPoints; i++ )
 367                     aPoly.setB2DPoint( i, B2DPoint( pPoints[i].mnX, pPoints[i].mnY ) );
 368
 369                 aPolyPoly.append( aPoly );
 370             }
 371         }
 372         if( m_bUseFillColor )
 373         {
 374             aPolyPoly.setClosed( true );
 375             m_aDevice->fillPolyPolygon( aPolyPoly, m_aFillColor, m_aDrawMode, m_aClipMap );
 376         }
 377         if( m_bUseLineColor )
 378         {
 379             aPolyPoly.setClosed( false );
 380             nPoly = aPolyPoly.count();
 381             for( sal_uInt32 i = 0; i < nPoly; i++ )
 382                 m_aDevice->drawPolygon( aPolyPoly.getB2DPolygon(i), m_aLineColor, m_aDrawMode, m_aClipMap );
 383         }
 384     }
 385     dbgOut( m_aDevice );
 386 }
 387
 388 bool SvpSalGraphics::drawPolyLine( const ::basegfx::B2DPolygon&, const ::basegfx::B2DVector& /*rLineWidths*/, basegfx::B2DLineJoin /*eJoin*/ )
 389 {
 390         // TODO: implement and advertise OutDevSupport_B2DDraw support
 391         return false;
 392 }
 393
 394 sal_Bool SvpSalGraphics::drawPolyLineBezier( ULONG,
 395                                              const SalPoint*,
 396                                              const BYTE* )
 397 {
 398     return sal_False;
 399 }
 400
 401 sal_Bool SvpSalGraphics::drawPolygonBezier( ULONG,
 402                                             const SalPoint*,
 403                                             const BYTE* )
 404 {
 405     return sal_False;
 406 }
 407
 408 sal_Bool SvpSalGraphics::drawPolyPolygonBezier( sal_uInt32,
 409                                                 const sal_uInt32*,
 410                                                 const SalPoint* const*,
 411                                                 const BYTE* const* )
 412 {
 413     return sal_False;
 414 }
 415
 416 bool SvpSalGraphics::drawPolyPolygon( const basegfx::B2DPolyPolygon&, double /*fTransparency*/ )
 417 {
 418     // TODO: maybe BaseBmp can draw B2DPolyPolygons directly
 419     return false;
 420 }
 421
 422 void SvpSalGraphics::copyArea( long nDestX,
 423                                       long nDestY,
 424                                       long nSrcX,
 425                                       long nSrcY,
 426                                       long nSrcWidth,
 427                                       long nSrcHeight,
 428                                       USHORT /*nFlags*/ )
 429 {
 430     B2IRange aSrcRect( nSrcX, nSrcY, nSrcX+nSrcWidth, nSrcY+nSrcHeight );
 431     B2IRange aDestRect( nDestX, nDestY, nDestX+nSrcWidth, nDestY+nSrcHeight );
 432     m_aDevice->drawBitmap( m_aOrigDevice, aSrcRect, aDestRect, DrawMode_PAINT, m_aClipMap );
 433     dbgOut( m_aDevice );
 434 }
 435
 436 void SvpSalGraphics::copyBits( const SalTwoRect* pPosAry,
 437                                SalGraphics*      pSrcGraphics )
 438 {
 439     SvpSalGraphics* pSrc = pSrcGraphics ?
 440         static_cast<SvpSalGraphics*>(pSrcGraphics) : this;
 441     B2IRange aSrcRect( pPosAry->mnSrcX, pPosAry->mnSrcY,
 442                        pPosAry->mnSrcX+pPosAry->mnSrcWidth,
 443                        pPosAry->mnSrcY+pPosAry->mnSrcHeight );
 444     B2IRange aDestRect( pPosAry->mnDestX, pPosAry->mnDestY,
 445                         pPosAry->mnDestX+pPosAry->mnDestWidth,
 446                         pPosAry->mnDestY+pPosAry->mnDestHeight );
 447     m_aDevice->drawBitmap( pSrc->m_aOrigDevice, aSrcRect, aDestRect, DrawMode_PAINT, m_aClipMap );
 448     dbgOut( m_aDevice );
 449 }
 450
 451 void SvpSalGraphics::drawBitmap( const SalTwoRect* pPosAry,
 452                                         const SalBitmap& rSalBitmap )
 453 {
 454     const SvpSalBitmap& rSrc = static_cast<const SvpSalBitmap&>(rSalBitmap);
 455     B2IRange aSrcRect( pPosAry->mnSrcX, pPosAry->mnSrcY,
 456                        pPosAry->mnSrcX+pPosAry->mnSrcWidth,
 457                        pPosAry->mnSrcY+pPosAry->mnSrcHeight );
 458     B2IRange aDestRect( pPosAry->mnDestX, pPosAry->mnDestY,
 459                         pPosAry->mnDestX+pPosAry->mnDestWidth,
 460                         pPosAry->mnDestY+pPosAry->mnDestHeight );
 461     m_aDevice->drawBitmap( rSrc.getBitmap(), aSrcRect, aDestRect, DrawMode_PAINT, m_aClipMap );
 462     dbgOut( m_aDevice );
 463 }
 464
 465 void SvpSalGraphics::drawBitmap( const SalTwoRect*,
 466                                  const SalBitmap&,
 467                                  SalColor )
 468 {
 469     // SNI, as in X11 plugin
 470 }
 471
 472 void SvpSalGraphics::drawBitmap( const SalTwoRect* pPosAry,
 473                                  const SalBitmap& rSalBitmap,
 474                                  const SalBitmap& rTransparentBitmap )
 475 {
 476     const SvpSalBitmap& rSrc = static_cast<const SvpSalBitmap&>(rSalBitmap);
 477     const SvpSalBitmap& rSrcTrans = static_cast<const SvpSalBitmap&>(rTransparentBitmap);
 478     B2IRange aSrcRect( pPosAry->mnSrcX, pPosAry->mnSrcY,
 479                        pPosAry->mnSrcX+pPosAry->mnSrcWidth,
 480                        pPosAry->mnSrcY+pPosAry->mnSrcHeight );
 481     B2IRange aDestRect( pPosAry->mnDestX, pPosAry->mnDestY,
 482                         pPosAry->mnDestX+pPosAry->mnDestWidth,
 483                         pPosAry->mnDestY+pPosAry->mnDestHeight );
 484     m_aDevice->drawMaskedBitmap( rSrc.getBitmap(), rSrcTrans.getBitmap(), aSrcRect, aDestRect, DrawMode_PAINT, m_aClipMap );
 485     dbgOut( m_aDevice );
 486 }
 487
 488 void SvpSalGraphics::drawMask( const SalTwoRect* pPosAry,
 489                                const SalBitmap& rSalBitmap,
 490                                SalColor nMaskColor )
 491 {
 492     const SvpSalBitmap& rSrc = static_cast<const SvpSalBitmap&>(rSalBitmap);
 493     B2IRange aSrcRect( pPosAry->mnSrcX, pPosAry->mnSrcY,
 494                        pPosAry->mnSrcX+pPosAry->mnSrcWidth,
 495                        pPosAry->mnSrcY+pPosAry->mnSrcHeight );
 496     B2IPoint aDestPoint( pPosAry->mnDestX, pPosAry->mnDestY );
 497
 498     // BitmapDevice::drawMaskedColor works with 0==transparent,
 499     // 255==opaque. drawMask() semantic is the other way
 500     // around. Therefore, invert mask.
 501     BitmapDeviceSharedPtr aCopy =
 502         cloneBitmapDevice( B2IVector( pPosAry->mnSrcWidth, pPosAry->mnSrcHeight ),
 503                            rSrc.getBitmap() );
 504     basebmp::Color aBgColor( COL_WHITE );
 505     aCopy->clear(aBgColor);
 506     basebmp::Color aFgColor( COL_BLACK );
 507     aCopy->drawMaskedColor( aFgColor, rSrc.getBitmap(), aSrcRect, B2IPoint() );
 508
 509     basebmp::Color aColor( nMaskColor );
 510     B2IRange aSrcRect2( 0, 0, pPosAry->mnSrcWidth, pPosAry->mnSrcHeight );
 511     m_aDevice->drawMaskedColor( aColor, aCopy, aSrcRect, aDestPoint, m_aClipMap );
 512     dbgOut( m_aDevice );
 513 }
 514
 515 SalBitmap* SvpSalGraphics::getBitmap( long nX, long nY, long nWidth, long nHeight )
 516 {
 517     BitmapDeviceSharedPtr aCopy =
 518         cloneBitmapDevice( B2IVector( nWidth, nHeight ),
 519                            m_aDevice );
 520     B2IRange aSrcRect( nX, nY, nX+nWidth, nY+nHeight );
 521     B2IRange aDestRect( 0, 0, nWidth, nHeight );
 522     aCopy->drawBitmap( m_aOrigDevice, aSrcRect, aDestRect, DrawMode_PAINT );
 523
 524     SvpSalBitmap* pBitmap = new SvpSalBitmap();
 525     pBitmap->setBitmap( aCopy );
 526     return pBitmap;
 527 }
 528
 529 SalColor SvpSalGraphics::getPixel( long nX, long nY )
 530 {
 531     basebmp::Color aColor( m_aDevice->getPixel( B2IPoint( nX, nY ) ) );
 532     return aColor.toInt32();
 533 }
 534
 535 void SvpSalGraphics::invert( long nX, long nY, long nWidth, long nHeight, SalInvert /*nFlags*/ )
 536 {
 537     // FIXME: handle SAL_INVERT_50 and SAL_INVERT_TRACKFRAME
 538     B2DPolygon aRect = tools::createPolygonFromRect( B2DRectangle( nX, nY, nX+nWidth, nY+nHeight ) );
 539     B2DPolyPolygon aPolyPoly( aRect );
 540     m_aDevice->fillPolyPolygon( aPolyPoly, basebmp::Color( 0xffffff ), DrawMode_XOR, m_aClipMap );
 541     dbgOut( m_aDevice );
 542 }
 543
 544 void SvpSalGraphics::invert( ULONG nPoints, const SalPoint* pPtAry, SalInvert /*nFlags*/ )
 545 {
 546     // FIXME: handle SAL_INVERT_50 and SAL_INVERT_TRACKFRAME
 547     B2DPolygon aPoly;
 548     aPoly.append( B2DPoint( pPtAry->mnX, pPtAry->mnY ), nPoints );
 549     for( ULONG i = 1; i < nPoints; i++ )
 550         aPoly.setB2DPoint( i, B2DPoint( pPtAry[i].mnX, pPtAry[i].mnY ) );
 551     aPoly.setClosed( true );
 552     m_aDevice->fillPolyPolygon( B2DPolyPolygon(aPoly), basebmp::Color( 0xffffff ), DrawMode_XOR, m_aClipMap );
 553     dbgOut( m_aDevice );
 554 }
 555
 556 BOOL SvpSalGraphics::drawEPS( long, long, long, long, void*, ULONG )
 557 {
 558     return FALSE;
 559 }
 560
 561 SystemFontData SvpSalGraphics::GetSysFontData( int nFallbacklevel ) const
 562 {
 563     SystemFontData aSysFontData;
 564
 565     if (nFallbacklevel >= MAX_FALLBACK) nFallbacklevel = MAX_FALLBACK - 1;
 566     if (nFallbacklevel < 0 ) nFallbacklevel = 0;
 567
 568     aSysFontData.nSize = sizeof( SystemFontData );
 569     aSysFontData.nFontId = 0;
 570     aSysFontData.nFontFlags = 0;
 571     aSysFontData.bFakeBold = false;
 572     aSysFontData.bFakeItalic = false;
 573     aSysFontData.bAntialias = true;
 574     return aSysFontData;
 575 }
 576
 577 SystemGraphicsData SvpSalGraphics::GetGraphicsData() const
 578 {
 579     SystemGraphicsData aRes;
 580     aRes.nSize = sizeof(aRes);
 581     aRes.hDrawable = 0;
 582     aRes.pRenderFormat = 0;
 583     return aRes;
 584 }
 585
 586 bool SvpSalGraphics::supportsOperation( OutDevSupportType ) const
 587 {
 588     return false;
 589 }