/* -*- 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 <cmath>

#include <memory>

#include "vclmetafileprocessor2d.hxx"

#include <rtl/ustring.hxx>

#include <tools/gen.hxx>

#include <tools/mapunit.hxx>

#include <tools/stream.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <comphelper/flagguard.hxx>

#include <comphelper/processfactory.hxx>

#include <basegfx/polygon/b2dpolygonclipper.hxx>

#include <basegfx/polygon/b2dpolypolygontools.hxx>

#include <basegfx/polygon/b2dpolygontools.hxx>

#include <basegfx/polygon/b2dlinegeometry.hxx>

#include <vcl/virdev.hxx>

#include <vcl/gdimtf.hxx>

#include <vcl/gradient.hxx>

#include <vcl/graphictools.hxx>

#include <tools/lazydelete.hxx>

#include <vcl/metaact.hxx>

#include <vcl/rendercontext/DrawModeFlags.hxx>

#include <vcl/graph.hxx> // for PDFExtOutDevData Graphic support

#include <vcl/formpdfexport.hxx> // for PDFExtOutDevData Graphic support

#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>

#include <drawinglayer/primitive2d/textprimitive2d.hxx>

#include <drawinglayer/primitive2d/PolygonHairlinePrimitive2D.hxx>

#include <drawinglayer/primitive2d/PolygonStrokeArrowPrimitive2D.hxx>

#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx>

#include <drawinglayer/primitive2d/PolyPolygonGradientPrimitive2D.hxx>

#include <drawinglayer/primitive2d/PolyPolygonHatchPrimitive2D.hxx>

#include <drawinglayer/primitive2d/PolyPolygonGraphicPrimitive2D.hxx>

#include <drawinglayer/primitive2d/bitmapprimitive2d.hxx>

#include <drawinglayer/primitive2d/maskprimitive2d.hxx>

#include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx>

#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>

#include <drawinglayer/primitive2d/transparenceprimitive2d.hxx>

#include <drawinglayer/primitive2d/fillgradientprimitive2d.hxx>

#include <drawinglayer/primitive2d/transformprimitive2d.hxx>

#include <drawinglayer/primitive2d/markerarrayprimitive2d.hxx>

#include <drawinglayer/primitive2d/pointarrayprimitive2d.hxx>

#include <drawinglayer/primitive2d/texthierarchyprimitive2d.hxx>

#include <drawinglayer/primitive2d/controlprimitive2d.hxx>

#include <drawinglayer/primitive2d/graphicprimitive2d.hxx>

#include <drawinglayer/primitive2d/pagepreviewprimitive2d.hxx>

#include <drawinglayer/primitive2d/epsprimitive2d.hxx>

#include <drawinglayer/primitive2d/structuretagprimitive2d.hxx>

#include <drawinglayer/primitive2d/objectinfoprimitive2d.hxx> // for Title/Description metadata

#include <drawinglayer/primitive2d/fillgraphicprimitive2d.hxx>

#include <drawinglayer/converters.hxx>

#include <basegfx/matrix/b2dhommatrixtools.hxx>

#include <tools/vcompat.hxx>

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

#include <com/sun/star/i18n/BreakIterator.hpp>

#include <com/sun/star/i18n/CharacterIteratorMode.hpp>

#include <com/sun/star/i18n/WordType.hpp>

#include <com/sun/star/beans/XPropertySet.hpp>

using namespace com::sun::star;

// #112245# definition for maximum allowed point count due to Metafile target.

// To be on the safe side with the old tools polygon, use slightly less than

// the theoretical maximum (bad experiences with tools polygon)

#define MAX_POLYGON_POINT_COUNT_METAFILE (0x0000fff0)

namespace

{

// #112245# helper to split line polygon in half

void splitLinePolygon(const basegfx::B2DPolygon& rBasePolygon, basegfx::B2DPolygon& o_aLeft,

                      basegfx::B2DPolygon& o_aRight)

{

    const sal_uInt32 nCount(rBasePolygon.count());

    if (nCount)

    {

        const sal_uInt32 nHalfCount((nCount - 1) >> 1);

        o_aLeft = basegfx::B2DPolygon(rBasePolygon, 0, nHalfCount + 1);

        o_aLeft.setClosed(false);

        o_aRight = basegfx::B2DPolygon(rBasePolygon, nHalfCount, nCount - nHalfCount);

        o_aRight.setClosed(false);

        if (rBasePolygon.isClosed())

        {

            o_aRight.append(rBasePolygon.getB2DPoint(0));

            if (rBasePolygon.areControlPointsUsed())

            {

                o_aRight.setControlPoints(o_aRight.count() - 1, rBasePolygon.getPrevControlPoint(0),

                                          rBasePolygon.getNextControlPoint(0));

            }

        }

    }

    else

    {

        o_aLeft.clear();

        o_aRight.clear();

    }

}

// #112245# helper to evtl. split filled polygons to maximum metafile point count

void fillPolyPolygonNeededToBeSplit(basegfx::B2DPolyPolygon& rPolyPolygon)

{

    const sal_uInt32 nPolyCount(rPolyPolygon.count());

    if (!nPolyCount)

        return;

    basegfx::B2DPolyPolygon aSplitted;

    for (sal_uInt32 a(0); a < nPolyCount; a++)

    {

        const basegfx::B2DPolygon& aCandidate(rPolyPolygon.getB2DPolygon(a));

        const sal_uInt32 nPointCount(aCandidate.count());

        bool bNeedToSplit(false);

        if (aCandidate.areControlPointsUsed())

        {

            // compare with the maximum for bezier curved polygons

            bNeedToSplit = nPointCount > ((MAX_POLYGON_POINT_COUNT_METAFILE / 3L) - 1);

        }

        else

        {

            // compare with the maximum for simple point polygons

            bNeedToSplit = nPointCount > (MAX_POLYGON_POINT_COUNT_METAFILE - 1);

        }

        if (bNeedToSplit)

        {

            // need to split the partial polygon

            const basegfx::B2DRange aRange(aCandidate.getB2DRange());

            const basegfx::B2DPoint aCenter(aRange.getCenter());

            if (aRange.getWidth() > aRange.getHeight())

            {

                // clip in left and right

                const basegfx::B2DPolyPolygon aLeft(basegfx::utils::clipPolygonOnParallelAxis(

                    aCandidate, false, true, aCenter.getX(), false));

                const basegfx::B2DPolyPolygon aRight(basegfx::utils::clipPolygonOnParallelAxis(

                    aCandidate, false, false, aCenter.getX(), false));

                aSplitted.append(aLeft);

                aSplitted.append(aRight);

            }

            else

            {

                // clip in top and bottom

                const basegfx::B2DPolyPolygon aTop(basegfx::utils::clipPolygonOnParallelAxis(

                    aCandidate, true, true, aCenter.getY(), false));

                const basegfx::B2DPolyPolygon aBottom(basegfx::utils::clipPolygonOnParallelAxis(

                    aCandidate, true, false, aCenter.getY(), false));

                aSplitted.append(aTop);

                aSplitted.append(aBottom);

            }

        }

        else

        {

            aSplitted.append(aCandidate);

        }

    }

    if (aSplitted.count() != nPolyCount)

    {

        rPolyPolygon = std::move(aSplitted);

    }

}

/** Filter input polypolygon for effectively empty sub-fills

    Needed to fix fdo#37559

    @param rPoly

    tools::PolyPolygon to filter

    @return converted tools PolyPolygon, w/o one-point fills

 */

tools::PolyPolygon getFillPolyPolygon(const ::basegfx::B2DPolyPolygon& rPoly)

{

    // filter input rPoly

    basegfx::B2DPolyPolygon aPoly;

    sal_uInt32 nCount(rPoly.count());

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

    {

        const basegfx::B2DPolygon& aCandidate(rPoly.getB2DPolygon(i));

        if (!aCandidate.isClosed() || aCandidate.count() > 1)

            aPoly.append(aCandidate);

    }

    return tools::PolyPolygon(aPoly);

}

} // end of anonymous namespace

namespace drawinglayer::processor2d

{

tools::Rectangle

VclMetafileProcessor2D::impDumpToMetaFile(const primitive2d::Primitive2DContainer& rContent,

                                          GDIMetaFile& o_rContentMetafile)

{

    // Prepare VDev, MetaFile and connections

    OutputDevice* pLastOutputDevice = mpOutputDevice;

    GDIMetaFile* pLastMetafile = mpMetaFile;

    basegfx::B2DRange aPrimitiveRange(rContent.getB2DRange(getViewInformation2D()));

    // transform primitive range with current transformation (e.g shadow offset)

    aPrimitiveRange.transform(maCurrentTransformation);

    const tools::Rectangle aPrimitiveRectangle(

        basegfx::fround<tools::Long>(aPrimitiveRange.getMinX()),

        basegfx::fround<tools::Long>(aPrimitiveRange.getMinY()),

        basegfx::fround<tools::Long>(aPrimitiveRange.getMaxX()),

        basegfx::fround<tools::Long>(aPrimitiveRange.getMaxY()));

    ScopedVclPtrInstance<VirtualDevice> aContentVDev;

    MapMode aNewMapMode(pLastOutputDevice->GetMapMode());

    mpOutputDevice = aContentVDev.get();

    mpMetaFile = &o_rContentMetafile;

    aContentVDev->EnableOutput(false);

    aContentVDev->SetMapMode(pLastOutputDevice->GetMapMode());

    o_rContentMetafile.Record(aContentVDev.get());

    aContentVDev->SetLineColor(pLastOutputDevice->GetLineColor());

    aContentVDev->SetFillColor(pLastOutputDevice->GetFillColor());

    aContentVDev->SetFont(pLastOutputDevice->GetFont());

    aContentVDev->SetDrawMode(pLastOutputDevice->GetDrawMode());

    aContentVDev->SetSettings(pLastOutputDevice->GetSettings());

    aContentVDev->SetRefPoint(pLastOutputDevice->GetRefPoint());

    // dump to MetaFile

    process(rContent);

    // cleanups

    o_rContentMetafile.Stop();

    o_rContentMetafile.WindStart();

    aNewMapMode.SetOrigin(aPrimitiveRectangle.TopLeft());

    o_rContentMetafile.SetPrefMapMode(aNewMapMode);

    o_rContentMetafile.SetPrefSize(aPrimitiveRectangle.GetSize());

    mpOutputDevice = pLastOutputDevice;

    mpMetaFile = pLastMetafile;

    return aPrimitiveRectangle;

}

void VclMetafileProcessor2D::impConvertFillGradientAttributeToVCLGradient(

    Gradient& o_rVCLGradient, const attribute::FillGradientAttribute& rFiGrAtt,

    bool bIsTransparenceGradient) const

{

    const basegfx::BColor aStartColor(rFiGrAtt.getColorStops().front().getStopColor());

    const basegfx::BColor aEndColor(rFiGrAtt.getColorStops().back().getStopColor());

    if (bIsTransparenceGradient)

    {

        // it's about transparence channel intensities (black/white), do not use color modifier

        o_rVCLGradient.SetStartColor(Color(aStartColor));

        o_rVCLGradient.SetEndColor(Color(aEndColor));

    }

    else

    {

        // use color modifier to influence start/end color of gradient

        o_rVCLGradient.SetStartColor(Color(maBColorModifierStack.getModifiedColor(aStartColor)));

        o_rVCLGradient.SetEndColor(Color(maBColorModifierStack.getModifiedColor(aEndColor)));

    }

    o_rVCLGradient.SetAngle(

        Degree10(static_cast<sal_uInt32>(basegfx::rad2deg<10>(rFiGrAtt.getAngle()))));

    o_rVCLGradient.SetBorder(static_cast<sal_uInt16>(rFiGrAtt.getBorder() * 100.0));

    o_rVCLGradient.SetOfsX(static_cast<sal_uInt16>(rFiGrAtt.getOffsetX() * 100.0));

    o_rVCLGradient.SetOfsY(static_cast<sal_uInt16>(rFiGrAtt.getOffsetY() * 100.0));

    o_rVCLGradient.SetSteps(rFiGrAtt.getSteps());

    // defaults for intensity; those were computed into the start/end colors already

    o_rVCLGradient.SetStartIntensity(100);

    o_rVCLGradient.SetEndIntensity(100);

    o_rVCLGradient.SetStyle(rFiGrAtt.getStyle());

}

void VclMetafileProcessor2D::impStartSvtGraphicFill(SvtGraphicFill const* pSvtGraphicFill)

{

    if (pSvtGraphicFill && !mnSvtGraphicFillCount)

    {

        SvMemoryStream aMemStm;

        WriteSvtGraphicFill(aMemStm, *pSvtGraphicFill);

        mpMetaFile->AddAction(new MetaCommentAction(

            "XPATHFILL_SEQ_BEGIN"_ostr, 0, static_cast<const sal_uInt8*>(aMemStm.GetData()),

            aMemStm.TellEnd()));

        mnSvtGraphicFillCount++;

    }

}

void VclMetafileProcessor2D::impEndSvtGraphicFill(SvtGraphicFill const* pSvtGraphicFill)

{

    if (pSvtGraphicFill && mnSvtGraphicFillCount)

    {

        mnSvtGraphicFillCount--;

        mpMetaFile->AddAction(new MetaCommentAction("XPATHFILL_SEQ_END"_ostr));

    }

}

double VclMetafileProcessor2D::getTransformedLineWidth(double fWidth) const

{

    // #i113922# the LineWidth is duplicated in the MetaPolylineAction,

    // and also inside the SvtGraphicStroke and needs transforming into

    // the same space as its coordinates here cf. fdo#61789

    // This is a partial fix. When an object transformation is used which

    // e.g. contains a scaleX != scaleY, an unproportional scaling will happen.

    const basegfx::B2DVector aDiscreteUnit(maCurrentTransformation

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

    return aDiscreteUnit.getLength();

}

std::unique_ptr<SvtGraphicStroke> VclMetafileProcessor2D::impTryToCreateSvtGraphicStroke(

    const basegfx::B2DPolygon& rB2DPolygon, const basegfx::BColor* pColor,

    const attribute::LineAttribute* pLineAttribute,

    const attribute::StrokeAttribute* pStrokeAttribute,

    const attribute::LineStartEndAttribute* pStart, const attribute::LineStartEndAttribute* pEnd)

{

    std::unique_ptr<SvtGraphicStroke> pRetval;

    if (rB2DPolygon.count() && !mnSvtGraphicStrokeCount)

    {

        basegfx::B2DPolygon aLocalPolygon(rB2DPolygon);

        basegfx::BColor aStrokeColor;

        basegfx::B2DPolyPolygon aStartArrow;

        basegfx::B2DPolyPolygon aEndArrow;

        if (pColor)

        {

            aStrokeColor = *pColor;

        }

        else if (pLineAttribute)

        {

            aStrokeColor = maBColorModifierStack.getModifiedColor(pLineAttribute->getColor());

        }

        // It IS needed to record the stroke color at all in the metafile,

        // SvtGraphicStroke has NO entry for stroke color(!)

        mpOutputDevice->SetLineColor(Color(aStrokeColor));

        if (!aLocalPolygon.isClosed())

        {

            const bool bCalcStart = pStart && pStart->isActive();

            const bool bCalcEnd = pEnd && pEnd->isActive();

            if (bCalcStart || bCalcEnd)

            {

                double fPolyLength = basegfx::utils::getLength(aLocalPolygon);

                double fStart(0.0);

                double fEnd(0.0);

                if (bCalcStart)

                {

                    aStartArrow = basegfx::utils::createAreaGeometryForLineStartEnd(

                        aLocalPolygon, pStart->getB2DPolyPolygon(), true, pStart->getWidth(),

                        fPolyLength, pStart->isCentered() ? 0.5 : 0.0, &fStart);

                }

                if (bCalcEnd)

                {

                    aEndArrow = basegfx::utils::createAreaGeometryForLineStartEnd(

                        aLocalPolygon, pEnd->getB2DPolyPolygon(), false, pEnd->getWidth(),

                        fPolyLength, pEnd->isCentered() ? 0.5 : 0.0, &fEnd);

                }

                if (0.0 != fStart || 0.0 != fEnd)

                {

                    // build new poly, consume something from old poly

                    aLocalPolygon = basegfx::utils::getSnippetAbsolute(

                        aLocalPolygon, fStart, fPolyLength - fEnd, fPolyLength);

                }

            }

        }

        SvtGraphicStroke::JoinType eJoin(SvtGraphicStroke::joinNone);

        SvtGraphicStroke::CapType eCap(SvtGraphicStroke::capButt);

        double fLineWidth(0.0);

        double fMiterLength(0.0);

        SvtGraphicStroke::DashArray aDashArray;

        if (pLineAttribute)

        {

            fLineWidth = fMiterLength = getTransformedLineWidth(pLineAttribute->getWidth());

            // get Join

            switch (pLineAttribute->getLineJoin())

            {

                case basegfx::B2DLineJoin::NONE:

                {

                    eJoin = SvtGraphicStroke::joinNone;

                    break;

                }

                case basegfx::B2DLineJoin::Bevel:

                {

                    eJoin = SvtGraphicStroke::joinBevel;

                    break;

                }

                case basegfx::B2DLineJoin::Miter:

                {

                    eJoin = SvtGraphicStroke::joinMiter;

                    // ATM 15 degrees is assumed

                    // TODO wait for P1383R0 and C++20's std::numbers::pi

                    fMiterLength /= std::sin(M_PI / 12);

                    break;

                }

                case basegfx::B2DLineJoin::Round:

                {

                    eJoin = SvtGraphicStroke::joinRound;

                    break;

                }

            }

            // get stroke

            switch (pLineAttribute->getLineCap())

            {

                default: /* css::drawing::LineCap_BUTT */

                {

                    eCap = SvtGraphicStroke::capButt;

                    break;

                }

                case css::drawing::LineCap_ROUND:

                {

                    eCap = SvtGraphicStroke::capRound;

                    break;

                }

                case css::drawing::LineCap_SQUARE:

                {

                    eCap = SvtGraphicStroke::capSquare;

                    break;

                }

            }

        }

        if (pStrokeAttribute)

        {

            // copy dash array

            aDashArray = pStrokeAttribute->getDotDashArray();

        }

        // #i101734# apply current object transformation to created geometry.

        // This is a partial fix. When an object transformation is used which

        // e.g. contains a scaleX != scaleY, an unproportional scaling would

        // have to be applied to the evtl. existing fat line. The current

        // concept of PDF export and SvtGraphicStroke usage does simply not

        // allow handling such definitions. The only clean way would be to

        // add the transformation to SvtGraphicStroke and to handle it there

        aLocalPolygon.transform(maCurrentTransformation);

        aStartArrow.transform(maCurrentTransformation);

        aEndArrow.transform(maCurrentTransformation);

        pRetval.reset(

            new SvtGraphicStroke(tools::Polygon(aLocalPolygon), tools::PolyPolygon(aStartArrow),

                                 tools::PolyPolygon(aEndArrow), mfCurrentUnifiedTransparence,

                                 fLineWidth, eCap, eJoin, fMiterLength, std::move(aDashArray)));

    }

    return pRetval;

}

void VclMetafileProcessor2D::impStartSvtGraphicStroke(SvtGraphicStroke const* pSvtGraphicStroke)

{

    if (pSvtGraphicStroke && !mnSvtGraphicStrokeCount)

    {

        SvMemoryStream aMemStm;

        WriteSvtGraphicStroke(aMemStm, *pSvtGraphicStroke);

        mpMetaFile->AddAction(new MetaCommentAction(

            "XPATHSTROKE_SEQ_BEGIN"_ostr, 0, static_cast<const sal_uInt8*>(aMemStm.GetData()),

            aMemStm.TellEnd()));

        mnSvtGraphicStrokeCount++;

    }

}

void VclMetafileProcessor2D::impEndSvtGraphicStroke(SvtGraphicStroke const* pSvtGraphicStroke)

{

    if (pSvtGraphicStroke && mnSvtGraphicStrokeCount)

    {

        mnSvtGraphicStrokeCount--;

        mpMetaFile->AddAction(new MetaCommentAction("XPATHSTROKE_SEQ_END"_ostr));

    }

}

void VclMetafileProcessor2D::popStructureElement(vcl::pdf::StructElement eElem)

{

    if (!maListElements.empty() && maListElements.top() == eElem)

    {

        maListElements.pop();

        mpPDFExtOutDevData->EndStructureElement();

    }

}

void VclMetafileProcessor2D::popListItem()

{

    popStructureElement(vcl::pdf::StructElement::LIBody);

    popStructureElement(vcl::pdf::StructElement::ListItem);

}

void VclMetafileProcessor2D::popList()

{

    popListItem();

    popStructureElement(vcl::pdf::StructElement::List);

}

VclMetafileProcessor2D::VclMetafileProcessor2D(const geometry::ViewInformation2D& rViewInformation,

                                               OutputDevice& rOutDev)

    : VclProcessor2D(rViewInformation, rOutDev)

    , mpMetaFile(rOutDev.GetConnectMetaFile())

    , mnSvtGraphicFillCount(0)

    , mnSvtGraphicStrokeCount(0)

    , mfCurrentUnifiedTransparence(0.0)

    , mpPDFExtOutDevData(dynamic_cast<vcl::PDFExtOutDevData*>(rOutDev.GetExtOutDevData()))

    , mnCurrentOutlineLevel(-1)

    , mbInListItem(false)

    , mbBulletPresent(false)

{

    OSL_ENSURE(rOutDev.GetConnectMetaFile(),

               "VclMetafileProcessor2D: Used on OutDev which has no MetaFile Target (!)");

    // draw to logic coordinates, do not initialize maCurrentTransformation to viewTransformation

    // but only to ObjectTransformation. Do not change MapMode of destination.

    maCurrentTransformation = rViewInformation.getObjectTransformation();

}

VclMetafileProcessor2D::~VclMetafileProcessor2D()

{

    // MapMode was not changed, no restore necessary

}

/***********************************************************************************************

    Support of MetaCommentActions in the VclMetafileProcessor2D

    Found MetaCommentActions and how they are supported:

    XGRAD_SEQ_BEGIN, XGRAD_SEQ_END:

    Used inside OutputDevice::DrawGradient to mark the start and end of a MetaGradientEx action.

    It is used in various exporters/importers to have direct access to the gradient before it

    is rendered by VCL (and thus fragmented to polygon color actions and others). On that base, e.g.

    the Metafile to SdrObject import creates its gradient objects.

    Best (and safest) way to support it here is to use PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D,

    map it back to the corresponding tools tools::PolyPolygon and the Gradient and just call

    OutputDevice::DrawGradient which creates the necessary compatible actions.

    XPATHFILL_SEQ_BEGIN, XPATHFILL_SEQ_END:

    Two producers, one is vcl/source/gdi/gdimtf.cxx, line 1273. There, it is transformed

    inside GDIMetaFile::Rotate, nothing to take care of here.

    The second producer is in graphics/svx/source/svdraw/impgrfll.cxx, line 374. This is used

    with each incarnation of Imp_GraphicFill when a metafile is recorded, fillstyle is not

    XFILL_NONE and not completely transparent. It creates a SvtGraphicFill and streams it

    to the comment action. A closing end token is created in the destructor.

    Usages of Imp_GraphicFill are in Do_Paint_Object-methods of SdrCircObj, SdrPathObj and

    SdrRectObj.

    The token users pick various actions from SvtGraphicFill, so it may need to be added for all kind

    of filled objects, even simple colored polygons. It is added as extra information; the

    Metafile actions between the two tokens are interpreted as output generated from those

    fills. Thus, users have the choice to use the SvtGraphicFill info or the created output

    actions.

    Even for XFillTransparenceItem it is used, thus it may need to be supported in

    UnifiedTransparencePrimitive2D, too, when interpreted as normally filled PolyPolygon.

    Implemented for:

        PRIMITIVE2D_ID_POLYPOLYGONGRAPHICPRIMITIVE2D,

        PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D,

        PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D,

        PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D,

        and for PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D when detected unified transparence

    XPATHSTROKE_SEQ_BEGIN, XPATHSTROKE_SEQ_END:

    Similar to pathfill, but using SvtGraphicStroke instead. It also has two producers where one

    is also the GDIMetaFile::Rotate. Another user is MetaCommentAction::Move which modifies the

    contained path accordingly.

    The other one is SdrObject::Imp_DrawLineGeometry. It's done when MetaFile is set at OutDev and

    only when geometry is a single polygon (!). I see no reason for that; in the PS exporter this

    would hinder to make use of tools::PolyPolygon strokes. I will need to add support at:

        PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D

        PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D

        PRIMITIVE2D_ID_POLYGONSTROKEARROWPRIMITIVE2D

    This can be done hierarchical, too.

    Okay, base implementation done based on those three primitives.

    FIELD_SEQ_BEGIN, FIELD_SEQ_END

    Used from slideshow for URLs, created from diverse SvxField implementations inside

    createBeginComment()/createEndComment(). createBeginComment() is used from editeng\impedit3.cxx

    inside ImpEditEngine::Paint.

    Created TextHierarchyFieldPrimitive2D and added needed infos there; it is a group primitive and wraps

    text primitives (but is not limited to that). It contains the field type if special actions for the

    support of FIELD_SEQ_BEGIN/END are needed; this is the case for Page and URL fields. If more is

    needed, it may be supported there.

    FIELD_SEQ_BEGIN;PageField

    FIELD_SEQ_END

    Okay, these are now completely supported by TextHierarchyFieldPrimitive2D. URL works, too.

    XTEXT

    XTEXT_EOC(i) end of character

    XTEXT_EOW(i) end of word

    XTEXT_EOS(i) end of sentence

    this three are with index and are created with the help of an i18n::XBreakIterator in

    ImplDrawWithComments. Simplifying, moving out text painting, reworking to create some

    data structure for holding those TEXT infos.

    Supported directly by TextSimplePortionPrimitive2D with adding a Locale to the basic text

    primitive. In the MetaFileRenderer, the creation is now done (see below). This has the advantage

    that this creations do not need to be done for all paints all the time. This would be

    expensive since the BreakIterator and it's usage is expensive and for each paint also the

    whole character stops would need to be created.

    Created only for TextDecoratedPortionPrimitive2D due to XTEXT_EOL and XTEXT_EOP (see below)

    XTEXT_EOL() end of line

    XTEXT_EOP() end of paragraph

    First try with boolean marks at TextDecoratedPortionPrimitive2D did not work too well,

    i decided to solve it with structure. I added the TextHierarchyPrimitives for this,

    namely:

    - TextHierarchyLinePrimitive2D: Encapsulates single line

    - TextHierarchyParagraphPrimitive2D: Encapsulates single paragraph

    - TextHierarchyBlockPrimitive2D: encapsulates object texts (only one ATM)

    Those are now supported in hierarchy. This means the MetaFile renderer will support them

    by using them, recursively using their content and adding MetaFile comments as needed.

    This also means that when another text layouter will be used it will be necessary to

    create/support the same HierarchyPrimitives to support users.

    To transport the information using this hierarchy is best suited to all future needs;

    the slideshow will be able to profit from it directly when using primitives; all other

    renderers not interested in the text structure will just ignore the encapsulations.

    XTEXT_PAINTSHAPE_BEGIN, XTEXT_PAINTSHAPE_END

    Supported now by the TextHierarchyBlockPrimitive2D.

    EPSReplacementGraphic:

    Only used in goodies\source\filter.vcl\ieps\ieps.cxx and svx\source\xml\xmlgrhlp.cxx to

    hold the original EPS which was imported in the same MetaFile as first 2 entries. Only

    used to export the original again (if exists).

    Not necessary to support with MetaFileRenderer.

    XTEXT_SCROLLRECT, XTEXT_PAINTRECT

    Currently used to get extra MetaFile infos using GraphicExporter which again uses

    SdrTextObj::GetTextScrollMetaFileAndRectangle(). ATM works with primitives since

    the rectangle data is added directly by the GraphicsExporter as comment. Does not need

    to be adapted at once.

    When adapting later, the only user - the diashow - should directly use the provided

    Animation infos in the appropriate primitives (e.g. AnimatedSwitchPrimitive2D)

    PRNSPOOL_TRANSPARENTBITMAP_BEGIN, PRNSPOOL_TRANSPARENTBITMAP_END

    VCL usage when printing PL -> THB. Okay, THB confirms that it is only used as

    a fix (hack) while VCL printing. It is needed to not downscale a bitmap which

    was explicitly created for the printer already again to some default maximum

    bitmap sizes.

    Nothing to do here for the primitive renderer.

    Support for vcl::PDFExtOutDevData:

    PL knows that SJ did that stuff, it's used to hold a pointer to PDFExtOutDevData at

    the OutDev. When set, some extra data is written there. Trying simple PDF export and

    watching if I get those infos.

    Well, a PDF export does not use e.g. ImpEditEngine::Paint since the PdfFilter uses

    the SdXImpressDocument::render and thus uses the VclMetafileProcessor2D. I will check

    if I get a PDFExtOutDevData at the target output device.

    Indeed, I get one. Checking what all may be done when that extra-device-info is there.

    All in all I have to talk to SJ. I will need to emulate some of those actions, but

    i need to discuss which ones.

    In the future, all those infos would be taken from the primitive sequence anyways,

    thus these extensions would potentially be temporary, too.

    Discussed with SJ, added the necessary support and tested it. Details follow.

    - In ImpEditEngine::Paint, paragraph infos and URL stuff is added.

      Added in primitive MetaFile renderer.

      Checking URL: Indeed, current version exports it, but it is missing in primitive

      CWS version. Adding support.

      Okay, URLs work. Checked, Done.

    - UnoControlPDFExportContact is only created when PDFExtOutDevData is used at the

      target and uno control data is created in UnoControlPDFExportContact::do_PaintObject.

      This was added in primitive MetaFile renderer.

      Checked form control export, it works well. Done.

    - In goodies, in GraphicObject::Draw, when the used Graphic is linked, infos are

      generated. I will need to check what happens here with primitives.

      To support, use of GraphicPrimitive2D (PRIMITIVE2D_ID_GRAPHICPRIMITIVE2D) may be needed.

      Added support, but feature is broken in main version, so i cannot test at all.

      Writing a bug to CL (or SJ) and seeing what happens (#i80380#).

      SJ took a look and we got it working. Tested VCL MetaFile Renderer based export,

      as intended, the original file is exported. Works, Done.

    To be done:

    - Maybe there are more places to take care of for vcl::PDFExtOutDevData!

****************************************************************************************************/

void VclMetafileProcessor2D::processBasePrimitive2D(const primitive2d::BasePrimitive2D& rCandidate)

{

    switch (rCandidate.getPrimitive2DID())

    {

        case PRIMITIVE2D_ID_WRONGSPELLPRIMITIVE2D:

        {

            // directdraw of wrong spell primitive

            // Ignore for VclMetafileProcessor2D, this is for printing and MetaFile recording only

            break;

        }

        case PRIMITIVE2D_ID_GRAPHICPRIMITIVE2D:

        {

            processGraphicPrimitive2D(

                static_cast<const primitive2d::GraphicPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_CONTROLPRIMITIVE2D:

        {

            processControlPrimitive2D(

                static_cast<const primitive2d::ControlPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_TEXTHIERARCHYFIELDPRIMITIVE2D:

        {

            processTextHierarchyFieldPrimitive2D(

                static_cast<const primitive2d::TextHierarchyFieldPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_TEXTHIERARCHYLINEPRIMITIVE2D:

        {

            processTextHierarchyLinePrimitive2D(

                static_cast<const primitive2d::TextHierarchyLinePrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_TEXTHIERARCHYBULLETPRIMITIVE2D:

        {

            processTextHierarchyBulletPrimitive2D(

                static_cast<const primitive2d::TextHierarchyBulletPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_TEXTHIERARCHYPARAGRAPHPRIMITIVE2D:

        {

            processTextHierarchyParagraphPrimitive2D(

                static_cast<const primitive2d::TextHierarchyParagraphPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_TEXTHIERARCHYBLOCKPRIMITIVE2D:

        {

            processTextHierarchyBlockPrimitive2D(

                static_cast<const primitive2d::TextHierarchyBlockPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_TEXTSIMPLEPORTIONPRIMITIVE2D:

        case PRIMITIVE2D_ID_TEXTDECORATEDPORTIONPRIMITIVE2D:

        {

            // for supporting TEXT_ MetaFile actions there is more to do here; get the candidate

            processTextSimplePortionPrimitive2D(

                static_cast<const primitive2d::TextSimplePortionPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D:

        {

            processPolygonHairlinePrimitive2D(

                static_cast<const primitive2d::PolygonHairlinePrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D:

        {

            processPolygonStrokePrimitive2D(

                static_cast<const primitive2d::PolygonStrokePrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_POLYGONSTROKEARROWPRIMITIVE2D:

        {

            processPolygonStrokeArrowPrimitive2D(

                static_cast<const primitive2d::PolygonStrokeArrowPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_BITMAPPRIMITIVE2D:

        {

            // direct draw of transformed Bitmap primitive; use default processing, but without

            // former testing if graphic content is inside discrete local viewport; this is not

            // setup for metafile targets (metafile renderer tries to render in logic coordinates,

            // the mapping is kept to the OutputDevice for better Metafile recording)

            RenderBitmapPrimitive2D(static_cast<const primitive2d::BitmapPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_POLYPOLYGONGRAPHICPRIMITIVE2D:

        {

            if (maBColorModifierStack.count())

            {

                // tdf#151104 unfortunately processPolyPolygonGraphicPrimitive2D below

                // does not support an active BColorModifierStack, so use the default

                process(rCandidate);

            }

            else

            {

                processPolyPolygonGraphicPrimitive2D(

                    static_cast<const primitive2d::PolyPolygonGraphicPrimitive2D&>(rCandidate));

            }

            break;

        }

        case PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D:

        {

            processPolyPolygonHatchPrimitive2D(

                static_cast<const primitive2d::PolyPolygonHatchPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D:

        {

            processPolyPolygonGradientPrimitive2D(

                static_cast<const primitive2d::PolyPolygonGradientPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D:

        {

            processPolyPolygonColorPrimitive2D(

                static_cast<const primitive2d::PolyPolygonColorPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_MASKPRIMITIVE2D:

        {

            processMaskPrimitive2D(static_cast<const primitive2d::MaskPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_MODIFIEDCOLORPRIMITIVE2D:

        {

            // modified color group. Force output to unified color. Use default processing.

            RenderModifiedColorPrimitive2D(

                static_cast<const primitive2d::ModifiedColorPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_UNIFIEDTRANSPARENCEPRIMITIVE2D:

        {

            processUnifiedTransparencePrimitive2D(

                static_cast<const primitive2d::UnifiedTransparencePrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_TRANSPARENCEPRIMITIVE2D:

        {

            processTransparencePrimitive2D(

                static_cast<const primitive2d::TransparencePrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D:

        {

            // use default transform group processing

            RenderTransformPrimitive2D(

                static_cast<const primitive2d::TransformPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_PAGEPREVIEWPRIMITIVE2D:

        {

            // new XDrawPage for ViewInformation2D

            RenderPagePreviewPrimitive2D(

                static_cast<const primitive2d::PagePreviewPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_MARKERARRAYPRIMITIVE2D:

        {

            // use default marker array processing

            RenderMarkerArrayPrimitive2D(

                static_cast<const primitive2d::MarkerArrayPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_POINTARRAYPRIMITIVE2D:

        {

            // use default point array processing

            RenderPointArrayPrimitive2D(

                static_cast<const primitive2d::PointArrayPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_STRUCTURETAGPRIMITIVE2D:

        {

            processStructureTagPrimitive2D(

                static_cast<const primitive2d::StructureTagPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_EPSPRIMITIVE2D:

        {

            RenderEpsPrimitive2D(static_cast<const primitive2d::EpsPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_OBJECTINFOPRIMITIVE2D:

        {

            processObjectInfoPrimitive2D(

                static_cast<const primitive2d::ObjectInfoPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_FILLGRAPHICPRIMITIVE2D:

        {

            processFillGraphicPrimitive2D(

                static_cast<const primitive2d::FillGraphicPrimitive2D&>(rCandidate));

            break;

        }

        case PRIMITIVE2D_ID_TEXTHIERARCHYEMPHASISMARKPRIMITIVE2D:

        {

            // EmphasisMarks are traditionally not added to Metafiles, see

            // OutputDevice::ImplDrawEmphasisMarks which resets GDIMetaFile*

            // while painting these, so just ignore these

            break;

        }

        default:

        {

            // process recursively

            process(rCandidate);

            break;

        }

    }

}

void VclMetafileProcessor2D::processObjectInfoPrimitive2D(

    primitive2d::ObjectInfoPrimitive2D const& rObjectInfoPrimitive2D)

{

    // tdf#154982 process content first, so this object overrides any nested one

    process(rObjectInfoPrimitive2D.getChildren());

    // currently StructureTagPrimitive2D is only used for SdrObjects - have to

    // avoid adding Alt text if the SdrObject is not actually tagged, as it

    // would then end up on an unrelated structure element.

    if (mpCurrentStructureTag && mpCurrentStructureTag->isTaggedSdrObject())

    {

        // Create image alternative description from ObjectInfoPrimitive2D info

        // for PDF export, for the currently active SdrObject's structure element

        if (mpPDFExtOutDevData->GetIsExportTaggedPDF())

        {

            OUString aAlternateDescription;

            if (!rObjectInfoPrimitive2D.getTitle().isEmpty())

            {

                aAlternateDescription += rObjectInfoPrimitive2D.getTitle();

            }

            if (!rObjectInfoPrimitive2D.getDesc().isEmpty())

            {

                if (!aAlternateDescription.isEmpty())

                {

                    aAlternateDescription += " - ";

                }

                aAlternateDescription += rObjectInfoPrimitive2D.getDesc();

            }

            // Use SetAlternateText to set it. This will work as long as some

            // structure is used (see PDFWriterImpl::setAlternateText and

            // m_nCurrentStructElement - tagged PDF export works with this in

            // Draw/Impress/Writer, but not in Calc due to too less structure...)

            //Z maybe add structure to Calc PDF export, may need some BeginGroup/EndGroup stuff ..?

            if (!aAlternateDescription.isEmpty())

            {

                mpPDFExtOutDevData->SetAlternateText(aAlternateDescription);

            }

        }

    }

}

void VclMetafileProcessor2D::processFillGraphicPrimitive2D(

    primitive2d::FillGraphicPrimitive2D const& rFillGraphicPrimitive2D)

{

    // tdf#166709 check if we have to make an exception handling this

    // FillGraphicPrimitive2D. If it

    // - has transparency

    // - is tiled

    // - is a Bitmap

    // - is not animated

    // - is no embedded SVG

    // we have to, see below

    if (!basegfx::fTools::equalZero(rFillGraphicPrimitive2D.getTransparency(), 0.0))

    {

        // we have transparency

        const attribute::FillGraphicAttribute& rAttribute(rFillGraphicPrimitive2D.getFillGraphic());

        if (rAttribute.getTiling())

        {

            // we have tiling

            const Graphic& rGraphic(rAttribute.getGraphic());