/* -*- 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 "vclprocessor2d.hxx"

#include "getdigitlanguage.hxx"

#include "vclhelperbufferdevice.hxx"

#include <cmath>

#include <comphelper/lok.hxx>

#include <tools/debug.hxx>

#include <tools/fract.hxx>

#include <utility>

#include <vcl/canvastools.hxx>

#include <vcl/fntstyle.hxx>

#include <vcl/glyphitemcache.hxx>

#include <vcl/graph.hxx>

#include <vcl/kernarray.hxx>

#include <vcl/outdev.hxx>

#include <vcl/rendercontext/DrawModeFlags.hxx>

#include <sal/log.hxx>

#include <basegfx/polygon/b2dpolygontools.hxx>

#include <basegfx/polygon/b2dpolypolygontools.hxx>

#include <basegfx/polygon/b2dpolygonclipper.hxx>

#include <basegfx/color/bcolor.hxx>

#include <basegfx/matrix/b2dhommatrixtools.hxx>

#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>

#include <drawinglayer/primitive2d/textprimitive2d.hxx>

#include <drawinglayer/primitive2d/textdecoratedprimitive2d.hxx>

#include <drawinglayer/primitive2d/bitmapprimitive2d.hxx>

#include <drawinglayer/primitive2d/fillgraphicprimitive2d.hxx>

#include <drawinglayer/primitive2d/PolygonHairlinePrimitive2D.hxx>

#include <drawinglayer/primitive2d/PolygonStrokePrimitive2D.hxx>

#include <drawinglayer/primitive2d/PolyPolygonGraphicPrimitive2D.hxx>

#include <drawinglayer/primitive2d/maskprimitive2d.hxx>

#include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx>

#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>

#include <drawinglayer/primitive2d/transparenceprimitive2d.hxx>

#include <drawinglayer/primitive2d/transformprimitive2d.hxx>

#include <drawinglayer/primitive2d/markerarrayprimitive2d.hxx>

#include <drawinglayer/primitive2d/pagepreviewprimitive2d.hxx>

#include <drawinglayer/primitive2d/textenumsprimitive2d.hxx>

#include <drawinglayer/primitive2d/svggradientprimitive2d.hxx>

// control support

#include <drawinglayer/primitive2d/textlayoutdevice.hxx>

#include <drawinglayer/primitive2d/pointarrayprimitive2d.hxx>

#include <drawinglayer/primitive2d/epsprimitive2d.hxx>

using namespace com::sun::star;

namespace

{

sal_uInt32 calculateStepsForSvgGradient(const basegfx::BColor& rColorA,

                                        const basegfx::BColor& rColorB, double fDelta,

                                        double fDiscreteUnit)

{

    // use color distance, assume to do every color step

    sal_uInt32 nSteps(basegfx::fround(rColorA.getDistance(rColorB) * 255.0));

    if (nSteps)

    {

        // calc discrete length to change color each discrete unit (pixel)

        const sal_uInt32 nDistSteps(basegfx::fround(fDelta / fDiscreteUnit));

        nSteps = std::min(nSteps, nDistSteps);

    }

    // reduce quality to 3 discrete units or every 3rd color step for rendering

    nSteps /= 2;

    // roughly cut when too big or too small (not full quality, reduce complexity)

    nSteps = std::min(nSteps, sal_uInt32(255));

    nSteps = std::max(nSteps, sal_uInt32(1));

    return nSteps;

}

}

namespace

{

/** helper to convert a MapMode to a transformation */

basegfx::B2DHomMatrix getTransformFromMapMode(const MapMode& rMapMode)

{

    basegfx::B2DHomMatrix aMapping;

    const double fNoScale = 1.0;

    const Point& rOrigin(rMapMode.GetOrigin());

    if (0 != rOrigin.X() || 0 != rOrigin.Y())

    {

        aMapping.translate(rOrigin.X(), rOrigin.Y());

    }

    if (rMapMode.GetScaleX() != fNoScale || rMapMode.GetScaleY() != fNoScale)

    {

        aMapping.scale(rMapMode.GetScaleX(), rMapMode.GetScaleY());

    }

    return aMapping;

}

}

namespace drawinglayer::processor2d

{

// rendering support

// directdraw of text simple portion or decorated portion primitive. When decorated, all the extra

// information is translated to VCL parameters and set at the font.

// Acceptance is restricted to no shearing and positive scaling in X and Y (no font mirroring

// for VCL)

void VclProcessor2D::RenderTextSimpleOrDecoratedPortionPrimitive2D(

    const primitive2d::TextSimplePortionPrimitive2D& rTextCandidate)

{

    // decompose matrix to have position and size of text

    basegfx::B2DHomMatrix aLocalTransform(maCurrentTransformation

                                          * rTextCandidate.getTextTransform());

    basegfx::B2DVector aFontScaling, aTranslate;

    double fRotate, fShearX;

    aLocalTransform.decompose(aFontScaling, aTranslate, fRotate, fShearX);

    bool bPrimitiveAccepted(false);

    // tdf#95581: Assume tiny shears are rounding artefacts or whatever and can be ignored,

    // especially if the effect is less than a pixel.

    if (std::abs(aFontScaling.getY() * fShearX) < 1)

    {

        if (aFontScaling.getX() < 0.0 && aFontScaling.getY() < 0.0)

        {

            // handle special case: If scale is negative in (x,y) (3rd quadrant), it can

            // be expressed as rotation by PI. Use this since the Font rendering will not

            // apply the negative scales in any form

            aFontScaling = basegfx::absolute(aFontScaling);

            fRotate += M_PI;

        }

        if (aFontScaling.getX() > 0.0 && aFontScaling.getY() > 0.0)

        {

            double fIgnoreRotate, fIgnoreShearX;

            basegfx::B2DVector aFontSize, aTextTranslate;

            rTextCandidate.getTextTransform().decompose(aFontSize, aTextTranslate, fIgnoreRotate,

                                                        fIgnoreShearX);

            // tdf#153092 Ideally we don't have to scale the font and dxarray, but we might have

            // to nevertheless if dealing with non integer sizes

            const bool bScaleFont(aFontSize.getY() != std::round(aFontSize.getY())

                                  || comphelper::LibreOfficeKit::isActive());

            vcl::Font aFont;

            // Get the VCL font

            if (!bScaleFont)

            {

                aFont = primitive2d::getVclFontFromFontAttribute(

                    rTextCandidate.getFontAttribute(), aFontSize.getX(), aFontSize.getY(), fRotate,

                    rTextCandidate.getLocale());

            }

            else

            {

                aFont = primitive2d::getVclFontFromFontAttribute(

                    rTextCandidate.getFontAttribute(), aFontScaling.getX(), aFontScaling.getY(),

                    fRotate, rTextCandidate.getLocale());

            }

            // Don't draw fonts without height

            Size aResultFontSize = aFont.GetFontSize();

            if (aResultFontSize.Height() <= 0)

                return;

            // set FillColor Attribute

            const Color aFillColor(rTextCandidate.getTextFillColor());

            aFont.SetTransparent(aFillColor.IsTransparent());

            aFont.SetFillColor(aFillColor);

            const sal_uInt8 nProportionalFontSize(rTextCandidate.getProportionalFontSize());

            assert(nProportionalFontSize > 0);

            const bool bManualBackground(!aFillColor.IsTransparent()

                                         && nProportionalFontSize != 100);

            if (bManualBackground)

            {

                aFont.SetTransparent(true);

                aFont.SetFillColor(COL_TRANSPARENT);

            }

            // handle additional font attributes

            const primitive2d::TextDecoratedPortionPrimitive2D* pTCPP = nullptr;

            if (rTextCandidate.getPrimitive2DID() == PRIMITIVE2D_ID_TEXTDECORATEDPORTIONPRIMITIVE2D)

                pTCPP = static_cast<const primitive2d::TextDecoratedPortionPrimitive2D*>(

                    &rTextCandidate);

            if (pTCPP != nullptr)

            {

                // set the color of text decorations

                const basegfx::BColor aTextlineColor

                    = maBColorModifierStack.getModifiedColor(pTCPP->getTextlineColor());

                mpOutputDevice->SetTextLineColor(Color(aTextlineColor));

                // set Overline attribute

                const FontLineStyle eFontOverline(

                    primitive2d::mapTextLineToFontLineStyle(pTCPP->getFontOverline()));

                if (eFontOverline != LINESTYLE_NONE)

                {

                    aFont.SetOverline(eFontOverline);

                    const basegfx::BColor aOverlineColor

                        = maBColorModifierStack.getModifiedColor(pTCPP->getOverlineColor());

                    mpOutputDevice->SetOverlineColor(Color(aOverlineColor));

                    if (pTCPP->getWordLineMode())

                        aFont.SetWordLineMode(true);

                }

                // set Underline attribute

                const FontLineStyle eFontLineStyle(

                    primitive2d::mapTextLineToFontLineStyle(pTCPP->getFontUnderline()));

                if (eFontLineStyle != LINESTYLE_NONE)

                {

                    aFont.SetUnderline(eFontLineStyle);

                    if (pTCPP->getWordLineMode())

                        aFont.SetWordLineMode(true);

                }

                // set Strikeout attribute

                const FontStrikeout eFontStrikeout(

                    primitive2d::mapTextStrikeoutToFontStrikeout(pTCPP->getTextStrikeout()));

                if (eFontStrikeout != STRIKEOUT_NONE)

                    aFont.SetStrikeout(eFontStrikeout);

                // set EmphasisMark attribute

                FontEmphasisMark eFontEmphasisMark = FontEmphasisMark::NONE;

                switch (pTCPP->getTextEmphasisMark())

                {

                    default:

                        SAL_WARN("drawinglayer",

                                 "Unknown EmphasisMark style " << pTCPP->getTextEmphasisMark());

                        [[fallthrough]];

                    case primitive2d::TEXT_FONT_EMPHASIS_MARK_NONE:

                        eFontEmphasisMark = FontEmphasisMark::NONE;

                        break;

                    case primitive2d::TEXT_FONT_EMPHASIS_MARK_DOT:

                        eFontEmphasisMark = FontEmphasisMark::Dot;

                        break;

                    case primitive2d::TEXT_FONT_EMPHASIS_MARK_CIRCLE:

                        eFontEmphasisMark = FontEmphasisMark::Circle;

                        break;

                    case primitive2d::TEXT_FONT_EMPHASIS_MARK_DISC:

                        eFontEmphasisMark = FontEmphasisMark::Disc;

                        break;

                    case primitive2d::TEXT_FONT_EMPHASIS_MARK_ACCENT:

                        eFontEmphasisMark = FontEmphasisMark::Accent;

                        break;

                }

                if (eFontEmphasisMark != FontEmphasisMark::NONE)

                {

                    DBG_ASSERT((pTCPP->getEmphasisMarkAbove() != pTCPP->getEmphasisMarkBelow()),

                               "DrawingLayer: Bad EmphasisMark position!");

                    if (pTCPP->getEmphasisMarkAbove())

                        eFontEmphasisMark |= FontEmphasisMark::PosAbove;

                    else

                        eFontEmphasisMark |= FontEmphasisMark::PosBelow;

                    aFont.SetEmphasisMark(eFontEmphasisMark);

                }

                // set Relief attribute

                FontRelief eFontRelief = FontRelief::NONE;

                switch (pTCPP->getTextRelief())

                {

                    default:

                        SAL_WARN("drawinglayer", "Unknown Relief style " << pTCPP->getTextRelief());

                        [[fallthrough]];

                    case primitive2d::TEXT_RELIEF_NONE:

                        eFontRelief = FontRelief::NONE;

                        break;

                    case primitive2d::TEXT_RELIEF_EMBOSSED:

                        eFontRelief = FontRelief::Embossed;

                        break;

                    case primitive2d::TEXT_RELIEF_ENGRAVED:

                        eFontRelief = FontRelief::Engraved;

                        break;

                }

                if (eFontRelief != FontRelief::NONE)

                    aFont.SetRelief(eFontRelief);

                // set Shadow attribute

                if (pTCPP->getShadow())

                    aFont.SetShadow(true);

            }

            // create integer DXArray

            KernArray aDXArray;

            if (!rTextCandidate.getDXArray().empty())

            {

                double fPixelVectorFactor(1.0);

                if (bScaleFont)

                {

                    const basegfx::B2DVector aPixelVector(maCurrentTransformation

                                                          * basegfx::B2DVector(1.0, 0.0));

                    fPixelVectorFactor = aPixelVector.getLength();

                }

                aDXArray.reserve(rTextCandidate.getDXArray().size());

                for (auto const& elem : rTextCandidate.getDXArray())

                    aDXArray.push_back(elem * fPixelVectorFactor);

            }

            // set parameters and paint text snippet

            const basegfx::BColor aRGBFontColor(

                maBColorModifierStack.getModifiedColor(rTextCandidate.getFontColor()));

            // Store previous complex text layout state, to be restored after drawing

            const vcl::text::ComplexTextLayoutFlags nOldLayoutMode(mpOutputDevice->GetLayoutMode());

            if (rTextCandidate.getFontAttribute().getRTL())

            {

                vcl::text::ComplexTextLayoutFlags nRTLLayoutMode(

                    nOldLayoutMode & ~vcl::text::ComplexTextLayoutFlags::BiDiStrong);

                nRTLLayoutMode |= vcl::text::ComplexTextLayoutFlags::BiDiRtl

                                  | vcl::text::ComplexTextLayoutFlags::TextOriginLeft;

                mpOutputDevice->SetLayoutMode(nRTLLayoutMode);

            }

            else

            {

                // tdf#101686: This is LTR text, but the output device may have RTL state.

                vcl::text::ComplexTextLayoutFlags nLTRLayoutMode(nOldLayoutMode);

                nLTRLayoutMode = nLTRLayoutMode & ~vcl::text::ComplexTextLayoutFlags::BiDiRtl;

                nLTRLayoutMode = nLTRLayoutMode & ~vcl::text::ComplexTextLayoutFlags::BiDiStrong;

                mpOutputDevice->SetLayoutMode(nLTRLayoutMode);

            }

            Point aStartPoint;

            bool bChangeMapMode(false);

            if (!bScaleFont)

            {

                basegfx::B2DHomMatrix aCombinedTransform(

                    getTransformFromMapMode(mpOutputDevice->GetMapMode())

                    * maCurrentTransformation);

                basegfx::B2DVector aCurrentScaling, aCurrentTranslate;

                double fCurrentRotate;

                aCombinedTransform.decompose(aCurrentScaling, aCurrentTranslate, fCurrentRotate,

                                             fIgnoreShearX);

                const Point aOrigin(

                    basegfx::fround<tools::Long>(aCurrentTranslate.getX() / aCurrentScaling.getX()),

                    basegfx::fround<tools::Long>(aCurrentTranslate.getY()

                                                 / aCurrentScaling.getY()));

                double fScaleX(aCurrentScaling.getX());

                double fScaleY(aCurrentScaling.getY());

                MapMode aMapMode(mpOutputDevice->GetMapMode().GetMapUnit(), aOrigin, fScaleX,

                                 fScaleY);

                bChangeMapMode = aMapMode != mpOutputDevice->GetMapMode();

                if (bChangeMapMode)

                {

                    mpOutputDevice->Push(vcl::PushFlags::MAPMODE);

                    mpOutputDevice->SetRelativeMapMode(aMapMode);

                }

                basegfx::B2DHomMatrix aFinalTransform(aCombinedTransform

                                                      * rTextCandidate.getTextTransform());

                const basegfx::B2DPoint aPoint(aFinalTransform * basegfx::B2DPoint(0.0, 0.0));

                Point aFinalPoint(

                    basegfx::fround<tools::Long>(aPoint.getX() / aCurrentScaling.getX()),

                    basegfx::fround<tools::Long>(aPoint.getY() / aCurrentScaling.getY()));

                aStartPoint = Point(aFinalPoint.X() - aOrigin.X(), aFinalPoint.Y() - aOrigin.Y());

            }

            else

            {

                const basegfx::B2DPoint aPoint(aLocalTransform * basegfx::B2DPoint(0.0, 0.0));

                double aPointX = aPoint.getX(), aPointY = aPoint.getY();

                if (!comphelper::LibreOfficeKit::isActive())

                {

                    // aFont has an integer size; we must scale a bit for precision

                    double nFontScalingFixY = aFontScaling.getY() / aResultFontSize.Height();

                    double nFontScalingFixX

                        = aFontScaling.getX()

                          / (aResultFontSize.Width() ? aResultFontSize.Width()

                                                     : aResultFontSize.Height());

#ifdef _WIN32

                    if (aResultFontSize.Width()

                        && aResultFontSize.Width() != aResultFontSize.Height())

                    {

                        // See getVclFontFromFontAttribute in drawinglayer/source/primitive2d/textlayoutdevice.cxx

                        vcl::Font aUnscaledTest(aFont);

                        aUnscaledTest.SetFontSize({ 0, aResultFontSize.Height() });

                        const FontMetric aUnscaledFontMetric(

                            Application::GetDefaultDevice()->GetFontMetric(aUnscaledTest));

                        if (aUnscaledFontMetric.GetAverageFontWidth() > 0)

                        {

                            double nExistingXScale = static_cast<double>(aResultFontSize.Width())

                                                     / aUnscaledFontMetric.GetAverageFontWidth();

                            nFontScalingFixX

                                = aFontScaling.getX() / aFontScaling.getY() / nExistingXScale;

                        }

                    }

#endif

                    if (!rtl_math_approxEqual(nFontScalingFixY, 1.0)

                        || !rtl_math_approxEqual(nFontScalingFixX, 1.0))

                    {

                        MapMode aMapMode = mpOutputDevice->GetMapMode();

                        aMapMode.SetScaleX(aMapMode.GetScaleX() * nFontScalingFixX);

                        aMapMode.SetScaleY(aMapMode.GetScaleY() * nFontScalingFixY);

                        assert(nFontScalingFixX != 0 && nFontScalingFixY != 0

                               && "or bValidScaling would be false");

                        Point origin = aMapMode.GetOrigin();

                        mpOutputDevice->Push(vcl::PushFlags::MAPMODE);

                        mpOutputDevice->SetRelativeMapMode(aMapMode);

                        bChangeMapMode = true;

                        aPointX = (aPointX + origin.X()) / nFontScalingFixX - origin.X();

                        aPointY = (aPointY + origin.Y()) / nFontScalingFixY - origin.Y();

                    }

                }

                aStartPoint = Point(basegfx::fround<tools::Long>(aPointX),

                                    basegfx::fround<tools::Long>(aPointY));

            }

            // tdf#168371 set letter spacing so that VCL knows it has to disable ligatures

            aFont.SetFixKerning(rTextCandidate.getLetterSpacing());

            aFont.SetOpticalSizing(rTextCandidate.getOpticalSizing());

            aFont.SetVariations(rTextCandidate.getFontVariations());

            // tdf#152990 set the font after the MapMode is (potentially) set so canvas uses the desired

            // font size

            mpOutputDevice->SetFont(aFont);

            mpOutputDevice->SetTextColor(Color(aRGBFontColor));

            if (bManualBackground)

            {

                FontMetric aFM = mpOutputDevice->GetFontMetric();

                tools::Long nPropAsc = aFM.GetAscent();

                tools::Long nPropDesc = aFM.GetDescent();

                double fScale = 100.0 / nProportionalFontSize;

                double fEscOff

                    = rTextCandidate.getEscapement() / -100.0 * aResultFontSize.Height() * fScale;

                tools::Long nAdjAsc = basegfx::fround<tools::Long>(fEscOff + nPropAsc * fScale);

                tools::Long nAdjDesc = basegfx::fround<tools::Long>(nPropDesc * fScale - fEscOff);

                tools::Long nTextWidth

                    = !aDXArray.empty()

                          ? basegfx::fround<tools::Long>(aDXArray.back())

                          : mpOutputDevice->GetTextWidth(rTextCandidate.getText(),

                                                         rTextCandidate.getTextPosition(),

                                                         rTextCandidate.getTextLength());

                // trim trailing whitespace from background width to not have background over

                // trailing whitespace, since that looks like an error for the user.

                if (!rTextCandidate.getDXArray().empty())

                {

                    sal_Int32 nLast(rTextCandidate.getTextPosition()

                                    + rTextCandidate.getTextLength() - 1);

                    sal_Int32 nFirst(rTextCandidate.getTextPosition());

                    while (nLast >= nFirst && rTextCandidate.getText()[nLast] == ' ')

                        nLast--;

                    sal_Int32 nTrimmedLen(nLast - nFirst + 1);

                    if (nTrimmedLen > 0 && nTrimmedLen < rTextCandidate.getTextLength())

                    {

                        double fPixelVectorFactor(1.0);

                        if (!aDXArray.empty() && !rTextCandidate.getDXArray().empty())

                            fPixelVectorFactor = static_cast<double>(aDXArray.back())

                                                 / rTextCandidate.getDXArray().back();

                        nTextWidth = basegfx::fround<tools::Long>(

                            rTextCandidate.getDXArray()[nTrimmedLen - 1] * fPixelVectorFactor);

                    }

                    else if (nTrimmedLen <= 0)

                        nTextWidth = 0;

                }

                auto aScopedPush = mpOutputDevice->ScopedPush(vcl::PushFlags::FILLCOLOR

                                                              | vcl::PushFlags::LINECOLOR);

                mpOutputDevice->SetFillColor(aFillColor);

                mpOutputDevice->SetLineColor();

                mpOutputDevice->DrawRect(

                    tools::Rectangle(aStartPoint.X(), aStartPoint.Y() - nAdjAsc,

                                     aStartPoint.X() + nTextWidth, aStartPoint.Y() + nAdjDesc));

            }

            if (!aDXArray.empty())

            {

                const SalLayoutGlyphs* pGlyphs = SalLayoutGlyphsCache::self()->GetLayoutGlyphs(

                    mpOutputDevice, rTextCandidate.getText(), rTextCandidate.getTextPosition(),

                    rTextCandidate.getTextLength());

                mpOutputDevice->DrawTextArray(

                    aStartPoint, rTextCandidate.getText(), aDXArray,

                    rTextCandidate.getKashidaArray(), rTextCandidate.getTextPosition(),

                    rTextCandidate.getTextLength(), SalLayoutFlags::NONE, pGlyphs);

            }

            else

            {

                mpOutputDevice->DrawText(aStartPoint, rTextCandidate.getText(),

                                         rTextCandidate.getTextPosition(),

                                         rTextCandidate.getTextLength());

            }

            // Restore previous layout mode

            mpOutputDevice->SetLayoutMode(nOldLayoutMode);

            if (bChangeMapMode)

                mpOutputDevice->Pop();

            bPrimitiveAccepted = true;

        }

    }

    if (!bPrimitiveAccepted)

    {

        // let break down

        process(rTextCandidate);

    }

}

// direct draw of hairline

void VclProcessor2D::RenderPolygonHairlinePrimitive2D(

    const primitive2d::PolygonHairlinePrimitive2D& rPolygonCandidate, bool bPixelBased)

{

    const basegfx::BColor aHairlineColor(

        maBColorModifierStack.getModifiedColor(rPolygonCandidate.getBColor()));

    mpOutputDevice->SetLineColor(Color(aHairlineColor));

    mpOutputDevice->SetFillColor();

    basegfx::B2DPolygon aLocalPolygon(rPolygonCandidate.getB2DPolygon());

    aLocalPolygon.transform(maCurrentTransformation);

    if (bPixelBased && getViewInformation2D().getPixelSnapHairline())

    {

        // #i98289#

        // when a Hairline is painted and AntiAliasing is on the option SnapHorVerLinesToDiscrete

        // allows to suppress AntiAliasing for pure horizontal or vertical lines. This is done since

        // not-AntiAliased such lines look more pleasing to the eye (e.g. 2D chart content). This

        // NEEDS to be done in discrete coordinates, so only useful for pixel based rendering.

        aLocalPolygon = basegfx::utils::snapPointsOfHorizontalOrVerticalEdges(aLocalPolygon);

    }

    mpOutputDevice->DrawPolyLine(aLocalPolygon, 0.0);

}

// direct draw of transformed Bitmap primitive

void VclProcessor2D::RenderBitmapPrimitive2D(const primitive2d::BitmapPrimitive2D& rBitmapCandidate)

{

    Bitmap aBitmap(rBitmapCandidate.getBitmap());

    const basegfx::B2DHomMatrix aLocalTransform(maCurrentTransformation

                                                * rBitmapCandidate.getTransform());

    if (maBColorModifierStack.count())

    {

        aBitmap = aBitmap.Modify(maBColorModifierStack);

        if (aBitmap.IsEmpty())

        {

            // color gets completely replaced, get it

            const basegfx::BColor aModifiedColor(

                maBColorModifierStack.getModifiedColor(basegfx::BColor()));

            basegfx::B2DPolygon aPolygon(basegfx::utils::createUnitPolygon());

            aPolygon.transform(aLocalTransform);

            mpOutputDevice->SetFillColor(Color(aModifiedColor));

            mpOutputDevice->SetLineColor();

            mpOutputDevice->DrawPolygon(aPolygon);

            return;

        }

    }

    // #122923# do no longer add Alpha channel here; the right place to do this is when really

    // the own transformer is used (see OutputDevice::DrawTransformedBitmapEx).

    // draw using OutputDevice'sDrawTransformedBitmapEx

    mpOutputDevice->DrawTransformedBitmapEx(aLocalTransform, aBitmap);

}

void VclProcessor2D::RenderFillGraphicPrimitive2D(

    const primitive2d::FillGraphicPrimitive2D& rFillBitmapCandidate)

{

    if (rFillBitmapCandidate.getTransparency() < 0.0

        || rFillBitmapCandidate.getTransparency() > 1.0)

    {

        // invalid transparence, done

        return;

    }

    bool bPrimitiveAccepted = RenderFillGraphicPrimitive2DImpl(rFillBitmapCandidate);

    if (!bPrimitiveAccepted)

    {

        // do not accept, use decomposition

        process(rFillBitmapCandidate);

    }

}

bool VclProcessor2D::RenderFillGraphicPrimitive2DImpl(

    const primitive2d::FillGraphicPrimitive2D& rFillBitmapCandidate)

{

    const attribute::FillGraphicAttribute& rFillGraphicAttribute(

        rFillBitmapCandidate.getFillGraphic());

    // #121194# when tiling is used and content is bitmap-based, do direct tiling in the

    // renderer on pixel base to ensure tight fitting. Do not do this when

    // the fill is rotated or sheared.

    if (!rFillGraphicAttribute.getTiling())

        return false;

    // content is bitmap(ex)

    //

    // for Vector Graphic Data (SVG, EMF+) support, force decomposition when present. This will lead to use

    // the primitive representation of the vector data directly.

    //

    // when graphic is animated, force decomposition to use the correct graphic, else

    // fill style will not be animated

    if (GraphicType::Bitmap != rFillGraphicAttribute.getGraphic().GetType()

        || rFillGraphicAttribute.getGraphic().getVectorGraphicData()

        || rFillGraphicAttribute.getGraphic().IsAnimated())

        return false;

    // decompose matrix to check for shear, rotate and mirroring

    basegfx::B2DHomMatrix aLocalTransform(maCurrentTransformation

                                          * rFillBitmapCandidate.getTransformation());

    basegfx::B2DVector aScale, aTranslate;

    double fRotate, fShearX;

    aLocalTransform.decompose(aScale, aTranslate, fRotate, fShearX);

    // when nopt rotated/sheared

    if (!basegfx::fTools::equalZero(fRotate) || !basegfx::fTools::equalZero(fShearX))

        return false;

    // no shear or rotate, draw direct in pixel coordinates

    // transform object range to device coordinates (pixels). Use

    // the device transformation for better accuracy

    basegfx::B2DRange aObjectRange(aTranslate, aTranslate + aScale);

    aObjectRange.transform(mpOutputDevice->GetViewTransformation());

    // extract discrete size of object

    const sal_Int32 nOWidth(basegfx::fround(aObjectRange.getWidth()));

    const sal_Int32 nOHeight(basegfx::fround(aObjectRange.getHeight()));

    // only do something when object has a size in discrete units

    if (nOWidth <= 0 || nOHeight <= 0)

        return true;

    // transform graphic range to device coordinates (pixels). Use

    // the device transformation for better accuracy

    basegfx::B2DRange aGraphicRange(rFillGraphicAttribute.getGraphicRange());

    aGraphicRange.transform(mpOutputDevice->GetViewTransformation() * aLocalTransform);

    // extract discrete size of graphic

    // caution: when getting to zero, nothing would be painted; thus, do not allow this

    const sal_Int32 nBWidth(std::max(sal_Int32(1), basegfx::fround(aGraphicRange.getWidth())));

    const sal_Int32 nBHeight(std::max(sal_Int32(1), basegfx::fround(aGraphicRange.getHeight())));

    // nBWidth, nBHeight is the pixel size of the needed bitmap. To not need to scale it

    // in vcl many times, create a size-optimized version

    const Size aNeededBitmapSizePixel(nBWidth, nBHeight);

    Bitmap aBitmap(rFillGraphicAttribute.getGraphic().GetBitmap());

    const bool bPreScaled(nBWidth * nBHeight < (250 * 250));

    // ... but only up to a maximum size, else it gets too expensive

    if (bPreScaled)

    {

        // if color depth is below 24bit, expand before scaling for better quality.

        // This is even needed for low colors, else the scale will produce

        // a bitmap in gray or Black/White (!)

        if (isPalettePixelFormat(aBitmap.getPixelFormat()))

        {

            aBitmap.Convert(BmpConversion::N24Bit);

        }

        aBitmap.Scale(aNeededBitmapSizePixel, BmpScaleFlag::Interpolate);

    }

    if (rFillBitmapCandidate.hasTransparency())

        aBitmap.BlendAlpha(

            static_cast<sal_uInt8>(255 - (rFillBitmapCandidate.getTransparency() * 255)));

    if (maBColorModifierStack.count())

    {

        // when color modifier, apply to bitmap

        aBitmap = aBitmap.Modify(maBColorModifierStack);

        // ModifyBitmapEx uses empty bitmap as sign to return that

        // the content will be completely replaced to mono color, use shortcut

        if (aBitmap.IsEmpty())

        {

            // color gets completely replaced, get it

            const basegfx::BColor aModifiedColor(

                maBColorModifierStack.getModifiedColor(basegfx::BColor()));

            basegfx::B2DPolygon aPolygon(basegfx::utils::createUnitPolygon());

            aPolygon.transform(aLocalTransform);

            mpOutputDevice->SetFillColor(Color(aModifiedColor));

            mpOutputDevice->SetLineColor();

            mpOutputDevice->DrawPolygon(aPolygon);

            return true;

        }

    }

    sal_Int32 nBLeft(basegfx::fround(aGraphicRange.getMinX()));

    sal_Int32 nBTop(basegfx::fround(aGraphicRange.getMinY()));

    const sal_Int32 nOLeft(basegfx::fround(aObjectRange.getMinX()));

    const sal_Int32 nOTop(basegfx::fround(aObjectRange.getMinY()));

    sal_Int32 nPosX(0);

    sal_Int32 nPosY(0);

    if (nBLeft > nOLeft)

    {

        const sal_Int32 nDiff((nBLeft / nBWidth) + 1);

        nPosX -= nDiff;

        nBLeft -= nDiff * nBWidth;

    }

    if (nBLeft + nBWidth <= nOLeft)

    {

        const sal_Int32 nDiff(-nBLeft / nBWidth);

        nPosX += nDiff;

        nBLeft += nDiff * nBWidth;

    }

    if (nBTop > nOTop)

    {

        const sal_Int32 nDiff((nBTop / nBHeight) + 1);

        nPosY -= nDiff;

        nBTop -= nDiff * nBHeight;

    }

    if (nBTop + nBHeight <= nOTop)

    {

        const sal_Int32 nDiff(-nBTop / nBHeight);

        nPosY += nDiff;

        nBTop += nDiff * nBHeight;

    }

    // prepare OutDev

    const Point aEmptyPoint(0, 0);

    // the visible rect, in pixels

    const ::tools::Rectangle aVisiblePixel(aEmptyPoint, mpOutputDevice->GetOutputSizePixel());

    const bool bWasEnabled(mpOutputDevice->IsMapModeEnabled());

    mpOutputDevice->EnableMapMode(false);

    // check if offset is used

    const sal_Int32 nOffsetX(basegfx::fround(rFillGraphicAttribute.getOffsetX() * nBWidth));

    const sal_Int32 nOffsetY(basegfx::fround(rFillGraphicAttribute.getOffsetY() * nBHeight));

    // if the tile is a single pixel big, just flood fill with that pixel color

    if (nOffsetX == 0 && nOffsetY == 0 && aNeededBitmapSizePixel.getWidth() == 1

        && aNeededBitmapSizePixel.getHeight() == 1)

    {

        Color col = aBitmap.GetPixelColor(0, 0);

        mpOutputDevice->SetLineColor(col);

        mpOutputDevice->SetFillColor(col);

        mpOutputDevice->DrawRect(aVisiblePixel);

    }

    else if (nOffsetX)

    {

        // offset in X, so iterate over Y first and draw lines

        for (sal_Int32 nYPos(nBTop); nYPos < nOTop + nOHeight; nYPos += nBHeight, nPosY++)

        {

            for (sal_Int32 nXPos((nPosY % 2) ? nBLeft - nBWidth + nOffsetX : nBLeft);

                 nXPos < nOLeft + nOWidth; nXPos += nBWidth)

            {

                const ::tools::Rectangle aOutRectPixel(Point(nXPos, nYPos), aNeededBitmapSizePixel);

                if (aOutRectPixel.Overlaps(aVisiblePixel))

                {

                    if (bPreScaled)

                    {

                        mpOutputDevice->DrawBitmap(aOutRectPixel.TopLeft(), aBitmap);

                    }

                    else

                    {

                        mpOutputDevice->DrawBitmap(aOutRectPixel.TopLeft(), aNeededBitmapSizePixel,

                                                   aBitmap);

                    }

                }

            }

        }

    }

    else // nOffsetY is used

    {

        // possible offset in Y, so iterate over X first and draw columns

        for (sal_Int32 nXPos(nBLeft); nXPos < nOLeft + nOWidth; nXPos += nBWidth, nPosX++)

        {

            for (sal_Int32 nYPos((nPosX % 2) ? nBTop - nBHeight + nOffsetY : nBTop);

                 nYPos < nOTop + nOHeight; nYPos += nBHeight)

            {

                const ::tools::Rectangle aOutRectPixel(Point(nXPos, nYPos), aNeededBitmapSizePixel);

                if (aOutRectPixel.Overlaps(aVisiblePixel))

                {

                    if (bPreScaled)

                    {

                        mpOutputDevice->DrawBitmap(aOutRectPixel.TopLeft(), aBitmap);

                    }

                    else

                    {

                        mpOutputDevice->DrawBitmap(aOutRectPixel.TopLeft(), aNeededBitmapSizePixel,

                                                   aBitmap);

                    }

                }

            }

        }

    }

    // restore OutDev

    mpOutputDevice->EnableMapMode(bWasEnabled);

    return true;

}

// direct draw of Graphic

void VclProcessor2D::RenderPolyPolygonGraphicPrimitive2D(

    const primitive2d::PolyPolygonGraphicPrimitive2D& rPolygonCandidate)

{

    bool bDone(false);

    const basegfx::B2DPolyPolygon& rPolyPolygon = rPolygonCandidate.getB2DPolyPolygon();

    // #121194# Todo: check if this works

    if (!rPolyPolygon.count())

    {

        // empty polyPolygon, done

        bDone = true;

    }

    else

    {

        const attribute::FillGraphicAttribute& rFillGraphicAttribute

            = rPolygonCandidate.getFillGraphic();

        // try to catch cases where the graphic will be color-modified to a single

        // color (e.g. shadow)

        switch (rFillGraphicAttribute.getGraphic().GetType())

        {

            case GraphicType::GdiMetafile:

            {

                // metafiles are potentially transparent, cannot optimize, not done

                break;

            }

            case GraphicType::Bitmap:

            {

                if (!rFillGraphicAttribute.getGraphic().IsTransparent()

                    && !rFillGraphicAttribute.getGraphic().IsAlpha()

                    && !rPolygonCandidate.hasTransparency())

                {

                    // bitmap is not transparent and has no alpha

                    const sal_uInt32 nBColorModifierStackCount(maBColorModifierStack.count());

                    if (nBColorModifierStackCount)

                    {

                        const basegfx::BColorModifierSharedPtr& rTopmostModifier

                            = maBColorModifierStack.getBColorModifier(nBColorModifierStackCount

                                                                      - 1);

                        const basegfx::BColorModifier_replace* pReplacer

                            = dynamic_cast<const basegfx::BColorModifier_replace*>(

                                rTopmostModifier.get());

                        if (pReplacer)

                        {

                            // the bitmap fill is in unified color, so we can replace it with

                            // a single polygon fill. The form of the fill depends on tiling

                            if (rFillGraphicAttribute.getTiling())

                            {

                                // with tiling, fill the whole tools::PolyPolygon with the modifier color

                                basegfx::B2DPolyPolygon aLocalPolyPolygon(rPolyPolygon);

                                aLocalPolyPolygon.transform(maCurrentTransformation);

                                mpOutputDevice->SetLineColor();

                                mpOutputDevice->SetFillColor(Color(pReplacer->getBColor()));

                                mpOutputDevice->DrawPolyPolygon(aLocalPolyPolygon);

                            }

                            else

                            {

                                // without tiling, only the area common to the bitmap tile and the

                                // tools::PolyPolygon is filled. Create the bitmap tile area in object

                                // coordinates. For this, the object transformation needs to be created

                                // from the already scaled PolyPolygon. The tile area in object

                                // coordinates will always be non-rotated, so it's not necessary to

                                // work with a polygon here

                                basegfx::B2DRange aTileRange(

                                    rFillGraphicAttribute.getGraphicRange());

                                const basegfx::B2DRange aPolyPolygonRange(

                                    rPolyPolygon.getB2DRange());

                                const basegfx::B2DHomMatrix aNewObjectTransform(

                                    basegfx::utils::createScaleTranslateB2DHomMatrix(

                                        aPolyPolygonRange.getRange(),

                                        aPolyPolygonRange.getMinimum()));

                                aTileRange.transform(aNewObjectTransform);

                                // now clip the object polyPolygon against the tile range

                                // to get the common area

                                basegfx::B2DPolyPolygon aTarget

                                    = basegfx::utils::clipPolyPolygonOnRange(

                                        rPolyPolygon, aTileRange, true, false);

                                if (aTarget.count())

                                {

                                    aTarget.transform(maCurrentTransformation);

                                    mpOutputDevice->SetLineColor();

                                    mpOutputDevice->SetFillColor(Color(pReplacer->getBColor()));

                                    mpOutputDevice->DrawPolyPolygon(aTarget);

                                }

                            }

                            // simplified output executed, we are done

                            bDone = true;

                        }

                    }

                }

                break;

            }

            default: //GraphicType::NONE, GraphicType::Default

            {

                // empty graphic, we are done

                bDone = true;

                break;

            }

        }