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

#include <ChartTypeManager.hxx>

#include <ChartTypeTemplate.hxx>

#include <servicenames.hxx>

#include <DataSource.hxx>

#include <DataSourceHelper.hxx>

#include <ChartType.hxx>

#include <DisposeHelper.hxx>

#include <ControllerLockGuard.hxx>

#include <InternalDataProvider.hxx>

#include <ObjectIdentifier.hxx>

#include <BaseCoordinateSystem.hxx>

#include "PageBackground.hxx"

#include <CloneHelper.hxx>

#include <NameContainer.hxx>

#include "UndoManager.hxx"

#include <ChartColorPaletteHelper.hxx>

#include <ChartView.hxx>

#include <PopupRequest.hxx>

#include <ModifyListenerHelper.hxx>

#include <RangeHighlighter.hxx>

#include <Diagram.hxx>

#include <ChartDocumentWrapper.hxx>

#include <comphelper/dumpxmltostring.hxx>

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

#include <com/sun/star/chart2/data/XPivotTableDataProvider.hpp>

#include <comphelper/processfactory.hxx>

#include <comphelper/propertysequence.hxx>

#include <cppuhelper/supportsservice.hxx>

#include <svl/numformat.hxx>

#include <svl/numuno.hxx>

#include <com/sun/star/lang/DisposedException.hpp>

#include <com/sun/star/view/XSelectionSupplier.hpp>

#include <com/sun/star/embed/EmbedMapUnits.hpp>

#include <com/sun/star/embed/Aspects.hpp>

#include <com/sun/star/datatransfer/UnsupportedFlavorException.hpp>

#include <com/sun/star/datatransfer/XTransferable.hpp>

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

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

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

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

#include <com/sun/star/document/DocumentProperties.hpp>

#include <com/sun/star/text/XTextDocument.hpp>

#include <com/sun/star/util/CloseVetoException.hpp>

#include <com/sun/star/util/XModifyBroadcaster.hpp>

#include <sal/log.hxx>

#include <utility>

#include <comphelper/diagnose_ex.hxx>

#include <libxml/xmlwriter.h>

#include <sfx2/objsh.hxx>

#include <sfx2/viewsh.hxx>

#include <com/sun/star/util/XTheme.hpp>

#include <docmodel/uno/UnoTheme.hxx>

#include <docmodel/theme/Theme.hxx>

#include <docmodel/uno/UnoChartStyle.hxx>

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

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

using ::com::sun::star::uno::Any;

using ::osl::MutexGuard;

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

using namespace ::apphelper;

namespace

{

constexpr OUString lcl_aGDIMetaFileMIMEType(

    u"application/x-openoffice-gdimetafile;windows_formatname=\"GDIMetaFile\""_ustr);

constexpr OUString lcl_aGDIMetaFileMIMETypeHighContrast(

    u"application/x-openoffice-highcontrast-gdimetafile;windows_formatname=\"GDIMetaFile\""_ustr);

} // anonymous namespace

// ChartModel Constructor and Destructor

namespace chart

{

namespace

{

SfxObjectShell* getParentShell(const uno::Reference<frame::XModel>& xDocModel)

{

    uno::Reference<lang::XUnoTunnel> xUnoTunnel(xDocModel, uno::UNO_QUERY);

    if (xUnoTunnel.is())

    {

        return comphelper::getFromUnoTunnel<SfxObjectShell>(xUnoTunnel);

    }

    return nullptr;

}

}

ChartModel::ChartModel(uno::Reference<uno::XComponentContext > xContext)

    : m_aLifeTimeManager( this, this )

    , m_bReadOnly( false )

    , m_bModified( false )

    , m_nInLoad(0)

    , m_bUpdateNotificationsPending(false)

    , mbTimeBased(false)

    , m_aControllers( m_aModelMutex )

    , m_nControllerLockCount(0)

    , m_xContext(std::move( xContext ))

    , m_aVisualAreaSize( ChartModel::getDefaultPageSize() )

    , m_xPageBackground( new PageBackground )

    , m_xXMLNamespaceMap( new NameContainer() )

    , m_eColorPaletteType(ChartColorPaletteType::Unknown)

    , m_nColorPaletteIndex(0)

    , m_aStyles(new UnoChartStyle)

    , mnStart(0)

    , mnEnd(0)

{

    osl_atomic_increment(&m_refCount);

    {

        m_xOldModelAgg = new wrapper::ChartDocumentWrapper(m_xContext);

        m_xOldModelAgg->setDelegator( *this );

    }

    {

        m_xPageBackground->addModifyListener( this );

#if 0 // TODO

        m_aStyles->addModifyListener( this );

#endif

        m_xChartTypeManager = new ::chart::ChartTypeManager( m_xContext );

    }

    osl_atomic_decrement(&m_refCount);

}

ChartModel::ChartModel( const ChartModel & rOther )

    : impl::ChartModel_Base(rOther)

    // not copy the listener

    , SfxListener()

    , m_aLifeTimeManager( this, this )

    , m_bReadOnly( rOther.m_bReadOnly )

    , m_bModified( rOther.m_bModified )

    , m_nInLoad(0)

    , m_bUpdateNotificationsPending(false)

    , mbTimeBased(rOther.mbTimeBased)

    , m_aResource( rOther.m_aResource )

    , m_aMediaDescriptor( rOther.m_aMediaDescriptor )

    , m_aControllers( m_aModelMutex )

    , m_nControllerLockCount(0)

    , m_xContext( rOther.m_xContext )

    // @note: the old model aggregate must not be shared with other models if it

    // is, you get mutex deadlocks

    //, m_xOldModelAgg( nullptr ) //rOther.m_xOldModelAgg )

    // m_xStorage( nullptr ) //rOther.m_xStorage )

    , m_aVisualAreaSize( rOther.m_aVisualAreaSize )

    , m_aGraphicObjectVector( rOther.m_aGraphicObjectVector )

    , m_xDataProvider( rOther.m_xDataProvider )

    , m_xInternalDataProvider( rOther.m_xInternalDataProvider )

    , m_eColorPaletteType(ChartColorPaletteType::Unknown)

    , m_nColorPaletteIndex(0)

    , mnStart(rOther.mnStart)

    , mnEnd(rOther.mnEnd)

{

    osl_atomic_increment(&m_refCount);

    {

        m_xOldModelAgg = new wrapper::ChartDocumentWrapper(m_xContext);

        m_xOldModelAgg->setDelegator( *this );

        Reference< util::XModifyListener > xListener;

        rtl::Reference< Title > xNewTitle;

        if ( rOther.m_xTitle )

            xNewTitle = new Title(*rOther.m_xTitle);

        rtl::Reference< ::chart::Diagram > xNewDiagram;

        if (rOther.m_xDiagram.is())

            xNewDiagram = new ::chart::Diagram( *rOther.m_xDiagram );

        rtl::Reference< ::chart::PageBackground > xNewPageBackground = new PageBackground( *rOther.m_xPageBackground );

        rtl::Reference<UnoChartStyle> xNewChartStyle = new UnoChartStyle(*rOther.m_aStyles);

        {

            rtl::Reference< ::chart::ChartTypeManager > xChartTypeManager; // does not implement XCloneable

            rtl::Reference< ::chart::NameContainer > xXMLNamespaceMap = new NameContainer( *rOther.m_xXMLNamespaceMap );

            {

                MutexGuard aGuard( m_aModelMutex );

                xListener = this;

                m_xTitle = xNewTitle;

                m_xDiagram = xNewDiagram;

                m_xPageBackground = xNewPageBackground;

                m_aStyles = xNewChartStyle;

                m_xChartTypeManager = std::move(xChartTypeManager);

                m_xXMLNamespaceMap = std::move(xXMLNamespaceMap);

            }

        }

        ModifyListenerHelper::addListener( xNewTitle, xListener );

        if( xNewDiagram && xListener)

            xNewDiagram->addModifyListener( xListener );

        if( xNewPageBackground && xListener)

            xNewPageBackground->addModifyListener( xListener );

#if 0 // TODO

        if( xNewChartStyle && xListener) {

            xNewChartStyle->addModifyListener( xListener );

        }

#endif

        xListener.clear();

    }

    osl_atomic_decrement(&m_refCount);

}

ChartModel::~ChartModel()

{

    if (SfxObjectShell* pShell = getParentShell(m_xParent))

        EndListening(*pShell);

    if( m_xOldModelAgg.is())

        m_xOldModelAgg->setDelegator( nullptr );

}

void SAL_CALL ChartModel::initialize( const Sequence< Any >& /*rArguments*/ )

{

    //#i113722# avoid duplicate creation

    //maybe additional todo?:

    //support argument "EmbeddedObject"?

    //support argument "EmbeddedScriptSupport"?

    //support argument "DocumentRecoverySupport"?

}

ChartView* ChartModel::getChartView() const

{

    return mxChartView.get();

}

// private methods

OUString ChartModel::impl_g_getLocation()

{

    LifeTimeGuard aGuard(m_aLifeTimeManager);

    if(!aGuard.startApiCall())

        return OUString(); //behave passive if already disposed or closed or throw exception @todo?

    //mutex is acquired

    return m_aResource;

}

bool ChartModel::impl_isControllerConnected( const uno::Reference< frame::XController >& xController )

{

    try

    {

        std::vector< uno::Reference<uno::XInterface> > aSeq = m_aControllers.getElements();

        for( const auto & r : aSeq )

        {

            if( r == xController )

                return true;

        }

    }

    catch (const uno::Exception&)

    {

    }

    return false;

}

uno::Reference< frame::XController > ChartModel::impl_getCurrentController()

{

        //@todo? hold only weak references to controllers

    // get the last active controller of this model

    if( m_xCurrentController.is() )

        return m_xCurrentController;

    // get the first controller of this model

    if( m_aControllers.getLength() )

    {

        uno::Reference<uno::XInterface> xI = m_aControllers.getInterface(0);

        return uno::Reference<frame::XController>( xI, uno::UNO_QUERY );

    }

    //return nothing if no controllers are connected at all

    return uno::Reference< frame::XController > ();

}

void ChartModel::impl_notifyCloseListeners()

{

    std::unique_lock aGuard(m_aLifeTimeManager.m_aAccessMutex);

    if( m_aLifeTimeManager.m_aCloseListeners.getLength(aGuard) )

    {

        lang::EventObject aEvent( static_cast< lang::XComponent*>(this) );

        m_aLifeTimeManager.m_aCloseListeners.notifyEach(aGuard, &util::XCloseListener::notifyClosing, aEvent);

    }

}

void ChartModel::impl_adjustAdditionalShapesPositionAndSize( const awt::Size& aVisualAreaSize )

{

    uno::Reference< beans::XPropertySet > xProperties( static_cast< ::cppu::OWeakObject* >( this ), uno::UNO_QUERY );

    if ( !xProperties.is() )

        return;

    uno::Reference< drawing::XShapes > xShapes;

    xProperties->getPropertyValue( u"AdditionalShapes"_ustr ) >>= xShapes;

    if ( !xShapes.is() )

        return;

    sal_Int32 nCount = xShapes->getCount();

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

    {

        Reference< drawing::XShape > xShape;

        if ( xShapes->getByIndex( i ) >>= xShape )

        {

            if ( xShape.is() )

            {

                awt::Point aPos( xShape->getPosition() );

                awt::Size aSize( xShape->getSize() );

                double fWidth = static_cast< double >( aVisualAreaSize.Width ) / m_aVisualAreaSize.Width;

                double fHeight = static_cast< double >( aVisualAreaSize.Height ) / m_aVisualAreaSize.Height;

                aPos.X = static_cast< tools::Long >( aPos.X * fWidth );

                aPos.Y = static_cast< tools::Long >( aPos.Y * fHeight );

                aSize.Width = static_cast< tools::Long >( aSize.Width * fWidth );

                aSize.Height = static_cast< tools::Long >( aSize.Height * fHeight );

                xShape->setPosition( aPos );

                xShape->setSize( aSize );

            }

        }

    }

}

// lang::XServiceInfo

OUString SAL_CALL ChartModel::getImplementationName()

{

    return u"com.sun.star.comp.chart2.ChartModel"_ustr;

}

sal_Bool SAL_CALL ChartModel::supportsService( const OUString& rServiceName )

{

    return cppu::supportsService(this, rServiceName);

}

css::uno::Sequence< OUString > SAL_CALL ChartModel::getSupportedServiceNames()

{

    return {

        u"com.sun.star.chart2.ChartDocument"_ustr,

        u"com.sun.star.document.OfficeDocument"_ustr,

        u"com.sun.star.chart.ChartDocument"_ustr

    };

}

// frame::XModel (required interface)

sal_Bool SAL_CALL ChartModel::attachResource( const OUString& rURL

        , const uno::Sequence< beans::PropertyValue >& rMediaDescriptor )

{

    /*

    The method attachResource() is used by the frame loader implementations

    to inform the model about its URL and MediaDescriptor.

    */

    LifeTimeGuard aGuard(m_aLifeTimeManager);

    if(!aGuard.startApiCall())

        return false; //behave passive if already disposed or closed or throw exception @todo?

    //mutex is acquired

    if(!m_aResource.isEmpty())//we have a resource already //@todo? or is setting a new resource allowed?

        return false;

    m_aResource = rURL;

    m_aMediaDescriptor = rMediaDescriptor;

    //@todo ? check rURL ??

    //@todo ? evaluate m_aMediaDescriptor;

    //@todo ? ... ??? --> nothing, this method is only for setting information

    return true;

}

OUString SAL_CALL ChartModel::getURL()

{

    return impl_g_getLocation();

}

uno::Sequence< beans::PropertyValue > SAL_CALL ChartModel::getArgs()

{

    /*

    The method getArgs() returns a sequence of property values

    that report the resource description according to com.sun.star.document.MediaDescriptor,

    specified on loading or saving with storeAsURL.

    */

    LifeTimeGuard aGuard(m_aLifeTimeManager);

    if(!aGuard.startApiCall())

        return uno::Sequence< beans::PropertyValue >(); //behave passive if already disposed or closed or throw exception @todo?

    //mutex is acquired

    return m_aMediaDescriptor;

}

void SAL_CALL ChartModel::connectController( const uno::Reference< frame::XController >& xController )

{

    //@todo? this method is declared as oneway -> ...?

    LifeTimeGuard aGuard(m_aLifeTimeManager);

    if(!aGuard.startApiCall())

        return ; //behave passive if already disposed or closed

    //mutex is acquired

    //--add controller

    m_aControllers.addInterface(xController);

}

void SAL_CALL ChartModel::disconnectController( const uno::Reference< frame::XController >& xController )

{

    //@todo? this method is declared as oneway -> ...?

    LifeTimeGuard aGuard(m_aLifeTimeManager);

    if(!aGuard.startApiCall())

        return; //behave passive if already disposed or closed

    //--remove controller

    m_aControllers.removeInterface(xController);

    //case: current controller is disconnected:

    if( m_xCurrentController == xController )

        m_xCurrentController.clear();

    if (m_xRangeHighlighter)

    {

        m_xRangeHighlighter->dispose();

        m_xRangeHighlighter.clear();

    }

    DisposeHelper::DisposeAndClear(m_xPopupRequest);

}

void SAL_CALL ChartModel::lockControllers()

{

    /*

    suspends some notifications to the controllers which are used for display updates.

    The calls to lockControllers() and unlockControllers() may be nested

    and even overlapping, but they must be in pairs. While there is at least one lock

    remaining, some notifications for display updates are not broadcasted.

    */

    //@todo? this method is declared as oneway -> ...?

    LifeTimeGuard aGuard(m_aLifeTimeManager);

    if(!aGuard.startApiCall())

        return; //behave passive if already disposed or closed or throw exception @todo?

    ++m_nControllerLockCount;

}

void SAL_CALL ChartModel::unlockControllers()

{

    /*

    resumes the notifications which were suspended by lockControllers() .

    The calls to lockControllers() and unlockControllers() may be nested

    and even overlapping, but they must be in pairs. While there is at least one lock

    remaining, some notifications for display updates are not broadcasted.

    */

    //@todo? this method is declared as oneway -> ...?

    LifeTimeGuard aGuard(m_aLifeTimeManager);

    if(!aGuard.startApiCall())

        return; //behave passive if already disposed or closed or throw exception @todo?

    if( m_nControllerLockCount == 0 )

    {

        SAL_WARN("chart2",  "ChartModel: unlockControllers called with m_nControllerLockCount == 0" );

        return;

    }

    --m_nControllerLockCount;

    if( m_nControllerLockCount == 0 && m_bUpdateNotificationsPending  )

    {

        aGuard.clear();

        impl_notifyModifiedListeners();

    }

}

sal_Bool SAL_CALL ChartModel::hasControllersLocked()

{

    LifeTimeGuard aGuard(m_aLifeTimeManager);

    if(!aGuard.startApiCall())

        return false; //behave passive if already disposed or closed or throw exception @todo?

    return ( m_nControllerLockCount != 0 ) ;

}

uno::Reference< frame::XController > SAL_CALL ChartModel::getCurrentController()

{

    LifeTimeGuard aGuard(m_aLifeTimeManager);

    if(!aGuard.startApiCall())

        throw lang::DisposedException(

                u"getCurrentController was called on an already disposed or closed model"_ustr,

                static_cast< ::cppu::OWeakObject* >(this) );

    return impl_getCurrentController();

}

void SAL_CALL ChartModel::setCurrentController( const uno::Reference< frame::XController >& xController )

{

    LifeTimeGuard aGuard(m_aLifeTimeManager);

    if(!aGuard.startApiCall())

        throw lang::DisposedException(

                u"setCurrentController was called on an already disposed or closed model"_ustr,

                static_cast< ::cppu::OWeakObject* >(this) );

    //OSL_ENSURE( impl_isControllerConnected(xController), "setCurrentController is called with a Controller which is not connected" );

    if(!impl_isControllerConnected(xController))

        throw container::NoSuchElementException(

                u"setCurrentController is called with a Controller which is not connected"_ustr,

                static_cast< ::cppu::OWeakObject* >(this) );

    m_xCurrentController = xController;

    if (m_xRangeHighlighter)

    {

        m_xRangeHighlighter->dispose();

        m_xRangeHighlighter.clear();

    }

    DisposeHelper::DisposeAndClear(m_xPopupRequest);

}

uno::Reference< uno::XInterface > SAL_CALL ChartModel::getCurrentSelection()

{

    LifeTimeGuard aGuard(m_aLifeTimeManager);

    if(!aGuard.startApiCall())

        throw lang::DisposedException(

                u"getCurrentSelection was called on an already disposed or closed model"_ustr,

                static_cast< ::cppu::OWeakObject* >(this) );

    uno::Reference< uno::XInterface > xReturn;

    uno::Reference< frame::XController > xController = impl_getCurrentController();

    aGuard.clear();

    if( xController.is() )

    {

        uno::Reference< view::XSelectionSupplier >  xSelectionSupl( xController, uno::UNO_QUERY );

        if ( xSelectionSupl.is() )

        {

            uno::Any aSel = xSelectionSupl->getSelection();

            OUString aObjectCID;

            if( aSel >>= aObjectCID )

                xReturn.set( ObjectIdentifier::getObjectPropertySet( aObjectCID, this));

        }

    }

    return xReturn;

}

// lang::XComponent (base of XModel)

void SAL_CALL ChartModel::dispose()

{

    Reference< XInterface > xKeepAlive( *this );

    //This object should release all resources and references in the

    //easiest possible manner

    //This object must notify all registered listeners using the method

    //<member>XEventListener::disposing</member>

    //hold no mutex

    if( !m_aLifeTimeManager.dispose() )

        return;

    //--release all resources and references

    //// @todo

    if ( m_xDiagram.is() )

        m_xDiagram->removeModifyListener( this );

    if ( m_xDataProvider.is() )

    {

        Reference<util::XModifyBroadcaster> xModifyBroadcaster( m_xDataProvider, uno::UNO_QUERY );

        if ( xModifyBroadcaster.is() )

            xModifyBroadcaster->removeModifyListener( this );

    }

    m_xDataProvider.clear();

    m_xInternalDataProvider.clear();

    m_xNumberFormatsSupplier.clear();

    m_xOwnNumberFormatsSupplier.clear();

    m_xChartTypeManager.clear();

    m_xDiagram.clear();

    m_xTitle.clear();

    m_xPageBackground.clear();

    m_xXMLNamespaceMap.clear();

    m_aStyles.clear();

    m_xStorage.clear();

        // just clear, don't dispose - we're not the owner

    if ( m_pUndoManager.is() )

        m_pUndoManager->disposing();

    m_pUndoManager.clear();

        // that's important, since the UndoManager implementation delegates its ref counting to ourself.

    if( m_xOldModelAgg.is())  // #i120828#, to release cyclic reference to ChartModel object

        m_xOldModelAgg->setDelegator( nullptr );

    m_aControllers.disposeAndClear( lang::EventObject( static_cast< cppu::OWeakObject * >( this )));

    m_xCurrentController.clear();

    if (m_xRangeHighlighter)

    {

        m_xRangeHighlighter->dispose();

        m_xRangeHighlighter.clear();

    }

    DisposeHelper::DisposeAndClear(m_xPopupRequest);

    if( m_xOldModelAgg.is())

        m_xOldModelAgg->setDelegator( nullptr );

}

void SAL_CALL ChartModel::addEventListener( const uno::Reference< lang::XEventListener > & xListener )

{

    if( m_aLifeTimeManager.impl_isDisposedOrClosed() )

        return; //behave passive if already disposed or closed

    std::unique_lock aGuard(m_aLifeTimeManager.m_aAccessMutex);

    m_aLifeTimeManager.m_aEventListeners.addInterface( aGuard, xListener );

}

void SAL_CALL ChartModel::removeEventListener( const uno::Reference< lang::XEventListener > & xListener )

{

    if( m_aLifeTimeManager.impl_isDisposedOrClosed(false) )

        return; //behave passive if already disposed or closed

    std::unique_lock aGuard(m_aLifeTimeManager.m_aAccessMutex);

    m_aLifeTimeManager.m_aEventListeners.removeInterface( aGuard, xListener );

}

// util::XCloseBroadcaster (base of XCloseable)

void SAL_CALL ChartModel::addCloseListener( const uno::Reference<   util::XCloseListener > & xListener )

{

    m_aLifeTimeManager.g_addCloseListener( xListener );

}

void SAL_CALL ChartModel::removeCloseListener( const uno::Reference< util::XCloseListener > & xListener )

{

    if( m_aLifeTimeManager.impl_isDisposedOrClosed(false) )

        return; //behave passive if already disposed or closed

    std::unique_lock aGuard(m_aLifeTimeManager.m_aAccessMutex);

    m_aLifeTimeManager.m_aCloseListeners.removeInterface( aGuard, xListener );

}

// util::XCloseable

void SAL_CALL ChartModel::close( sal_Bool bDeliverOwnership )

{

    //hold no mutex

    if( !m_aLifeTimeManager.g_close_startTryClose( bDeliverOwnership ) )

        return;

    //no mutex is acquired

    // At the end of this method may we must dispose ourself ...

    // and may nobody from outside hold a reference to us ...

    // then it's a good idea to do that by ourself.

    uno::Reference< uno::XInterface > xSelfHold( static_cast< ::cppu::OWeakObject* >(this) );

    //the listeners have had no veto

    //check whether we self can close

    {

        util::CloseVetoException aVetoException(

                        u"the model itself could not be closed"_ustr,

                        static_cast< ::cppu::OWeakObject* >(this) );

        m_aLifeTimeManager.g_close_isNeedToCancelLongLastingCalls( bDeliverOwnership, aVetoException );

    }

    m_aLifeTimeManager.g_close_endTryClose_doClose();

    // BM @todo: is it ok to call the listeners here?

    impl_notifyCloseListeners();

}

// lang::XTypeProvider

uno::Sequence< uno::Type > SAL_CALL ChartModel::getTypes()

{

    uno::Reference< lang::XTypeProvider > xAggTypeProvider;

    if( (m_xOldModelAgg->queryAggregation( cppu::UnoType<decltype(xAggTypeProvider)>::get()) >>= xAggTypeProvider)

        && xAggTypeProvider.is())

    {

        return comphelper::concatSequences(

            impl::ChartModel_Base::getTypes(),

            xAggTypeProvider->getTypes());

    }

    return impl::ChartModel_Base::getTypes();

}

// document::XDocumentPropertiesSupplier

uno::Reference< document::XDocumentProperties > SAL_CALL

        ChartModel::getDocumentProperties()

{

    ::osl::MutexGuard aGuard( m_aModelMutex );

    if ( !m_xDocumentProperties.is() )

    {

        m_xDocumentProperties.set( document::DocumentProperties::create( ::comphelper::getProcessComponentContext() ) );

    }

    return m_xDocumentProperties;

}

// document::XDocumentPropertiesSupplier

Reference< document::XUndoManager > SAL_CALL ChartModel::getUndoManager(  )

{

    ::osl::MutexGuard aGuard( m_aModelMutex );

    if ( !m_pUndoManager.is() )

        m_pUndoManager.set( new UndoManager( *this, m_aModelMutex ) );

    return m_pUndoManager;

}

// chart2::XChartDocument

uno::Reference< chart2::XDiagram > SAL_CALL ChartModel::getFirstDiagram()

{

    MutexGuard aGuard( m_aModelMutex );

    return m_xDiagram;

}

void SAL_CALL ChartModel::setFirstDiagram( const uno::Reference< chart2::XDiagram >& xDiagram )

{

    rtl::Reference< ::chart::Diagram > xOldDiagram;

    Reference< util::XModifyListener > xListener;

    {

        MutexGuard aGuard( m_aModelMutex );

        if( xDiagram.get() == m_xDiagram.get() )

            return;

        xOldDiagram = m_xDiagram;

        assert(!xDiagram || dynamic_cast<::chart::Diagram*>(xDiagram.get()));

        m_xDiagram = dynamic_cast<::chart::Diagram*>(xDiagram.get());

        xListener = this;

    }

    //don't keep the mutex locked while calling out

    if( xOldDiagram && xListener )

        xOldDiagram->removeModifyListener( xListener );

    ModifyListenerHelper::addListener( xDiagram, xListener );

    setModified( true );

}

Reference< chart2::data::XDataSource > ChartModel::impl_createDefaultData()

{

    Reference< chart2::data::XDataSource > xDataSource;

    if( hasInternalDataProvider() )

    {

        //init internal dataprovider

        {

            beans::NamedValue aParam( u"CreateDefaultData"_ustr ,uno::Any(true) );

            uno::Sequence< uno::Any > aArgs{ uno::Any(aParam) };

            m_xInternalDataProvider->initialize(aArgs);

        }

        //create data

        uno::Sequence<beans::PropertyValue> aArgs( comphelper::InitPropertySequence({

            { "CellRangeRepresentation", uno::Any( u"all"_ustr ) },

            { "HasCategories", uno::Any( true ) },

            { "FirstCellAsLabel", uno::Any( true ) },

            { "DataRowSource", uno::Any( css::chart::ChartDataRowSource_COLUMNS ) }

            }));

        xDataSource = m_xInternalDataProvider->createDataSource( aArgs );

    }

    return xDataSource;

}

void SAL_CALL ChartModel::createInternalDataProvider( sal_Bool bCloneExistingData )

{

    // don't lock the mutex, because this call calls out to code that tries to

    // lock the solar mutex. On the other hand, a paint locks the solar mutex

    // and calls to the model lock the model's mutex => deadlock

    // @todo: lock a separate mutex in the InternalData class

    if( !hasInternalDataProvider() )

    {

        if( bCloneExistingData )

            m_xInternalDataProvider = new InternalDataProvider( this, /*bConnectToModel*/true, /*bDefaultDataInColumns*/ true );

        else

        {

            m_xInternalDataProvider = new InternalDataProvider( nullptr, /*bConnectToModel*/true, /*bDefaultDataInColumns*/ true );

            m_xInternalDataProvider->setChartModel(this);

        }

        m_xDataProvider.set( m_xInternalDataProvider );

    }

    setModified( true );

}

void ChartModel::removeDataProviders()

{

    if (m_xInternalDataProvider.is())

        m_xInternalDataProvider.clear();

    if (m_xDataProvider.is())

        m_xDataProvider.clear();

}

void ChartModel::dumpAsXml(xmlTextWriterPtr pWriter) const

{

    (void)xmlTextWriterStartElement(pWriter, BAD_CAST("ChartModel"));

    (void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);

    if (mxChartView.is())

    {

        mxChartView->dumpAsXml(pWriter);

    }

    (void)xmlTextWriterEndElement(pWriter);

}

sal_Bool SAL_CALL ChartModel::hasInternalDataProvider()

{

    return m_xDataProvider.is() && m_xInternalDataProvider.is();

}

uno::Reference< chart2::data::XDataProvider > SAL_CALL ChartModel::getDataProvider()

{

    MutexGuard aGuard( m_aModelMutex );

    return m_xDataProvider;

}

uno::Reference< chart2::XChartStyle > SAL_CALL ChartModel::getStyles()

{

    MutexGuard aGuard( m_aModelMutex );

    return m_aStyles;

}

// ____ XDataReceiver ____

void SAL_CALL ChartModel::attachDataProvider( const uno::Reference< chart2::data::XDataProvider >& xDataProvider )

{

    {

        MutexGuard aGuard( m_aModelMutex );

        uno::Reference< beans::XPropertySet > xProp( xDataProvider, uno::UNO_QUERY );

        if( xProp.is() )

        {

            try

            {

                bool bIncludeHiddenCells = isIncludeHiddenCells();

                xProp->setPropertyValue(u"IncludeHiddenCells"_ustr, uno::Any(bIncludeHiddenCells));

            }

            catch (const beans::UnknownPropertyException&)

            {

            }

        }

        uno::Reference<util::XModifyBroadcaster> xModifyBroadcaster(xDataProvider, uno::UNO_QUERY);

        if (xModifyBroadcaster.is())

        {

            xModifyBroadcaster->addModifyListener(this);

        }

        m_xDataProvider.set( xDataProvider );

        m_xInternalDataProvider.clear();

        //the numberformatter is kept independent of the data provider!

    }

    setModified( true );

}

void SAL_CALL ChartModel::attachNumberFormatsSupplier( const uno::Reference< util::XNumberFormatsSupplier >& xNewSupplier )

{

    {

        // Mostly the supplier is SvNumberFormatsSupplierObj, but sometimes it is reportdesign::OReportDefinition

        MutexGuard aGuard( m_aModelMutex );

        if( xNewSupplier == m_xNumberFormatsSupplier )

            return;

        if( xNewSupplier == uno::Reference<XNumberFormatsSupplier>(m_xOwnNumberFormatsSupplier) )

            return;

        if( m_xOwnNumberFormatsSupplier.is() && xNewSupplier.is() )

        {

            //@todo

            //merge missing numberformats from own to new formatter

        }

        else if( !xNewSupplier.is() )

        {

            if( m_xNumberFormatsSupplier.is() )

            {

                //@todo

                //merge missing numberformats from old numberformatter to own numberformatter

                //create own numberformatter if necessary

            }

        }

        m_xNumberFormatsSupplier.set( xNewSupplier );

        m_xOwnNumberFormatsSupplier.clear();

    }

    setModified( true );

}

void SAL_CALL ChartModel::setArguments( const Sequence< beans::PropertyValue >& aArguments )

{

    {

        MutexGuard aGuard( m_aModelMutex );

        if( !m_xDataProvider.is() )

            return;

        lockControllers();

        try

        {

            Reference< chart2::data::XDataSource > xDataSource( m_xDataProvider->createDataSource( aArguments ) );

            if( xDataSource.is() )

            {

                rtl::Reference< Diagram > xDia = getFirstChartDiagram();

                if( !xDia.is() )

                {

                    rtl::Reference< ::chart::ChartTypeTemplate > xTemplate( impl_createDefaultChartTypeTemplate() );

                    if( xTemplate.is())

                        setFirstDiagram( xTemplate->createDiagramByDataSource( xDataSource, aArguments ) );

                }

                else

                    xDia->setDiagramData( xDataSource, aArguments );

            }

        }

        catch (const lang::IllegalArgumentException&)

        {

            throw;

        }

        catch (const uno::Exception&)

        {