/* -*- 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 <svx/diagram/IDiagramHelper.hxx>

#include <svx/svdogrp.hxx>

#include <svx/svdhdl.hxx>

#include <svx/svdmrkv.hxx>

#include <svx/svdpagv.hxx>

#include <svx/sdrpagewindow.hxx>

#include <svx/sdrpaintwindow.hxx>

#include <basegfx/polygon/b2dpolygontools.hxx>

#include <svx/sdr/primitive2d/svx_primitivetypes2d.hxx>

#include <drawinglayer/primitive2d/primitivetools2d.hxx>

#include <svx/sdr/overlay/overlaymanager.hxx>

#include <drawinglayer/attribute/lineattribute.hxx>

#include <drawinglayer/primitive2d/PolyPolygonStrokePrimitive2D.hxx>

#include <drawinglayer/primitive2d/PolygonStrokePrimitive2D.hxx>

#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx>

#include <drawinglayer/primitive2d/groupprimitive2d.hxx>

#include <comphelper/dispatchcommand.hxx>

#include <drawinglayer/primitive2d/textlayoutdevice.hxx>

#include <officecfg/Office/Common.hxx>

#include <svx/strings.hrc>

#include <svx/dialmgr.hxx>

namespace {

// helper to create the geometry for a rounded polygon, maybe

// containing a Lap positioned inside top-left for some text

basegfx::B2DPolygon createRoundedPolygon(

    const basegfx::B2DRange& rRange,

    double fDistance,

    bool bCreateLap,

    double fTextWidth)

{

    basegfx::B2DPolygon aRetval;

    // TopLeft rounded edge

    aRetval.append(

        basegfx::utils::createPolygonFromEllipseSegment(

            basegfx::B2DPoint(rRange.getMinX(), rRange.getMinY()),

            fDistance,

            fDistance,

            M_PI * 1.0,

            M_PI * 1.5));

    // create Lap topLeft inside

    if(bCreateLap)

    {

        const double fLapLeft(rRange.getMinX() + fDistance);

        double fLapRight(rRange.getMinX() + (rRange.getWidth() * 0.5)  - fDistance);

        const double fLapTop(rRange.getMinY() - fDistance);

        const double fLapBottom(fLapTop + (fDistance * 2.0));

        const double fExtendedTextWidth(fTextWidth + (fDistance * 3.0));

        if(0.0 != fExtendedTextWidth && fLapLeft + fExtendedTextWidth < fLapRight)

        {

            fLapRight = fLapLeft + fExtendedTextWidth;

        }

        aRetval.append(basegfx::B2DPoint(fLapLeft, fLapTop));

        aRetval.append(basegfx::B2DPoint(fLapLeft + (fDistance * 0.5), fLapBottom));

        aRetval.append(basegfx::B2DPoint(fLapRight - (fDistance * 0.5), fLapBottom));

        aRetval.append(basegfx::B2DPoint(fLapRight, fLapTop));

    }

    // TopRight rounded edge

    aRetval.append(

        basegfx::utils::createPolygonFromEllipseSegment(

            basegfx::B2DPoint(rRange.getMaxX(), rRange.getMinY()),

            fDistance,

            fDistance,

            M_PI * 1.5,

            M_PI * 0.0));

    // BottomRight rounded edge

    aRetval.append(

        basegfx::utils::createPolygonFromEllipseSegment(

            basegfx::B2DPoint(rRange.getMaxX(), rRange.getMaxY()),

            fDistance,

            fDistance,

            M_PI * 0.0,

            M_PI * 0.5));

    // BottomLeft rounded edge

    aRetval.append(

        basegfx::utils::createPolygonFromEllipseSegment(

            basegfx::B2DPoint(rRange.getMinX(), rRange.getMaxY()),

            fDistance,

            fDistance,

            M_PI * 0.5,

            M_PI * 1.0));

    aRetval.setClosed(true);

    return aRetval;

}

// helper primitive to create/show the overlay geometry for a DynamicDiagram

class OverlayDiagramPrimitive final : public drawinglayer::primitive2d::DiscreteMetricDependentPrimitive2D

{

private:

    basegfx::B2DHomMatrix maTransformation;  // object dimensions

    double mfDiscreteDistance; // distance from object in pixels

    double mfDiscreteGap; // gap/width of visualization in pixels

    Color maColor;  // base color (made lighter/darker as needed, should be system selection color)

    virtual drawinglayer::primitive2d::Primitive2DReference create2DDecomposition(

        const drawinglayer::geometry::ViewInformation2D& rViewInformation) const override;

public:

    OverlayDiagramPrimitive(

        const basegfx::B2DHomMatrix& rTransformation,

        double fDiscreteDistance,

        double fDiscreteGap,

        Color const & rColor);

    virtual sal_uInt32 getPrimitive2DID() const override;

};

drawinglayer::primitive2d::Primitive2DReference OverlayDiagramPrimitive::create2DDecomposition(

    const drawinglayer::geometry::ViewInformation2D& /*rViewInformation*/) const

{

    // get the dimensions. Do *not* take rotation/shear into account,

    // this is intended to be a pure expanded/frame visualization as

    // needed in UI for simplified visualization

    basegfx::B2DRange aRange(0.0, 0.0, 1.0, 1.0);

    aRange.transform(maTransformation);

    basegfx::B2DPolyPolygon aPolyPolygon;

    const double fInnerDistance(mfDiscreteDistance * getDiscreteUnit());

    const double fOuterDistance((mfDiscreteDistance + mfDiscreteGap) * getDiscreteUnit());

    bool bCreateLap(true);

    basegfx::B2DPolyPolygon aTextAsPolyPolygon;

    double fTextWidth(0.0);

    // initially try to create lap

    if(bCreateLap)

    {

        // take a resource text (for now existing one that fits)

        const OUString aName(SvxResId(RID_STR_DATANAV_EDIT_ELEMENT));

        drawinglayer::primitive2d::TextLayouterDevice aTextLayouter;

        basegfx::B2DPolyPolygonVector aTarget;

        std::vector<double> aDXArray;

        // to simplify things for now, do not create a TextSimplePortionPrimitive2D

        // and needed FontAttribute, just get the TextOutlines as geometry

        aTextLayouter.getTextOutlines(

            aTarget,

            aName,

            0,

            aName.getLength(),

            aDXArray,

            {});

        // put into one PolyPolygon (also simplification - overlapping chars

        // may create XOR gaps, so these exist for a reason, but low probability)

        for (auto const& elem : aTarget)

        {

            aTextAsPolyPolygon.append(elem);

        }

        // get text dimensions & transform to destination

        const basegfx::B2DRange aTextRange(aTextAsPolyPolygon.getB2DRange());

        basegfx::B2DHomMatrix aTextTransform;

        aTextTransform.translate(aTextRange.getMinX(), aTextRange.getMinY());

        const double fTargetTextHeight((mfDiscreteDistance + mfDiscreteGap - 2.0) * getDiscreteUnit());

        const double fTextScale(fTargetTextHeight / aTextRange.getHeight());

        aTextTransform.scale(fTextScale, fTextScale);

        aTextTransform.translate(

            aRange.getMinX() + (fInnerDistance * 2.0),

            aRange.getMinY() + fTargetTextHeight + (fOuterDistance - fInnerDistance) - (2.0 * getDiscreteUnit()));

        aTextAsPolyPolygon.transform(aTextTransform);

        // check text size/position

        fTextWidth = aTextRange.getWidth() * fTextScale;

        const double fLapLeft(aRange.getMinX() + fInnerDistance);

        const double fLapRight(aRange.getMinX() + (aRange.getWidth() * 0.5)  - fInnerDistance);

        // if text is too big, do not create a Lap at all

        // to avoid trouble. It is expected that the user keeps

        // the object he works with big enough to do useful actions

        if(fTextWidth + (4.0 * getDiscreteUnit()) > fLapRight - fLapLeft)

            bCreateLap = false;

    }

    // create outer polygon

    aPolyPolygon.append(

        createRoundedPolygon(

            aRange,

            fOuterDistance,

            false,

            0.0));

    // create inner polygon, maybe with Lap

    aPolyPolygon.append(

        createRoundedPolygon(

            aRange,

            fInnerDistance,

            bCreateLap,

            fTextWidth));

    Color aFillColor(maColor);

    Color aLineColor(maColor);

    aFillColor.IncreaseLuminance(10);

    aLineColor.DecreaseLuminance(30);

    const drawinglayer::attribute::LineAttribute aLineAttribute(

        aLineColor.getBColor(),

        1.0 * getDiscreteUnit());

    drawinglayer::primitive2d::Primitive2DContainer aContainer;

    // filled polygon as BG (may get transparence for better look ?)

    aContainer.push_back(

        new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(

            aPolyPolygon,

            aFillColor.getBColor()));

    // outline polygon for visibility (may be accentuated shaded

    // top/left, would require alternative creation)

    aContainer.push_back(

        new drawinglayer::primitive2d::PolyPolygonStrokePrimitive2D(

            std::move(aPolyPolygon),

            aLineAttribute));

    // top-left line pattern (as grep-here-sign to signal

    // that this construct may be also dragged by the user)

    const double fLapLeft(aRange.getMinX() + fInnerDistance);

    const double fLapRight(aRange.getMinX() + (aRange.getWidth() * 0.5)  - fInnerDistance);

    const double  fLapUp(aRange.getMinY() - ((mfDiscreteDistance + mfDiscreteDistance * 0.666) * getDiscreteUnit()));

    const double  fLapDown(aRange.getMinY() - ((mfDiscreteDistance + mfDiscreteDistance * 0.333) * getDiscreteUnit()));

    basegfx::B2DPolygon aPolygonLapUp;

    aPolygonLapUp.append(basegfx::B2DPoint(fLapLeft, fLapUp));

    aPolygonLapUp.append(basegfx::B2DPoint(fLapRight, fLapUp));

    basegfx::B2DPolygon aPolygonLapDown;

    aPolygonLapDown.append(basegfx::B2DPoint(fLapLeft, fLapDown));

    aPolygonLapDown.append(basegfx::B2DPoint(fLapRight, fLapDown));

    drawinglayer::attribute::StrokeAttribute aStrokeAttribute({ 2.0 * getDiscreteUnit(), 2.0 * getDiscreteUnit() });

    aContainer.push_back(

        new drawinglayer::primitive2d::PolygonStrokePrimitive2D(

            std::move(aPolygonLapUp),

            aLineAttribute,

            aStrokeAttribute));

    aContainer.push_back(

        new drawinglayer::primitive2d::PolygonStrokePrimitive2D(

            std::move(aPolygonLapDown),

            aLineAttribute,

            std::move(aStrokeAttribute)));

    // add text last. May use darker text color, go for same color

    // as accentuation line for now

    if(bCreateLap && 0 != aTextAsPolyPolygon.count())

    {

        aContainer.push_back(

            new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(

                std::move(aTextAsPolyPolygon),

                aLineColor.getBColor()));

    }

    return new drawinglayer::primitive2d::GroupPrimitive2D(std::move(aContainer));

}

OverlayDiagramPrimitive::OverlayDiagramPrimitive(

    const basegfx::B2DHomMatrix& rTransformation,

    double fDiscreteDistance,

    double fDiscreteGap,

    Color const & rColor)

: drawinglayer::primitive2d::DiscreteMetricDependentPrimitive2D()

, maTransformation(rTransformation)

, mfDiscreteDistance(fDiscreteDistance)

, mfDiscreteGap(fDiscreteGap)

, maColor(rColor)

{

}

sal_uInt32 OverlayDiagramPrimitive::getPrimitive2DID() const

{

    return PRIMITIVE2D_ID_OVERLAYDIAGRAMPRIMITIVE2D;

}

// helper object for DiagramOverlay

class OverlayDiagramFrame final : public sdr::overlay::OverlayObject

{

private:

    basegfx::B2DHomMatrix maTransformation; // object dimensions

    Color maColor; // base color

    virtual drawinglayer::primitive2d::Primitive2DContainer createOverlayObjectPrimitive2DSequence() override;

public:

    explicit OverlayDiagramFrame(

        const basegfx::B2DHomMatrix& rTransformation,

        Color const & rColor);

};

OverlayDiagramFrame::OverlayDiagramFrame(

    const basegfx::B2DHomMatrix& rTransformation,

    const Color& rColor)

: sdr::overlay::OverlayObject(rColor)

, maTransformation(rTransformation)

, maColor(rColor)

{

}

drawinglayer::primitive2d::Primitive2DContainer OverlayDiagramFrame::createOverlayObjectPrimitive2DSequence()

{

    drawinglayer::primitive2d::Primitive2DContainer aReturnContainer;

    if ( !officecfg::Office::Common::Misc::ExperimentalMode::get() )

        return aReturnContainer;

    if (getOverlayManager())

    {

        aReturnContainer = drawinglayer::primitive2d::Primitive2DContainer {

            new OverlayDiagramPrimitive(

                maTransformation,

                8.0, // distance from geometry in pixels

                8.0, // gap/width of visualization in pixels

                maColor) };

    }

    return aReturnContainer;

}

} // end of anonymous namespace

namespace svx { namespace diagram {

void DiagramFrameHdl::clicked(const Point& /*rPnt*/)

{

    // this may check for a direct hit at the text later

    // and only then take action. That would require

    // to evaluate & keep that (maybe during creation).

    // For now, just trigger to open the Dialog

    comphelper::dispatchCommand(u".uno:EditDiagram"_ustr, {});

}

void DiagramFrameHdl::CreateB2dIAObject()

{

    // first throw away old one

    GetRidOfIAObject();

    SdrMarkView* pView = m_pHdlList->GetView();

    if(!pView || pView->areMarkHandlesHidden())

        return;

    SdrPageView* pPageView = pView->GetSdrPageView();

    if(!pPageView)

        return;

    for(sal_uInt32 b(0); b < pPageView->PageWindowCount(); b++)

    {

        const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b);

        if(rPageWindow.GetPaintWindow().OutputToWindow())

        {

            const rtl::Reference< sdr::overlay::OverlayManager >& xManager = rPageWindow.GetOverlayManager();

            if (xManager.is())

            {

                OutputDevice& rOutDev(rPageWindow.GetPaintWindow().GetOutputDevice());

                const StyleSettings& rStyles(rOutDev.GetSettings().GetStyleSettings());

                Color aFillColor(rStyles.GetHighlightColor());

                std::unique_ptr<sdr::overlay::OverlayObject> pNewOverlayObject(

                    new OverlayDiagramFrame(

                        maTransformation,

                        aFillColor));

                // OVERLAYMANAGER

                insertNewlyCreatedOverlayObjectForSdrHdl(

                    std::move(pNewOverlayObject),

                    rPageWindow.GetObjectContact(),

                    *xManager);

            }

        }

    }

}

DiagramFrameHdl::DiagramFrameHdl(const basegfx::B2DHomMatrix& rTransformation)

: SdrHdl(Point(), SdrHdlKind::Move)

, maTransformation(rTransformation)

{

}

IDiagramHelper::IDiagramHelper(bool bSelfCreated)

: mbUseDiagramThemeData(false)

, mbUseDiagramModelData(true)

, mbForceThemePtrRecreation(false)

, mbSelfCreated(bSelfCreated)

{

}

IDiagramHelper::~IDiagramHelper() {}

void IDiagramHelper::anchorToSdrObjGroup(SdrObjGroup& rTarget)

{

    rTarget.mp_DiagramHelper.reset(this);

}

void IDiagramHelper::AddAdditionalVisualization(const SdrObjGroup& rTarget, SdrHdlList& rHdlList)

{

    // create an extra frame visualization here

    basegfx::B2DHomMatrix aTransformation;

    basegfx::B2DPolyPolygon aPolyPolygon;

    rTarget.TRGetBaseGeometry(aTransformation, aPolyPolygon);

    std::unique_ptr<SdrHdl> pHdl(new DiagramFrameHdl(aTransformation));

    rHdlList.AddHdl(std::move(pHdl));

}

}} // end of namespace

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */