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

#include <ChartWindow.hxx>

#include <ChartModel.hxx>

#include <ChartType.hxx>

#include <TitleHelper.hxx>

#include <DataSeries.hxx>

#include <DataSeriesHelper.hxx>

#include "UndoGuard.hxx"

#include <ControllerLockGuard.hxx>

#include <ResId.hxx>

#include <strings.hrc>

#include <ObjectIdentifier.hxx>

#include <ReferenceSizeProvider.hxx>

#include <chartview/DrawModelWrapper.hxx>

#include "ChartTransferable.hxx"

#include <DrawViewWrapper.hxx>

#include <Legend.hxx>

#include <LegendHelper.hxx>

#include <Axis.hxx>

#include <AxisHelper.hxx>

#include <RegressionCurveModel.hxx>

#include <RegressionCurveHelper.hxx>

#include "ShapeController.hxx"

#include <DiagramHelper.hxx>

#include <Diagram.hxx>

#include <ObjectNameProvider.hxx>

#include <unonames.hxx>

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

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

#include <com/sun/star/chart2/DataPointLabel.hpp>

#include <com/sun/star/graphic/XGraphic.hpp>

#include <com/sun/star/drawing/TextVerticalAdjust.hpp>

#include <com/sun/star/drawing/TextHorizontalAdjust.hpp>

#include <com/sun/star/chart/ErrorBarStyle.hpp>

#include <com/sun/star/chart2/XRegressionCurveContainer.hpp>

#include <docmodel/uno/UnoGradientTools.hxx>

#include <editeng/editview.hxx>

#include <editeng/outliner.hxx>

#include <svx/ActionDescriptionProvider.hxx>

#include <vcl/transfer.hxx>

#include <sot/storage.hxx>

#include <vcl/graph.hxx>

#include <vcl/TypeSerializer.hxx>

#include <svx/unomodel.hxx>

#include <svx/svdmodel.hxx>

#include <unotools/streamwrap.hxx>

#include <vcl/svapp.hxx>

#include <svx/dialmgr.hxx>

#include <svx/strings.hrc>

#include <svx/svditer.hxx>

#include <svx/svdpage.hxx>

#include <svx/svdundo.hxx>

#include <svx/unoapi.hxx>

#include <svx/unopage.hxx>

#include <svx/unoshape.hxx>

#include <PropertyHelper.hxx>

#include <LibreOfficeKit/LibreOfficeKitEnums.h>

#include <tools/debug.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <tools/UnitConversion.hxx>

#include <memory>

using namespace ::com::sun::star;

using ::com::sun::star::uno::Reference;

using ::com::sun::star::uno::Sequence;

namespace chart

{

namespace

{

bool lcl_deleteDataSeries(

    std::u16string_view rCID,

    const rtl::Reference<::chart::ChartModel> & xModel,

    const Reference< document::XUndoManager > & xUndoManager )

{

    bool bResult = false;

    rtl::Reference< DataSeries > xSeries = ObjectIdentifier::getDataSeriesForCID( rCID, xModel );

    if( xSeries.is() && xModel.is())

    {

        rtl::Reference< ::chart::ChartType > xChartType =

            DataSeriesHelper::getChartTypeOfSeries( xSeries, xModel->getFirstChartDiagram());

        if( xChartType.is())

        {

            UndoGuard aUndoGuard(

                ActionDescriptionProvider::createDescription(

                    ActionDescriptionProvider::ActionType::Delete, SchResId( STR_OBJECT_DATASERIES )),

                xUndoManager );

            rtl::Reference< Diagram > xDiagram = xModel->getFirstChartDiagram();

            rtl::Reference< Axis > xAxis = xDiagram->getAttachedAxis( xSeries );

            xChartType->deleteSeries( xSeries );

            AxisHelper::hideAxisIfNoDataIsAttached( xAxis, xDiagram );

            bResult = true;

            aUndoGuard.commit();

        }

    }

    return bResult;

}

bool lcl_deleteDataCurve(

    std::u16string_view rCID,

    const rtl::Reference<::chart::ChartModel> & xModel,

    const Reference< document::XUndoManager > & xUndoManager )

{

    bool bResult = false;

    uno::Reference< beans::XPropertySet > xProperties(

        ObjectIdentifier::getObjectPropertySet( rCID, xModel));

    uno::Reference< chart2::XRegressionCurve > xRegressionCurve( xProperties, uno::UNO_QUERY );

    if( xRegressionCurve.is())

    {

        uno::Reference< chart2::XRegressionCurveContainer > xRegressionCurveContainer(

            ObjectIdentifier::getObjectPropertySet(

                ObjectIdentifier::getFullParentParticle( rCID ), xModel), uno::UNO_QUERY );

        if( xRegressionCurveContainer.is())

        {

            UndoGuard aUndoGuard(

                ActionDescriptionProvider::createDescription(

                    ActionDescriptionProvider::ActionType::Delete, SchResId( STR_OBJECT_CURVE )),

                xUndoManager );

            xRegressionCurveContainer->removeRegressionCurve( xRegressionCurve );

            bResult = true;

            aUndoGuard.commit();

        }

    }

    return bResult;

}

bool lcl_arePropertiesSame(const std::vector<Reference<beans::XPropertySet>>& xProperties,

                           OUString& aPropName)

{

    if (xProperties.size() == 1)

        return true;

    if (xProperties.size() < 1)

        return false;

    uno::Any aValue = xProperties[0]->getPropertyValue(aPropName);

    for (std::size_t i = 1; i < xProperties.size(); i++)

    {

        if (aValue != xProperties[i]->getPropertyValue(aPropName))

            return false;

    }

    return true;

}

} // anonymous namespace

ReferenceSizeProvider ChartController::impl_createReferenceSizeProvider()

{

    awt::Size aPageSize( getChartModel()->getPageSize() );

    return ReferenceSizeProvider(aPageSize, getChartModel());

}

void ChartController::impl_adaptDataSeriesAutoResize()

{

    impl_createReferenceSizeProvider().setValuesAtAllDataSeries();

}

void ChartController::executeDispatch_NewArrangement()

{

    // remove manual positions at titles, legend and the diagram, remove manual

    // size at the diagram

    try

    {

        rtl::Reference<::chart::ChartModel> xModel( getChartModel() );

        rtl::Reference< Diagram > xDiagram = xModel->getFirstChartDiagram();

        if( xDiagram.is())

        {

            UndoGuard aUndoGuard(

                SchResId( STR_ACTION_REARRANGE_CHART ),

                m_xUndoManager );

            ControllerLockGuardUNO aCtlLockGuard( xModel );

            // diagram

            xDiagram->setPropertyToDefault( u"RelativeSize"_ustr);

            xDiagram->setPropertyToDefault( u"RelativePosition"_ustr);

            xDiagram->setPropertyToDefault( u"PosSizeExcludeAxes"_ustr);

            // 3d rotation

            xDiagram->set3DSettingsToDefault();

            // legend

            rtl::Reference< Legend > xLegend = xDiagram->getLegend2();

            if( xLegend.is())

            {

                xLegend->setPropertyToDefault( u"RelativePosition"_ustr);

                xLegend->setPropertyToDefault( u"RelativeSize"_ustr);

                xLegend->setPropertyToDefault( u"AnchorPosition"_ustr);

            }

            // titles

            for( sal_Int32 eType = TitleHelper::TITLE_BEGIN;

                 eType < TitleHelper::NORMAL_TITLE_END;

                 ++eType )

            {

                rtl::Reference< Title > xTitleState =

                    TitleHelper::getTitle(

                        static_cast< TitleHelper::eTitleType >( eType ), xModel );

                if( xTitleState.is())

                    xTitleState->setPropertyToDefault( u"RelativePosition"_ustr);

            }

            // regression curve equations

            std::vector< rtl::Reference< RegressionCurveModel > > aRegressionCurves =

                xDiagram->getAllRegressionCurvesNotMeanValueLine();

            // reset equation position

            for( const auto& xCurve : aRegressionCurves )

                RegressionCurveHelper::resetEquationPosition( xCurve );

            aUndoGuard.commit();

        }

    }

    catch( const uno::RuntimeException & )

    {

        DBG_UNHANDLED_EXCEPTION("chart2");

    }

}

void ChartController::executeDispatch_ScaleText()

{

    SolarMutexGuard aSolarGuard;

    UndoGuard aUndoGuard(

        SchResId( STR_ACTION_SCALE_TEXT ),

        m_xUndoManager );

    ControllerLockGuardUNO aCtlLockGuard( getChartModel() );

    impl_createReferenceSizeProvider().toggleAutoResizeState();

    aUndoGuard.commit();

}

void ChartController::executeDispatch_FontBold(

    const std::vector<css::uno::Reference<css::beans::XPropertySet>>& xProperties)

{

    OUString aPropName = u"CharWeight"_ustr;

    float nFontWeight = awt::FontWeight::NORMAL;

    if (lcl_arePropertiesSame(xProperties, aPropName))

    {

        xProperties[0]->getPropertyValue(aPropName) >>= nFontWeight;

    }

    nFontWeight = (nFontWeight == awt::FontWeight::NORMAL) ? awt::FontWeight::BOLD

                                                           : awt::FontWeight::NORMAL;

    for (std::size_t i = 0; i < xProperties.size(); i++)

        xProperties[i]->setPropertyValue(aPropName, uno::Any(nFontWeight));

}

void ChartController::executeDispatch_FontName(

    const std::vector<css::uno::Reference<css::beans::XPropertySet>>& xProperties,

    const css::uno::Sequence<css::beans::PropertyValue>& rArgs)

{

    // the sent font may have a lot of properties that we could set.

    // but now we set only this

    awt::FontDescriptor aFont;

    rArgs[0].Value >>= aFont;

    for (std::size_t i = 0; i < xProperties.size(); i++)

        xProperties[i]->setPropertyValue(u"CharFontName"_ustr, css::uno::Any(aFont.Name));

}

void ChartController::executeDispatch_FontHeight(

    const std::vector<css::uno::Reference<css::beans::XPropertySet>>& xProperties,

    const css::uno::Sequence<css::beans::PropertyValue>& rArgs)

{

    for (std::size_t i = 0; i < xProperties.size(); i++)

        xProperties[i]->setPropertyValue(u"CharHeight"_ustr, rArgs[0].Value);

}

void ChartController::executeDispatch_FontItalic(

    const std::vector<css::uno::Reference<css::beans::XPropertySet>>& xProperties)

{

    OUString aPropName = u"CharPosture"_ustr;

    awt::FontSlant nFontItalic = awt::FontSlant::FontSlant_NONE;

    if (lcl_arePropertiesSame(xProperties, aPropName))

    {

        xProperties[0]->getPropertyValue(aPropName) >>= nFontItalic;

    }

    nFontItalic = (nFontItalic == awt::FontSlant::FontSlant_NONE ? awt::FontSlant::FontSlant_ITALIC

                                                                 : awt::FontSlant::FontSlant_NONE);

    for (std::size_t i = 0; i < xProperties.size(); i++)

        xProperties[i]->setPropertyValue(aPropName, css::uno::Any(nFontItalic));

}

void ChartController::executeDispatch_FontUnderline(

    const std::vector<css::uno::Reference<css::beans::XPropertySet>>& xProperties,

    const css::uno::Sequence<css::beans::PropertyValue>& rArgs)

{

    OUString aPropName = u"CharUnderline"_ustr;

    sal_Int16 nFontUnderline = 0;

    sal_Int32 nFontUnderline32 = 0;

    if (!(rArgs[0].Value >>= nFontUnderline) && (rArgs[0].Value >>= nFontUnderline32))

    {

        nFontUnderline = nFontUnderline32;

    }

    else

    {

        if (lcl_arePropertiesSame(xProperties, aPropName))

        {

            xProperties[0]->getPropertyValue(aPropName) >>= nFontUnderline;

        }

        nFontUnderline = (nFontUnderline == 0 ? 1 : 0);

    }

    for (std::size_t i = 0; i < xProperties.size(); i++)

        xProperties[i]->setPropertyValue(aPropName, css::uno::Any(nFontUnderline));

}

void ChartController::executeDispatch_FontStrikeout(

    const std::vector<css::uno::Reference<css::beans::XPropertySet>>& xProperties)

{

    OUString aPropName = u"CharStrikeout"_ustr;

    sal_Int16 nFontStrikeout = 0;

    if (lcl_arePropertiesSame(xProperties, aPropName))

    {

        xProperties[0]->getPropertyValue(aPropName) >>= nFontStrikeout;

    }

    nFontStrikeout = (nFontStrikeout == 0 ? 1 : 0);

    for (std::size_t i = 0; i < xProperties.size(); i++)

        xProperties[i]->setPropertyValue(aPropName, css::uno::Any(nFontStrikeout));

}

void ChartController::executeDispatch_FontShadowed(

    const std::vector<css::uno::Reference<css::beans::XPropertySet>>& xProperties)

{

    OUString aPropName = u"CharShadowed"_ustr;

    bool bFontShadowed = false;

    if (lcl_arePropertiesSame(xProperties, aPropName))

    {

        xProperties[0]->getPropertyValue(aPropName) >>= bFontShadowed;

    }

    for (std::size_t i = 0; i < xProperties.size(); i++)

        xProperties[i]->setPropertyValue(u"CharShadowed"_ustr, css::uno::Any(!bFontShadowed));

}

void ChartController::executeDispatch_FontColor(

    const std::vector<css::uno::Reference<css::beans::XPropertySet>>& xProperties,

    const css::uno::Sequence<css::beans::PropertyValue>& rArgs)

{

    for (std::size_t i = 0; i < xProperties.size(); i++)

        xProperties[i]->setPropertyValue(u"CharColor"_ustr, rArgs[0].Value);

}

void ChartController::executeDispatch_FontGrow(

    const std::vector<css::uno::Reference<css::beans::XPropertySet>>& xProperties)

{

    for (std::size_t i = 0; i < xProperties.size(); i++)

    {

        float nFontHeight = 0;

        xProperties[i]->getPropertyValue(u"CharHeight"_ustr) >>= nFontHeight;

        if (nFontHeight > 0)

        {

            nFontHeight = ceil(nFontHeight); //round

            nFontHeight += 1;

            if (nFontHeight > 999)

                nFontHeight = 999;

            xProperties[i]->setPropertyValue(u"CharHeight"_ustr, css::uno::Any(nFontHeight));

        }

    }

}

void ChartController::executeDispatch_FontShrink(

    const std::vector<css::uno::Reference<css::beans::XPropertySet>>& xProperties)

{

    for (std::size_t i = 0; i < xProperties.size(); i++)

    {

        float nFontHeight = 0;

        xProperties[i]->getPropertyValue(u"CharHeight"_ustr) >>= nFontHeight;

        if (nFontHeight > 0)

        {

            if (nFontHeight - ceil(nFontHeight) >= 0.4)

                nFontHeight = ceil(nFontHeight); //round

            else

            {

                nFontHeight -= 1;

                if (nFontHeight < 2)

                    nFontHeight = 2;

            }

            xProperties[i]->setPropertyValue(u"CharHeight"_ustr, css::uno::Any(nFontHeight));

        }

    }

}

void ChartController::executeDispatch_FontReset(

    const std::vector<css::uno::Reference<css::beans::XPropertySet>>& xProperties)

{

    for (std::size_t i = 0; i < xProperties.size(); i++)

    {

        xProperties[i]->setPropertyValue(u"CharFontName"_ustr,

                                         css::uno::Any(OUString("Liberation Sans")));

        xProperties[i]->setPropertyValue(u"CharHeight"_ustr, css::uno::Any(float(13)));

        xProperties[i]->setPropertyValue(u"CharWeight"_ustr, uno::Any(float(100)));

        xProperties[i]->setPropertyValue(u"CharPosture"_ustr,

                                         css::uno::Any(awt::FontSlant::FontSlant_NONE));

        xProperties[i]->setPropertyValue(u"CharUnderline"_ustr, css::uno::Any(sal_Int16(0)));

        xProperties[i]->setPropertyValue(u"CharStrikeout"_ustr, css::uno::Any(sal_Int16(0)));

        xProperties[i]->setPropertyValue(u"CharShadowed"_ustr, css::uno::Any(false));

        xProperties[i]->setPropertyValue(u"CharColor"_ustr, css::uno::Any(Color(0)));

        xProperties[i]->setPropertyValue(u"CharKerning"_ustr, css::uno::Any(sal_Int16(0)));

        xProperties[i]->setPropertyValue(u"CharEscapement"_ustr, css::uno::Any(sal_Int16(0)));

        xProperties[i]->setPropertyValue(u"CharEscapementHeight"_ustr,

                                         css::uno::Any(sal_Int8(100)));

    }

}

void ChartController::executeDispatch_FontSpacing(

    const std::vector<css::uno::Reference<css::beans::XPropertySet>>& xProperties,

    const css::uno::Sequence<css::beans::PropertyValue>& rArgs)

{

    sal_Int16 nKerning = 0;

    rArgs[0].Value >>= nKerning;

    for (std::size_t i = 0; i < xProperties.size(); i++)

        xProperties[i]->setPropertyValue(u"CharKerning"_ustr, css::uno::Any(nKerning));

}

void ChartController::executeDispatch_FontSuperScript(

    const std::vector<css::uno::Reference<css::beans::XPropertySet>>& xProperties)

{

    sal_Int16 nCharEscapement = 0;

    xProperties[0]->getPropertyValue(u"CharEscapement"_ustr) >>= nCharEscapement;

    for (std::size_t i = 0; i < xProperties.size(); i++)

    {

        if (nCharEscapement > 0)

        {

            xProperties[i]->setPropertyValue(u"CharEscapement"_ustr, css::uno::Any(sal_Int16(0)));

            xProperties[i]->setPropertyValue(u"CharEscapementHeight"_ustr,

                                             css::uno::Any(sal_Int8(100)));

        }

        else

        {

            xProperties[i]->setPropertyValue(u"CharEscapement"_ustr,

                                             css::uno::Any(sal_Int16(14000)));

            xProperties[i]->setPropertyValue(u"CharEscapementHeight"_ustr,

                                             css::uno::Any(sal_Int8(58)));

        }

    }

}

void ChartController::executeDispatch_FontSubScript(

    const std::vector<css::uno::Reference<css::beans::XPropertySet>>& xProperties)

{

    sal_Int16 nCharEscapement = 0;

    xProperties[0]->getPropertyValue(u"CharEscapement"_ustr) >>= nCharEscapement;

    for (std::size_t i = 0; i < xProperties.size(); i++)

    {

        if (nCharEscapement < 0)

        {

            xProperties[i]->setPropertyValue(u"CharEscapement"_ustr, css::uno::Any(sal_Int16(0)));

            xProperties[i]->setPropertyValue(u"CharEscapementHeight"_ustr,

                                             css::uno::Any(sal_Int8(100)));

        }

        else

        {

            xProperties[i]->setPropertyValue(u"CharEscapement"_ustr,

                                             css::uno::Any(sal_Int16(-14000)));

            xProperties[i]->setPropertyValue(u"CharEscapementHeight"_ustr,

                                             css::uno::Any(sal_Int8(58)));

        }

    }

}

void ChartController::executeDispatch_Paste()

{

    SolarMutexGuard aGuard;

    auto pChartWindow(GetChartWindow());

    if( !pChartWindow )

        return;

    Graphic aGraphic;

    // paste location: center of window

    Point aPos = pChartWindow->PixelToLogic( tools::Rectangle(Point{}, pChartWindow->GetSizePixel()).Center());

    // handle different formats

    TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( pChartWindow ));

    if( aDataHelper.GetTransferable().is())

    {

        if ( aDataHelper.HasFormat( SotClipboardFormatId::DRAWING ) )

        {

            if (std::unique_ptr<SvStream> xStm = aDataHelper.GetSotStorageStream( SotClipboardFormatId::DRAWING) )

            {

                xStm->Seek( 0 );

                Reference< io::XInputStream > xInputStream( new utl::OInputStreamWrapper( *xStm ) );

                std::unique_ptr< SdrModel > spModel(

                    new SdrModel());

                if ( SvxDrawingLayerImport( spModel.get(), xInputStream ) )

                {

                    impl_PasteShapes( spModel.get() );

                }

            }

        }

        else if ( aDataHelper.HasFormat( SotClipboardFormatId::SVXB ) )

        {

            // graphic exchange format (graphic manager bitmap format?)

            if (std::unique_ptr<SvStream> xStm = aDataHelper.GetSotStorageStream( SotClipboardFormatId::SVXB ))

            {

                TypeSerializer aSerializer(*xStm);

                aSerializer.readGraphic(aGraphic);

            }

        }

        else if( aDataHelper.HasFormat( SotClipboardFormatId::GDIMETAFILE ))

        {

            // meta file

            GDIMetaFile aMetafile;

            if( aDataHelper.GetGDIMetaFile( SotClipboardFormatId::GDIMETAFILE, aMetafile ))

                aGraphic = Graphic( aMetafile );

        }

        else if( aDataHelper.HasFormat( SotClipboardFormatId::BITMAP ))

        {

            // bitmap (non-graphic-manager)

            BitmapEx aBmpEx;

            if( aDataHelper.GetBitmapEx( SotClipboardFormatId::BITMAP, aBmpEx ))

                aGraphic = Graphic( aBmpEx );

        }

        else if( aDataHelper.HasFormat( SotClipboardFormatId::STRING ))

        {

            OUString aString;

            if( aDataHelper.GetString( SotClipboardFormatId::STRING, aString ) && m_pDrawModelWrapper )

            {

                if( m_pDrawViewWrapper )

                {

                    OutlinerView* pOutlinerView = m_pDrawViewWrapper->GetTextEditOutlinerView();

                    if (pOutlinerView)//in case of edit mode insert the formatted string

                        pOutlinerView->PasteSpecial();

                    else

                    {

                        impl_PasteStringAsTextShape( aString, awt::Point( 0, 0 ) );

                    }

                }

            }

        }

    }

    if( aGraphic.GetType() != GraphicType::NONE )

    {

        Reference< graphic::XGraphic > xGraphic( aGraphic.GetXGraphic());

        if( xGraphic.is())

            impl_PasteGraphic( xGraphic, aPos );

    }

}

// note: aPosition is ignored for now. The object is always pasted centered to

// the page

void ChartController::impl_PasteGraphic(

    uno::Reference< graphic::XGraphic > const & xGraphic,

    const ::Point & /* aPosition */ )

{

    DBG_TESTSOLARMUTEX();

    // note: the XPropertySet of the model is the old API. Also the property

    // "AdditionalShapes" that is used there.

    rtl::Reference< ChartModel > xModel = getChartModel();

    DrawModelWrapper * pDrawModelWrapper( GetDrawModelWrapper());

    if( ! (xGraphic.is() && xModel.is()))

        return;

    rtl::Reference<SvxGraphicObject> xGraphicShape = new SvxGraphicObject(nullptr);

    xGraphicShape->setShapeKind(SdrObjKind::Graphic);

    rtl::Reference< SvxDrawPage > xPage = pDrawModelWrapper->getMainDrawPage();

    if( xPage.is())

    {

        xPage->add( xGraphicShape );

        //need to change the model state manually

        xModel->setModified( true );

        //select new shape

        m_aSelection.setSelection( xGraphicShape );

        m_aSelection.applySelection( m_pDrawViewWrapper.get() );

    }

    xGraphicShape->SvxShape::setPropertyValue( u"Graphic"_ustr, uno::Any( xGraphic ));

    awt::Size aGraphicSize( 1000, 1000 );

    bool bGotGraphicSize = false;

    try

    {

        bGotGraphicSize = xGraphicShape->SvxShape::getPropertyValue( u"Size100thMM"_ustr) >>= aGraphicSize;

    }

    catch (css::beans::UnknownPropertyException& )

    {}

    auto pChartWindow(GetChartWindow());

    // first try size in 100th mm, then pixel size

    if( !bGotGraphicSize )

    {

        bool bGotSizePixel = false;

        try

        {

            bGotSizePixel = xGraphicShape->SvxShape::getPropertyValue( u"SizePixel"_ustr) >>= aGraphicSize;

        }

        catch (css::beans::UnknownPropertyException& )

        {}

        if ( bGotSizePixel && pChartWindow )

        {

            ::Size aVCLSize( pChartWindow->PixelToLogic( Size( aGraphicSize.Width, aGraphicSize.Height )));

            aGraphicSize.Width = aVCLSize.getWidth();

            aGraphicSize.Height = aVCLSize.getHeight();

        }

    }

    xGraphicShape->setSize( aGraphicSize );

    xGraphicShape->setPosition( awt::Point( 0, 0 ) );

}

void ChartController::impl_PasteShapes( SdrModel* pModel )

{

    DrawModelWrapper* pDrawModelWrapper( GetDrawModelWrapper() );

    if ( !(pDrawModelWrapper && m_pDrawViewWrapper) )

        return;

    rtl::Reference< SvxDrawPage > xDestPage( pDrawModelWrapper->getMainDrawPage() );

    SdrPage* pDestPage = GetSdrPageFromXDrawPage( xDestPage );

    if ( !pDestPage )

        return;

    Reference< drawing::XShape > xSelShape;

    m_pDrawViewWrapper->BegUndo( SvxResId( RID_SVX_3D_UNDO_EXCHANGE_PASTE ) );

    sal_uInt16 nCount = pModel->GetPageCount();

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

    {

        const SdrPage* pPage = pModel->GetPage( i );

        SdrObjListIter aIter( pPage, SdrIterMode::DeepNoGroups );

        while ( aIter.IsMore() )

        {

            SdrObject* pObj(aIter.Next());

            // Clone to new SdrModel

            rtl::Reference<SdrObject> pNewObj;

            if (pObj)

                pNewObj = pObj->CloneSdrObject(pDrawModelWrapper->getSdrModel());

            if ( pNewObj )

            {

                // set position

                Reference< drawing::XShape > xShape( pNewObj->getUnoShape(), uno::UNO_QUERY );

                if ( xShape.is() )

                {

                    xShape->setPosition( awt::Point( 0, 0 ) );

                }

                pDestPage->InsertObject( pNewObj.get() );

                m_pDrawViewWrapper->AddUndo( std::make_unique<SdrUndoInsertObj>( *pNewObj ) );

                xSelShape = std::move(xShape);

            }

        }

    }

    rtl::Reference< ChartModel > xModifiable = getChartModel();

    if ( xModifiable.is() )

    {

        xModifiable->setModified( true );

    }

    // select last inserted shape

    m_aSelection.setSelection( xSelShape );

    m_aSelection.applySelection( m_pDrawViewWrapper.get() );

    m_pDrawViewWrapper->EndUndo();

    impl_switchDiagramPositioningToExcludingPositioning();

}

void ChartController::impl_PasteStringAsTextShape( const OUString& rString, const awt::Point& rPosition )

{

    DrawModelWrapper* pDrawModelWrapper( GetDrawModelWrapper() );

    if ( !(pDrawModelWrapper && m_pDrawViewWrapper) )

        return;

    const rtl::Reference< SvxDrawPage > xDrawPage( pDrawModelWrapper->getMainDrawPage() );

    OSL_ASSERT( xDrawPage.is() );

    if ( !xDrawPage )

        return;

    try

    {

        rtl::Reference<SvxShapeText> xTextShape = new SvxShapeText(nullptr);

        xTextShape->setShapeKind(SdrObjKind::Text);

        xDrawPage->add( xTextShape );

        xTextShape->setString( rString );

        float fCharHeight = 10.0;

        xTextShape->SvxShape::setPropertyValue( u"TextAutoGrowHeight"_ustr, uno::Any( true ) );

        xTextShape->SvxShape::setPropertyValue( u"TextAutoGrowWidth"_ustr, uno::Any( true ) );

        xTextShape->SvxShape::setPropertyValue( u"CharHeight"_ustr, uno::Any( fCharHeight ) );

        xTextShape->SvxShape::setPropertyValue( u"CharHeightAsian"_ustr, uno::Any( fCharHeight ) );

        xTextShape->SvxShape::setPropertyValue( u"CharHeightComplex"_ustr, uno::Any( fCharHeight ) );

        xTextShape->SvxShape::setPropertyValue( u"TextVerticalAdjust"_ustr, uno::Any( drawing::TextVerticalAdjust_CENTER ) );

        xTextShape->SvxShape::setPropertyValue( u"TextHorizontalAdjust"_ustr, uno::Any( drawing::TextHorizontalAdjust_CENTER ) );

        xTextShape->SvxShape::setPropertyValue( u"CharFontName"_ustr, uno::Any( u"Albany"_ustr ) );

        xTextShape->setPosition( rPosition );

        m_aSelection.setSelection( xTextShape );

        m_aSelection.applySelection( m_pDrawViewWrapper.get() );

        SdrObject* pObj = DrawViewWrapper::getSdrObject( xTextShape );

        if ( pObj )

        {

            m_pDrawViewWrapper->BegUndo( SvxResId( RID_SVX_3D_UNDO_EXCHANGE_PASTE ) );

            m_pDrawViewWrapper->AddUndo( std::make_unique<SdrUndoInsertObj>( *pObj ) );

            m_pDrawViewWrapper->EndUndo();

            impl_switchDiagramPositioningToExcludingPositioning();

        }

    }

    catch ( const uno::Exception& )

    {

        DBG_UNHANDLED_EXCEPTION("chart2");

    }

}

void ChartController::executeDispatch_Copy()

{

    SolarMutexGuard aSolarGuard;

    if (!m_pDrawViewWrapper)

        return;

    OutlinerView* pOutlinerView = m_pDrawViewWrapper->GetTextEditOutlinerView();

    if (pOutlinerView)

        pOutlinerView->Copy();

    else

    {

        SdrObject* pSelectedObj = nullptr;

        ObjectIdentifier aSelOID(m_aSelection.getSelectedOID());

        if (aSelOID.isAutoGeneratedObject())

            pSelectedObj = m_pDrawModelWrapper->getNamedSdrObject( aSelOID.getObjectCID() );

        else if (aSelOID.isAdditionalShape())

            pSelectedObj = DrawViewWrapper::getSdrObject( aSelOID.getAdditionalShape() );

        if (pSelectedObj)

        {

            Reference<datatransfer::clipboard::XClipboard> xClipboard(GetChartWindow()->GetClipboard());

            if (xClipboard.is())

            {

                Reference< datatransfer::XTransferable > xTransferable(

                    new ChartTransferable(m_pDrawModelWrapper->getSdrModel(),

                                          pSelectedObj, aSelOID.isAdditionalShape()));

                xClipboard->setContents(xTransferable, Reference< datatransfer::clipboard::XClipboardOwner >());

            }

        }

    }

}

void ChartController::executeDispatch_Cut()

{

    executeDispatch_Copy();

    executeDispatch_Delete();

}

bool ChartController::isObjectDeleteable( const uno::Any& rSelection )

{

    ObjectIdentifier aSelOID( rSelection );

    if ( aSelOID.isAutoGeneratedObject() )

    {

        const OUString& aSelObjCID( aSelOID.getObjectCID() );

        ObjectType aObjectType(ObjectIdentifier::getObjectType( aSelObjCID ));

        switch(aObjectType)

        {

        case OBJECTTYPE_TITLE:

        case OBJECTTYPE_LEGEND:

        case OBJECTTYPE_DATA_SERIES:

        case OBJECTTYPE_LEGEND_ENTRY:

        case OBJECTTYPE_DATA_CURVE_EQUATION:

        case OBJECTTYPE_DATA_CURVE:

        case OBJECTTYPE_DATA_AVERAGE_LINE:

        case OBJECTTYPE_DATA_ERRORS_X:

        case OBJECTTYPE_DATA_ERRORS_Y:

        case OBJECTTYPE_DATA_ERRORS_Z:

        case OBJECTTYPE_DATA_LABELS:

        case OBJECTTYPE_DATA_LABEL:

        case OBJECTTYPE_AXIS:

        case OBJECTTYPE_GRID:

        case OBJECTTYPE_SUBGRID:

            return true;

        default:

            break;

        }

    }

    else if ( aSelOID.isAdditionalShape() )

    {

        return true;

    }

    return false;

}

bool ChartController::isShapeContext() const

{

    return m_aSelection.isAdditionalShapeSelected() ||

         ( m_pDrawViewWrapper && m_pDrawViewWrapper->GetMarkedObjectList().GetMarkCount() != 0 &&

           ( m_pDrawViewWrapper->GetCurrentObjIdentifier() == SdrObjKind::Text ) );

}

bool ChartController::IsTextEdit() const

{

    // only Title objects and additional shapes are editable textshapes in chart

    return m_pDrawViewWrapper && m_pDrawViewWrapper->IsTextEdit() &&

        (m_aSelection.isTitleObjectSelected() || m_aSelection.isAdditionalShapeSelected());

}

void ChartController::impl_ClearSelection()

{

    if( m_aSelection.hasSelection())

    {

        m_aSelection.clearSelection();

        impl_notifySelectionChangeListeners();

    }

}

bool ChartController::executeDispatch_Delete()

{

    bool bReturn = false;

    // remove the selected object

    OUString aCID( m_aSelection.getSelectedCID() );

    if( !aCID.isEmpty() )

    {

        if( !isObjectDeleteable( uno::Any( aCID ) ) )

            return false;

        //remove chart object

        rtl::Reference< ChartModel > xChartDoc = getChartModel();

        if( !xChartDoc.is() )

            return false;

        ObjectType aObjectType( ObjectIdentifier::getObjectType( aCID ));

        switch( aObjectType )

        {

            case OBJECTTYPE_TITLE:

            {

                UndoGuard aUndoGuard(

                    ActionDescriptionProvider::createDescription(

                        ActionDescriptionProvider::ActionType::Delete, SchResId( STR_OBJECT_TITLE )),

                    m_xUndoManager );

                TitleHelper::removeTitle(

                    ObjectIdentifier::getTitleTypeForCID( aCID ), getChartModel() );

                bReturn = true;

                aUndoGuard.commit();

                break;

            }

            case OBJECTTYPE_LEGEND:

            {

                rtl::Reference< Diagram > xDiagram( xChartDoc->getFirstChartDiagram());

                if( xDiagram.is())

                {

                    rtl::Reference< Legend > xLegend( xDiagram->getLegend2() );

                    if( xLegend.is())

                    {

                        UndoGuard aUndoGuard(

                            ActionDescriptionProvider::createDescription(

                                ActionDescriptionProvider::ActionType::Delete, SchResId( STR_OBJECT_LEGEND )),

                            m_xUndoManager );

                        xLegend->setPropertyValue( u"Show"_ustr, uno::Any( false ));

                        bReturn = true;

                        aUndoGuard.commit();