/* -*- 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 <sal/types.h>

#include <osl/diagnose.h>

#include <rtl/math.hxx>

#include <basegfx/polygon/b2dpolygontools.hxx>

#include <tools/helpers.hxx>

#include <tools/mapunit.hxx>

#include <officecfg/Office/Common.hxx>

#include <vcl/BitmapTools.hxx>

#include <vcl/metaact.hxx>

#include <vcl/metaactiontypes.hxx>

#include <vcl/print.hxx>

#include <vcl/rendercontext/AntialiasingFlags.hxx>

#include <vcl/rendercontext/DrawModeFlags.hxx>

#include <vcl/settings.hxx>

#include <vcl/svapp.hxx>

#include <vcl/virdev.hxx>

#include <vcl/BitmapWriteAccess.hxx>

#include <pdf/pdfwriter_impl.hxx>

#include <salgdi.hxx>

#include <list>

#include <memory>

#define MAX_TILE_WIDTH  1024

#define MAX_TILE_HEIGHT 1024

namespace

{

    /**

     * Perform a safe approximation of a polygon from double-precision

     * coordinates to integer coordinates, to ensure that it has at least 2

     * pixels in both X and Y directions.

     */

    tools::Polygon toPolygon( const basegfx::B2DPolygon& rPoly )

    {

        basegfx::B2DRange aRange = rPoly.getB2DRange();

        double fW = aRange.getWidth(), fH = aRange.getHeight();

        if (0.0 < fW && 0.0 < fH && (fW <= 1.0 || fH <= 1.0))

        {

            // This polygon not empty but is too small to display.  Approximate it

            // with a rectangle large enough to be displayed.

            double nX = aRange.getMinX(), nY = aRange.getMinY();

            double nW = std::max<double>(1.0, rtl::math::round(fW));

            double nH = std::max<double>(1.0, rtl::math::round(fH));

            tools::Polygon aTarget;

            aTarget.Insert(0, Point(nX, nY));

            aTarget.Insert(1, Point(nX+nW, nY));

            aTarget.Insert(2, Point(nX+nW, nY+nH));

            aTarget.Insert(3, Point(nX, nY+nH));

            aTarget.Insert(4, Point(nX, nY));

            return aTarget;

        }

        return tools::Polygon(rPoly);

    }

    tools::PolyPolygon toPolyPolygon( const basegfx::B2DPolyPolygon& rPolyPoly )

    {

        tools::PolyPolygon aTarget;

        for (auto const& rB2DPolygon : rPolyPoly)

            aTarget.Insert(toPolygon(rB2DPolygon));

        return aTarget;

    }

}

// Caution: This method is nearly the same as

// void OutputDevice::DrawPolyPolygon( const basegfx::B2DPolyPolygon& rB2DPolyPoly )

// so when changes are made here do not forget to make changes there, too

void OutputDevice::DrawTransparent(

    const basegfx::B2DHomMatrix& rObjectTransform,

    const basegfx::B2DPolyPolygon& rB2DPolyPoly,

    double fTransparency)

{

    assert(!is_double_buffered_window());

    // AW: Do NOT paint empty PolyPolygons

    if(!rB2DPolyPoly.count())

        return;

    // we need a graphics

    if( !mpGraphics && !AcquireGraphics() )

        return;

    assert(mpGraphics);

    if( mbInitClipRegion )

        InitClipRegion();

    if( mbOutputClipped )

        return;

    if( mbInitLineColor )

        InitLineColor();

    if( mbInitFillColor )

        InitFillColor();

    if (RasterOp::OverPaint == GetRasterOp())

    {

        // b2dpolygon support not implemented yet on non-UNX platforms

        basegfx::B2DPolyPolygon aB2DPolyPolygon(rB2DPolyPoly);

        // ensure it is closed

        if(!aB2DPolyPolygon.isClosed())

        {

            // maybe assert, prevents buffering due to making a copy

            aB2DPolyPolygon.setClosed( true );

        }

        // create ObjectToDevice transformation

        const basegfx::B2DHomMatrix aFullTransform(ImplGetDeviceTransformation() * rObjectTransform);

        // TODO: this must not drop transparency for mpAlphaVDev case, but instead use premultiplied

        // alpha... but that requires using premultiplied alpha also for already drawn data

        if (IsFillColor())

        {

            mpGraphics->DrawPolyPolygon(

                aFullTransform,

                aB2DPolyPolygon,

                fTransparency,

                *this);

        }

        if (IsLineColor())

        {

            const bool bPixelSnapHairline(mnAntialiasing & AntialiasingFlags::PixelSnapHairline);

            for(auto const& rPolygon : std::as_const(aB2DPolyPolygon))

            {

                mpGraphics->DrawPolyLine(

                    aFullTransform,

                    rPolygon,

                    fTransparency,

                    0.0, // tdf#124848 hairline

                    nullptr, // MM01

                    basegfx::B2DLineJoin::NONE,

                    css::drawing::LineCap_BUTT,

                    basegfx::deg2rad(15.0), // not used with B2DLineJoin::NONE, but the correct default

                    bPixelSnapHairline,

                    *this );

            }

        }

        if( mpMetaFile )

        {

            // tdf#119843 need transformed Polygon here

            basegfx::B2DPolyPolygon aB2DPolyPoly(rB2DPolyPoly);

            aB2DPolyPoly.transform(rObjectTransform);

            mpMetaFile->AddAction(

                new MetaTransparentAction(

                    tools::PolyPolygon(aB2DPolyPoly),

                    static_cast< sal_uInt16 >(fTransparency * 100.0)));

        }

        return;

    }

    // fallback to old polygon drawing if needed

    // tdf#119843 need transformed Polygon here

    basegfx::B2DPolyPolygon aB2DPolyPoly(rB2DPolyPoly);

    aB2DPolyPoly.transform(rObjectTransform);

    DrawTransparent(

        toPolyPolygon(aB2DPolyPoly),

        static_cast<sal_uInt16>(fTransparency * 100.0));

}

bool OutputDevice::DrawTransparentNatively ( const tools::PolyPolygon& rPolyPoly,

                                             sal_uInt16 nTransparencePercent )

{

    assert(!is_double_buffered_window());

    bool bDrawn = false;

    if (true

#if defined UNX && ! defined MACOSX && ! defined IOS

        && GetBitCount() > 8

#endif

#ifdef _WIN32

        // workaround bad dithering on remote displaying when using GDI+ with toolbar button highlighting

        && !rPolyPoly.IsRect()

#endif

        )

    {

        // prepare the graphics device

        if( mbInitClipRegion )

            InitClipRegion();

        if( mbOutputClipped )

            return true;

        if( mbInitLineColor )

            InitLineColor();

        if( mbInitFillColor )

            InitFillColor();

        // get the polygon in device coordinates

        basegfx::B2DPolyPolygon aB2DPolyPolygon(rPolyPoly.getB2DPolyPolygon());

        const basegfx::B2DHomMatrix aTransform(ImplGetDeviceTransformation());

        const double fTransparency = 0.01 * nTransparencePercent;

        if( mbFillColor )

        {

            // #i121591#

            // CAUTION: Only non printing (pixel-renderer) VCL commands from OutputDevices

            // should be used when printing. Normally this is avoided by the printer being

            // non-AAed and thus e.g. on WIN GdiPlus calls are not used. It may be necessary

            // to figure out a way of moving this code to its own function that is

            // overridden by the Print class, which will mean we deliberately override the

            // functionality and we use the fallback some lines below (which is not very good,

            // though. For now, WinSalGraphics::drawPolyPolygon will detect printer usage and

            // correct the wrong mapping (see there for details)

            mpGraphics->DrawPolyPolygon(

                aTransform,

                aB2DPolyPolygon,

                fTransparency,

                *this);

            bDrawn = true;

        }

        if( mbLineColor )

        {

            // disable the fill color for now

            mpGraphics->SetFillColor();

            // draw the border line

            const bool bPixelSnapHairline(mnAntialiasing & AntialiasingFlags::PixelSnapHairline);

            for(auto const& rPolygon : std::as_const(aB2DPolyPolygon))

            {

                bDrawn = mpGraphics->DrawPolyLine(

                    aTransform,

                    rPolygon,

                    fTransparency,

                    0.0, // tdf#124848 hairline

                    nullptr, // MM01

                    basegfx::B2DLineJoin::NONE,

                    css::drawing::LineCap_BUTT,

                    basegfx::deg2rad(15.0), // not used with B2DLineJoin::NONE, but the correct default

                    bPixelSnapHairline,

                    *this );

            }

            // prepare to restore the fill color

            mbInitFillColor = mbFillColor;

        }

    }

    return bDrawn;

}

void OutputDevice::EmulateDrawTransparent ( const tools::PolyPolygon& rPolyPoly,

                                            sal_uInt16 nTransparencePercent )

{

    GDIMetaFile* pOldMetaFile = mpMetaFile;

    mpMetaFile = nullptr;

    tools::PolyPolygon aPolyPoly( LogicToPixel( rPolyPoly ) );

    tools::Rectangle aPolyRect( aPolyPoly.GetBoundRect() );

    tools::Rectangle aDstRect( Point(), GetOutputSizePixel() );

    aDstRect.Intersection( aPolyRect );

    ClipToPaintRegion( aDstRect );

    if( !aDstRect.IsEmpty() )

    {

        bool bDrawn = false;

        // #i66849# Added fast path for exactly rectangular

        // polygons

        if( aPolyPoly.IsRect() )

        {

            // setup Graphics only here (other cases delegate

            // to basic OutDev methods)

            if ( mbInitClipRegion )

                InitClipRegion();

            if ( mbInitLineColor )

                InitLineColor();

            if ( mbInitFillColor )

                InitFillColor();

            tools::Rectangle aLogicPolyRect( rPolyPoly.GetBoundRect() );

            tools::Rectangle aPixelRect(LogicToDevicePixel(aLogicPolyRect));

            if( !mbOutputClipped )

            {

                bDrawn = mpGraphics->DrawAlphaRect( aPixelRect.Left(), aPixelRect.Top(),

                    // #i98405# use methods with small g, else one pixel too much will be painted.

                    // This is because the source is a polygon which when painted would not paint

                    // the rightmost and lowest pixel line(s), so use one pixel less for the

                    // rectangle, too.

                                                    aPixelRect.getOpenWidth(), aPixelRect.getOpenHeight(),

                                                    sal::static_int_cast<sal_uInt8>(nTransparencePercent),

                                                    *this );

            }

            else

            {

                bDrawn = true;

            }

        }

        if( !bDrawn )

        {

            ScopedVclPtrInstance< VirtualDevice > aVDev(*this);

            const Size aDstSz( aDstRect.GetSize() );

            const sal_uInt8 cTrans = basegfx::fround<sal_uInt8>(nTransparencePercent * 2.55);

            if( aDstRect.Left() || aDstRect.Top() )

                aPolyPoly.Move( -aDstRect.Left(), -aDstRect.Top() );

            if( aVDev->SetOutputSizePixel( aDstSz ) )

            {

                const bool bOldMap = mbMap;

                EnableMapMode( false );

                aVDev->SetLineColor( COL_BLACK );

                aVDev->SetFillColor( COL_BLACK );

                aVDev->DrawPolyPolygon( aPolyPoly );

                Bitmap aPaint( GetBitmap( aDstRect.TopLeft(), aDstSz ) );

                Bitmap aPolyMask( aVDev->GetBitmap( Point(), aDstSz ) );

                // #107766# check for non-empty bitmaps before accessing them

                if( !aPaint.IsEmpty() && !aPolyMask.IsEmpty() )

                {

                    BitmapScopedWriteAccess pW(aPaint);

                    BitmapScopedReadAccess pR(aPolyMask);

                    if( pW && pR )

                    {

                        BitmapColor aPixCol;

                        const BitmapColor aFillCol( GetFillColor() );

                        const BitmapColor aBlack( pR->GetBestMatchingColor( COL_BLACK ) );

                        const tools::Long nWidth = pW->Width();

                        const tools::Long nHeight = pW->Height();

                        tools::Long nX, nY;

                        if (vcl::isPalettePixelFormat(aPaint.getPixelFormat()))

                        {

                            const BitmapPalette& rPal = pW->GetPalette();

                            const sal_uInt16 nCount = rPal.GetEntryCount();

                            std::unique_ptr<sal_uInt8[]> xMap(new sal_uInt8[ nCount * sizeof( BitmapColor )]);

                            BitmapColor* pMap = reinterpret_cast<BitmapColor*>(xMap.get());

                            for( sal_uInt16 i = 0; i < nCount; i++ )

                            {

                                BitmapColor aCol( rPal[ i ] );

                                aCol.Merge( aFillCol, cTrans );

                                pMap[ i ] = BitmapColor( static_cast<sal_uInt8>(rPal.GetBestIndex( aCol )) );

                            }

                            for( nY = 0; nY < nHeight; nY++ )

                            {

                                Scanline pScanline = pW->GetScanline(nY);

                                Scanline pScanlineRead = pR->GetScanline(nY);

                                for( nX = 0; nX < nWidth; nX++ )

                                {

                                    if( pR->GetPixelFromData( pScanlineRead, nX ) == aBlack )

                                    {

                                        pW->SetPixelOnData( pScanline, nX, pMap[ pW->GetIndexFromData( pScanline, nX ) ] );

                                    }

                                }

                            }

                        }

                        else

                        {

                            for( nY = 0; nY < nHeight; nY++ )

                            {

                                Scanline pScanline = pW->GetScanline(nY);

                                Scanline pScanlineRead = pR->GetScanline(nY);

                                for( nX = 0; nX < nWidth; nX++ )

                                {

                                    if( pR->GetPixelFromData( pScanlineRead, nX ) == aBlack )

                                    {

                                        aPixCol = pW->GetColor( nY, nX );

                                        aPixCol.Merge(aFillCol, cTrans);

                                        pW->SetPixelOnData(pScanline, nX, aPixCol);

                                    }

                                }

                            }

                        }

                    }

                    pR.reset();

                    pW.reset();

                    DrawBitmap( aDstRect.TopLeft(), aPaint );

                    EnableMapMode( bOldMap );

                    if( mbLineColor )

                    {

                        auto popIt = ScopedPush(vcl::PushFlags::FILLCOLOR);

                        SetFillColor();

                        DrawPolyPolygon( rPolyPoly );

                    }

                }

            }

            else

            {

                DrawPolyPolygon( rPolyPoly );

            }

        }

    }

    mpMetaFile = pOldMetaFile;

}

void OutputDevice::DrawTransparent( const tools::PolyPolygon& rPolyPoly,

                                    sal_uInt16 nTransparencePercent )

{

    assert(!is_double_buffered_window());

    // short circuit for drawing an opaque polygon

    if( (nTransparencePercent < 1) || (mnDrawMode & DrawModeFlags::NoTransparency) )

    {

        DrawPolyPolygon( rPolyPoly );

        return;

    }

    // short circuit for drawing an invisible polygon

    if( (!mbFillColor && !mbLineColor) || (nTransparencePercent >= 100) )

        return; // tdf#84294: do not record it in metafile

    // handle metafile recording

    if( mpMetaFile )

        mpMetaFile->AddAction( new MetaTransparentAction( rPolyPoly, nTransparencePercent ) );

    bool bDrawn = !IsDeviceOutputNecessary() || ImplIsRecordLayout();

    if( bDrawn )

        return;

    // get the device graphics as drawing target

    if( !mpGraphics && !AcquireGraphics() )

        return;

    assert(mpGraphics);

    // try hard to draw it directly, because the emulation layers are slower

    bDrawn = DrawTransparentNatively( rPolyPoly, nTransparencePercent );

    if (!bDrawn)

        EmulateDrawTransparent( rPolyPoly, nTransparencePercent );

}

void OutputDevice::DrawTransparent( const GDIMetaFile& rMtf, const Point& rPos,

                                    const Size& rSize, const Gradient& rTransparenceGradient )

{

    DrawTransparent( rMtf, rPos, rSize, rPos, rSize, rTransparenceGradient );

}

void OutputDevice::DrawTransparent( const GDIMetaFile& rMtf, const Point& rPos, const Size& rSize,

                                    const Point& rMtfPos, const Size& rMtfSize,

                                    const Gradient& rTransparenceGradient )

{

    assert(!is_double_buffered_window());

    const Color aBlack( COL_BLACK );

    if( mpMetaFile )

    {

         // missing here is to map the data using the DeviceTransformation

        mpMetaFile->AddAction( new MetaFloatTransparentAction( rMtf, rPos, rSize, rTransparenceGradient ) );

    }

    if ( !IsDeviceOutputNecessary() )

        return;

    if( ( rTransparenceGradient.GetStartColor() == aBlack && rTransparenceGradient.GetEndColor() == aBlack ) ||

        ( mnDrawMode & DrawModeFlags::NoTransparency ) )

    {

        const_cast<GDIMetaFile&>(rMtf).WindStart();

        const_cast<GDIMetaFile&>(rMtf).Play(*this, rMtfPos, rMtfSize);

        const_cast<GDIMetaFile&>(rMtf).WindStart();

    }

    else

    {

        GDIMetaFile* pOldMetaFile = mpMetaFile;

        tools::Rectangle aOutRect( LogicToPixel( tools::Rectangle(rPos, rSize) ) );

        Point aPoint;

        tools::Rectangle aDstRect( aPoint, GetOutputSizePixel() );

        mpMetaFile = nullptr;

        aDstRect.Intersection( aOutRect );

        ClipToPaintRegion( aDstRect );

        if( !aDstRect.IsEmpty() )

        {

            // Create transparent buffer

            ScopedVclPtrInstance<VirtualDevice> xVDev(DeviceFormat::WITH_ALPHA);

            xVDev->SetDPIX(GetDPIX());

            xVDev->SetDPIY(GetDPIY());

            if( xVDev->SetOutputSizePixel( aDstRect.GetSize(), true, true ) )

            {

                // tdf#150610 fix broken rendering of text meta actions

                // Even when drawing to a VirtualDevice that has antialiasing

                // disabled, text will still be drawn with some antialiased

                // pixels on HiDPI displays. So, use the antialiasing enabled

                // code to render if there are any text meta actions in the

                // metafile.

                if(GetAntialiasing() != AntialiasingFlags::NONE || rPos != rMtfPos || rSize != rMtfSize)

                {

                    // #i102109#

                    // For MetaFile replay (see task) it may now be necessary to take

                    // into account that the content is AntiAlialiased and needs to be masked

                    // like that. Instead of masking, i will use a copy-modify-paste cycle

                    // here (as i already use in the VclPrimiziveRenderer with success)

                    xVDev->SetAntialiasing(GetAntialiasing());

                    // create MapMode for buffer (offset needed) and set

                    MapMode aMap(GetMapMode());

                    const Point aOutPos(PixelToLogic(aDstRect.TopLeft()));

                    aMap.SetOrigin(Point(-aOutPos.X(), -aOutPos.Y()));

                    xVDev->SetMapMode(aMap);

                    // copy MapMode state and disable for target

                    const bool bOrigMapModeEnabled(IsMapModeEnabled());

                    EnableMapMode(false);

                    // copy MapMode state and disable for buffer

                    const bool bBufferMapModeEnabled(xVDev->IsMapModeEnabled());

                    xVDev->EnableMapMode(false);

                    // copy content from original to buffer

                    xVDev->DrawOutDev( aPoint, xVDev->GetOutputSizePixel(), // dest

                                       aDstRect.TopLeft(), xVDev->GetOutputSizePixel(), // source

                                       *this);

                    // draw MetaFile to buffer

                    xVDev->EnableMapMode(bBufferMapModeEnabled);

                    const_cast<GDIMetaFile&>(rMtf).WindStart();

                    const_cast<GDIMetaFile&>(rMtf).Play(*xVDev, rMtfPos, rMtfSize);

                    const_cast<GDIMetaFile&>(rMtf).WindStart();

                    // get content bitmap from buffer

                    xVDev->EnableMapMode(false);

                    const Bitmap aPaint(xVDev->GetBitmap(aPoint, xVDev->GetOutputSizePixel()));

                    // create alpha mask from gradient and get as Bitmap

                    xVDev->EnableMapMode(bBufferMapModeEnabled);

                    xVDev->SetDrawMode(DrawModeFlags::GrayGradient);

                    // Related tdf#150610 draw gradient to VirtualDevice bounds

                    // If we are here and the metafile bounds differs from the

                    // VirtualDevice bounds so that we apply the transparency

                    // gradient to any pixels drawn outside of the metafile

                    // bounds.

                    xVDev->DrawGradient(tools::Rectangle(rPos, rSize), rTransparenceGradient);

                    xVDev->SetDrawMode(DrawModeFlags::Default);

                    xVDev->EnableMapMode(false);

                    AlphaMask aAlpha(xVDev->GetBitmap(aPoint, xVDev->GetOutputSizePixel()));

                    const AlphaMask aPaintAlpha(aPaint.CreateAlphaMask());

                    // The alpha mask is inverted from what

                    // is expected so invert it again

                    aAlpha.Invert(); // convert to alpha

                    aAlpha.BlendWith(aPaintAlpha);

                    xVDev.disposeAndClear();

                    // draw masked content to target and restore MapMode

                    DrawBitmap(aDstRect.TopLeft(), Bitmap(aPaint.CreateColorBitmap(), aAlpha));

                    EnableMapMode(bOrigMapModeEnabled);

                }

                else

                {

                    MapMode aMap( GetMapMode() );

                    Point aOutPos( PixelToLogic( aDstRect.TopLeft() ) );

                    const bool bOldMap = mbMap;

                    aMap.SetOrigin( Point( -aOutPos.X(), -aOutPos.Y() ) );

                    xVDev->SetMapMode( aMap );

                    const bool bVDevOldMap = xVDev->IsMapModeEnabled();

                    // create paint bitmap

                    const_cast<GDIMetaFile&>(rMtf).WindStart();

                    const_cast<GDIMetaFile&>(rMtf).Play(*xVDev, rMtfPos, rMtfSize);

                    const_cast<GDIMetaFile&>(rMtf).WindStart();

                    xVDev->EnableMapMode( false );

                    Bitmap aPaint(xVDev->GetBitmap(Point(), xVDev->GetOutputSizePixel()));

                    xVDev->EnableMapMode( bVDevOldMap ); // #i35331#: MUST NOT use EnableMapMode( sal_True ) here!

                    // create alpha mask from gradient

                    xVDev->SetDrawMode( DrawModeFlags::GrayGradient );

                    xVDev->DrawGradient( tools::Rectangle( rMtfPos, rMtfSize ), rTransparenceGradient );

                    xVDev->SetDrawMode( DrawModeFlags::Default );

                    xVDev->EnableMapMode( false );

                    AlphaMask aAlpha(xVDev->GetBitmap(Point(), xVDev->GetOutputSizePixel()));

                    const AlphaMask aPaintAlpha(aPaint.CreateAlphaMask());

                    // The alpha mask is inverted from what

                    // is expected so invert it again

                    aAlpha.Invert(); // convert to alpha

                    aAlpha.BlendWith(aPaintAlpha);

                    xVDev.disposeAndClear();

                    EnableMapMode( false );

                    DrawBitmap(aDstRect.TopLeft(), Bitmap(aPaint.CreateColorBitmap(), aAlpha));

                    EnableMapMode( bOldMap );

                }

            }

        }

        mpMetaFile = pOldMetaFile;

    }

}

typedef ::std::pair< MetaAction*, int > Component; // MetaAction plus index in metafile

namespace {

// List of (intersecting) actions, plus overall bounds

struct ConnectedComponents

{

    ConnectedComponents() :

        aComponentList(),

        aBounds(),

        aBgColor(COL_WHITE),

        bIsSpecial(false),

        bIsFullyTransparent(false)

    {}

    ::std::list< Component > aComponentList;

    tools::Rectangle       aBounds;

    Color           aBgColor;

    bool            bIsSpecial;

    bool            bIsFullyTransparent;

};

}

namespace {

/** Determines whether the action can handle transparency correctly

  (i.e. when painted on white background, does the action still look

  correct)?

 */

bool DoesActionHandleTransparency( const MetaAction& rAct )

{

    // MetaActionType::FLOATTRANSPARENT can contain a whole metafile,

    // which is to be rendered with the given transparent gradient. We

    // currently cannot emulate transparent painting on a white

    // background reliably.

    // the remainder can handle printing itself correctly on a uniform

    // white background.

    switch( rAct.GetType() )

    {

        case MetaActionType::Transparent:

        case MetaActionType::BMPEX:

        case MetaActionType::BMPEXSCALE:

        case MetaActionType::BMPEXSCALEPART:

            return true;

        default:

            return false;

    }

}

bool doesRectCoverWithUniformColor(

        tools::Rectangle const & rPrevRect,

        tools::Rectangle const & rCurrRect,

        OutputDevice const & rMapModeVDev)

{

    // shape needs to fully cover previous content, and have uniform

    // color

    return (rMapModeVDev.LogicToPixel(rCurrRect).Contains(rPrevRect) &&

        rMapModeVDev.IsFillColor());

}

/** Check whether rCurrRect rectangle fully covers io_rPrevRect - if

    yes, return true and update o_rBgColor

 */

bool checkRect( tools::Rectangle&       io_rPrevRect,

                       Color&           o_rBgColor,

                       const tools::Rectangle& rCurrRect,

                       OutputDevice const &    rMapModeVDev )

{

    bool bRet = doesRectCoverWithUniformColor(io_rPrevRect, rCurrRect, rMapModeVDev);

    if( bRet )

    {

        io_rPrevRect = rCurrRect;

        o_rBgColor = rMapModeVDev.GetFillColor();

    }

    return bRet;

}

/** #107169# Convert to Bitmap with appropriately blended

    color. Convert MetaTransparentAction to plain polygon,

    appropriately colored

    @param o_rMtf

    Add converted actions to this metafile

*/

void ImplConvertTransparentAction( GDIMetaFile&        o_rMtf,

                                   const MetaAction&   rAct,

                                   const OutputDevice& rStateOutDev,

                                   Color               aBgColor )

{

    if (rAct.GetType() == MetaActionType::Transparent)

    {

        const MetaTransparentAction* pTransAct = static_cast<const MetaTransparentAction*>(&rAct);

        sal_uInt16 nTransparency( pTransAct->GetTransparence() );

        // #i10613# Respect transparency for draw color

        if (nTransparency)

        {

            o_rMtf.AddAction(new MetaPushAction(vcl::PushFlags::LINECOLOR|vcl::PushFlags::FILLCOLOR));

            // assume white background for alpha blending

            Color aLineColor(rStateOutDev.GetLineColor());

            aLineColor.SetRed(static_cast<sal_uInt8>((255*nTransparency + (100 - nTransparency) * aLineColor.GetRed()) / 100));

            aLineColor.SetGreen(static_cast<sal_uInt8>((255*nTransparency + (100 - nTransparency) * aLineColor.GetGreen()) / 100));

            aLineColor.SetBlue(static_cast<sal_uInt8>((255*nTransparency + (100 - nTransparency) * aLineColor.GetBlue()) / 100));

            o_rMtf.AddAction(new MetaLineColorAction(aLineColor, true));

            Color aFillColor(rStateOutDev.GetFillColor());

            aFillColor.SetRed(static_cast<sal_uInt8>((255*nTransparency + (100 - nTransparency)*aFillColor.GetRed()) / 100));

            aFillColor.SetGreen(static_cast<sal_uInt8>((255*nTransparency + (100 - nTransparency)*aFillColor.GetGreen()) / 100));

            aFillColor.SetBlue(static_cast<sal_uInt8>((255*nTransparency + (100 - nTransparency)*aFillColor.GetBlue()) / 100));

            o_rMtf.AddAction(new MetaFillColorAction(aFillColor, true));

        }

        o_rMtf.AddAction(new MetaPolyPolygonAction(pTransAct->GetPolyPolygon()));

        if(nTransparency)

            o_rMtf.AddAction(new MetaPopAction());

    }

    else

    {

        Bitmap aBmp;

        switch (rAct.GetType())

        {

            case MetaActionType::BMPEX:

                aBmp = static_cast<const MetaBmpExAction&>(rAct).GetBitmap();

                break;

            case MetaActionType::BMPEXSCALE:

            case MetaActionType::BMPEXSCALEPART:

                aBmp = static_cast<const MetaBmpExScaleAction&>(rAct).GetBitmap();

                break;

            case MetaActionType::Transparent:

            default:

                OSL_FAIL("Printer::GetPreparedMetafile impossible state reached");

                break;

        }

        if (aBmp.HasAlpha())

        {

            AlphaMask aMask = aBmp.CreateAlphaMask();

            // blend with alpha channel

            aBmp.Convert(BmpConversion::N24Bit);

            aBmp.Blend(aMask, aBgColor);

        }

        // add corresponding action

        switch (rAct.GetType())

        {

            case MetaActionType::BMPEX:

                o_rMtf.AddAction(new MetaBmpAction(

                                       static_cast<const MetaBmpExAction&>(rAct).GetPoint(),

                                       aBmp));

                break;

            case MetaActionType::BMPEXSCALE:

                o_rMtf.AddAction(new MetaBmpScaleAction(

                                       static_cast<const MetaBmpExScaleAction&>(rAct).GetPoint(),

                                       static_cast<const MetaBmpExScaleAction&>(rAct).GetSize(),

                                       aBmp));

                break;

            case MetaActionType::BMPEXSCALEPART:

                o_rMtf.AddAction(new MetaBmpScalePartAction(

                                       static_cast<const MetaBmpExScalePartAction&>(rAct).GetDestPoint(),

                                       static_cast<const MetaBmpExScalePartAction&>(rAct).GetDestSize(),

                                       static_cast<const MetaBmpExScalePartAction&>(rAct).GetSrcPoint(),

                                       static_cast<const MetaBmpExScalePartAction&>(rAct).GetSrcSize(),

                                       aBmp));

                break;

            default:

                OSL_FAIL("Unexpected case");

                break;

        }

    }

}

// #i10613# Extracted from ImplCheckRect::ImplCreate

// Returns true, if given action creates visible (i.e. non-transparent) output

bool ImplIsNotTransparent( const MetaAction& rAct, const OutputDevice& rOut )

{

    const bool  bLineTransparency( !rOut.IsLineColor() || rOut.GetLineColor().IsFullyTransparent() );

    const bool  bFillTransparency( !rOut.IsFillColor() || rOut.GetFillColor().IsFullyTransparent() );

    bool        bRet( false );

    switch( rAct.GetType() )

    {

        case MetaActionType::POINT:

        case MetaActionType::LINE:

        case MetaActionType::POLYLINE:

            if( !bLineTransparency )

                bRet = true;

            break;

        case MetaActionType::RECT:

            if( !bLineTransparency || !bFillTransparency )

                bRet = true;

            break;

        case MetaActionType::ROUNDRECT:

            if( !bLineTransparency || !bFillTransparency )

                bRet = true;

            break;

        case MetaActionType::ELLIPSE:

            if( !bLineTransparency || !bFillTransparency )

                bRet = true;

            break;

        case MetaActionType::ARC:

            if( !bLineTransparency || !bFillTransparency )

                bRet = true;

            break;

        case MetaActionType::PIE:

            if( !bLineTransparency || !bFillTransparency )

                bRet = true;

            break;

        case MetaActionType::CHORD:

            if( !bLineTransparency || !bFillTransparency )

                bRet = true;

            break;

        case MetaActionType::POLYGON:

            if( !bLineTransparency || !bFillTransparency )

                bRet = true;

            break;

        case MetaActionType::POLYPOLYGON:

            if( !bLineTransparency || !bFillTransparency )

                bRet = true;

            break;

        case MetaActionType::TEXT:

        {

            const MetaTextAction& rTextAct = static_cast<const MetaTextAction&>(rAct);

            const OUString aString( rTextAct.GetText().copy(rTextAct.GetIndex(), rTextAct.GetLen()) );

            if (!aString.isEmpty())

                bRet = true;

        }

        break;

        case MetaActionType::TEXTARRAY:

        {

            const MetaTextArrayAction& rTextAct = static_cast<const MetaTextArrayAction&>(rAct);

            const OUString aString( rTextAct.GetText().copy(rTextAct.GetIndex(), rTextAct.GetLen()) );

            if (!aString.isEmpty())

                bRet = true;

        }

        break;

        case MetaActionType::PIXEL:

        case MetaActionType::BMP:

        case MetaActionType::BMPSCALE:

        case MetaActionType::BMPSCALEPART:

        case MetaActionType::BMPEX:

        case MetaActionType::BMPEXSCALE:

        case MetaActionType::BMPEXSCALEPART:

        case MetaActionType::MASK:

        case MetaActionType::MASKSCALE:

        case MetaActionType::MASKSCALEPART:

        case MetaActionType::GRADIENT:

        case MetaActionType::GRADIENTEX:

        case MetaActionType::HATCH:

        case MetaActionType::WALLPAPER:

        case MetaActionType::Transparent:

        case MetaActionType::FLOATTRANSPARENT:

        case MetaActionType::EPS:

        case MetaActionType::TEXTRECT:

        case MetaActionType::STRETCHTEXT:

        case MetaActionType::TEXTLINE:

            // all other actions: generate non-transparent output

            bRet = true;

            break;

        default:

            break;

    }

    return bRet;

}

// #i10613# Extracted from ImplCheckRect::ImplCreate

tools::Rectangle ImplCalcActionBounds( const MetaAction& rAct, const OutputDevice& rOut )

{

    tools::Rectangle aActionBounds;

    switch( rAct.GetType() )

    {

        case MetaActionType::PIXEL:

            aActionBounds = tools::Rectangle( static_cast<const MetaPixelAction&>(rAct).GetPoint(), Size( 1, 1 ) );

            break;

        case MetaActionType::POINT:

            aActionBounds = tools::Rectangle( static_cast<const MetaPointAction&>(rAct).GetPoint(), Size( 1, 1 ) );

            break;

        case MetaActionType::LINE:

        {

            const MetaLineAction& rMetaLineAction = static_cast<const MetaLineAction&>(rAct);