| /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ |
| /* |
| * This file is part of the Collabora Office project. |
| * |
| * This Source Code Form is subject to the terms of the Mozilla Public |
| * License, v. 2.0. If a copy of the MPL was not distributed with this |
| * file, You can obtain one at http://mozilla.org/MPL/2.0/. |
| * |
| * This file incorporates work covered by the following license notice: |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed |
| * with this work for additional information regarding copyright |
| * ownership. The ASF licenses this file to you under the Apache |
| * License, Version 2.0 (the "License"); you may not use this file |
| * except in compliance with the License. You may obtain a copy of |
| * the License at http://www.apache.org/licenses/LICENSE-2.0 . |
| */ |
| |
| #include <headless/SvpGraphicsBackend.hxx> |
| |
| SvpGraphicsBackend::SvpGraphicsBackend(CairoCommon& rCairoCommon) |
| : m_rCairoCommon(rCairoCommon) |
| { |
| } |
| |
| void SvpGraphicsBackend::setClipRegion(const vcl::Region& i_rClip) |
| { |
| m_rCairoCommon.m_aClipRegion = i_rClip; |
| } |
| |
| void SvpGraphicsBackend::ResetClipRegion() { m_rCairoCommon.m_aClipRegion.SetNull(); } |
| |
| sal_uInt16 SvpGraphicsBackend::GetBitCount() const { return m_rCairoCommon.GetBitCount(); } |
| |
| tools::Long SvpGraphicsBackend::GetGraphicsWidth() const |
| { |
| return m_rCairoCommon.m_pSurface ? m_rCairoCommon.m_aFrameSize.getX() : 0; |
| } |
| |
| void SvpGraphicsBackend::SetLineColor() { m_rCairoCommon.m_oLineColor = std::nullopt; } |
| |
| void SvpGraphicsBackend::SetLineColor(Color nColor) { m_rCairoCommon.m_oLineColor = nColor; } |
| |
| void SvpGraphicsBackend::SetFillColor() { m_rCairoCommon.m_oFillColor = std::nullopt; } |
| |
| void SvpGraphicsBackend::SetFillColor(Color nColor) { m_rCairoCommon.m_oFillColor = nColor; } |
| |
| void SvpGraphicsBackend::SetXORMode(bool bSet, bool bInvertOnly) |
| { |
| m_rCairoCommon.SetXORMode(bSet, bInvertOnly); |
| } |
| |
| void SvpGraphicsBackend::SetROPLineColor(SalROPColor nROPColor) |
| { |
| m_rCairoCommon.SetROPLineColor(nROPColor); |
| } |
| |
| void SvpGraphicsBackend::SetROPFillColor(SalROPColor nROPColor) |
| { |
| m_rCairoCommon.SetROPFillColor(nROPColor); |
| } |
| |
| void SvpGraphicsBackend::drawPixel(tools::Long nX, tools::Long nY) |
| { |
| m_rCairoCommon.drawPixel(m_rCairoCommon.m_oLineColor, nX, nY, getAntiAlias()); |
| } |
| |
| void SvpGraphicsBackend::drawPixel(tools::Long nX, tools::Long nY, Color aColor) |
| { |
| m_rCairoCommon.drawPixel(aColor, nX, nY, getAntiAlias()); |
| } |
| |
| void SvpGraphicsBackend::drawLine(tools::Long nX1, tools::Long nY1, tools::Long nX2, |
| tools::Long nY2) |
| { |
| m_rCairoCommon.drawLine(nX1, nY1, nX2, nY2, getAntiAlias()); |
| } |
| |
| void SvpGraphicsBackend::drawRect(tools::Long nX, tools::Long nY, tools::Long nWidth, |
| tools::Long nHeight) |
| { |
| m_rCairoCommon.drawRect(nX, nY, nWidth, nHeight, getAntiAlias()); |
| } |
| |
| void SvpGraphicsBackend::drawPolyLine(sal_uInt32 nPoints, const Point* pPtAry) |
| { |
| m_rCairoCommon.drawPolyLine(nPoints, pPtAry, getAntiAlias()); |
| } |
| |
| void SvpGraphicsBackend::drawPolygon(sal_uInt32 nPoints, const Point* pPtAry) |
| { |
| m_rCairoCommon.drawPolygon(nPoints, pPtAry, getAntiAlias()); |
| } |
| |
| void SvpGraphicsBackend::drawPolyPolygon(sal_uInt32 nPoly, const sal_uInt32* pPointCounts, |
| const Point** pPtAry) |
| { |
| m_rCairoCommon.drawPolyPolygon(nPoly, pPointCounts, pPtAry, getAntiAlias()); |
| } |
| |
| void SvpGraphicsBackend::drawPolyPolygon(const basegfx::B2DHomMatrix& rObjectToDevice, |
| const basegfx::B2DPolyPolygon& rPolyPolygon, |
| double fTransparency) |
| { |
| m_rCairoCommon.drawPolyPolygon(rObjectToDevice, rPolyPolygon, fTransparency, getAntiAlias()); |
| } |
| |
| bool SvpGraphicsBackend::drawPolyLine(const basegfx::B2DHomMatrix& rObjectToDevice, |
| const basegfx::B2DPolygon& rPolyLine, double fTransparency, |
| double fLineWidth, const std::vector<double>* pStroke, |
| basegfx::B2DLineJoin eLineJoin, |
| css::drawing::LineCap eLineCap, double fMiterMinimumAngle, |
| bool bPixelSnapHairline) |
| { |
| return m_rCairoCommon.drawPolyLine(rObjectToDevice, rPolyLine, fTransparency, fLineWidth, |
| pStroke, eLineJoin, eLineCap, fMiterMinimumAngle, |
| bPixelSnapHairline, getAntiAlias()); |
| } |
| |
| bool SvpGraphicsBackend::drawPolyLineBezier(sal_uInt32, const Point*, const PolyFlags*) |
| { |
| SAL_INFO("vcl.gdi", "unsupported SvpSalGraphics::drawPolyLineBezier case"); |
| return false; |
| } |
| |
| bool SvpGraphicsBackend::drawPolygonBezier(sal_uInt32, const Point*, const PolyFlags*) |
| { |
| SAL_INFO("vcl.gdi", "unsupported SvpSalGraphics::drawPolygonBezier case"); |
| return false; |
| } |
| |
| bool SvpGraphicsBackend::drawPolyPolygonBezier(sal_uInt32, const sal_uInt32*, const Point* const*, |
| const PolyFlags* const*) |
| { |
| SAL_INFO("vcl.gdi", "unsupported SvpSalGraphics::drawPolyPolygonBezier case"); |
| return false; |
| } |
| |
| void SvpGraphicsBackend::copyArea(tools::Long nDestX, tools::Long nDestY, tools::Long nSrcX, |
| tools::Long nSrcY, tools::Long nSrcWidth, tools::Long nSrcHeight, |
| bool /*bWindowInvalidate*/) |
| { |
| SalTwoRect aTR(nSrcX, nSrcY, nSrcWidth, nSrcHeight, nDestX, nDestY, nSrcWidth, nSrcHeight); |
| |
| cairo_surface_t* source = m_rCairoCommon.m_pSurface; |
| m_rCairoCommon.copyBitsCairo(aTR, source, getAntiAlias()); |
| } |
| |
| void SvpGraphicsBackend::copyBits(const SalTwoRect& rTR, SalGraphics* pSrcGraphics) |
| { |
| cairo_surface_t* source = nullptr; |
| |
| if (pSrcGraphics) |
| { |
| SvpGraphicsBackend* pSrc = static_cast<SvpGraphicsBackend*>(pSrcGraphics->GetImpl()); |
| source = pSrc->m_rCairoCommon.m_pSurface; |
| } |
| else |
| { |
| source = m_rCairoCommon.m_pSurface; |
| } |
| |
| m_rCairoCommon.copyBitsCairo(rTR, source, getAntiAlias()); |
| } |
| |
| void SvpGraphicsBackend::drawBitmap(const SalTwoRect& rPosAry, const SalBitmap& rSalBitmap) |
| { |
| m_rCairoCommon.drawBitmap(rPosAry, rSalBitmap, getAntiAlias()); |
| } |
| |
| void SvpGraphicsBackend::drawMask(const SalTwoRect& rTR, const SalBitmap& rSalBitmap, |
| Color nMaskColor) |
| { |
| m_rCairoCommon.drawMask(rTR, rSalBitmap, nMaskColor, getAntiAlias()); |
| } |
| |
| std::shared_ptr<SalBitmap> SvpGraphicsBackend::getBitmap(tools::Long nX, tools::Long nY, |
| tools::Long nWidth, tools::Long nHeight, |
| bool bWithoutAlpha) |
| { |
| return m_rCairoCommon.getBitmap(nX, nY, nWidth, nHeight, bWithoutAlpha); |
| } |
| |
| void SvpGraphicsBackend::drawBitmapBuffer(const SalTwoRect& rTR, const BitmapBuffer* pBuffer, |
| cairo_operator_t eOp) |
| { |
| cairo_surface_t* source = CairoCommon::createCairoSurface(pBuffer); |
| m_rCairoCommon.copyWithOperator(rTR, source, eOp, getAntiAlias()); |
| cairo_surface_destroy(source); |
| } |
| |
| Color SvpGraphicsBackend::getPixel(tools::Long nX, tools::Long nY) |
| { |
| return CairoCommon::getPixel(m_rCairoCommon.m_pSurface, nX, nY); |
| } |
| |
| void SvpGraphicsBackend::invert(tools::Long nX, tools::Long nY, tools::Long nWidth, |
| tools::Long nHeight, SalInvert nFlags) |
| { |
| m_rCairoCommon.invert(nX, nY, nWidth, nHeight, nFlags, getAntiAlias()); |
| } |
| |
| void SvpGraphicsBackend::invert(sal_uInt32 nPoints, const Point* pPtAry, SalInvert nFlags) |
| { |
| m_rCairoCommon.invert(nPoints, pPtAry, nFlags, getAntiAlias()); |
| } |
| |
| void SvpGraphicsBackend::drawAlphaBitmap(const SalTwoRect& rTR, const SalBitmap& rSourceBitmap) |
| { |
| m_rCairoCommon.drawAlphaBitmap(rTR, rSourceBitmap, getAntiAlias()); |
| } |
| |
| bool SvpGraphicsBackend::drawTransformedBitmap(const basegfx::B2DPoint& rNull, |
| const basegfx::B2DPoint& rX, |
| const basegfx::B2DPoint& rY, |
| const SalBitmap& rSourceBitmap, double fAlpha) |
| { |
| return m_rCairoCommon.drawTransformedBitmap(rNull, rX, rY, rSourceBitmap, fAlpha, |
| getAntiAlias()); |
| } |
| |
| bool SvpGraphicsBackend::drawAlphaRect(tools::Long nX, tools::Long nY, tools::Long nWidth, |
| tools::Long nHeight, sal_uInt8 nTransparency) |
| { |
| return m_rCairoCommon.drawAlphaRect(nX, nY, nWidth, nHeight, nTransparency, getAntiAlias()); |
| } |
| |
| bool SvpGraphicsBackend::drawGradient(const tools::PolyPolygon& rPolyPolygon, |
| const Gradient& rGradient) |
| { |
| return m_rCairoCommon.drawGradient(rPolyPolygon, rGradient, getAntiAlias()); |
| } |
| |
| bool SvpGraphicsBackend::implDrawGradient(basegfx::B2DPolyPolygon const& rPolyPolygon, |
| SalGradient const& rGradient) |
| { |
| return m_rCairoCommon.implDrawGradient(rPolyPolygon, rGradient, getAntiAlias()); |
| } |
| |
| bool SvpGraphicsBackend::supportsOperation(OutDevSupportType eType) const |
| { |
| return CairoCommon::supportsOperation(eType); |
| } |
| |
| /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |