vcl/qt5/QtGraphics_GDI.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 <QtGraphics.hxx>
  21
  22 #include <QtBitmap.hxx>
  23 #include <QtPainter.hxx>
  24
  25 #include <sal/log.hxx>
  26
  27 #include <QtGui/QPainter>
  28 #include <QtGui/QScreen>
  29 #include <QtGui/QWindow>
  30 #include <QtWidgets/QWidget>
  31
  32 #include <numeric>
  33 #include <basegfx/polygon/b2dpolygontools.hxx>
  34 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  35
  36 QtGraphicsBackend::QtGraphicsBackend(QtFrame* pFrame, QImage* pQImage)
  37     : m_pFrame(pFrame)
  38     , m_pQImage(pQImage)
  39     , m_oLineColor(std::in_place, 0x00, 0x00, 0x00)
  40     , m_oFillColor(std::in_place, 0xFF, 0xFF, 0XFF)
  41     , m_eCompositionMode(QPainter::CompositionMode_SourceOver)
  42 {
  43     ResetClipRegion();
  44 }
  45
  46 QtGraphicsBackend::~QtGraphicsBackend() {}
  47
  48 const basegfx::B2DPoint aHalfPointOfs(0.5, 0.5);
  49
  50 static void AddPolygonToPath(QPainterPath& rPath, const basegfx::B2DPolygon& rPolygon,
  51                              bool bClosePath, bool bPixelSnap, bool bLineDraw)
  52 {
  53     const int nPointCount = rPolygon.count();
  54     // short circuit if there is nothing to do
  55     if (nPointCount == 0)
  56         return;
  57
  58     const bool bHasCurves = rPolygon.areControlPointsUsed();
  59     for (int nPointIdx = 0, nPrevIdx = 0;; nPrevIdx = nPointIdx++)
  60     {
  61         int nClosedIdx = nPointIdx;
  62         if (nPointIdx >= nPointCount)
  63         {
  64             // prepare to close last curve segment if needed
  65             if (bClosePath && (nPointIdx == nPointCount))
  66                 nClosedIdx = 0;
  67             else
  68                 break;
  69         }
  70
  71         basegfx::B2DPoint aPoint = rPolygon.getB2DPoint(nClosedIdx);
  72
  73         if (bPixelSnap)
  74         {
  75             // snap device coordinates to full pixels
  76             aPoint.setX(basegfx::fround(aPoint.getX()));
  77             aPoint.setY(basegfx::fround(aPoint.getY()));
  78         }
  79
  80         if (bLineDraw)
  81             aPoint += aHalfPointOfs;
  82         if (!nPointIdx)
  83         {
  84             // first point => just move there
  85             rPath.moveTo(aPoint.getX(), aPoint.getY());
  86             continue;
  87         }
  88
  89         bool bPendingCurve = false;
  90         if (bHasCurves)
  91         {
  92             bPendingCurve = rPolygon.isNextControlPointUsed(nPrevIdx);
  93             bPendingCurve |= rPolygon.isPrevControlPointUsed(nClosedIdx);
  94         }
  95
  96         if (!bPendingCurve) // line segment
  97             rPath.lineTo(aPoint.getX(), aPoint.getY());
  98         else // cubic bezier segment
  99         {
 100             basegfx::B2DPoint aCP1 = rPolygon.getNextControlPoint(nPrevIdx);
 101             basegfx::B2DPoint aCP2 = rPolygon.getPrevControlPoint(nClosedIdx);
 102             if (bLineDraw)
 103             {
 104                 aCP1 += aHalfPointOfs;
 105                 aCP2 += aHalfPointOfs;
 106             }
 107             rPath.cubicTo(aCP1.getX(), aCP1.getY(), aCP2.getX(), aCP2.getY(), aPoint.getX(),
 108                           aPoint.getY());
 109         }
 110     }
 111
 112     if (bClosePath)
 113         rPath.closeSubpath();
 114 }
 115
 116 static bool AddPolyPolygonToPath(QPainterPath& rPath, const basegfx::B2DPolyPolygon& rPolyPoly,
 117                                  bool bPixelSnap, bool bLineDraw)
 118 {
 119     if (rPolyPoly.count() == 0)
 120         return false;
 121     for (auto const& rPolygon : rPolyPoly)
 122     {
 123         AddPolygonToPath(rPath, rPolygon, true, bPixelSnap, bLineDraw);
 124     }
 125     return true;
 126 }
 127
 128 void QtGraphicsBackend::setClipRegion(const vcl::Region& rRegion)
 129 {
 130     if (rRegion.IsRectangle())
 131     {
 132         m_aClipRegion = toQRect(rRegion.GetBoundRect());
 133         if (!m_aClipPath.isEmpty())
 134         {
 135             QPainterPath aPath;
 136             m_aClipPath.swap(aPath);
 137         }
 138     }
 139     else if (!rRegion.HasPolyPolygonOrB2DPolyPolygon())
 140     {
 141         QRegion aQRegion;
 142         RectangleVector aRectangles;
 143         rRegion.GetRegionRectangles(aRectangles);
 144         for (const auto& rRect : aRectangles)
 145             aQRegion += toQRect(rRect);
 146         m_aClipRegion = aQRegion;
 147         if (!m_aClipPath.isEmpty())
 148         {
 149             QPainterPath aPath;
 150             m_aClipPath.swap(aPath);
 151         }
 152     }
 153     else
 154     {
 155         QPainterPath aPath;
 156         const basegfx::B2DPolyPolygon aPolyClip(rRegion.GetAsB2DPolyPolygon());
 157         AddPolyPolygonToPath(aPath, aPolyClip, !getAntiAlias(), false);
 158         m_aClipPath.swap(aPath);
 159         if (!m_aClipRegion.isEmpty())
 160         {
 161             QRegion aRegion;
 162             m_aClipRegion.swap(aRegion);
 163         }
 164     }
 165 }
 166
 167 void QtGraphicsBackend::ResetClipRegion()
 168 {
 169     if (m_pQImage)
 170         m_aClipRegion = QRegion(m_pQImage->rect());
 171     else
 172         m_aClipRegion = QRegion();
 173     if (!m_aClipPath.isEmpty())
 174     {
 175         QPainterPath aPath;
 176         m_aClipPath.swap(aPath);
 177     }
 178 }
 179
 180 void QtGraphicsBackend::drawPixel(tools::Long nX, tools::Long nY)
 181 {
 182     QtPainter aPainter(*this);
 183     aPainter.drawPoint(nX, nY);
 184     aPainter.update(nX, nY, 1, 1);
 185 }
 186
 187 void QtGraphicsBackend::drawPixel(tools::Long nX, tools::Long nY, Color nColor)
 188 {
 189     QtPainter aPainter(*this);
 190     aPainter.setPen(toQColor(nColor));
 191     aPainter.setPen(Qt::SolidLine);
 192     aPainter.drawPoint(nX, nY);
 193     aPainter.update(nX, nY, 1, 1);
 194 }
 195
 196 void QtGraphicsBackend::drawLine(tools::Long nX1, tools::Long nY1, tools::Long nX2, tools::Long nY2)
 197 {
 198     QtPainter aPainter(*this);
 199     aPainter.drawLine(nX1, nY1, nX2, nY2);
 200
 201     if (nX1 > nX2)
 202         std::swap(nX1, nX2);
 203     if (nY1 > nY2)
 204         std::swap(nY1, nY2);
 205     aPainter.update(nX1, nY1, nX2 - nX1 + 1, nY2 - nY1 + 1);
 206 }
 207
 208 void QtGraphicsBackend::drawRect(tools::Long nX, tools::Long nY, tools::Long nWidth,
 209                                  tools::Long nHeight)
 210 {
 211     if (!m_oFillColor && !m_oLineColor)
 212         return;
 213
 214     QtPainter aPainter(*this, true);
 215     if (m_oFillColor)
 216         aPainter.fillRect(nX, nY, nWidth, nHeight, aPainter.brush());
 217     if (m_oLineColor)
 218         aPainter.drawRect(nX, nY, nWidth - 1, nHeight - 1);
 219     aPainter.update(nX, nY, nWidth, nHeight);
 220 }
 221
 222 void QtGraphicsBackend::drawPolyLine(sal_uInt32 nPoints, const Point* pPtAry)
 223 {
 224     if (0 == nPoints)
 225         return;
 226
 227     QtPainter aPainter(*this);
 228     QPoint* pPoints = new QPoint[nPoints];
 229     QPoint aTopLeft(pPtAry->getX(), pPtAry->getY());
 230     QPoint aBottomRight = aTopLeft;
 231     for (sal_uInt32 i = 0; i < nPoints; ++i, ++pPtAry)
 232     {
 233         pPoints[i] = QPoint(pPtAry->getX(), pPtAry->getY());
 234         if (pPtAry->getX() < aTopLeft.x())
 235             aTopLeft.setX(pPtAry->getX());
 236         if (pPtAry->getY() < aTopLeft.y())
 237             aTopLeft.setY(pPtAry->getY());
 238         if (pPtAry->getX() > aBottomRight.x())
 239             aBottomRight.setX(pPtAry->getX());
 240         if (pPtAry->getY() > aBottomRight.y())
 241             aBottomRight.setY(pPtAry->getY());
 242     }
 243     aPainter.drawPolyline(pPoints, nPoints);
 244     delete[] pPoints;
 245     aPainter.update(QRect(aTopLeft, aBottomRight));
 246 }
 247
 248 void QtGraphicsBackend::drawPolygon(sal_uInt32 nPoints, const Point* pPtAry)
 249 {
 250     QtPainter aPainter(*this, true);
 251     QPolygon aPolygon(nPoints);
 252     for (sal_uInt32 i = 0; i < nPoints; ++i, ++pPtAry)
 253         aPolygon.setPoint(i, pPtAry->getX(), pPtAry->getY());
 254     aPainter.drawPolygon(aPolygon);
 255     aPainter.update(aPolygon.boundingRect());
 256 }
 257
 258 void QtGraphicsBackend::drawPolyPolygon(sal_uInt32 nPolyCount, const sal_uInt32* pPoints,
 259                                         const Point** ppPtAry)
 260 {
 261     // ignore invisible polygons
 262     if (!m_oFillColor && !m_oLineColor)
 263         return;
 264
 265     QPainterPath aPath;
 266     for (sal_uInt32 nPoly = 0; nPoly < nPolyCount; nPoly++)
 267     {
 268         const sal_uInt32 nPoints = pPoints[nPoly];
 269         if (nPoints > 1)
 270         {
 271             const Point* pPtAry = ppPtAry[nPoly];
 272             aPath.moveTo(pPtAry->getX(), pPtAry->getY());
 273             pPtAry++;
 274             for (sal_uInt32 nPoint = 1; nPoint < nPoints; nPoint++, pPtAry++)
 275                 aPath.lineTo(pPtAry->getX(), pPtAry->getY());
 276             aPath.closeSubpath();
 277         }
 278     }
 279
 280     QtPainter aPainter(*this, true);
 281     aPainter.drawPath(aPath);
 282     aPainter.update(aPath.boundingRect());
 283 }
 284
 285 bool QtGraphicsBackend::drawPolyPolygon(const basegfx::B2DHomMatrix& rObjectToDevice,
 286                                         const basegfx::B2DPolyPolygon& rPolyPolygon,
 287                                         double fTransparency)
 288 {
 289     // ignore invisible polygons
 290     if (!m_oFillColor && !m_oLineColor)
 291         return true;
 292     if ((fTransparency >= 1.0) || (fTransparency < 0))
 293         return true;
 294
 295     // Fallback: Transform to DeviceCoordinates
 296     basegfx::B2DPolyPolygon aPolyPolygon(rPolyPolygon);
 297     aPolyPolygon.transform(rObjectToDevice);
 298
 299     QPainterPath aPath;
 300     // ignore empty polygons
 301     if (!AddPolyPolygonToPath(aPath, aPolyPolygon, !getAntiAlias(), m_oLineColor.has_value()))
 302         return true;
 303
 304     QtPainter aPainter(*this, true, 255 * (1.0 - fTransparency));
 305     aPainter.drawPath(aPath);
 306     aPainter.update(aPath.boundingRect());
 307     return true;
 308 }
 309
 310 bool QtGraphicsBackend::drawPolyLineBezier(sal_uInt32 /*nPoints*/, const Point* /*pPtAry*/,
 311                                            const PolyFlags* /*pFlgAry*/)
 312 {
 313     return false;
 314 }
 315
 316 bool QtGraphicsBackend::drawPolygonBezier(sal_uInt32 /*nPoints*/, const Point* /*pPtAry*/,
 317                                           const PolyFlags* /*pFlgAry*/)
 318 {
 319     return false;
 320 }
 321
 322 bool QtGraphicsBackend::drawPolyPolygonBezier(sal_uInt32 /*nPoly*/, const sal_uInt32* /*pPoints*/,
 323                                               const Point* const* /*pPtAry*/,
 324                                               const PolyFlags* const* /*pFlgAry*/)
 325 {
 326     return false;
 327 }
 328
 329 bool QtGraphicsBackend::drawPolyLine(const basegfx::B2DHomMatrix& rObjectToDevice,
 330                                      const basegfx::B2DPolygon& rPolyLine, double fTransparency,
 331                                      double fLineWidth,
 332                                      const std::vector<double>* pStroke, // MM01
 333                                      basegfx::B2DLineJoin eLineJoin, css::drawing::LineCap eLineCap,
 334                                      double fMiterMinimumAngle, bool bPixelSnapHairline)
 335 {
 336     if (!m_oFillColor && !m_oLineColor)
 337     {
 338         return true;
 339     }
 340
 341     // MM01 check done for simple reasons
 342     if (!rPolyLine.count() || fTransparency < 0.0 || fTransparency > 1.0)
 343     {
 344         return true;
 345     }
 346
 347     // MM01 need to do line dashing as fallback stuff here now
 348     const double fDotDashLength(
 349         nullptr != pStroke ? std::accumulate(pStroke->begin(), pStroke->end(), 0.0) : 0.0);
 350     const bool bStrokeUsed(0.0 != fDotDashLength);
 351     assert(!bStrokeUsed || (bStrokeUsed && pStroke));
 352     basegfx::B2DPolyPolygon aPolyPolygonLine;
 353
 354     if (bStrokeUsed)
 355     {
 356         // apply LineStyle
 357         basegfx::utils::applyLineDashing(rPolyLine, // source
 358                                          *pStroke, // pattern
 359                                          &aPolyPolygonLine, // target for lines
 360                                          nullptr, // target for gaps
 361                                          fDotDashLength); // full length if available
 362     }
 363     else
 364     {
 365         // no line dashing, just copy
 366         aPolyPolygonLine.append(rPolyLine);
 367     }
 368
 369     // Transform to DeviceCoordinates, get DeviceLineWidth, execute PixelSnapHairline
 370     aPolyPolygonLine.transform(rObjectToDevice);
 371     if (bPixelSnapHairline)
 372     {
 373         aPolyPolygonLine = basegfx::utils::snapPointsOfHorizontalOrVerticalEdges(aPolyPolygonLine);
 374     }
 375
 376     // tdf#124848 get correct LineWidth in discrete coordinates,
 377     if (fLineWidth == 0) // hairline
 378         fLineWidth = 1.0;
 379     else // Adjust line width for object-to-device scale.
 380         fLineWidth = (rObjectToDevice * basegfx::B2DVector(fLineWidth, 0)).getLength();
 381
 382     // setup poly-polygon path
 383     QPainterPath aPath;
 384
 385     // MM01 todo - I assume that this is OKAY to be done in one run for Qt,
 386     // but this NEEDS to be checked/verified
 387     for (sal_uInt32 a(0); a < aPolyPolygonLine.count(); a++)
 388     {
 389         const basegfx::B2DPolygon aPolyLine(aPolyPolygonLine.getB2DPolygon(a));
 390         AddPolygonToPath(aPath, aPolyLine, aPolyLine.isClosed(), !getAntiAlias(), true);
 391     }
 392
 393     QtPainter aPainter(*this, false, 255 * (1.0 - fTransparency));
 394
 395     // setup line attributes
 396     QPen aPen = aPainter.pen();
 397     aPen.setWidth(fLineWidth);
 398
 399     switch (eLineJoin)
 400     {
 401         case basegfx::B2DLineJoin::Bevel:
 402             aPen.setJoinStyle(Qt::BevelJoin);
 403             break;
 404         case basegfx::B2DLineJoin::Round:
 405             aPen.setJoinStyle(Qt::RoundJoin);
 406             break;
 407         case basegfx::B2DLineJoin::NONE:
 408         case basegfx::B2DLineJoin::Miter:
 409             aPen.setMiterLimit(1.0 / sin(fMiterMinimumAngle / 2.0));
 410             aPen.setJoinStyle(Qt::MiterJoin);
 411             break;
 412     }
 413
 414     switch (eLineCap)
 415     {
 416         default: // css::drawing::LineCap_BUTT:
 417             aPen.setCapStyle(Qt::FlatCap);
 418             break;
 419         case css::drawing::LineCap_ROUND:
 420             aPen.setCapStyle(Qt::RoundCap);
 421             break;
 422         case css::drawing::LineCap_SQUARE:
 423             aPen.setCapStyle(Qt::SquareCap);
 424             break;
 425     }
 426
 427     aPainter.setPen(aPen);
 428     aPainter.drawPath(aPath);
 429     aPainter.update(aPath.boundingRect());
 430     return true;
 431 }
 432
 433 bool QtGraphicsBackend::drawGradient(const tools::PolyPolygon& /*rPolyPolygon*/,
 434                                      const Gradient& /*rGradient*/)
 435 {
 436     return false;
 437 }
 438
 439 bool QtGraphicsBackend::implDrawGradient(basegfx::B2DPolyPolygon const& /*rPolyPolygon*/,
 440                                          SalGradient const& /*rGradient*/)
 441 {
 442     return false;
 443 }
 444
 445 void QtGraphicsBackend::drawScaledImage(const SalTwoRect& rPosAry, const QImage& rImage)
 446 {
 447     QtPainter aPainter(*this);
 448     QRect aSrcRect(rPosAry.mnSrcX, rPosAry.mnSrcY, rPosAry.mnSrcWidth, rPosAry.mnSrcHeight);
 449     QRect aDestRect(rPosAry.mnDestX, rPosAry.mnDestY, rPosAry.mnDestWidth, rPosAry.mnDestHeight);
 450     aPainter.drawImage(aDestRect, rImage, aSrcRect);
 451     aPainter.update(aDestRect);
 452 }
 453
 454 void QtGraphicsBackend::copyArea(tools::Long nDestX, tools::Long nDestY, tools::Long nSrcX,
 455                                  tools::Long nSrcY, tools::Long nSrcWidth, tools::Long nSrcHeight,
 456                                  bool /*bWindowInvalidate*/)
 457 {
 458     if (nDestX == nSrcX && nDestY == nSrcY)
 459         return;
 460
 461     SalTwoRect aTR(nSrcX, nSrcY, nSrcWidth, nSrcHeight, nDestX, nDestY, nSrcWidth, nSrcHeight);
 462
 463     QImage* pImage = m_pQImage;
 464     QImage aImage = pImage->copy(aTR.mnSrcX, aTR.mnSrcY, aTR.mnSrcWidth, aTR.mnSrcHeight);
 465     pImage = &aImage;
 466     aTR.mnSrcX = 0;
 467     aTR.mnSrcY = 0;
 468
 469     drawScaledImage(aTR, *pImage);
 470 }
 471
 472 void QtGraphicsBackend::copyBits(const SalTwoRect& rPosAry, SalGraphics* pSrcGraphics)
 473 {
 474     if (rPosAry.mnSrcWidth <= 0 || rPosAry.mnSrcHeight <= 0 || rPosAry.mnDestWidth <= 0
 475         || rPosAry.mnDestHeight <= 0)
 476         return;
 477
 478     QImage aImage, *pImage;
 479     SalTwoRect aPosAry = rPosAry;
 480
 481     if (!pSrcGraphics)
 482     {
 483         pImage = m_pQImage;
 484         aImage
 485             = pImage->copy(rPosAry.mnSrcX, rPosAry.mnSrcY, rPosAry.mnSrcWidth, rPosAry.mnSrcHeight);
 486         pImage = &aImage;
 487         aPosAry.mnSrcX = 0;
 488         aPosAry.mnSrcY = 0;
 489     }
 490     else
 491         pImage = static_cast<QtGraphics*>(pSrcGraphics)->getQImage();
 492
 493     drawScaledImage(aPosAry, *pImage);
 494 }
 495
 496 void QtGraphicsBackend::drawBitmap(const SalTwoRect& rPosAry, const SalBitmap& rSalBitmap)
 497 {
 498     if (rPosAry.mnSrcWidth <= 0 || rPosAry.mnSrcHeight <= 0 || rPosAry.mnDestWidth <= 0
 499         || rPosAry.mnDestHeight <= 0)
 500         return;
 501
 502     const QImage* pImage = static_cast<const QtBitmap*>(&rSalBitmap)->GetQImage();
 503
 504     assert(pImage);
 505
 506     drawScaledImage(rPosAry, *pImage);
 507 }
 508
 509 void QtGraphicsBackend::drawBitmap(const SalTwoRect& rPosAry, const SalBitmap& /*rSalBitmap*/,
 510                                    const SalBitmap& /*rTransparentBitmap*/)
 511 {
 512     if (rPosAry.mnSrcWidth <= 0 || rPosAry.mnSrcHeight <= 0 || rPosAry.mnDestWidth <= 0
 513         || rPosAry.mnDestHeight <= 0)
 514         return;
 515
 516     assert(rPosAry.mnSrcWidth == rPosAry.mnDestWidth);
 517     assert(rPosAry.mnSrcHeight == rPosAry.mnDestHeight);
 518 }
 519
 520 void QtGraphicsBackend::drawMask(const SalTwoRect& rPosAry, const SalBitmap& /*rSalBitmap*/,
 521                                  Color /*nMaskColor*/)
 522 {
 523     if (rPosAry.mnSrcWidth <= 0 || rPosAry.mnSrcHeight <= 0 || rPosAry.mnDestWidth <= 0
 524         || rPosAry.mnDestHeight <= 0)
 525         return;
 526
 527     assert(rPosAry.mnSrcWidth == rPosAry.mnDestWidth);
 528     assert(rPosAry.mnSrcHeight == rPosAry.mnDestHeight);
 529 }
 530
 531 std::shared_ptr<SalBitmap> QtGraphicsBackend::getBitmap(tools::Long nX, tools::Long nY,
 532                                                         tools::Long nWidth, tools::Long nHeight)
 533 {
 534     return std::make_shared<QtBitmap>(m_pQImage->copy(nX, nY, nWidth, nHeight));
 535 }
 536
 537 Color QtGraphicsBackend::getPixel(tools::Long nX, tools::Long nY)
 538 {
 539     return Color(ColorTransparency, m_pQImage->pixel(nX, nY));
 540 }
 541
 542 void QtGraphicsBackend::invert(tools::Long nX, tools::Long nY, tools::Long nWidth,
 543                                tools::Long nHeight, SalInvert nFlags)
 544 {
 545     QtPainter aPainter(*this);
 546     if (SalInvert::N50 & nFlags)
 547     {
 548         aPainter.setCompositionMode(QPainter::RasterOp_SourceXorDestination);
 549         QBrush aBrush(Qt::white, Qt::Dense4Pattern);
 550         aPainter.fillRect(nX, nY, nWidth, nHeight, aBrush);
 551     }
 552     else
 553     {
 554         if (SalInvert::TrackFrame & nFlags)
 555         {
 556             aPainter.setCompositionMode(QPainter::RasterOp_SourceXorDestination);
 557             QPen aPen(Qt::white);
 558             aPen.setStyle(Qt::DotLine);
 559             aPainter.setPen(aPen);
 560             aPainter.drawRect(nX, nY, nWidth, nHeight);
 561         }
 562         else
 563         {
 564             aPainter.setCompositionMode(QPainter::RasterOp_SourceXorDestination);
 565             aPainter.fillRect(nX, nY, nWidth, nHeight, Qt::white);
 566         }
 567     }
 568     aPainter.update(nX, nY, nWidth, nHeight);
 569 }
 570
 571 void QtGraphicsBackend::invert(sal_uInt32 /*nPoints*/, const Point* /*pPtAry*/,
 572                                SalInvert /*nFlags*/)
 573 {
 574 }
 575
 576 bool QtGraphicsBackend::drawEPS(tools::Long /*nX*/, tools::Long /*nY*/, tools::Long /*nWidth*/,
 577                                 tools::Long /*nHeight*/, void* /*pPtr*/, sal_uInt32 /*nSize*/)
 578 {
 579     return false;
 580 }
 581
 582 bool QtGraphicsBackend::blendBitmap(const SalTwoRect&, const SalBitmap& /*rBitmap*/)
 583 {
 584     return false;
 585 }
 586
 587 bool QtGraphicsBackend::blendAlphaBitmap(const SalTwoRect&, const SalBitmap& /*rSrcBitmap*/,
 588                                          const SalBitmap& /*rMaskBitmap*/,
 589                                          const SalBitmap& /*rAlphaBitmap*/)
 590 {
 591     return false;
 592 }
 593
 594 static QImage getAlphaImage(const SalBitmap& rSourceBitmap, const SalBitmap& rAlphaBitmap)
 595 {
 596     assert(rSourceBitmap.GetSize() == rAlphaBitmap.GetSize());
 597     assert(rAlphaBitmap.GetBitCount() == 8 || rAlphaBitmap.GetBitCount() == 1);
 598
 599     QImage aAlphaMask = *static_cast<const QtBitmap*>(&rAlphaBitmap)->GetQImage();
 600     aAlphaMask.invertPixels();
 601
 602     const QImage* pBitmap = static_cast<const QtBitmap*>(&rSourceBitmap)->GetQImage();
 603     QImage aImage = pBitmap->convertToFormat(Qt_DefaultFormat32);
 604     aImage.setAlphaChannel(aAlphaMask);
 605     return aImage;
 606 }
 607
 608 bool QtGraphicsBackend::drawAlphaBitmap(const SalTwoRect& rPosAry, const SalBitmap& rSourceBitmap,
 609                                         const SalBitmap& rAlphaBitmap)
 610 {
 611     drawScaledImage(rPosAry, getAlphaImage(rSourceBitmap, rAlphaBitmap));
 612     return true;
 613 }
 614
 615 bool QtGraphicsBackend::drawTransformedBitmap(const basegfx::B2DPoint& rNull,
 616                                               const basegfx::B2DPoint& rX,
 617                                               const basegfx::B2DPoint& rY,
 618                                               const SalBitmap& rSourceBitmap,
 619                                               const SalBitmap* pAlphaBitmap, double fAlpha)
 620 {
 621     QImage aImage;
 622     if (!pAlphaBitmap)
 623         aImage = *static_cast<const QtBitmap*>(&rSourceBitmap)->GetQImage();
 624     else
 625         aImage = getAlphaImage(rSourceBitmap, *pAlphaBitmap);
 626
 627     const basegfx::B2DVector aXRel = rX - rNull;
 628     const basegfx::B2DVector aYRel = rY - rNull;
 629
 630     QtPainter aPainter(*this);
 631     aPainter.setOpacity(fAlpha);
 632     aPainter.setTransform(QTransform(aXRel.getX() / aImage.width(), aXRel.getY() / aImage.width(),
 633                                      aYRel.getX() / aImage.height(), aYRel.getY() / aImage.height(),
 634                                      rNull.getX(), rNull.getY()));
 635     aPainter.drawImage(QPoint(0, 0), aImage);
 636     aPainter.update(aImage.rect());
 637     return true;
 638 }
 639
 640 bool QtGraphicsBackend::hasFastDrawTransformedBitmap() const { return false; }
 641
 642 bool QtGraphicsBackend::drawAlphaRect(tools::Long nX, tools::Long nY, tools::Long nWidth,
 643                                       tools::Long nHeight, sal_uInt8 nTransparency)
 644 {
 645     if (!m_oFillColor && !m_oLineColor)
 646         return true;
 647     assert(nTransparency <= 100);
 648     if (nTransparency > 100)
 649         nTransparency = 100;
 650     QtPainter aPainter(*this, true, (100 - nTransparency) * (255.0 / 100));
 651     if (m_oFillColor)
 652         aPainter.fillRect(nX, nY, nWidth, nHeight, aPainter.brush());
 653     if (m_oLineColor)
 654         aPainter.drawRect(nX, nY, nWidth - 1, nHeight - 1);
 655     aPainter.update(nX, nY, nWidth, nHeight);
 656     return true;
 657 }
 658
 659 sal_uInt16 QtGraphicsBackend::GetBitCount() const { return getFormatBits(m_pQImage->format()); }
 660
 661 tools::Long QtGraphicsBackend::GetGraphicsWidth() const { return m_pQImage->width(); }
 662
 663 void QtGraphicsBackend::SetLineColor() { m_oLineColor = std::nullopt; }
 664
 665 void QtGraphicsBackend::SetLineColor(Color nColor) { m_oLineColor = nColor; }
 666
 667 void QtGraphicsBackend::SetFillColor() { m_oFillColor = std::nullopt; }
 668
 669 void QtGraphicsBackend::SetFillColor(Color nColor) { m_oFillColor = nColor; }
 670
 671 void QtGraphicsBackend::SetXORMode(bool bSet, bool)
 672 {
 673     if (bSet)
 674         m_eCompositionMode = QPainter::CompositionMode_Xor;
 675     else
 676         m_eCompositionMode = QPainter::CompositionMode_SourceOver;
 677 }
 678
 679 void QtGraphicsBackend::SetROPLineColor(SalROPColor /*nROPColor*/) {}
 680
 681 void QtGraphicsBackend::SetROPFillColor(SalROPColor /*nROPColor*/) {}
 682
 683 bool QtGraphicsBackend::supportsOperation(OutDevSupportType eType) const
 684 {
 685     switch (eType)
 686     {
 687         case OutDevSupportType::B2DDraw:
 688         case OutDevSupportType::TransparentRect:
 689             return true;
 690         default:
 691             return false;
 692     }
 693 }
 694
 695 void QtGraphics::GetResolution(sal_Int32& rDPIX, sal_Int32& rDPIY)
 696 {
 697     char* pForceDpi;
 698     if ((pForceDpi = getenv("SAL_FORCEDPI")))
 699     {
 700         OString sForceDPI(pForceDpi);
 701         rDPIX = rDPIY = sForceDPI.toInt32();
 702         return;
 703     }
 704
 705     if (!m_pFrame)
 706         return;
 707
 708 #if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
 709     QScreen* pScreen = m_pFrame->GetQWidget()->screen();
 710 #else
 711     if (!m_pFrame->GetQWidget()->window()->windowHandle())
 712         return;
 713
 714     QScreen* pScreen = m_pFrame->GetQWidget()->window()->windowHandle()->screen();
 715 #endif
 716     rDPIX = pScreen->logicalDotsPerInchX() * pScreen->devicePixelRatio() + 0.5;
 717     rDPIY = pScreen->logicalDotsPerInchY() * pScreen->devicePixelRatio() + 0.5;
 718 }
 719
 720 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */