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 <memory>
  21 #include "headless/svpgdi.hxx"
  22 #include "headless/svpbmp.hxx"
  23 #include "headless/svpframe.hxx"
  24 #include "headless/svpcairotextrender.hxx"
  25 #include "saldatabasic.hxx"
  26
  27 #include <vcl/sysdata.hxx>
  28 #include <config_cairo_canvas.h>
  29 #include <basegfx/numeric/ftools.hxx>
  30 #include <basegfx/range/b2drange.hxx>
  31 #include <basegfx/range/b2ibox.hxx>
  32 #include <basegfx/polygon/b2dpolypolygon.hxx>
  33 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  34 #include <basegfx/polygon/b2dpolygon.hxx>
  35 #include <basegfx/polygon/b2dpolygontools.hxx>
  36
  37 #include <cairo.h>
  38
  39 #if ENABLE_CAIRO_CANVAS
  40 #if defined CAIRO_VERSION && CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 10, 0)
  41 #   define CAIRO_OPERATOR_DIFFERENCE (static_cast<cairo_operator_t>(23))
  42 #endif
  43 #endif
  44
  45 namespace
  46 {
  47     basegfx::B2DRange getClipBox(cairo_t* cr)
  48     {
  49         double x1, y1, x2, y2;
  50
  51         cairo_clip_extents(cr, &x1, &y1, &x2, &y2);
  52
  53         return basegfx::B2DRange(x1, y1, x2, y2);
  54     }
  55
  56     basegfx::B2DRange getFillDamage(cairo_t* cr)
  57     {
  58         double x1, y1, x2, y2;
  59
  60         cairo_fill_extents(cr, &x1, &y1, &x2, &y2);
  61
  62         return basegfx::B2DRange(x1, y1, x2, y2);
  63     }
  64
  65     basegfx::B2DRange getClippedFillDamage(cairo_t* cr)
  66     {
  67         basegfx::B2DRange aDamageRect(getFillDamage(cr));
  68         aDamageRect.intersect(getClipBox(cr));
  69         return aDamageRect;
  70     }
  71
  72     basegfx::B2DRange getStrokeDamage(cairo_t* cr)
  73     {
  74         double x1, y1, x2, y2;
  75
  76         cairo_stroke_extents(cr, &x1, &y1, &x2, &y2);
  77
  78         return basegfx::B2DRange(x1, y1, x2, y2);
  79     }
  80
  81     basegfx::B2DRange getClippedStrokeDamage(cairo_t* cr)
  82     {
  83         basegfx::B2DRange aDamageRect(getStrokeDamage(cr));
  84         aDamageRect.intersect(getClipBox(cr));
  85         return aDamageRect;
  86     }
  87 }
  88
  89 bool SvpSalGraphics::blendBitmap( const SalTwoRect&, const SalBitmap& /*rBitmap*/ )
  90 {
  91     SAL_WARN("vcl.gdi", "unsupported SvpSalGraphics::blendBitmap case");
  92     return false;
  93 }
  94
  95 bool SvpSalGraphics::blendAlphaBitmap( const SalTwoRect&, const SalBitmap&, const SalBitmap&, const SalBitmap& )
  96 {
  97     SAL_WARN("vcl.gdi", "unsupported SvpSalGraphics::blendAlphaBitmap case");
  98     return false;
  99 }
 100
 101 namespace
 102 {
 103     cairo_format_t getCairoFormat(const BitmapBuffer& rBuffer)
 104     {
 105         cairo_format_t nFormat;
 106         assert(rBuffer.mnBitCount == 32 || rBuffer.mnBitCount == 1);
 107         if (rBuffer.mnBitCount == 32)
 108             nFormat = CAIRO_FORMAT_ARGB32;
 109         else
 110             nFormat = CAIRO_FORMAT_A1;
 111         return nFormat;
 112     }
 113
 114     void Toggle1BitTransparency(const BitmapBuffer& rBuf)
 115     {
 116         assert(rBuf.maPalette.GetBestIndex(BitmapColor(Color(COL_BLACK))) == 0);
 117         // TODO: make upper layers use standard alpha
 118         if (getCairoFormat(rBuf) == CAIRO_FORMAT_A1)
 119         {
 120             const int nImageSize = rBuf.mnHeight * rBuf.mnScanlineSize;
 121             unsigned char* pDst = rBuf.mpBits;
 122             for (int i = nImageSize; --i >= 0; ++pDst)
 123                 *pDst = ~*pDst;
 124         }
 125     }
 126
 127     class SourceHelper
 128     {
 129     public:
 130         explicit SourceHelper(const SalBitmap& rSourceBitmap)
 131         {
 132             const SvpSalBitmap& rSrcBmp = static_cast<const SvpSalBitmap&>(rSourceBitmap);
 133
 134             if (rSrcBmp.GetBitCount() != 32)
 135             {
 136                 //big stupid copy here
 137                 static bool bWarnedOnce;
 138                 SAL_WARN_IF(!bWarnedOnce, "vcl.gdi", "non default depth bitmap, slow convert, upscale the input");
 139                 bWarnedOnce = true;
 140
 141                 const BitmapBuffer* pSrc = rSrcBmp.GetBuffer();
 142                 const SalTwoRect aTwoRect = { 0, 0, pSrc->mnWidth, pSrc->mnHeight,
 143                                               0, 0, pSrc->mnWidth, pSrc->mnHeight };
 144                 aTmpBmp.Create(StretchAndConvert(*pSrc, aTwoRect, SVP_CAIRO_FORMAT));
 145
 146
 147                 assert(aTmpBmp.GetBitCount() == 32);
 148                 source = SvpSalGraphics::createCairoSurface(aTmpBmp.GetBuffer());
 149             }
 150             else
 151                 source = SvpSalGraphics::createCairoSurface(rSrcBmp.GetBuffer());
 152         }
 153         ~SourceHelper()
 154         {
 155             cairo_surface_destroy(source);
 156         }
 157         cairo_surface_t* getSurface()
 158         {
 159             return source;
 160         }
 161         void mark_dirty()
 162         {
 163             cairo_surface_mark_dirty(source);
 164         }
 165         unsigned char* getBits(sal_Int32 &rStride)
 166         {
 167             cairo_surface_flush(source);
 168
 169             unsigned char *mask_data = cairo_image_surface_get_data(source);
 170
 171             cairo_format_t nFormat = cairo_image_surface_get_format(source);
 172             assert(nFormat == CAIRO_FORMAT_ARGB32 && "need to implement CAIRO_FORMAT_A1 after all here");
 173             rStride = cairo_format_stride_for_width(nFormat, cairo_image_surface_get_width(source));
 174
 175             return mask_data;
 176         }
 177     private:
 178         SvpSalBitmap aTmpBmp;
 179         cairo_surface_t* source;
 180
 181         SourceHelper(const SourceHelper&) = delete;
 182         SourceHelper& operator=(const SourceHelper&) = delete;
 183     };
 184
 185     class MaskHelper
 186     {
 187     public:
 188         explicit MaskHelper(const SalBitmap& rAlphaBitmap)
 189         {
 190             const SvpSalBitmap& rMask = static_cast<const SvpSalBitmap&>(rAlphaBitmap);
 191             const BitmapBuffer* pMaskBuf = rMask.GetBuffer();
 192
 193             if (rAlphaBitmap.GetBitCount() == 8)
 194             {
 195                 // the alpha values need to be inverted for Cairo
 196                 // so big stupid copy and invert here
 197                 const int nImageSize = pMaskBuf->mnHeight * pMaskBuf->mnScanlineSize;
 198                 pAlphaBits = new unsigned char[nImageSize];
 199                 memcpy(pAlphaBits, pMaskBuf->mpBits, nImageSize);
 200
 201                 // TODO: make upper layers use standard alpha
 202                 sal_uInt32* pLDst = reinterpret_cast<sal_uInt32*>(pAlphaBits);
 203                 for( int i = nImageSize/sizeof(sal_uInt32); --i >= 0; ++pLDst )
 204                     *pLDst = ~*pLDst;
 205                 assert(reinterpret_cast<unsigned char*>(pLDst) == pAlphaBits+nImageSize);
 206
 207                 mask = cairo_image_surface_create_for_data(pAlphaBits,
 208                                                 CAIRO_FORMAT_A8,
 209                                                 pMaskBuf->mnWidth, pMaskBuf->mnHeight,
 210                                                 pMaskBuf->mnScanlineSize);
 211             }
 212             else
 213             {
 214                 // the alpha values need to be inverted for Cairo
 215                 // so big stupid copy and invert here
 216                 const int nImageSize = pMaskBuf->mnHeight * pMaskBuf->mnScanlineSize;
 217                 pAlphaBits = new unsigned char[nImageSize];
 218                 memcpy(pAlphaBits, pMaskBuf->mpBits, nImageSize);
 219
 220                 const sal_Int32 nBlackIndex = pMaskBuf->maPalette.GetBestIndex(BitmapColor(Color(COL_BLACK)));
 221                 if (nBlackIndex == 0)
 222                 {
 223                     // TODO: make upper layers use standard alpha
 224                     unsigned char* pDst = pAlphaBits;
 225                     for (int i = nImageSize; --i >= 0; ++pDst)
 226                         *pDst = ~*pDst;
 227                 }
 228
 229                 mask = cairo_image_surface_create_for_data(pAlphaBits,
 230                                                 CAIRO_FORMAT_A1,
 231                                                 pMaskBuf->mnWidth, pMaskBuf->mnHeight,
 232                                                 pMaskBuf->mnScanlineSize);
 233             }
 234         }
 235         ~MaskHelper()
 236         {
 237             cairo_surface_destroy(mask);
 238             delete[] pAlphaBits;
 239         }
 240         cairo_surface_t* getMask()
 241         {
 242             return mask;
 243         }
 244     private:
 245         cairo_surface_t *mask;
 246         unsigned char* pAlphaBits;
 247
 248         MaskHelper(const MaskHelper&) = delete;
 249         MaskHelper& operator=(const MaskHelper&) = delete;
 250     };
 251 }
 252
 253 bool SvpSalGraphics::drawAlphaBitmap( const SalTwoRect& rTR, const SalBitmap& rSourceBitmap, const SalBitmap& rAlphaBitmap )
 254 {
 255     if (rAlphaBitmap.GetBitCount() != 8 && rAlphaBitmap.GetBitCount() != 1)
 256     {
 257         SAL_WARN("vcl.gdi", "unsupported SvpSalGraphics::drawAlphaBitmap alpha depth case: " << rAlphaBitmap.GetBitCount());
 258         return false;
 259     }
 260
 261     SourceHelper aSurface(rSourceBitmap);
 262     cairo_surface_t* source = aSurface.getSurface();
 263     if (!source)
 264     {
 265         SAL_WARN("vcl.gdi", "unsupported SvpSalGraphics::drawAlphaBitmap case");
 266         return false;
 267     }
 268
 269     MaskHelper aMask(rAlphaBitmap);
 270     cairo_surface_t *mask = aMask.getMask();
 271     if (!mask)
 272     {
 273         SAL_WARN("vcl.gdi", "unsupported SvpSalGraphics::drawAlphaBitmap case");
 274         return false;
 275     }
 276
 277     cairo_t* cr = getCairoContext(false);
 278     clipRegion(cr);
 279
 280     cairo_rectangle(cr, rTR.mnDestX, rTR.mnDestY, rTR.mnDestWidth, rTR.mnDestHeight);
 281
 282     basegfx::B2DRange extents = getClippedFillDamage(cr);
 283
 284     cairo_clip(cr);
 285
 286     cairo_translate(cr, rTR.mnDestX, rTR.mnDestY);
 287     cairo_scale(cr, (double)(rTR.mnDestWidth)/rTR.mnSrcWidth, ((double)rTR.mnDestHeight)/rTR.mnSrcHeight);
 288     cairo_set_source_surface(cr, source, -rTR.mnSrcX, -rTR.mnSrcY);
 289     cairo_mask_surface(cr, mask, -rTR.mnSrcX, -rTR.mnSrcY);
 290
 291     releaseCairoContext(cr, false, extents);
 292
 293     return true;
 294 }
 295
 296 bool SvpSalGraphics::drawTransformedBitmap(
 297     const basegfx::B2DPoint& rNull,
 298     const basegfx::B2DPoint& rX,
 299     const basegfx::B2DPoint& rY,
 300     const SalBitmap& rSourceBitmap,
 301     const SalBitmap* pAlphaBitmap)
 302 {
 303     if (pAlphaBitmap && pAlphaBitmap->GetBitCount() != 8 && pAlphaBitmap->GetBitCount() != 1)
 304     {
 305         SAL_WARN("vcl.gdi", "unsupported SvpSalGraphics::drawTransformedBitmap alpha depth case: " << pAlphaBitmap->GetBitCount());
 306         return false;
 307     }
 308
 309     SourceHelper aSurface(rSourceBitmap);
 310     cairo_surface_t* source = aSurface.getSurface();
 311     if (!source)
 312     {
 313         SAL_WARN("vcl.gdi", "unsupported SvpSalGraphics::drawTransformedBitmap case");
 314         return false;
 315     }
 316
 317     std::unique_ptr<MaskHelper> xMask;
 318     cairo_surface_t *mask = nullptr;
 319     if (pAlphaBitmap)
 320     {
 321         xMask.reset(new MaskHelper(*pAlphaBitmap));
 322         mask = xMask->getMask();
 323         if (!mask)
 324         {
 325             SAL_WARN("vcl.gdi", "unsupported SvpSalGraphics::drawTransformedBitmap case");
 326             return false;
 327         }
 328     }
 329
 330     const Size aSize = rSourceBitmap.GetSize();
 331
 332     cairo_t* cr = getCairoContext(false);
 333     clipRegion(cr);
 334
 335     // setup the image transformation
 336     // using the rNull,rX,rY points as destinations for the (0,0),(0,Width),(Height,0) source points
 337     const basegfx::B2DVector aXRel = rX - rNull;
 338     const basegfx::B2DVector aYRel = rY - rNull;
 339     cairo_matrix_t matrix;
 340     cairo_matrix_init(&matrix,
 341                       aXRel.getX()/aSize.Width(), aXRel.getY()/aSize.Width(),
 342                       aYRel.getX()/aSize.Height(), aYRel.getY()/aSize.Height(),
 343                       rNull.getX(), rNull.getY());
 344
 345     cairo_transform(cr, &matrix);
 346
 347     cairo_rectangle(cr, 0, 0, aSize.Width(), aSize.Height());
 348     basegfx::B2DRange extents = getClippedFillDamage(cr);
 349     cairo_clip(cr);
 350
 351     cairo_set_source_surface(cr, source, 0, 0);
 352     if (mask)
 353         cairo_mask_surface(cr, mask, 0, 0);
 354     else
 355         cairo_paint(cr);
 356
 357     releaseCairoContext(cr, false, extents);
 358
 359     return true;
 360 }
 361
 362 void SvpSalGraphics::clipRegion(cairo_t* cr)
 363 {
 364     RectangleVector aRectangles;
 365     if (!m_aClipRegion.IsEmpty())
 366     {
 367         m_aClipRegion.GetRegionRectangles(aRectangles);
 368     }
 369     if (!aRectangles.empty())
 370     {
 371         for (RectangleVector::const_iterator aRectIter(aRectangles.begin()); aRectIter != aRectangles.end(); ++aRectIter)
 372         {
 373             cairo_rectangle(cr, aRectIter->Left(), aRectIter->Top(), aRectIter->GetWidth(), aRectIter->GetHeight());
 374         }
 375         cairo_clip(cr);
 376     }
 377 }
 378
 379 bool SvpSalGraphics::drawAlphaRect(long nX, long nY, long nWidth, long nHeight, sal_uInt8 nTransparency)
 380 {
 381     cairo_t* cr = getCairoContext(false);
 382     clipRegion(cr);
 383
 384     const double fTransparency = (100 - nTransparency) * (1.0/100);
 385
 386     basegfx::B2DRange extents(0, 0, 0, 0);
 387
 388     cairo_rectangle(cr, nX, nY, nWidth, nHeight);
 389
 390     if (m_aFillColor != SALCOLOR_NONE)
 391     {
 392         cairo_set_source_rgba(cr, SALCOLOR_RED(m_aFillColor)/255.0,
 393                                   SALCOLOR_GREEN(m_aFillColor)/255.0,
 394                                   SALCOLOR_BLUE(m_aFillColor)/255.0,
 395                                   fTransparency);
 396
 397         if (m_aLineColor == SALCOLOR_NONE)
 398             extents = getClippedFillDamage(cr);
 399
 400         cairo_fill_preserve(cr);
 401     }
 402
 403     if (m_aLineColor != SALCOLOR_NONE)
 404     {
 405         cairo_set_source_rgba(cr, SALCOLOR_RED(m_aLineColor)/255.0,
 406                                   SALCOLOR_GREEN(m_aLineColor)/255.0,
 407                                   SALCOLOR_BLUE(m_aLineColor)/255.0,
 408                                   fTransparency);
 409
 410         extents = getClippedStrokeDamage(cr);
 411
 412         cairo_stroke_preserve(cr);
 413     }
 414
 415     releaseCairoContext(cr, false, extents);
 416
 417     return true;
 418 }
 419
 420 SvpSalGraphics::SvpSalGraphics()
 421     : m_pSurface(nullptr)
 422     , m_fScale(1.0)
 423     , m_aLineColor(MAKE_SALCOLOR(0x00, 0x00, 0x00))
 424     , m_aFillColor(MAKE_SALCOLOR(0xFF, 0xFF, 0XFF))
 425     , m_ePaintMode(PaintMode::Over)
 426     , m_aTextRenderImpl(*this)
 427 {
 428 }
 429
 430 SvpSalGraphics::~SvpSalGraphics()
 431 {
 432 }
 433
 434 void SvpSalGraphics::setSurface(cairo_surface_t* pSurface, const basegfx::B2IVector& rSize)
 435 {
 436     m_pSurface = pSurface;
 437     m_aFrameSize = rSize;
 438 #if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 14, 0)
 439     cairo_surface_get_device_scale(pSurface, &m_fScale, nullptr);
 440 #endif
 441     ResetClipRegion();
 442 }
 443
 444 void SvpSalGraphics::GetResolution( sal_Int32& rDPIX, sal_Int32& rDPIY )
 445 {
 446     rDPIX = rDPIY = 96;
 447 }
 448
 449 sal_uInt16 SvpSalGraphics::GetBitCount() const
 450 {
 451     if (cairo_surface_get_content(m_pSurface) != CAIRO_CONTENT_COLOR_ALPHA)
 452         return 1;
 453     return 32;
 454 }
 455
 456 long SvpSalGraphics::GetGraphicsWidth() const
 457 {
 458     return m_pSurface ? m_aFrameSize.getX() : 0;
 459 }
 460
 461 void SvpSalGraphics::ResetClipRegion()
 462 {
 463     m_aClipRegion.SetNull();
 464 }
 465
 466 bool SvpSalGraphics::setClipRegion( const vcl::Region& i_rClip )
 467 {
 468     m_aClipRegion = i_rClip;
 469     return true;
 470 }
 471
 472 void SvpSalGraphics::SetLineColor()
 473 {
 474     m_aLineColor = SALCOLOR_NONE;
 475 }
 476
 477 void SvpSalGraphics::SetLineColor( SalColor nSalColor )
 478 {
 479     m_aLineColor = nSalColor;
 480 }
 481
 482 void SvpSalGraphics::SetFillColor()
 483 {
 484     m_aFillColor = SALCOLOR_NONE;
 485 }
 486
 487 void SvpSalGraphics::SetFillColor( SalColor nSalColor )
 488 {
 489     m_aFillColor = nSalColor;
 490 }
 491
 492 void SvpSalGraphics::SetXORMode(bool bSet )
 493 {
 494     m_ePaintMode = bSet ? PaintMode::Xor : PaintMode::Over;
 495 }
 496
 497 void SvpSalGraphics::SetROPLineColor( SalROPColor nROPColor )
 498 {
 499     switch( nROPColor )
 500     {
 501         case SalROPColor::N0:
 502             m_aLineColor = MAKE_SALCOLOR(0, 0, 0);
 503             break;
 504         case SalROPColor::N1:
 505             m_aLineColor = MAKE_SALCOLOR(0xff, 0xff, 0xff);
 506             break;
 507         case SalROPColor::Invert:
 508             m_aLineColor = MAKE_SALCOLOR(0xff, 0xff, 0xff);
 509             break;
 510     }
 511 }
 512
 513 void SvpSalGraphics::SetROPFillColor( SalROPColor nROPColor )
 514 {
 515     switch( nROPColor )
 516     {
 517         case SalROPColor::N0:
 518             m_aFillColor = MAKE_SALCOLOR(0, 0, 0);
 519             break;
 520         case SalROPColor::N1:
 521             m_aFillColor = MAKE_SALCOLOR(0xff, 0xff, 0xff);
 522             break;
 523         case SalROPColor::Invert:
 524             m_aFillColor = MAKE_SALCOLOR(0xff, 0xff, 0xff);
 525             break;
 526     }
 527 }
 528
 529 void SvpSalGraphics::drawPixel( long nX, long nY )
 530 {
 531     if (m_aLineColor != SALCOLOR_NONE)
 532     {
 533         drawPixel(nX, nY, m_aLineColor);
 534     }
 535 }
 536
 537 void SvpSalGraphics::drawPixel( long nX, long nY, SalColor nSalColor )
 538 {
 539     SalColor aOrigFillColor = m_aFillColor;
 540     SalColor aOrigLineColor = m_aLineColor;
 541
 542     basegfx::B2DPolygon aRect = basegfx::tools::createPolygonFromRect(basegfx::B2DRectangle(nX, nY, nX+1, nY+1));
 543     m_aLineColor = SALCOLOR_NONE;
 544     m_aFillColor = nSalColor;
 545
 546     drawPolyPolygon(basegfx::B2DPolyPolygon(aRect));
 547
 548     m_aFillColor = aOrigFillColor;
 549     m_aLineColor = aOrigLineColor;
 550 }
 551
 552 void SvpSalGraphics::drawRect( long nX, long nY, long nWidth, long nHeight )
 553 {
 554     // because of the -1 hack we have to do fill and draw separately
 555     SalColor aOrigFillColor = m_aFillColor;
 556     SalColor aOrigLineColor = m_aLineColor;
 557     m_aFillColor = SALCOLOR_NONE;
 558     m_aLineColor = SALCOLOR_NONE;
 559
 560     if (aOrigFillColor != SALCOLOR_NONE)
 561     {
 562         basegfx::B2DPolygon aRect = basegfx::tools::createPolygonFromRect(basegfx::B2DRectangle(nX, nY, nX+nWidth, nY+nHeight));
 563         m_aFillColor = aOrigFillColor;
 564         drawPolyPolygon(basegfx::B2DPolyPolygon(aRect));
 565         m_aFillColor = SALCOLOR_NONE;
 566     }
 567
 568     if (aOrigLineColor != SALCOLOR_NONE)
 569     {
 570         // need same -1 hack as X11SalGraphicsImpl::drawRect
 571         basegfx::B2DPolygon aRect = basegfx::tools::createPolygonFromRect(basegfx::B2DRectangle( nX, nY, nX+nWidth-1, nY+nHeight-1));
 572         m_aLineColor = aOrigLineColor;
 573         drawPolyPolygon(basegfx::B2DPolyPolygon(aRect));
 574         m_aLineColor = SALCOLOR_NONE;
 575     }
 576
 577     m_aFillColor = aOrigFillColor;
 578     m_aLineColor = aOrigLineColor;
 579 }
 580
 581 void SvpSalGraphics::drawPolyLine(sal_uInt32 nPoints, const SalPoint* pPtAry)
 582 {
 583     basegfx::B2DPolygon aPoly;
 584     aPoly.append(basegfx::B2DPoint(pPtAry->mnX, pPtAry->mnY), nPoints);
 585     for (sal_uInt32 i = 1; i < nPoints; ++i)
 586         aPoly.setB2DPoint(i, basegfx::B2DPoint(pPtAry[i].mnX, pPtAry[i].mnY));
 587     aPoly.setClosed(false);
 588
 589     drawPolyLine(aPoly, 0.0, basegfx::B2DVector(1.0, 1.0), basegfx::B2DLineJoin::Miter,
 590                  css::drawing::LineCap_BUTT, 15.0 * F_PI180 /*default*/);
 591 }
 592
 593 void SvpSalGraphics::drawPolygon(sal_uInt32 nPoints, const SalPoint* pPtAry)
 594 {
 595     basegfx::B2DPolygon aPoly;
 596     aPoly.append(basegfx::B2DPoint(pPtAry->mnX, pPtAry->mnY), nPoints);
 597     for (sal_uInt32 i = 1; i < nPoints; ++i)
 598         aPoly.setB2DPoint(i, basegfx::B2DPoint(pPtAry[i].mnX, pPtAry[i].mnY));
 599
 600     drawPolyPolygon(basegfx::B2DPolyPolygon(aPoly));
 601 }
 602
 603 void SvpSalGraphics::drawPolyPolygon(sal_uInt32 nPoly,
 604                                      const sal_uInt32* pPointCounts,
 605                                      PCONSTSALPOINT*   pPtAry)
 606 {
 607     basegfx::B2DPolyPolygon aPolyPoly;
 608     for(sal_uInt32 nPolygon = 0; nPolygon < nPoly; ++nPolygon)
 609     {
 610         sal_uInt32 nPoints = pPointCounts[nPolygon];
 611         if (nPoints)
 612         {
 613             PCONSTSALPOINT pPoints = pPtAry[nPolygon];
 614             basegfx::B2DPolygon aPoly;
 615             aPoly.append( basegfx::B2DPoint(pPoints->mnX, pPoints->mnY), nPoints);
 616             for (sal_uInt32 i = 1; i < nPoints; ++i)
 617                 aPoly.setB2DPoint(i, basegfx::B2DPoint( pPoints[i].mnX, pPoints[i].mnY));
 618
 619             aPolyPoly.append(aPoly);
 620         }
 621     }
 622
 623     drawPolyPolygon(aPolyPoly);
 624 }
 625
 626 static const basegfx::B2DPoint aHalfPointOfs(0.5, 0.5);
 627
 628 static void AddPolygonToPath(cairo_t* cr, const basegfx::B2DPolygon& rPolygon, bool bClosePath,
 629                              bool bPixelSnap, bool bLineDraw)
 630 {
 631     // short circuit if there is nothing to do
 632     const int nPointCount = rPolygon.count();
 633     if( nPointCount <= 0 )
 634     {
 635         return;
 636     }
 637
 638     const bool bHasCurves = rPolygon.areControlPointsUsed();
 639     basegfx::B2DPoint aLast;
 640
 641     for( int nPointIdx = 0, nPrevIdx = 0;; nPrevIdx = nPointIdx++ )
 642     {
 643         int nClosedIdx = nPointIdx;
 644         if( nPointIdx >= nPointCount )
 645         {
 646             // prepare to close last curve segment if needed
 647             if( bClosePath && (nPointIdx == nPointCount) )
 648             {
 649                 nClosedIdx = 0;
 650             }
 651             else
 652             {
 653                 break;
 654             }
 655         }
 656
 657         basegfx::B2DPoint aPoint = rPolygon.getB2DPoint( nClosedIdx );
 658
 659         if( bPixelSnap)
 660         {
 661             // snap device coordinates to full pixels
 662             aPoint.setX( basegfx::fround( aPoint.getX() ) );
 663             aPoint.setY( basegfx::fround( aPoint.getY() ) );
 664         }
 665
 666         if( bLineDraw )
 667         {
 668             aPoint += aHalfPointOfs;
 669         }
 670
 671         if( !nPointIdx )
 672         {
 673             // first point => just move there
 674             cairo_move_to(cr, aPoint.getX(), aPoint.getY());
 675             aLast = aPoint;
 676             continue;
 677         }
 678
 679         bool bPendingCurve = false;
 680         if( bHasCurves )
 681         {
 682             bPendingCurve = rPolygon.isNextControlPointUsed( nPrevIdx );
 683             bPendingCurve |= rPolygon.isPrevControlPointUsed( nClosedIdx );
 684         }
 685
 686         if( !bPendingCurve )    // line segment
 687         {
 688             cairo_line_to(cr, aPoint.getX(), aPoint.getY());
 689         }
 690         else                        // cubic bezier segment
 691         {
 692             basegfx::B2DPoint aCP1 = rPolygon.getNextControlPoint( nPrevIdx );
 693             basegfx::B2DPoint aCP2 = rPolygon.getPrevControlPoint( nClosedIdx );
 694             if( bLineDraw )
 695             {
 696                 aCP1 += aHalfPointOfs;
 697                 aCP2 += aHalfPointOfs;
 698             }
 699
 700             // tdf#99165 if the control points are 'empty', create the mathematical
 701             // correct replacement ones to avoid problems with the graphical sub-system
 702             // tdf#101026 The 1st attempt to create a mathematically correct replacement control
 703             // vector was wrong. Best alternative is one as close as possible which means short.
 704             if (aCP1.equal(aLast))
 705             {
 706                 aCP1 = aLast + ((aCP2 - aLast) * 0.0005);
 707             }
 708
 709             if(aCP2.equal(aPoint))
 710             {
 711                 aCP2 = aPoint + ((aCP1 - aPoint) * 0.0005);
 712             }
 713
 714             cairo_curve_to(cr, aCP1.getX(), aCP1.getY(), aCP2.getX(), aCP2.getY(),
 715                                aPoint.getX(), aPoint.getY());
 716         }
 717
 718         aLast = aPoint;
 719     }
 720
 721     if( bClosePath )
 722     {
 723         cairo_close_path(cr);
 724     }
 725 }
 726
 727 void SvpSalGraphics::drawLine( long nX1, long nY1, long nX2, long nY2 )
 728 {
 729     basegfx::B2DPolygon aPoly;
 730     aPoly.append(basegfx::B2DPoint(nX1, nY1), 2);
 731     aPoly.setB2DPoint(1, basegfx::B2DPoint(nX2, nY2));
 732     aPoly.setClosed(false);
 733
 734     cairo_t* cr = getCairoContext(false);
 735     clipRegion(cr);
 736
 737     AddPolygonToPath(cr, aPoly, aPoly.isClosed(), !getAntiAliasB2DDraw(), true);
 738
 739     applyColor(cr, m_aLineColor);
 740
 741     basegfx::B2DRange extents = getClippedStrokeDamage(cr);
 742
 743     cairo_stroke(cr);
 744
 745     releaseCairoContext(cr, false, extents);
 746 }
 747
 748 bool SvpSalGraphics::drawPolyLine(
 749     const basegfx::B2DPolygon& rPolyLine,
 750     double fTransparency,
 751     const basegfx::B2DVector& rLineWidths,
 752     basegfx::B2DLineJoin eLineJoin,
 753     css::drawing::LineCap eLineCap,
 754     double fMiterMinimumAngle)
 755 {
 756     // short circuit if there is nothing to do
 757     const int nPointCount = rPolyLine.count();
 758     if (nPointCount <= 0)
 759     {
 760         return true;
 761     }
 762
 763     const bool bNoJoin = (basegfx::B2DLineJoin::NONE == eLineJoin && basegfx::fTools::more(rLineWidths.getX(), 0.0));
 764
 765     cairo_t* cr = getCairoContext(false);
 766     clipRegion(cr);
 767
 768     // setup line attributes
 769     cairo_line_join_t eCairoLineJoin = CAIRO_LINE_JOIN_MITER;
 770     switch (eLineJoin)
 771     {
 772         case basegfx::B2DLineJoin::Bevel:
 773             eCairoLineJoin = CAIRO_LINE_JOIN_BEVEL;
 774             break;
 775         case basegfx::B2DLineJoin::Round:
 776             eCairoLineJoin = CAIRO_LINE_JOIN_ROUND;
 777             break;
 778         case basegfx::B2DLineJoin::NONE:
 779         case basegfx::B2DLineJoin::Miter:
 780             eCairoLineJoin = CAIRO_LINE_JOIN_MITER;
 781             break;
 782     }
 783
 784     // convert miter minimum angle to miter limit
 785     double fMiterLimit = 1.0 / sin( fMiterMinimumAngle / 2.0);
 786
 787     // setup cap attribute
 788     cairo_line_cap_t eCairoLineCap(CAIRO_LINE_CAP_BUTT);
 789
 790     switch (eLineCap)
 791     {
 792         default: // css::drawing::LineCap_BUTT:
 793         {
 794             eCairoLineCap = CAIRO_LINE_CAP_BUTT;
 795             break;
 796         }
 797         case css::drawing::LineCap_ROUND:
 798         {
 799             eCairoLineCap = CAIRO_LINE_CAP_ROUND;
 800             break;
 801         }
 802         case css::drawing::LineCap_SQUARE:
 803         {
 804             eCairoLineCap = CAIRO_LINE_CAP_SQUARE;
 805             break;
 806         }
 807     }
 808
 809     cairo_set_source_rgba(cr, SALCOLOR_RED(m_aLineColor)/255.0,
 810                               SALCOLOR_GREEN(m_aLineColor)/255.0,
 811                               SALCOLOR_BLUE(m_aLineColor)/255.0,
 812                               1.0-fTransparency);
 813
 814     cairo_set_line_join(cr, eCairoLineJoin);
 815     cairo_set_line_cap(cr, eCairoLineCap);
 816     cairo_set_line_width(cr, rLineWidths.getX());
 817     cairo_set_miter_limit(cr, fMiterLimit);
 818
 819
 820     basegfx::B2DRange extents(0, 0, 0, 0);
 821
 822     if (!bNoJoin)
 823     {
 824         AddPolygonToPath(cr, rPolyLine, rPolyLine.isClosed(), !getAntiAliasB2DDraw(), true);
 825         extents = getClippedStrokeDamage(cr);
 826         cairo_stroke(cr);
 827     }
 828     else
 829     {
 830         // emulate rendering::PathJoinType::NONE by painting single edges
 831         const sal_uInt32 nEdgeCount(rPolyLine.isClosed() ? nPointCount : nPointCount - 1);
 832         basegfx::B2DPolygon aEdge;
 833         aEdge.append(rPolyLine.getB2DPoint(0));
 834         aEdge.append(basegfx::B2DPoint(0.0, 0.0));
 835
 836         for (sal_uInt32 i = 0; i < nEdgeCount; ++i)
 837         {
 838             const sal_uInt32 nNextIndex((i + 1) % nPointCount);
 839             aEdge.setB2DPoint(1, rPolyLine.getB2DPoint(nNextIndex));
 840             aEdge.setNextControlPoint(0, rPolyLine.getNextControlPoint(i % nPointCount));
 841             aEdge.setPrevControlPoint(1, rPolyLine.getPrevControlPoint(nNextIndex));
 842
 843             AddPolygonToPath(cr, aEdge, false, !getAntiAliasB2DDraw(), true);
 844
 845             extents.expand(getStrokeDamage(cr));
 846
 847             cairo_stroke(cr);
 848
 849             // prepare next step
 850             aEdge.setB2DPoint(0, aEdge.getB2DPoint(1));
 851         }
 852
 853         extents.intersect(getClipBox(cr));
 854     }
 855
 856     releaseCairoContext(cr, false, extents);
 857
 858     return true;
 859 }
 860
 861 bool SvpSalGraphics::drawPolyLineBezier( sal_uInt32,
 862                                          const SalPoint*,
 863                                          const PolyFlags* )
 864 {
 865     SAL_INFO("vcl.gdi", "unsupported SvpSalGraphics::drawPolyLineBezier case");
 866     return false;
 867 }
 868
 869 bool SvpSalGraphics::drawPolygonBezier( sal_uInt32,
 870                                         const SalPoint*,
 871                                         const PolyFlags* )
 872 {
 873     SAL_INFO("vcl.gdi", "unsupported SvpSalGraphics::drawPolygonBezier case");
 874     return false;
 875 }
 876
 877 bool SvpSalGraphics::drawPolyPolygonBezier( sal_uInt32,
 878                                             const sal_uInt32*,
 879                                             const SalPoint* const*,
 880                                             const PolyFlags* const* )
 881 {
 882     SAL_INFO("vcl.gdi", "unsupported SvpSalGraphics::drawPolyPolygonBezier case");
 883     return false;
 884 }
 885
 886 void SvpSalGraphics::setupPolyPolygon(cairo_t* cr, const basegfx::B2DPolyPolygon& rPolyPoly)
 887 {
 888     clipRegion(cr);
 889
 890     for (const auto & rPoly : rPolyPoly)
 891         AddPolygonToPath(cr, rPoly, true, !getAntiAliasB2DDraw(), m_aLineColor != SALCOLOR_NONE);
 892 }
 893
 894 bool SvpSalGraphics::drawPolyPolygon(const basegfx::B2DPolyPolygon& rPolyPoly, double fTransparency)
 895 {
 896     cairo_t* cr = getCairoContext(true);
 897
 898     setupPolyPolygon(cr, rPolyPoly);
 899
 900     basegfx::B2DRange extents(0, 0, 0, 0);
 901
 902     if (m_aFillColor != SALCOLOR_NONE)
 903     {
 904         cairo_set_source_rgba(cr, SALCOLOR_RED(m_aFillColor)/255.0,
 905                                   SALCOLOR_GREEN(m_aFillColor)/255.0,
 906                                   SALCOLOR_BLUE(m_aFillColor)/255.0,
 907                                   1.0-fTransparency);
 908
 909         if (m_aLineColor == SALCOLOR_NONE)
 910             extents = getClippedFillDamage(cr);
 911
 912         cairo_fill_preserve(cr);
 913     }
 914
 915     if (m_aLineColor != SALCOLOR_NONE)
 916     {
 917         cairo_set_source_rgba(cr, SALCOLOR_RED(m_aLineColor)/255.0,
 918                                   SALCOLOR_GREEN(m_aLineColor)/255.0,
 919                                   SALCOLOR_BLUE(m_aLineColor)/255.0,
 920                                   1.0-fTransparency);
 921
 922         extents = getClippedStrokeDamage(cr);
 923
 924         cairo_stroke_preserve(cr);
 925     }
 926
 927     releaseCairoContext(cr, true, extents);
 928
 929     return true;
 930 }
 931
 932 void SvpSalGraphics::applyColor(cairo_t *cr, SalColor aColor)
 933 {
 934     if (cairo_surface_get_content(m_pSurface) == CAIRO_CONTENT_COLOR_ALPHA)
 935     {
 936         cairo_set_source_rgba(cr, SALCOLOR_RED(aColor)/255.0,
 937                                   SALCOLOR_GREEN(aColor)/255.0,
 938                                   SALCOLOR_BLUE(aColor)/255.0,
 939                                   1.0);
 940     }
 941     else
 942     {
 943         double fSet = aColor == COL_BLACK ? 1.0 : 0.0;
 944         cairo_set_source_rgba(cr, 1, 1, 1, fSet);
 945         cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
 946     }
 947 }
 948
 949 void SvpSalGraphics::drawPolyPolygon(const basegfx::B2DPolyPolygon& rPolyPoly)
 950 {
 951     cairo_t* cr = getCairoContext(true);
 952
 953     setupPolyPolygon(cr, rPolyPoly);
 954
 955     basegfx::B2DRange extents(0, 0, 0, 0);
 956
 957     if (m_aFillColor != SALCOLOR_NONE)
 958     {
 959         applyColor(cr, m_aFillColor);
 960         if (m_aLineColor == SALCOLOR_NONE)
 961             extents = getClippedFillDamage(cr);
 962         cairo_fill_preserve(cr);
 963     }
 964
 965     if (m_aLineColor != SALCOLOR_NONE)
 966     {
 967         applyColor(cr, m_aLineColor);
 968         extents = getClippedStrokeDamage(cr);
 969         cairo_stroke_preserve(cr);
 970     }
 971
 972     releaseCairoContext(cr, true, extents);
 973 }
 974
 975 void SvpSalGraphics::copyArea( long nDestX,
 976                                long nDestY,
 977                                long nSrcX,
 978                                long nSrcY,
 979                                long nSrcWidth,
 980                                long nSrcHeight,
 981                                bool /*bWindowInvalidate*/ )
 982 {
 983     SalTwoRect aTR(nSrcX, nSrcY, nSrcWidth, nSrcHeight, nDestX, nDestY, nSrcWidth, nSrcHeight);
 984     copyBits(aTR, this);
 985 }
 986
 987 static basegfx::B2DRange renderSource(cairo_t* cr, const SalTwoRect& rTR,
 988                                           cairo_surface_t* source)
 989 {
 990     cairo_rectangle(cr, rTR.mnDestX, rTR.mnDestY, rTR.mnDestWidth, rTR.mnDestHeight);
 991
 992     basegfx::B2DRange extents = getClippedFillDamage(cr);
 993
 994     cairo_clip(cr);
 995
 996     cairo_translate(cr, rTR.mnDestX, rTR.mnDestY);
 997     if (rTR.mnSrcWidth != 0 && rTR.mnSrcHeight != 0) {
 998         cairo_scale(cr, (double)(rTR.mnDestWidth)/rTR.mnSrcWidth, ((double)rTR.mnDestHeight)/rTR.mnSrcHeight);
 999     }
1000
1001     cairo_save(cr);
1002     cairo_set_source_surface(cr, source, -rTR.mnSrcX, -rTR.mnSrcY);
1003     cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
1004     cairo_paint(cr);
1005     cairo_restore(cr);
1006
1007     return extents;
1008 }
1009
1010 void SvpSalGraphics::copySource( const SalTwoRect& rTR,
1011                                  cairo_surface_t* source )
1012 {
1013     cairo_t* cr = getCairoContext(false);
1014     clipRegion(cr);
1015
1016     basegfx::B2DRange extents = renderSource(cr, rTR, source);
1017
1018     releaseCairoContext(cr, false, extents);
1019 }
1020
1021 void SvpSalGraphics::copyBits( const SalTwoRect& rTR,
1022                                SalGraphics*      pSrcGraphics )
1023 {
1024     SalTwoRect aTR(rTR);
1025
1026     SvpSalGraphics* pSrc = pSrcGraphics ?
1027         static_cast<SvpSalGraphics*>(pSrcGraphics) : this;
1028
1029     cairo_surface_t* source = pSrc->m_pSurface;
1030
1031     cairo_surface_t *pCopy = nullptr;
1032     if (pSrc == this)
1033     {
1034         //self copy is a problem, so dup source in that case
1035         pCopy = cairo_surface_create_similar(source,
1036                                             cairo_surface_get_content(m_pSurface),
1037                                             aTR.mnSrcWidth * m_fScale,
1038                                             aTR.mnSrcHeight * m_fScale);
1039 #if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 14, 0)
1040         cairo_surface_set_device_scale(pCopy, m_fScale, m_fScale);
1041 #endif
1042         cairo_t* cr = cairo_create(pCopy);
1043         cairo_set_source_surface(cr, source, -aTR.mnSrcX, -aTR.mnSrcY);
1044         cairo_rectangle(cr, 0, 0, aTR.mnSrcWidth, aTR.mnSrcHeight);
1045         cairo_fill(cr);
1046         cairo_destroy(cr);
1047
1048         source = pCopy;
1049
1050         aTR.mnSrcX = 0;
1051         aTR.mnSrcY = 0;
1052     }
1053
1054     copySource(aTR, source);
1055
1056     if (pCopy)
1057         cairo_surface_destroy(pCopy);
1058 }
1059
1060 void SvpSalGraphics::drawBitmap(const SalTwoRect& rTR, const SalBitmap& rSourceBitmap)
1061 {
1062     if (rSourceBitmap.GetBitCount() == 1)
1063     {
1064         MaskHelper aMask(rSourceBitmap);
1065         cairo_surface_t* source = aMask.getMask();
1066         copySource(rTR, source);
1067         return;
1068     }
1069
1070     SourceHelper aSurface(rSourceBitmap);
1071     cairo_surface_t* source = aSurface.getSurface();
1072     copySource(rTR, source);
1073 }
1074
1075 void SvpSalGraphics::drawBitmap( const SalTwoRect& rTR,
1076                                  const SalBitmap& rSourceBitmap,
1077                                  const SalBitmap& rTransparentBitmap )
1078 {
1079     drawAlphaBitmap(rTR, rSourceBitmap, rTransparentBitmap);
1080 }
1081
1082 static sal_uInt8 unpremultiply(sal_uInt8 c, sal_uInt8 a)
1083 {
1084     return (a > 0) ? (c * 255 + a / 2) / a : 0;
1085 }
1086
1087 static sal_uInt8 premultiply(sal_uInt8 c, sal_uInt8 a)
1088 {
1089     return (c * a + 127) / 255;
1090 }
1091
1092 void SvpSalGraphics::drawMask( const SalTwoRect& rTR,
1093                                const SalBitmap& rSalBitmap,
1094                                SalColor nMaskColor )
1095 {
1096     /** creates an image from the given rectangle, replacing all black pixels
1097      *  with nMaskColor and make all other full transparent */
1098     SourceHelper aSurface(rSalBitmap);
1099     sal_Int32 nStride;
1100     unsigned char *mask_data = aSurface.getBits(nStride);
1101     for (sal_Int32 y = rTR.mnSrcY ; y < rTR.mnSrcY + rTR.mnSrcHeight; ++y)
1102     {
1103         unsigned char *row = mask_data + (nStride*y);
1104         unsigned char *data = row + (rTR.mnSrcX * 4);
1105         for (sal_Int32 x = rTR.mnSrcX; x < rTR.mnSrcX + rTR.mnSrcWidth; ++x)
1106         {
1107             sal_uInt8 b = unpremultiply(data[SVP_CAIRO_BLUE], data[SVP_CAIRO_ALPHA]);
1108             sal_uInt8 g = unpremultiply(data[SVP_CAIRO_GREEN], data[SVP_CAIRO_ALPHA]);
1109             sal_uInt8 r = unpremultiply(data[SVP_CAIRO_RED], data[SVP_CAIRO_ALPHA]);
1110             if (r == 0 && g == 0 && b == 0)
1111             {
1112                 data[0] = SALCOLOR_BLUE(nMaskColor);
1113                 data[1] = SALCOLOR_GREEN(nMaskColor);
1114                 data[2] = SALCOLOR_RED(nMaskColor);
1115                 data[3] = 0xff;
1116             }
1117             else
1118             {
1119                 data[0] = 0;
1120                 data[1] = 0;
1121                 data[2] = 0;
1122                 data[3] = 0;
1123             }
1124             data+=4;
1125         }
1126     }
1127     aSurface.mark_dirty();
1128
1129     cairo_t* cr = getCairoContext(false);
1130     clipRegion(cr);
1131
1132     cairo_rectangle(cr, rTR.mnDestX, rTR.mnDestY, rTR.mnDestWidth, rTR.mnDestHeight);
1133
1134     basegfx::B2DRange extents = getClippedFillDamage(cr);
1135
1136     cairo_clip(cr);
1137
1138     cairo_translate(cr, rTR.mnDestX, rTR.mnDestY);
1139     cairo_scale(cr, (double)(rTR.mnDestWidth)/rTR.mnSrcWidth, ((double)rTR.mnDestHeight)/rTR.mnSrcHeight);
1140     cairo_set_source_surface(cr, aSurface.getSurface(), -rTR.mnSrcX, -rTR.mnSrcY);
1141     cairo_paint(cr);
1142
1143     releaseCairoContext(cr, false, extents);
1144 }
1145
1146 SalBitmap* SvpSalGraphics::getBitmap( long nX, long nY, long nWidth, long nHeight )
1147 {
1148     SvpSalBitmap* pBitmap = new SvpSalBitmap();
1149     BitmapPalette aPal;
1150     if (GetBitCount() == 1)
1151     {
1152         aPal.SetEntryCount(2);
1153         aPal[0] = Color(COL_BLACK);
1154         aPal[1] = Color(COL_WHITE);
1155     }
1156     pBitmap->Create(Size(nWidth, nHeight), GetBitCount(), aPal);
1157
1158     cairo_surface_t* target = SvpSalGraphics::createCairoSurface(pBitmap->GetBuffer());
1159     cairo_t* cr = cairo_create(target);
1160
1161     SalTwoRect aTR(nX, nY, nWidth, nHeight, 0, 0, nWidth, nHeight);
1162     renderSource(cr, aTR, m_pSurface);
1163
1164     cairo_destroy(cr);
1165     cairo_surface_destroy(target);
1166
1167     Toggle1BitTransparency(*pBitmap->GetBuffer());
1168
1169     return pBitmap;
1170 }
1171
1172 SalColor SvpSalGraphics::getPixel( long nX, long nY )
1173 {
1174     cairo_surface_t *target = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 1, 1);
1175     cairo_t* cr = cairo_create(target);
1176
1177     cairo_rectangle(cr, 0, 0, 1, 1);
1178     cairo_set_source_surface(cr, m_pSurface, -nX, -nY);
1179     cairo_paint(cr);
1180     cairo_destroy(cr);
1181
1182     cairo_surface_flush(target);
1183     unsigned char *data = cairo_image_surface_get_data(target);
1184     sal_uInt8 b = unpremultiply(data[SVP_CAIRO_BLUE], data[SVP_CAIRO_ALPHA]);
1185     sal_uInt8 g = unpremultiply(data[SVP_CAIRO_GREEN], data[SVP_CAIRO_ALPHA]);
1186     sal_uInt8 r = unpremultiply(data[SVP_CAIRO_RED], data[SVP_CAIRO_ALPHA]);
1187     SalColor nRet = MAKE_SALCOLOR(r, g, b);
1188
1189     cairo_surface_destroy(target);
1190
1191     return nRet;
1192 }
1193
1194 namespace
1195 {
1196     cairo_pattern_t * create_stipple()
1197     {
1198         static unsigned char data[16] = { 0xFF, 0xFF, 0x00, 0x00,
1199                                           0xFF, 0xFF, 0x00, 0x00,
1200                                           0x00, 0x00, 0xFF, 0xFF,
1201                                           0x00, 0x00, 0xFF, 0xFF };
1202         cairo_surface_t* surface = cairo_image_surface_create_for_data(data, CAIRO_FORMAT_A8, 4, 4, 4);
1203         cairo_pattern_t* pattern = cairo_pattern_create_for_surface(surface);
1204         cairo_surface_destroy(surface);
1205         cairo_pattern_set_extend(pattern, CAIRO_EXTEND_REPEAT);
1206         cairo_pattern_set_filter(pattern, CAIRO_FILTER_NEAREST);
1207         return pattern;
1208     }
1209 }
1210
1211 void SvpSalGraphics::invert(const basegfx::B2DPolygon &rPoly, SalInvert nFlags)
1212 {
1213     cairo_t* cr = getCairoContext(false);
1214     clipRegion(cr);
1215
1216     basegfx::B2DRange extents(0, 0, 0, 0);
1217
1218     AddPolygonToPath(cr, rPoly, true, !getAntiAliasB2DDraw(), false);
1219
1220     cairo_set_source_rgb(cr, 1.0, 1.0, 1.0);
1221
1222     if (cairo_version() >= CAIRO_VERSION_ENCODE(1, 10, 0))
1223     {
1224         cairo_set_operator(cr, CAIRO_OPERATOR_DIFFERENCE);
1225     }
1226     else
1227     {
1228         SAL_WARN("vcl.gdi", "SvpSalGraphics::invert, archaic cairo");
1229     }
1230
1231     if (nFlags & SalInvert::TrackFrame)
1232     {
1233         cairo_set_line_width(cr, 2.0);
1234         const double dashLengths[2] = { 4.0, 4.0 };
1235         cairo_set_dash(cr, dashLengths, 2, 0);
1236
1237         extents = getClippedStrokeDamage(cr);
1238         //see tdf#106577 under wayland, some pixel droppings seen, maybe we're
1239         //out by one somewhere, or cairo_stroke_extents is confused by
1240         //dashes/line width
1241         extents.grow(1);
1242
1243         cairo_stroke(cr);
1244     }
1245     else
1246     {
1247         extents = getClippedFillDamage(cr);
1248
1249         cairo_clip(cr);
1250
1251         if (nFlags & SalInvert::N50)
1252         {
1253             cairo_pattern_t *pattern = create_stipple();
1254             cairo_surface_t* surface = cairo_surface_create_similar(m_pSurface,
1255                                                                     cairo_surface_get_content(m_pSurface),
1256                                                                     extents.getWidth() * m_fScale,
1257                                                                     extents.getHeight() * m_fScale);
1258
1259 #if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 14, 0)
1260             cairo_surface_set_device_scale(surface, m_fScale, m_fScale);
1261 #endif
1262             cairo_t* stipple_cr = cairo_create(surface);
1263             cairo_set_source_rgb(stipple_cr, 1.0, 1.0, 1.0);
1264             cairo_mask(stipple_cr, pattern);
1265             cairo_pattern_destroy(pattern);
1266             cairo_destroy(stipple_cr);
1267             cairo_mask_surface(cr, surface, extents.getMinX(), extents.getMinY());
1268             cairo_surface_destroy(surface);
1269         }
1270         else
1271         {
1272             cairo_paint(cr);
1273         }
1274     }
1275
1276     releaseCairoContext(cr, false, extents);
1277 }
1278
1279 void SvpSalGraphics::invert( long nX, long nY, long nWidth, long nHeight, SalInvert nFlags )
1280 {
1281     basegfx::B2DPolygon aRect = basegfx::tools::createPolygonFromRect(basegfx::B2DRectangle(nX, nY, nX+nWidth, nY+nHeight));
1282
1283     invert(aRect, nFlags);
1284 }
1285
1286 void SvpSalGraphics::invert(sal_uInt32 nPoints, const SalPoint* pPtAry, SalInvert nFlags)
1287 {
1288     basegfx::B2DPolygon aPoly;
1289     aPoly.append(basegfx::B2DPoint(pPtAry->mnX, pPtAry->mnY), nPoints);
1290     for (sal_uInt32 i = 1; i < nPoints; ++i)
1291         aPoly.setB2DPoint(i, basegfx::B2DPoint(pPtAry[i].mnX, pPtAry[i].mnY));
1292     aPoly.setClosed(true);
1293
1294     invert(aPoly, nFlags);
1295 }
1296
1297 bool SvpSalGraphics::drawEPS( long, long, long, long, void*, sal_uLong )
1298 {
1299     return false;
1300 }
1301
1302 namespace
1303 {
1304     bool isCairoCompatible(const BitmapBuffer* pBuffer)
1305     {
1306         if (!pBuffer)
1307             return false;
1308
1309         if (pBuffer->mnBitCount != 32 && pBuffer->mnBitCount != 1)
1310             return false;
1311
1312         cairo_format_t nFormat = getCairoFormat(*pBuffer);
1313         return (cairo_format_stride_for_width(nFormat, pBuffer->mnWidth) == pBuffer->mnScanlineSize);
1314     }
1315 }
1316
1317 cairo_surface_t* SvpSalGraphics::createCairoSurface(const BitmapBuffer *pBuffer)
1318 {
1319     if (!isCairoCompatible(pBuffer))
1320         return nullptr;
1321
1322     cairo_format_t nFormat = getCairoFormat(*pBuffer);
1323     cairo_surface_t *target =
1324         cairo_image_surface_create_for_data(pBuffer->mpBits,
1325                                         nFormat,
1326                                         pBuffer->mnWidth, pBuffer->mnHeight,
1327                                         pBuffer->mnScanlineSize);
1328     return target;
1329 }
1330
1331 cairo_t* SvpSalGraphics::createTmpCompatibleCairoContext() const
1332 {
1333     cairo_surface_t *target = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
1334                                                          m_aFrameSize.getX() * m_fScale,
1335                                                          m_aFrameSize.getY() * m_fScale);
1336 #if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 14, 0)
1337     cairo_surface_set_device_scale(target, m_fScale, m_fScale);
1338 #endif
1339
1340     return cairo_create(target);
1341 }
1342
1343 cairo_t* SvpSalGraphics::getCairoContext(bool bXorModeAllowed) const
1344 {
1345     cairo_t* cr;
1346     if (m_ePaintMode == PaintMode::Xor && bXorModeAllowed)
1347         cr = createTmpCompatibleCairoContext();
1348     else
1349         cr = cairo_create(m_pSurface);
1350     cairo_set_line_width(cr, 1);
1351     cairo_set_fill_rule(cr, CAIRO_FILL_RULE_EVEN_ODD);
1352     cairo_set_antialias(cr, getAntiAliasB2DDraw() ? CAIRO_ANTIALIAS_DEFAULT : CAIRO_ANTIALIAS_NONE);
1353     cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
1354     return cr;
1355 }
1356
1357 cairo_user_data_key_t* SvpSalGraphics::getDamageKey()
1358 {
1359     static cairo_user_data_key_t aDamageKey;
1360     return &aDamageKey;
1361 }
1362
1363 void SvpSalGraphics::releaseCairoContext(cairo_t* cr, bool bXorModeAllowed, const basegfx::B2DRange& rExtents) const
1364 {
1365     const bool bXoring = (m_ePaintMode == PaintMode::Xor && bXorModeAllowed);
1366
1367     if (rExtents.isEmpty())
1368     {
1369         //nothing changed, return early
1370         if (bXoring)
1371         {
1372             cairo_surface_t* surface = cairo_get_target(cr);
1373             cairo_surface_destroy(surface);
1374         }
1375         cairo_destroy(cr);
1376         return;
1377     }
1378
1379     sal_Int32 nExtentsLeft(rExtents.getMinX()), nExtentsTop(rExtents.getMinY());
1380     sal_Int32 nExtentsRight(rExtents.getMaxX()), nExtentsBottom(rExtents.getMaxY());
1381     sal_Int32 nWidth = m_aFrameSize.getX();
1382     sal_Int32 nHeight = m_aFrameSize.getY();
1383     nExtentsLeft = std::max<sal_Int32>(nExtentsLeft, 0);
1384     nExtentsTop = std::max<sal_Int32>(nExtentsTop, 0);
1385     nExtentsRight = std::min<sal_Int32>(nExtentsRight, nWidth);
1386     nExtentsBottom = std::min<sal_Int32>(nExtentsBottom, nHeight);
1387
1388     cairo_surface_t* surface = cairo_get_target(cr);
1389     cairo_surface_flush(surface);
1390
1391     //For the most part we avoid the use of XOR these days, but there
1392     //are some edge cases where legacy stuff still supports it, so
1393     //emulate it (slowly) here.
1394     if (bXoring)
1395     {
1396         cairo_surface_t* target_surface = m_pSurface;
1397         if (cairo_surface_get_type(target_surface) != CAIRO_SURFACE_TYPE_IMAGE)
1398         {
1399             //in the unlikely case we can't use m_pSurface directly, copy contents
1400             //to another temp image surface
1401             cairo_t* copycr = createTmpCompatibleCairoContext();
1402             cairo_rectangle(copycr, nExtentsLeft, nExtentsTop,
1403                                     nExtentsRight - nExtentsLeft,
1404                                     nExtentsBottom - nExtentsTop);
1405             cairo_set_source_surface(copycr, m_pSurface, 0, 0);
1406             cairo_paint(copycr);
1407             target_surface = cairo_get_target(copycr);
1408             cairo_destroy(copycr);
1409         }
1410
1411         cairo_surface_flush(target_surface);
1412         unsigned char *target_surface_data = cairo_image_surface_get_data(target_surface);
1413         unsigned char *xor_surface_data = cairo_image_surface_get_data(surface);
1414
1415         cairo_format_t nFormat = cairo_image_surface_get_format(target_surface);
1416         assert(nFormat == CAIRO_FORMAT_ARGB32 && "need to implement CAIRO_FORMAT_A1 after all here");
1417         sal_Int32 nStride = cairo_format_stride_for_width(nFormat, nWidth * m_fScale);
1418         sal_Int32 nUnscaledExtentsLeft = nExtentsLeft * m_fScale;
1419         sal_Int32 nUnscaledExtentsRight = nExtentsRight * m_fScale;
1420         sal_Int32 nUnscaledExtentsTop = nExtentsTop * m_fScale;
1421         sal_Int32 nUnscaledExtentsBottom = nExtentsBottom * m_fScale;
1422         for (sal_Int32 y = nUnscaledExtentsTop; y < nUnscaledExtentsBottom; ++y)
1423         {
1424             unsigned char *true_row = target_surface_data + (nStride*y);
1425             unsigned char *xor_row = xor_surface_data + (nStride*y);
1426             unsigned char *true_data = true_row + (nUnscaledExtentsLeft * 4);
1427             unsigned char *xor_data = xor_row + (nUnscaledExtentsLeft * 4);
1428             for (sal_Int32 x = nUnscaledExtentsLeft; x < nUnscaledExtentsRight; ++x)
1429             {
1430                 sal_uInt8 b = unpremultiply(true_data[SVP_CAIRO_BLUE], true_data[SVP_CAIRO_ALPHA]) ^
1431                               unpremultiply(xor_data[SVP_CAIRO_BLUE], xor_data[SVP_CAIRO_ALPHA]);
1432                 sal_uInt8 g = unpremultiply(true_data[SVP_CAIRO_GREEN], true_data[SVP_CAIRO_ALPHA]) ^
1433                               unpremultiply(xor_data[SVP_CAIRO_GREEN], xor_data[SVP_CAIRO_ALPHA]);
1434                 sal_uInt8 r = unpremultiply(true_data[SVP_CAIRO_RED], true_data[SVP_CAIRO_ALPHA]) ^
1435                               unpremultiply(xor_data[SVP_CAIRO_RED], xor_data[SVP_CAIRO_ALPHA]);
1436                 true_data[0] = premultiply(b, true_data[SVP_CAIRO_ALPHA]);
1437                 true_data[1] = premultiply(g, true_data[SVP_CAIRO_ALPHA]);
1438                 true_data[2] = premultiply(r, true_data[SVP_CAIRO_ALPHA]);
1439                 true_data+=4;
1440                 xor_data+=4;
1441             }
1442         }
1443         cairo_surface_mark_dirty(target_surface);
1444
1445         if (target_surface != m_pSurface)
1446         {
1447             cairo_t* copycr = cairo_create(m_pSurface);
1448             //unlikely case we couldn't use m_pSurface directly, copy contents
1449             //back from image surface
1450             cairo_rectangle(copycr, nExtentsLeft, nExtentsTop,
1451                                     nExtentsRight - nExtentsLeft,
1452                                     nExtentsBottom - nExtentsTop);
1453             cairo_set_source_surface(copycr, target_surface, 0, 0);
1454             cairo_paint(copycr);
1455             cairo_destroy(copycr);
1456             cairo_surface_destroy(target_surface);
1457         }
1458
1459         cairo_surface_destroy(surface);
1460     }
1461
1462     cairo_destroy(cr); // unref
1463
1464     DamageHandler* pDamage = static_cast<DamageHandler*>(cairo_surface_get_user_data(m_pSurface, getDamageKey()));
1465
1466     if (pDamage)
1467     {
1468         pDamage->damaged(pDamage->handle, nExtentsLeft, nExtentsTop,
1469                                           nExtentsRight - nExtentsLeft,
1470                                           nExtentsBottom - nExtentsTop);
1471     }
1472 }
1473
1474 #if ENABLE_CAIRO_CANVAS
1475 bool SvpSalGraphics::SupportsCairo() const
1476 {
1477     return false;
1478 }
1479
1480 cairo::SurfaceSharedPtr SvpSalGraphics::CreateSurface(const cairo::CairoSurfaceSharedPtr& /*rSurface*/) const
1481 {
1482     return cairo::SurfaceSharedPtr();
1483 }
1484
1485 cairo::SurfaceSharedPtr SvpSalGraphics::CreateSurface(const OutputDevice& /*rRefDevice*/, int /*x*/, int /*y*/, int /*width*/, int /*height*/) const
1486 {
1487     return cairo::SurfaceSharedPtr();
1488 }
1489
1490 cairo::SurfaceSharedPtr SvpSalGraphics::CreateBitmapSurface(const OutputDevice& /*rRefDevice*/, const BitmapSystemData& /*rData*/, const Size& /*rSize*/) const
1491 {
1492     return cairo::SurfaceSharedPtr();
1493 }
1494
1495 css::uno::Any SvpSalGraphics::GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& /*rSurface*/, const basegfx::B2ISize& /*rSize*/) const
1496 {
1497     return css::uno::Any();
1498 }
1499
1500 #endif // ENABLE_CAIRO_CANVAS
1501
1502 SystemGraphicsData SvpSalGraphics::GetGraphicsData() const
1503 {
1504     return SystemGraphicsData();
1505 }
1506
1507 bool SvpSalGraphics::supportsOperation(OutDevSupportType eType) const
1508 {
1509     switch (eType)
1510     {
1511         case OutDevSupportType::TransparentRect:
1512         case OutDevSupportType::B2DDraw:
1513             return true;
1514     }
1515     return false;
1516 }
1517
1518 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */