/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice 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 <vcl/gradient.hxx>

#include <vcl/svapp.hxx>

#include <headless/BitmapHelper.hxx>

#include <headless/CairoCommon.hxx>

#include <vcl/cairo.hxx>

#include <vcl/CairoFormats.hxx>

#include <vcl/BitmapTools.hxx>

#include <SalGradient.hxx>

#include <tools/helpers.hxx>

#include <basegfx/utils/canvastools.hxx>

#include <basegfx/matrix/b2dhommatrixtools.hxx>

#include <basegfx/polygon/b2dpolygontools.hxx>

#include <basegfx/range/b2irange.hxx>

#include <comphelper/configuration.hxx>

#include <sal/log.hxx>

#include <osl/module.h>

#include <com/sun/star/awt/GradientStyle.hpp>

#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 12, 0)

#error "require at least cairo 1.12.0"

#endif

void dl_cairo_surface_set_device_scale(cairo_surface_t* surface, double x_scale, double y_scale)

{

#if !HAVE_DLAPI || !defined(SYSTEM_CAIRO)

    cairo_surface_set_device_scale(surface, x_scale, y_scale);

#else

    static auto func = reinterpret_cast<void (*)(cairo_surface_t*, double, double)>(

        osl_getAsciiFunctionSymbol(nullptr, "cairo_surface_set_device_scale"));

    if (func)

        func(surface, x_scale, y_scale);

#endif

}

void dl_cairo_surface_get_device_scale(cairo_surface_t* surface, double* x_scale, double* y_scale)

{

#if !HAVE_DLAPI || !defined(SYSTEM_CAIRO)

    cairo_surface_get_device_scale(surface, x_scale, y_scale);

#else

    static auto func = reinterpret_cast<void (*)(cairo_surface_t*, double*, double*)>(

        osl_getAsciiFunctionSymbol(nullptr, "cairo_surface_get_device_scale"));

    if (func)

        func(surface, x_scale, y_scale);

    else

    {

        if (x_scale)

            *x_scale = 1.0;

        if (y_scale)

            *y_scale = 1.0;

    }

#endif

}

basegfx::B2DRange getFillDamage(cairo_t* cr)

{

    double x1, y1, x2, y2;

    // this is faster than cairo_fill_extents, at the cost of some overdraw

    cairo_path_extents(cr, &x1, &y1, &x2, &y2);

    // support B2DRange::isEmpty()

    if (0.0 != x1 || 0.0 != y1 || 0.0 != x2 || 0.0 != y2)

    {

        return basegfx::B2DRange(x1, y1, x2, y2);

    }

    return basegfx::B2DRange();

}

basegfx::B2DRange getClipBox(cairo_t* cr)

{

    double x1, y1, x2, y2;

    cairo_clip_extents(cr, &x1, &y1, &x2, &y2);

    // support B2DRange::isEmpty()

    if (0.0 != x1 || 0.0 != y1 || 0.0 != x2 || 0.0 != y2)

    {

        return basegfx::B2DRange(x1, y1, x2, y2);

    }

    return basegfx::B2DRange();

}

basegfx::B2DRange getClippedFillDamage(cairo_t* cr)

{

    basegfx::B2DRange aDamageRect(getFillDamage(cr));

    aDamageRect.intersect(getClipBox(cr));

    return aDamageRect;

}

basegfx::B2DRange getStrokeDamage(cairo_t* cr)

{

    double x1, y1, x2, y2;

    // less accurate, but much faster

    cairo_path_extents(cr, &x1, &y1, &x2, &y2);

    // support B2DRange::isEmpty()

    if (0.0 != x1 || 0.0 != y1 || 0.0 != x2 || 0.0 != y2)

    {

        return basegfx::B2DRange(x1, y1, x2, y2);

    }

    return basegfx::B2DRange();

}

basegfx::B2DRange getClippedStrokeDamage(cairo_t* cr)

{

    basegfx::B2DRange aDamageRect(getStrokeDamage(cr));

    aDamageRect.intersect(getClipBox(cr));

    return aDamageRect;

}

// Remove bClosePath: Checked that the already used mechanism for Win using

// Gdiplus already relies on rPolygon.isClosed(), so should be safe to replace

// this.

// For PixelSnap we need the ObjectToDevice transformation here now. This is a

// special case relative to the also executed LineDraw-Offset of (0.5, 0.5) in

// DeviceCoordinates: The LineDraw-Offset is applied *after* the snap, so we

// need the ObjectToDevice transformation *without* that offset here to do the

// same. The LineDraw-Offset will be applied by the callers using a linear

// transformation for Cairo now

// For support of PixelSnapHairline we also need the ObjectToDevice transformation

// and a method (same as in gdiimpl.cxx for Win and Gdiplus). This is needed e.g.

// for Chart-content visualization. CAUTION: It's not the same as PixelSnap (!)

// tdf#129845 add reply value to allow counting a point/byte/size measurement to

// be included

static size_t AddPolygonToPath(cairo_t* cr, const basegfx::B2DPolygon& rPolygon,

                               const basegfx::B2DHomMatrix& rObjectToDevice, bool bPixelSnap,

                               bool bPixelSnapHairline)

{

    // short circuit if there is nothing to do

    const sal_uInt32 nPointCount(rPolygon.count());

    size_t nSizeMeasure(0);

    if (0 == nPointCount)

    {

        return nSizeMeasure;

    }

    const bool bHasCurves(rPolygon.areControlPointsUsed());

    const bool bClosePath(rPolygon.isClosed());

    const bool bObjectToDeviceUsed(!rObjectToDevice.isIdentity());

    basegfx::B2DHomMatrix aObjectToDeviceInv;

    basegfx::B2DPoint aLast;

    PixelSnapper aSnapper;

    for (sal_uInt32 nPointIdx = 0, nPrevIdx = 0;; nPrevIdx = nPointIdx++)

    {

        int nClosedIdx = nPointIdx;

        if (nPointIdx >= nPointCount)

        {

            // prepare to close last curve segment if needed

            if (bClosePath && (nPointIdx == nPointCount))

            {

                nClosedIdx = 0;

            }

            else

            {

                break;

            }

        }

        basegfx::B2DPoint aPoint(rPolygon.getB2DPoint(nClosedIdx));

        if (bPixelSnap)

        {

            // snap device coordinates to full pixels

            if (bObjectToDeviceUsed)

            {

                // go to DeviceCoordinates

                aPoint *= rObjectToDevice;

            }

            // snap by rounding

            aPoint.setX(basegfx::fround(aPoint.getX()));

            aPoint.setY(basegfx::fround(aPoint.getY()));

            if (bObjectToDeviceUsed)

            {

                if (aObjectToDeviceInv.isIdentity())

                {

                    aObjectToDeviceInv = rObjectToDevice;

                    aObjectToDeviceInv.invert();

                }

                // go back to ObjectCoordinates

                aPoint *= aObjectToDeviceInv;

            }

        }

        if (bPixelSnapHairline)

        {

            // snap horizontal and vertical lines (mainly used in Chart for

            // 'nicer' AAing)

            aPoint = aSnapper.snap(rPolygon, rObjectToDevice, aObjectToDeviceInv, nClosedIdx);

        }

        if (!nPointIdx)

        {

            // first point => just move there

            cairo_move_to(cr, aPoint.getX(), aPoint.getY());

            aLast = aPoint;

            continue;

        }

        bool bPendingCurve(false);

        if (bHasCurves)

        {

            bPendingCurve = rPolygon.isNextControlPointUsed(nPrevIdx);

            bPendingCurve |= rPolygon.isPrevControlPointUsed(nClosedIdx);

        }

        if (!bPendingCurve) // line segment

        {

            cairo_line_to(cr, aPoint.getX(), aPoint.getY());

            nSizeMeasure++;

        }

        else // cubic bezier segment

        {

            basegfx::B2DPoint aCP1 = rPolygon.getNextControlPoint(nPrevIdx);

            basegfx::B2DPoint aCP2 = rPolygon.getPrevControlPoint(nClosedIdx);

            // tdf#99165 if the control points are 'empty', create the mathematical

            // correct replacement ones to avoid problems with the graphical sub-system

            // tdf#101026 The 1st attempt to create a mathematically correct replacement control

            // vector was wrong. Best alternative is one as close as possible which means short.

            if (aCP1.equal(aLast))

            {

                aCP1 = aLast + ((aCP2 - aLast) * 0.0005);

            }

            if (aCP2.equal(aPoint))

            {

                aCP2 = aPoint + ((aCP1 - aPoint) * 0.0005);

            }

            cairo_curve_to(cr, aCP1.getX(), aCP1.getY(), aCP2.getX(), aCP2.getY(), aPoint.getX(),

                           aPoint.getY());

            // take some bigger measure for curve segments - too expensive to subdivide

            // here and that precision not needed, but four (2 points, 2 control-points)

            // would be a too low weight

            nSizeMeasure += 10;

        }

        aLast = aPoint;

    }

    if (bClosePath)

    {

        cairo_close_path(cr);

    }

    return nSizeMeasure;

}

basegfx::B2DPoint PixelSnapper::snap(const basegfx::B2DPolygon& rPolygon,

                                     const basegfx::B2DHomMatrix& rObjectToDevice,

                                     basegfx::B2DHomMatrix& rObjectToDeviceInv, sal_uInt32 nIndex)

{

    const sal_uInt32 nCount(rPolygon.count());

    // get the data

    if (nIndex == 0)

    {

        // if it's the first time, we need to calculate everything

        maPrevPoint = rObjectToDevice * rPolygon.getB2DPoint((nIndex + nCount - 1) % nCount);

        maCurrPoint = rObjectToDevice * rPolygon.getB2DPoint(nIndex);

        maPrevTuple = basegfx::fround(maPrevPoint);

        maCurrTuple = basegfx::fround(maCurrPoint);

    }

    else

    {

        // but for all other times, we can re-use the previous iteration computations

        maPrevPoint = maCurrPoint;

        maPrevTuple = maCurrTuple;

        maCurrPoint = maNextPoint;

        maCurrTuple = maNextTuple;

    }

    maNextPoint = rObjectToDevice * rPolygon.getB2DPoint((nIndex + 1) % nCount);

    maNextTuple = basegfx::fround(maNextPoint);

    // get the states

    const bool bPrevVertical(maPrevTuple.getX() == maCurrTuple.getX());

    const bool bNextVertical(maNextTuple.getX() == maCurrTuple.getX());

    const bool bPrevHorizontal(maPrevTuple.getY() == maCurrTuple.getY());

    const bool bNextHorizontal(maNextTuple.getY() == maCurrTuple.getY());

    const bool bSnapX(bPrevVertical || bNextVertical);

    const bool bSnapY(bPrevHorizontal || bNextHorizontal);

    if (bSnapX || bSnapY)

    {

        basegfx::B2DPoint aSnappedPoint(bSnapX ? maCurrTuple.getX() : maCurrPoint.getX(),

                                        bSnapY ? maCurrTuple.getY() : maCurrPoint.getY());

        if (rObjectToDeviceInv.isIdentity())

        {

            rObjectToDeviceInv = rObjectToDevice;

            rObjectToDeviceInv.invert();

        }

        aSnappedPoint *= rObjectToDeviceInv;

        return aSnappedPoint;

    }

    return rPolygon.getB2DPoint(nIndex);

}

SystemDependentData_CairoPath::SystemDependentData_CairoPath(size_t nSizeMeasure, cairo_t* cr,

                                                             bool bNoJoin, bool bAntiAlias,

                                                             const std::vector<double>* pStroke)

    : basegfx::SystemDependentData(Application::GetSystemDependentDataManager(),

                                   basegfx::SDD_Type::SDDType_CairoPath)

    , mpCairoPath(nullptr)

    , mbNoJoin(bNoJoin)

    , mbAntiAlias(bAntiAlias)

{

    static const bool bFuzzing = comphelper::IsFuzzing();

    // tdf#129845 only create a copy of the path when nSizeMeasure is

    // bigger than some decent threshold

    if (!bFuzzing && nSizeMeasure > 50)

    {

        mpCairoPath = cairo_copy_path(cr);

        if (nullptr != pStroke)

        {

            maStroke = *pStroke;

        }

    }

}

SystemDependentData_CairoPath::~SystemDependentData_CairoPath()

{

    if (nullptr != mpCairoPath)

    {

        cairo_path_destroy(mpCairoPath);

        mpCairoPath = nullptr;

    }

}

sal_Int64 SystemDependentData_CairoPath::estimateUsageInBytes() const

{

    // tdf#129845 by using the default return value of zero when no path

    // was created, SystemDependentData::calculateCombinedHoldCyclesInSeconds

    // will do the right thing and not buffer this entry at all

    sal_Int64 nRetval(0);

    if (nullptr != mpCairoPath)

    {

        // per node

        // - num_data incarnations of

        // - sizeof(cairo_path_data_t) which is a union of defines and point data

        //   thus may 2 x sizeof(double)

        nRetval = mpCairoPath->num_data * sizeof(cairo_path_data_t);

    }

    return nRetval;

}

void add_polygon_path(cairo_t* cr, const basegfx::B2DPolyPolygon& rPolyPolygon,

                      const basegfx::B2DHomMatrix& rObjectToDevice, bool bPixelSnap)

{

    // try to access buffered data

    std::shared_ptr<SystemDependentData_CairoPath> pSystemDependentData_CairoPath(

        rPolyPolygon.getSystemDependentData<SystemDependentData_CairoPath>(

            basegfx::SDD_Type::SDDType_CairoPath));

    if (pSystemDependentData_CairoPath)

    {

        // re-use data

        cairo_append_path(cr, pSystemDependentData_CairoPath->getCairoPath());

    }

    else

    {

        // create data

        size_t nSizeMeasure(0);

        for (const auto& rPoly : rPolyPolygon)

        {

            // PixelOffset used: Was dependent of 'm_aLineColor != SALCOLOR_NONE'

            // Adapt setupPolyPolygon-users to set a linear transformation to achieve PixelOffset

            nSizeMeasure += AddPolygonToPath(cr, rPoly, rObjectToDevice, bPixelSnap, false);

        }

        // copy and add to buffering mechanism

        // for decisions how/what to buffer, see Note in WinSalGraphicsImpl::drawPolyPolygon

        pSystemDependentData_CairoPath

            = rPolyPolygon.addOrReplaceSystemDependentData<SystemDependentData_CairoPath>(

                nSizeMeasure, cr, false, false, nullptr);

    }

}

cairo_user_data_key_t* CairoCommon::getDamageKey()

{

    static cairo_user_data_key_t aDamageKey;

    return &aDamageKey;

}

sal_uInt16 CairoCommon::GetBitCount() const

{

    if (cairo_surface_get_content(m_pSurface) == CAIRO_CONTENT_ALPHA)

        return 1;

    return 32;

}

cairo_t* CairoCommon::getCairoContext(bool bXorModeAllowed, bool bAntiAlias) const

{

    cairo_t* cr;

    if (m_ePaintMode == PaintMode::Xor && bXorModeAllowed)

        cr = createTmpCompatibleCairoContext();

    else

        cr = cairo_create(m_pSurface);

    cairo_set_line_width(cr, 1);

    cairo_set_fill_rule(cr, CAIRO_FILL_RULE_EVEN_ODD);

    cairo_set_antialias(cr, bAntiAlias ? CAIRO_ANTIALIAS_DEFAULT : CAIRO_ANTIALIAS_NONE);

    cairo_set_operator(cr, CAIRO_OPERATOR_OVER);

    // ensure no linear transformation and no PathInfo in local cairo_path_t

    cairo_identity_matrix(cr);

    cairo_new_path(cr);

    return cr;

}

void CairoCommon::releaseCairoContext(cairo_t* cr, bool bXorModeAllowed,

                                      const basegfx::B2DRange& rExtents) const

{

    const bool bXoring = (m_ePaintMode == PaintMode::Xor && bXorModeAllowed);

    if (rExtents.isEmpty())

    {

        //nothing changed, return early

        if (bXoring)

        {

            cairo_surface_t* surface = cairo_get_target(cr);

            cairo_surface_destroy(surface);

        }

        cairo_destroy(cr);

        return;

    }

    basegfx::B2IRange aIntExtents(basegfx::unotools::b2ISurroundingRangeFromB2DRange(rExtents));

    sal_Int32 nExtentsLeft(aIntExtents.getMinX()), nExtentsTop(aIntExtents.getMinY());

    sal_Int32 nExtentsRight(aIntExtents.getMaxX()), nExtentsBottom(aIntExtents.getMaxY());

    sal_Int32 nWidth = m_aFrameSize.getX();

    sal_Int32 nHeight = m_aFrameSize.getY();

    nExtentsLeft = std::max<sal_Int32>(nExtentsLeft, 0);

    nExtentsTop = std::max<sal_Int32>(nExtentsTop, 0);

    nExtentsRight = std::min<sal_Int32>(nExtentsRight, nWidth);

    nExtentsBottom = std::min<sal_Int32>(nExtentsBottom, nHeight);

    cairo_surface_t* surface = cairo_get_target(cr);

    cairo_surface_flush(surface);

    //For the most part we avoid the use of XOR these days, but there

    //are some edge cases where legacy stuff still supports it, so

    //emulate it (slowly) here.

    if (bXoring)

        doXorOnRelease(nExtentsLeft, nExtentsTop, nExtentsRight, nExtentsBottom, surface, nWidth);

    cairo_destroy(cr); // unref

    DamageHandler* pDamage

        = static_cast<DamageHandler*>(cairo_surface_get_user_data(m_pSurface, getDamageKey()));

    if (pDamage)

    {

        pDamage->damaged(pDamage->handle, nExtentsLeft, nExtentsTop, nExtentsRight - nExtentsLeft,

                         nExtentsBottom - nExtentsTop);

    }

}

void CairoCommon::applyFullDamage() const

{

    if (nullptr == m_pSurface)

        return;

    DamageHandler* pDamage

        = static_cast<DamageHandler*>(cairo_surface_get_user_data(m_pSurface, getDamageKey()));

    if (nullptr == pDamage)

        return;

    pDamage->damaged(pDamage->handle, 0, 0, m_aFrameSize.getX(), m_aFrameSize.getY());

}

void CairoCommon::doXorOnRelease(sal_Int32 nExtentsLeft, sal_Int32 nExtentsTop,

                                 sal_Int32 nExtentsRight, sal_Int32 nExtentsBottom,

                                 cairo_surface_t* const surface, sal_Int32 nWidth) const

{

    //For the most part we avoid the use of XOR these days, but there

    //are some edge cases where legacy stuff still supports it, so

    //emulate it (slowly) here.

    cairo_surface_t* target_surface = m_pSurface;

    if (cairo_surface_get_type(target_surface) != CAIRO_SURFACE_TYPE_IMAGE)

    {

        //in the unlikely case we can't use m_pSurface directly, copy contents

        //to another temp image surface

        if (cairo_surface_get_content(m_pSurface) == CAIRO_CONTENT_COLOR_ALPHA)

            target_surface = cairo_surface_map_to_image(target_surface, nullptr);

        else

        {

            // for gen, which is CAIRO_FORMAT_RGB24/CAIRO_CONTENT_COLOR I'm getting

            // visual corruption in vcldemo with cairo_surface_map_to_image

            cairo_t* copycr = createTmpCompatibleCairoContext();

            cairo_rectangle(copycr, nExtentsLeft, nExtentsTop, nExtentsRight - nExtentsLeft,

                            nExtentsBottom - nExtentsTop);

            cairo_set_source_surface(copycr, m_pSurface, 0, 0);

            cairo_fill(copycr);

            target_surface = cairo_get_target(copycr);

            cairo_destroy(copycr);

        }

    }

    cairo_surface_flush(target_surface);

    unsigned char* target_surface_data = cairo_image_surface_get_data(target_surface);

    unsigned char* xor_surface_data = cairo_image_surface_get_data(surface);

    cairo_format_t nFormat = cairo_image_surface_get_format(target_surface);

    assert(nFormat == CAIRO_FORMAT_ARGB32 && "need to implement CAIRO_FORMAT_A1 after all here");

    sal_Int32 nStride = cairo_format_stride_for_width(nFormat, nWidth * m_fScale);

    sal_Int32 nUnscaledExtentsLeft = nExtentsLeft * m_fScale;

    sal_Int32 nUnscaledExtentsRight = nExtentsRight * m_fScale;

    sal_Int32 nUnscaledExtentsTop = nExtentsTop * m_fScale;

    sal_Int32 nUnscaledExtentsBottom = nExtentsBottom * m_fScale;

    // Handle headless size forced to (1,1) by SvpSalFrame::GetSurfaceFrameSize().

    int target_surface_width = cairo_image_surface_get_width(target_surface);

    if (nUnscaledExtentsLeft > target_surface_width)

        nUnscaledExtentsLeft = target_surface_width;

    if (nUnscaledExtentsRight > target_surface_width)

        nUnscaledExtentsRight = target_surface_width;

    int target_surface_height = cairo_image_surface_get_height(target_surface);

    if (nUnscaledExtentsTop > target_surface_height)

        nUnscaledExtentsTop = target_surface_height;

    if (nUnscaledExtentsBottom > target_surface_height)

        nUnscaledExtentsBottom = target_surface_height;

#if !ENABLE_WASM_STRIP_PREMULTIPLY

    vcl::bitmap::lookup_table const& unpremultiply_table = vcl::bitmap::get_unpremultiply_table();

    vcl::bitmap::lookup_table const& premultiply_table = vcl::bitmap::get_premultiply_table();

#endif

    for (sal_Int32 y = nUnscaledExtentsTop; y < nUnscaledExtentsBottom; ++y)

    {

        unsigned char* true_row = target_surface_data + (nStride * y);

        unsigned char* xor_row = xor_surface_data + (nStride * y);

        unsigned char* true_data = true_row + (nUnscaledExtentsLeft * 4);

        unsigned char* xor_data = xor_row + (nUnscaledExtentsLeft * 4);

        for (sal_Int32 x = nUnscaledExtentsLeft; x < nUnscaledExtentsRight; ++x)

        {

            sal_uInt8 a = true_data[SVP_CAIRO_ALPHA];

            sal_uInt8 xor_a = xor_data[SVP_CAIRO_ALPHA];

#if ENABLE_WASM_STRIP_PREMULTIPLY

            sal_uInt8 b = vcl::bitmap::unpremultiply(true_data[SVP_CAIRO_BLUE], a)

                          ^ vcl::bitmap::unpremultiply(xor_data[SVP_CAIRO_BLUE], xor_a);

            sal_uInt8 g = vcl::bitmap::unpremultiply(true_data[SVP_CAIRO_GREEN], a)

                          ^ vcl::bitmap::unpremultiply(xor_data[SVP_CAIRO_GREEN], xor_a);

            sal_uInt8 r = vcl::bitmap::unpremultiply(true_data[SVP_CAIRO_RED], a)

                          ^ vcl::bitmap::unpremultiply(xor_data[SVP_CAIRO_RED], xor_a);

            true_data[SVP_CAIRO_BLUE] = vcl::bitmap::premultiply(b, a);

            true_data[SVP_CAIRO_GREEN] = vcl::bitmap::premultiply(g, a);

            true_data[SVP_CAIRO_RED] = vcl::bitmap::premultiply(r, a);

#else

            sal_uInt8 b = unpremultiply_table[a][true_data[SVP_CAIRO_BLUE]]

                          ^ unpremultiply_table[xor_a][xor_data[SVP_CAIRO_BLUE]];

            sal_uInt8 g = unpremultiply_table[a][true_data[SVP_CAIRO_GREEN]]

                          ^ unpremultiply_table[xor_a][xor_data[SVP_CAIRO_GREEN]];

            sal_uInt8 r = unpremultiply_table[a][true_data[SVP_CAIRO_RED]]

                          ^ unpremultiply_table[xor_a][xor_data[SVP_CAIRO_RED]];

            true_data[SVP_CAIRO_BLUE] = premultiply_table[a][b];

            true_data[SVP_CAIRO_GREEN] = premultiply_table[a][g];

            true_data[SVP_CAIRO_RED] = premultiply_table[a][r];

#endif

            true_data += 4;

            xor_data += 4;

        }

    }

    cairo_surface_mark_dirty(target_surface);

    if (target_surface != m_pSurface)

    {

        if (cairo_surface_get_content(m_pSurface) == CAIRO_CONTENT_COLOR_ALPHA)

            cairo_surface_unmap_image(m_pSurface, target_surface);

        else

        {

            cairo_t* copycr = cairo_create(m_pSurface);

            //copy contents back from image surface

            cairo_rectangle(copycr, nExtentsLeft, nExtentsTop, nExtentsRight - nExtentsLeft,

                            nExtentsBottom - nExtentsTop);

            cairo_set_source_surface(copycr, target_surface, 0, 0);

            cairo_fill(copycr);

            cairo_destroy(copycr);

            cairo_surface_destroy(target_surface);

        }

    }

    cairo_surface_destroy(surface);

}

cairo_t* CairoCommon::createTmpCompatibleCairoContext() const

{

    cairo_surface_t* target = cairo_surface_create_similar_image(m_pSurface, CAIRO_FORMAT_ARGB32,

                                                                 m_aFrameSize.getX() * m_fScale,

                                                                 m_aFrameSize.getY() * m_fScale);

    dl_cairo_surface_set_device_scale(target, m_fScale, m_fScale);

    return cairo_create(target);

}

void CairoCommon::applyColor(cairo_t* cr, Color aColor, double fTransparency)

{

    if (cairo_surface_get_content(cairo_get_target(cr)) != CAIRO_CONTENT_ALPHA)

    {

        cairo_set_source_rgba(cr, aColor.GetRed() / 255.0, aColor.GetGreen() / 255.0,

                              aColor.GetBlue() / 255.0, 1.0 - fTransparency);

    }

    else

    {

        double fSet = aColor == COL_BLACK ? 1.0 : 0.0;

        cairo_set_source_rgba(cr, 1, 1, 1, fSet);

        cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);

    }

}

void CairoCommon::applyColor2(cairo_t* cr, Color aColor)

{

    cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);

    cairo_content_t eContentType = cairo_surface_get_content(cairo_get_target(cr));

    if (eContentType == CAIRO_CONTENT_COLOR_ALPHA)

    {

        cairo_set_source_rgba(cr, aColor.GetRed() / 255.0, aColor.GetGreen() / 255.0,

                              aColor.GetBlue() / 255.0, aColor.GetAlpha() / 255.0);

    }

    else if (eContentType == CAIRO_CONTENT_COLOR)

    {

        cairo_set_source_rgba(cr, aColor.GetRed() / 255.0, aColor.GetGreen() / 255.0,

                              aColor.GetBlue() / 255.0, 1.0);

    }

    else // CAIRO_CONTENT_ALPHA

    {

        double fSet = aColor == COL_BLACK ? 1.0 : 0.0;

        cairo_set_source_rgba(cr, 1, 1, 1, fSet);

    }

}

void CairoCommon::clipRegion(cairo_t* cr, const vcl::Region& rClipRegion)

{

    RectangleVector aRectangles;

    if (!rClipRegion.IsEmpty())

    {

        rClipRegion.GetRegionRectangles(aRectangles);

    }

    if (!aRectangles.empty())

    {

        bool bEmpty = true;

        for (auto const& rectangle : aRectangles)

        {

            if (rectangle.GetWidth() <= 0 || rectangle.GetHeight() <= 0)

            {

                SAL_WARN("vcl.gdi", "bad clip rect of: " << rectangle);

                continue;

            }

            cairo_rectangle(cr, rectangle.Left(), rectangle.Top(), rectangle.GetWidth(),

                            rectangle.GetHeight());

            bEmpty = false;

        }

        if (!bEmpty)

            cairo_clip(cr);

    }

}

void CairoCommon::clipRegion(cairo_t* cr) { CairoCommon::clipRegion(cr, m_aClipRegion); }

void CairoCommon::SetXORMode(bool bSet, bool /*bInvertOnly*/)

{

    m_ePaintMode = bSet ? PaintMode::Xor : PaintMode::Over;

}

void CairoCommon::SetROPLineColor(SalROPColor nROPColor)

{

    switch (nROPColor)

    {

        case SalROPColor::N0:

            m_oLineColor = Color(0, 0, 0);

            break;

        case SalROPColor::N1:

        case SalROPColor::Invert:

            m_oLineColor = Color(0xff, 0xff, 0xff);

            break;

    }

}

void CairoCommon::SetROPFillColor(SalROPColor nROPColor)

{

    switch (nROPColor)

    {

        case SalROPColor::N0:

            m_oFillColor = Color(0, 0, 0);

            break;

        case SalROPColor::N1:

        case SalROPColor::Invert:

            m_oFillColor = Color(0xff, 0xff, 0xff);

            break;

    }

}

void CairoCommon::drawPixel(const std::optional<Color>& rLineColor, tools::Long nX, tools::Long nY,

                            bool bAntiAlias)

{

    if (!rLineColor)

        return;

    cairo_t* cr = getCairoContext(true, bAntiAlias);

    clipRegion(cr);

    cairo_rectangle(cr, nX, nY, 1, 1);

    cairo_content_t eContentType = cairo_surface_get_content(cairo_get_target(cr));

    if (eContentType == CAIRO_CONTENT_COLOR_ALPHA)

    {

        cairo_set_source_rgba(cr, rLineColor->GetRed() / 255.0, rLineColor->GetGreen() / 255.0,

                              rLineColor->GetBlue() / 255.0, rLineColor->GetAlpha() / 255.0);

    }

    else if (eContentType == CAIRO_CONTENT_COLOR)

    {

        cairo_set_source_rgba(cr, rLineColor->GetRed() / 255.0, rLineColor->GetGreen() / 255.0,

                              rLineColor->GetBlue() / 255.0, 1.0);

    }

    else // eContentType == CAIRO_CONTENT_ALPHA

    {

        double fSet = *rLineColor == COL_BLACK ? 1.0 : 0.0;

        cairo_set_source_rgba(cr, 1, 1, 1, fSet);

        cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);

    }

    cairo_fill(cr);

    basegfx::B2DRange extents = getClippedFillDamage(cr);

    releaseCairoContext(cr, true, extents);

}

Color CairoCommon::getPixel(cairo_surface_t* pSurface, tools::Long nX, tools::Long nY)

{

    cairo_surface_t* target

        = cairo_surface_create_similar_image(pSurface, CAIRO_FORMAT_ARGB32, 1, 1);

    cairo_t* cr = cairo_create(target);

    cairo_rectangle(cr, 0, 0, 1, 1);

    cairo_set_source_surface(cr, pSurface, -nX, -nY);

    cairo_paint(cr);

    cairo_destroy(cr);

    cairo_surface_flush(target);

#if !ENABLE_WASM_STRIP_PREMULTIPLY

    vcl::bitmap::lookup_table const& unpremultiply_table = vcl::bitmap::get_unpremultiply_table();

#endif

    unsigned char* data = cairo_image_surface_get_data(target);

    sal_uInt8 a = data[SVP_CAIRO_ALPHA];

#if ENABLE_WASM_STRIP_PREMULTIPLY

    sal_uInt8 b = vcl::bitmap::unpremultiply(data[SVP_CAIRO_BLUE], a);

    sal_uInt8 g = vcl::bitmap::unpremultiply(data[SVP_CAIRO_GREEN], a);

    sal_uInt8 r = vcl::bitmap::unpremultiply(data[SVP_CAIRO_RED], a);

#else

    sal_uInt8 b = unpremultiply_table[a][data[SVP_CAIRO_BLUE]];

    sal_uInt8 g = unpremultiply_table[a][data[SVP_CAIRO_GREEN]];

    sal_uInt8 r = unpremultiply_table[a][data[SVP_CAIRO_RED]];

#endif

    Color aColor(ColorAlpha, a, r, g, b);

    cairo_surface_destroy(target);

    return aColor;

}

void CairoCommon::drawLine(tools::Long nX1, tools::Long nY1, tools::Long nX2, tools::Long nY2,

                           bool bAntiAlias)

{

    cairo_t* cr = getCairoContext(false, bAntiAlias);

    clipRegion(cr);

    basegfx::B2DPolygon aPoly;

    // PixelOffset used: To not mix with possible PixelSnap, cannot do

    // directly on coordinates as tried before - despite being already 'snapped'

    // due to being integer. If it would be directly added here, it would be

    // 'snapped' again when !getAntiAlias(), losing the (0.5, 0.5) offset

    aPoly.append(basegfx::B2DPoint(nX1, nY1));

    aPoly.append(basegfx::B2DPoint(nX2, nY2));

    // PixelOffset used: Set PixelOffset as linear transformation

    cairo_matrix_t aMatrix;

    cairo_matrix_init_translate(&aMatrix, 0.5, 0.5);

    cairo_set_matrix(cr, &aMatrix);

    AddPolygonToPath(cr, aPoly, basegfx::B2DHomMatrix(), !bAntiAlias, false);

    CairoCommon::applyColor(cr, *m_oLineColor);

    basegfx::B2DRange extents = getClippedStrokeDamage(cr);

    extents.translate(0.5, 0.5);

    cairo_stroke(cr);

    releaseCairoContext(cr, false, extents);

}

// true if we have a fill color and the line color is the same or non-existent

static bool onlyFillRect(const std::optional<Color>& rFillColor,

                         const std::optional<Color>& rLineColor)

{

    if (!rFillColor)

        return false;

    if (!rLineColor)

        return true;

    return *rFillColor == *rLineColor;

}

void CairoCommon::drawRect(double nX, double nY, double nWidth, double nHeight, bool bAntiAlias)

{

    // fast path for the common case of simply creating a solid block of color

    if (onlyFillRect(m_oFillColor, m_oLineColor))

    {

        // don't bother trying to draw stuff which is effectively invisible

        if (nWidth < 0.1 || nHeight < 0.1)

            return;

        cairo_t* cr = getCairoContext(true, bAntiAlias);

        clipRegion(cr);

        bool bPixelSnap = !bAntiAlias;

        if (bPixelSnap)

        {

            // snap by rounding

            nX = basegfx::fround(nX);

            nY = basegfx::fround(nY);

            nWidth = basegfx::fround(nWidth);

            nHeight = basegfx::fround(nHeight);

        }

        cairo_rectangle(cr, nX, nY, nWidth, nHeight);

        CairoCommon::applyColor2(cr, *m_oFillColor);

        // Get FillDamage

        basegfx::B2DRange extents = getClippedFillDamage(cr);

        cairo_fill(cr);

        releaseCairoContext(cr, true, extents);

        return;

    }

    // because of the -1 hack we have to do fill and draw separately

    std::optional<Color> aOrigFillColor = m_oFillColor;

    std::optional<Color> aOrigLineColor = m_oLineColor;

    m_oFillColor = std::nullopt;

    m_oLineColor = std::nullopt;

    if (aOrigFillColor)

    {

        basegfx::B2DPolygon aRect = basegfx::utils::createPolygonFromRect(

            basegfx::B2DRectangle(nX, nY, nX + nWidth, nY + nHeight));

        m_oFillColor = aOrigFillColor;

        drawPolyPolygon(basegfx::B2DHomMatrix(), basegfx::B2DPolyPolygon(aRect),

                        (255 - aOrigFillColor->GetAlpha()) / 255.0, bAntiAlias);

        m_oFillColor = std::nullopt;

    }

    if (aOrigLineColor)

    {

        // need -1 hack to exclude the bottom and right edges to act like wingdi "Rectangle"

        // function which is what was probably the ultimate origin of this behavior

        basegfx::B2DPolygon aRect = basegfx::utils::createPolygonFromRect(

            basegfx::B2DRectangle(nX, nY, nX + nWidth - 1, nY + nHeight - 1));

        m_oLineColor = aOrigLineColor;

        drawPolyPolygon(basegfx::B2DHomMatrix(), basegfx::B2DPolyPolygon(aRect),

                        (255 - aOrigLineColor->GetAlpha()) / 255.0, bAntiAlias);

        m_oLineColor = std::nullopt;

    }

    m_oFillColor = aOrigFillColor;

    m_oLineColor = aOrigLineColor;

}

void CairoCommon::drawPolygon(sal_uInt32 nPoints, const Point* pPtAry, bool bAntiAlias)

{

    basegfx::B2DPolygon aPoly;

    aPoly.append(basegfx::B2DPoint(pPtAry->getX(), pPtAry->getY()), nPoints);

    for (sal_uInt32 i = 1; i < nPoints; ++i)

        aPoly.setB2DPoint(i, basegfx::B2DPoint(pPtAry[i].getX(), pPtAry[i].getY()));

    drawPolyPolygon(basegfx::B2DHomMatrix(), basegfx::B2DPolyPolygon(aPoly), 0.0, bAntiAlias);

}

void CairoCommon::drawPolyPolygon(sal_uInt32 nPoly, const sal_uInt32* pPointCounts,

                                  const Point** pPtAry, bool bAntiAlias)

{

    basegfx::B2DPolyPolygon aPolyPoly;

    for (sal_uInt32 nPolygon = 0; nPolygon < nPoly; ++nPolygon)

    {

        sal_uInt32 nPoints = pPointCounts[nPolygon];

        if (nPoints)

        {

            const Point* pPoints = pPtAry[nPolygon];

            basegfx::B2DPolygon aPoly;

            aPoly.append(basegfx::B2DPoint(pPoints->getX(), pPoints->getY()), nPoints);

            for (sal_uInt32 i = 1; i < nPoints; ++i)

                aPoly.setB2DPoint(i, basegfx::B2DPoint(pPoints[i].getX(), pPoints[i].getY()));

            aPolyPoly.append(aPoly);

        }

    }

    drawPolyPolygon(basegfx::B2DHomMatrix(), aPolyPoly, 0.0, bAntiAlias);

}

void CairoCommon::drawPolyPolygon(const basegfx::B2DHomMatrix& rObjectToDevice,

                                  const basegfx::B2DPolyPolygon& rPolyPolygon, double fTransparency,

                                  bool bAntiAlias)