Quelle  IDiagramHelper.cxx   Sprache: C

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