/* -*- 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 <ChartDocumentWrapper.hxx>
#include <servicenames.hxx>
#include <PropertyHelper.hxx>
#include <TitleHelper.hxx>
#include <LegendHelper.hxx>
#include <ControllerLockGuard.hxx>
#include <ModifyListenerHelper.hxx>
#include <DisposeHelper.hxx>
#include "DataSeriesPointWrapper.hxx"
#include <chartview/ExplicitValueProvider.hxx>
#include <chartview/DrawModelWrapper.hxx>
#include "Chart2ModelContact.hxx"
#include <ChartModel.hxx>
#include <DiagramHelper.hxx>
#include <DataSourceHelper.hxx>
#include <ChartModelHelper.hxx>
#include <AxisHelper.hxx>
#include <ThreeDHelper.hxx>
#include "TitleWrapper.hxx"
#include "ChartDataWrapper.hxx"
#include "DiagramWrapper.hxx"
#include "LegendWrapper.hxx"
#include "AreaWrapper.hxx"
#include "WrappedAddInProperty.hxx"
#include <WrappedIgnoreProperty.hxx>
#include <cppuhelper/supportsservice.hxx>
#include <com/sun/star/chart2/XTitled.hpp>
#include <com/sun/star/chart2/data/XDataReceiver.hpp>
#include <com/sun/star/chart/ChartDataRowSource.hpp>
#include <comphelper/processfactory.hxx>
#include <comphelper/sequence.hxx>
#include <vcl/svapp.hxx>
#include <vcl/settings.hxx>
#include <com/sun/star/drawing/ShapeCollection.hpp>
#include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
#include <com/sun/star/beans/PropertyAttribute.hpp>
#include <com/sun/star/lang/DisposedException.hpp>
#include <com/sun/star/lang/XInitialization.hpp>
#include <com/sun/star/util/DateTime.hpp>
#include <tools/diagnose_ex.h>
#include <vector>
#include <algorithm>
#include <functional>
#include <map>
#include <o3tl/functional.hxx>
using namespace ::com::sun::star;
using namespace ::com::sun::star::chart;
using ::com::sun::star::uno::Any;
using ::com::sun::star::uno::UNO_QUERY_THROW;
using ::com::sun::star::uno::Reference;
using ::com::sun::star::uno::Sequence;
using ::com::sun::star::beans::Property;
namespace
{
enum eServiceType
{
SERVICE_NAME_AREA_DIAGRAM = 0,
SERVICE_NAME_BAR_DIAGRAM,
SERVICE_NAME_DONUT_DIAGRAM,
SERVICE_NAME_LINE_DIAGRAM,
SERVICE_NAME_NET_DIAGRAM,
SERVICE_NAME_FILLED_NET_DIAGRAM,
SERVICE_NAME_PIE_DIAGRAM,
SERVICE_NAME_STOCK_DIAGRAM,
SERVICE_NAME_XY_DIAGRAM,
SERVICE_NAME_BUBBLE_DIAGRAM,
SERVICE_NAME_DASH_TABLE,
SERVICE_NAME_GARDIENT_TABLE,
SERVICE_NAME_HATCH_TABLE,
SERVICE_NAME_BITMAP_TABLE,
SERVICE_NAME_TRANSP_GRADIENT_TABLE,
SERVICE_NAME_MARKER_TABLE,
SERVICE_NAME_NAMESPACE_MAP,
SERVICE_NAME_EXPORT_GRAPHIC_STORAGE_RESOLVER,
SERVICE_NAME_IMPORT_GRAPHIC_STORAGE_RESOLVER
};
typedef std::map< OUString, enum eServiceType > tServiceNameMap;
tServiceNameMap & lcl_getStaticServiceNameMap()
{
static tServiceNameMap aServiceNameMap {
{"com.sun.star.chart.AreaDiagram", SERVICE_NAME_AREA_DIAGRAM},
{"com.sun.star.chart.BarDiagram", SERVICE_NAME_BAR_DIAGRAM},
{"com.sun.star.chart.DonutDiagram", SERVICE_NAME_DONUT_DIAGRAM},
{"com.sun.star.chart.LineDiagram", SERVICE_NAME_LINE_DIAGRAM},
{"com.sun.star.chart.NetDiagram", SERVICE_NAME_NET_DIAGRAM},
{"com.sun.star.chart.FilledNetDiagram", SERVICE_NAME_FILLED_NET_DIAGRAM},
{"com.sun.star.chart.PieDiagram", SERVICE_NAME_PIE_DIAGRAM},
{"com.sun.star.chart.StockDiagram", SERVICE_NAME_STOCK_DIAGRAM},
{"com.sun.star.chart.XYDiagram", SERVICE_NAME_XY_DIAGRAM},
{"com.sun.star.chart.BubbleDiagram", SERVICE_NAME_BUBBLE_DIAGRAM},
{"com.sun.star.drawing.DashTable", SERVICE_NAME_DASH_TABLE},
{"com.sun.star.drawing.GradientTable", SERVICE_NAME_GARDIENT_TABLE},
{"com.sun.star.drawing.HatchTable", SERVICE_NAME_HATCH_TABLE},
{"com.sun.star.drawing.BitmapTable", SERVICE_NAME_BITMAP_TABLE},
{"com.sun.star.drawing.TransparencyGradientTable", SERVICE_NAME_TRANSP_GRADIENT_TABLE},
{"com.sun.star.drawing.MarkerTable", SERVICE_NAME_MARKER_TABLE},
{"com.sun.star.xml.NamespaceMap", SERVICE_NAME_NAMESPACE_MAP},
{"com.sun.star.document.ExportGraphicStoreageHandler", SERVICE_NAME_EXPORT_GRAPHIC_STORAGE_RESOLVER},
{"com.sun.star.document.ImportGraphicStoreageHandler", SERVICE_NAME_IMPORT_GRAPHIC_STORAGE_RESOLVER}
};
return aServiceNameMap;
}
enum
{
PROP_DOCUMENT_HAS_MAIN_TITLE,
PROP_DOCUMENT_HAS_SUB_TITLE,
PROP_DOCUMENT_HAS_LEGEND,
PROP_DOCUMENT_LABELS_IN_FIRST_ROW,
PROP_DOCUMENT_LABELS_IN_FIRST_COLUMN,
PROP_DOCUMENT_ADDIN,
PROP_DOCUMENT_BASEDIAGRAM,
PROP_DOCUMENT_ADDITIONAL_SHAPES,
PROP_DOCUMENT_UPDATE_ADDIN,
PROP_DOCUMENT_NULL_DATE,
PROP_DOCUMENT_ENABLE_COMPLEX_CHARTTYPES,
PROP_DOCUMENT_ENABLE_DATATABLE_DIALOG
};
void lcl_AddPropertiesToVector(
std::vector< Property > & rOutProperties )
{
rOutProperties.emplace_back( "HasMainTitle",
PROP_DOCUMENT_HAS_MAIN_TITLE,
cppu::UnoType<bool>::get(),
//#i111967# no PropertyChangeEvent is fired on change so far
beans::PropertyAttribute::MAYBEDEFAULT );
rOutProperties.emplace_back( "HasSubTitle",
PROP_DOCUMENT_HAS_SUB_TITLE,
cppu::UnoType<bool>::get(),
//#i111967# no PropertyChangeEvent is fired on change so far
beans::PropertyAttribute::MAYBEDEFAULT );
rOutProperties.emplace_back( "HasLegend",
PROP_DOCUMENT_HAS_LEGEND,
cppu::UnoType<bool>::get(),
//#i111967# no PropertyChangeEvent is fired on change so far
beans::PropertyAttribute::MAYBEDEFAULT );
// really needed?
rOutProperties.emplace_back( "DataSourceLabelsInFirstRow",
PROP_DOCUMENT_LABELS_IN_FIRST_ROW,
cppu::UnoType<bool>::get(),
beans::PropertyAttribute::BOUND
| beans::PropertyAttribute::MAYBEDEFAULT );
rOutProperties.emplace_back( "DataSourceLabelsInFirstColumn",
PROP_DOCUMENT_LABELS_IN_FIRST_COLUMN,
cppu::UnoType<bool>::get(),
//#i111967# no PropertyChangeEvent is fired on change so far
beans::PropertyAttribute::MAYBEDEFAULT );
//add-in
rOutProperties.emplace_back( "AddIn",
PROP_DOCUMENT_ADDIN,
cppu::UnoType<util::XRefreshable>::get(),
beans::PropertyAttribute::BOUND
| beans::PropertyAttribute::MAYBEVOID );
rOutProperties.emplace_back( "BaseDiagram",
PROP_DOCUMENT_BASEDIAGRAM,
cppu::UnoType<OUString>::get(),
beans::PropertyAttribute::BOUND
| beans::PropertyAttribute::MAYBEVOID );
rOutProperties.emplace_back( "AdditionalShapes",
PROP_DOCUMENT_ADDITIONAL_SHAPES,
cppu::UnoType<drawing::XShapes>::get(),
beans::PropertyAttribute::BOUND
| beans::PropertyAttribute::MAYBEVOID
| beans::PropertyAttribute::READONLY );
rOutProperties.emplace_back( "RefreshAddInAllowed",
PROP_DOCUMENT_UPDATE_ADDIN,
cppu::UnoType<bool>::get(),
//#i111967# no PropertyChangeEvent is fired on change so far
beans::PropertyAttribute::TRANSIENT );
// table:null-date // i99104
rOutProperties.emplace_back( "NullDate",
PROP_DOCUMENT_NULL_DATE,
::cppu::UnoType<css::util::DateTime>::get(),
beans::PropertyAttribute::MAYBEVOID );
rOutProperties.emplace_back( "EnableComplexChartTypes",
PROP_DOCUMENT_ENABLE_COMPLEX_CHARTTYPES,
cppu::UnoType<bool>::get(),
//#i112666# no PropertyChangeEvent is fired on change so far
beans::PropertyAttribute::MAYBEDEFAULT );
rOutProperties.emplace_back( "EnableDataTableDialog",
PROP_DOCUMENT_ENABLE_DATATABLE_DIALOG,
cppu::UnoType<bool>::get(),
//#i112666# no PropertyChangeEvent is fired on change so far
beans::PropertyAttribute::MAYBEDEFAULT );
}
struct StaticChartDocumentWrapperPropertyArray_Initializer
{
Sequence< Property >* operator()()
{
static Sequence< Property > aPropSeq( lcl_GetPropertySequence() );
return &aPropSeq;
}
private:
static uno::Sequence< Property > lcl_GetPropertySequence()
{
std::vector< css::beans::Property > aProperties;
lcl_AddPropertiesToVector( aProperties );
std::sort( aProperties.begin(), aProperties.end(),
::chart::PropertyNameLess() );
return comphelper::containerToSequence( aProperties );
}
};
struct StaticChartDocumentWrapperPropertyArray : public rtl::StaticAggregate< Sequence< Property >, StaticChartDocumentWrapperPropertyArray_Initializer >
{
};
} // anonymous namespace
namespace chart
{
namespace wrapper
{
//PROP_DOCUMENT_LABELS_IN_FIRST_ROW
class WrappedDataSourceLabelsInFirstRowProperty : public WrappedProperty
{
public:
explicit WrappedDataSourceLabelsInFirstRowProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
virtual css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
virtual css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& xInnerPropertyState ) const override;
private: //member
std::shared_ptr< Chart2ModelContact > m_spChart2ModelContact;
mutable Any m_aOuterValue;
};
WrappedDataSourceLabelsInFirstRowProperty::WrappedDataSourceLabelsInFirstRowProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
: WrappedProperty("DataSourceLabelsInFirstRow",OUString())
, m_spChart2ModelContact( spChart2ModelContact )
, m_aOuterValue()
{
m_aOuterValue = WrappedDataSourceLabelsInFirstRowProperty::getPropertyDefault( nullptr );
}
void WrappedDataSourceLabelsInFirstRowProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
{
bool bLabelsInFirstRow = true;
if( ! (rOuterValue >>= bLabelsInFirstRow) )
throw lang::IllegalArgumentException("Property DataSourceLabelsInFirstRow requires value of type boolean", nullptr, 0 );
m_aOuterValue = rOuterValue;
bool bNewValue = bLabelsInFirstRow;
OUString aRangeString;
bool bUseColumns = true;
bool bFirstCellAsLabel = true;
bool bHasCategories = true;
uno::Sequence< sal_Int32 > aSequenceMapping;
if( DataSourceHelper::detectRangeSegmentation(
m_spChart2ModelContact->getChartModel(), aRangeString, aSequenceMapping, bUseColumns
, bFirstCellAsLabel, bHasCategories ) )
{
if( bUseColumns && bNewValue != bFirstCellAsLabel )
{
DataSourceHelper::setRangeSegmentation(
m_spChart2ModelContact->getChartModel(), aSequenceMapping, bUseColumns ,bNewValue, bHasCategories );
}
else if( !bUseColumns && bNewValue != bHasCategories )
{
DataSourceHelper::setRangeSegmentation(
m_spChart2ModelContact->getChartModel(), aSequenceMapping, bUseColumns , bFirstCellAsLabel, bNewValue );
}
}
}
Any WrappedDataSourceLabelsInFirstRowProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
{
OUString aRangeString;
bool bUseColumns = true;
bool bFirstCellAsLabel = true;
bool bHasCategories = true;
uno::Sequence< sal_Int32 > aSequenceMapping;
if( DataSourceHelper::detectRangeSegmentation(
m_spChart2ModelContact->getChartModel(), aRangeString, aSequenceMapping, bUseColumns
, bFirstCellAsLabel, bHasCategories ) )
{
bool bLabelsInFirstRow = true;
if( bUseColumns )
bLabelsInFirstRow = bFirstCellAsLabel;
else
bLabelsInFirstRow = bHasCategories;
m_aOuterValue <<= bLabelsInFirstRow;
}
return m_aOuterValue;
}
Any WrappedDataSourceLabelsInFirstRowProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
{
Any aRet;
aRet <<= true;
return aRet;
}
//PROP_DOCUMENT_LABELS_IN_FIRST_COLUMN
class WrappedDataSourceLabelsInFirstColumnProperty : public WrappedProperty
{
public:
explicit WrappedDataSourceLabelsInFirstColumnProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
virtual css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
virtual css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& xInnerPropertyState ) const override;
private: //member
std::shared_ptr< Chart2ModelContact > m_spChart2ModelContact;
mutable Any m_aOuterValue;
};
WrappedDataSourceLabelsInFirstColumnProperty::WrappedDataSourceLabelsInFirstColumnProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
: WrappedProperty("DataSourceLabelsInFirstColumn",OUString())
, m_spChart2ModelContact( spChart2ModelContact )
, m_aOuterValue()
{
m_aOuterValue = WrappedDataSourceLabelsInFirstColumnProperty::getPropertyDefault( nullptr );
}
void WrappedDataSourceLabelsInFirstColumnProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
{
bool bLabelsInFirstRow = true;
if( ! (rOuterValue >>= bLabelsInFirstRow) )
throw lang::IllegalArgumentException("Property DataSourceLabelsInFirstRow requires value of type boolean", nullptr, 0 );
m_aOuterValue = rOuterValue;
bool bNewValue = bLabelsInFirstRow;
OUString aRangeString;
bool bUseColumns = true;
bool bFirstCellAsLabel = true;
bool bHasCategories = true;
uno::Sequence< sal_Int32 > aSequenceMapping;
if( DataSourceHelper::detectRangeSegmentation(
m_spChart2ModelContact->getChartModel(), aRangeString, aSequenceMapping, bUseColumns
, bFirstCellAsLabel, bHasCategories ) )
{
if( bUseColumns && bNewValue != bHasCategories )
{
DataSourceHelper::setRangeSegmentation(
m_spChart2ModelContact->getChartModel(), aSequenceMapping, bUseColumns, bFirstCellAsLabel, bNewValue );
}
else if( !bUseColumns && bNewValue != bFirstCellAsLabel )
{
DataSourceHelper::setRangeSegmentation(
m_spChart2ModelContact->getChartModel(), aSequenceMapping, bUseColumns , bNewValue, bHasCategories );
}
}
}
Any WrappedDataSourceLabelsInFirstColumnProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
{
OUString aRangeString;
bool bUseColumns = true;
bool bFirstCellAsLabel = true;
bool bHasCategories = true;
uno::Sequence< sal_Int32 > aSequenceMapping;
if( DataSourceHelper::detectRangeSegmentation(
m_spChart2ModelContact->getChartModel(), aRangeString, aSequenceMapping, bUseColumns
, bFirstCellAsLabel, bHasCategories ) )
{
bool bLabelsInFirstColumn = true;
if( bUseColumns )
bLabelsInFirstColumn = bHasCategories;
else
bLabelsInFirstColumn = bFirstCellAsLabel;
m_aOuterValue <<= bLabelsInFirstColumn;
}
return m_aOuterValue;
}
Any WrappedDataSourceLabelsInFirstColumnProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
{
Any aRet;
aRet <<= true;
return aRet;
}
//PROP_DOCUMENT_HAS_LEGEND
class WrappedHasLegendProperty : public WrappedProperty
{
public:
explicit WrappedHasLegendProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
virtual css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
virtual css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& xInnerPropertyState ) const override;
private: //member
std::shared_ptr< Chart2ModelContact > m_spChart2ModelContact;
};
WrappedHasLegendProperty::WrappedHasLegendProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
: WrappedProperty("HasLegend",OUString())
, m_spChart2ModelContact( spChart2ModelContact )
{
}
void WrappedHasLegendProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
{
bool bNewValue = true;
if( ! (rOuterValue >>= bNewValue) )
throw lang::IllegalArgumentException("Property HasLegend requires value of type boolean", nullptr, 0 );
try
{
Reference< chart2::XLegend > xLegend( LegendHelper::getLegend( *m_spChart2ModelContact->getModel(), m_spChart2ModelContact->m_xContext,bNewValue ));
if(xLegend.is())
{
Reference< beans::XPropertySet > xLegendProp( xLegend, uno::UNO_QUERY_THROW );
bool bOldValue = true;
Any aAOld = xLegendProp->getPropertyValue("Show");
aAOld >>= bOldValue;
if( bOldValue != bNewValue )
xLegendProp->setPropertyValue("Show", uno::Any( bNewValue ));
}
}
catch (const uno::Exception&)
{
DBG_UNHANDLED_EXCEPTION("chart2");
}
}
Any WrappedHasLegendProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
{
Any aRet;
try
{
Reference< beans::XPropertySet > xLegendProp(
LegendHelper::getLegend( *m_spChart2ModelContact->getModel() ), uno::UNO_QUERY );
if( xLegendProp.is())
aRet = xLegendProp->getPropertyValue("Show");
else
aRet <<= false;
}
catch (const uno::Exception&)
{
DBG_UNHANDLED_EXCEPTION("chart2");
}
return aRet;
}
Any WrappedHasLegendProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
{
Any aRet;
aRet <<= false;
return aRet;
}
//PROP_DOCUMENT_HAS_MAIN_TITLE
class WrappedHasMainTitleProperty : public WrappedProperty
{
public:
explicit WrappedHasMainTitleProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
virtual css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
virtual css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& xInnerPropertyState ) const override;
private: //member
std::shared_ptr< Chart2ModelContact > m_spChart2ModelContact;
};
WrappedHasMainTitleProperty::WrappedHasMainTitleProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
: WrappedProperty("HasMainTitle",OUString())
, m_spChart2ModelContact( spChart2ModelContact )
{
}
void WrappedHasMainTitleProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
{
bool bNewValue = true;
if( ! (rOuterValue >>= bNewValue) )
throw lang::IllegalArgumentException("Property HasMainTitle requires value of type boolean", nullptr, 0 );
try
{
if( bNewValue )
TitleHelper::createTitle( TitleHelper::MAIN_TITLE, "main-title", m_spChart2ModelContact->getChartModel(), m_spChart2ModelContact->m_xContext );
else
TitleHelper::removeTitle( TitleHelper::MAIN_TITLE, m_spChart2ModelContact->getChartModel() );
}
catch (const uno::Exception&)
{
DBG_UNHANDLED_EXCEPTION("chart2");
}
}
Any WrappedHasMainTitleProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
{
Any aRet;
try
{
aRet <<= TitleHelper::getTitle( TitleHelper::MAIN_TITLE, m_spChart2ModelContact->getChartModel() ).is();
}
catch (const uno::Exception&)
{
DBG_UNHANDLED_EXCEPTION("chart2");
}
return aRet;
}
Any WrappedHasMainTitleProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
{
Any aRet;
aRet <<= false;
return aRet;
}
//PROP_DOCUMENT_HAS_SUB_TITLE
class WrappedHasSubTitleProperty : public WrappedProperty
{
public:
explicit WrappedHasSubTitleProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact);
virtual void setPropertyValue( const css::uno::Any& rOuterValue, const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
virtual css::uno::Any getPropertyValue( const css::uno::Reference< css::beans::XPropertySet >& xInnerPropertySet ) const override;
virtual css::uno::Any getPropertyDefault( const css::uno::Reference< css::beans::XPropertyState >& xInnerPropertyState ) const override;
private: //member
std::shared_ptr< Chart2ModelContact > m_spChart2ModelContact;
};
WrappedHasSubTitleProperty::WrappedHasSubTitleProperty(const std::shared_ptr<Chart2ModelContact>& spChart2ModelContact)
: WrappedProperty("HasSubTitle",OUString())
, m_spChart2ModelContact( spChart2ModelContact )
{
}
void WrappedHasSubTitleProperty::setPropertyValue( const Any& rOuterValue, const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
{
bool bNewValue = true;
if( ! (rOuterValue >>= bNewValue) )
throw lang::IllegalArgumentException("Property HasSubTitle requires value of type boolean", nullptr, 0 );
try
{
if( bNewValue )
TitleHelper::createTitle( TitleHelper::SUB_TITLE, "", m_spChart2ModelContact->getChartModel(), m_spChart2ModelContact->m_xContext );
else
TitleHelper::removeTitle( TitleHelper::SUB_TITLE, m_spChart2ModelContact->getChartModel() );
}
catch (const uno::Exception&)
{
DBG_UNHANDLED_EXCEPTION("chart2");
}
}
Any WrappedHasSubTitleProperty::getPropertyValue( const Reference< beans::XPropertySet >& /*xInnerPropertySet*/ ) const
{
Any aRet;
try
{
aRet <<= TitleHelper::getTitle( TitleHelper::SUB_TITLE, m_spChart2ModelContact->getChartModel() ).is();
}
catch (const uno::Exception&)
{
DBG_UNHANDLED_EXCEPTION("chart2");
}
return aRet;
}
Any WrappedHasSubTitleProperty::getPropertyDefault( const Reference< beans::XPropertyState >& /*xInnerPropertyState*/ ) const
{
Any aRet;
aRet <<= false;
return aRet;
}
ChartDocumentWrapper::ChartDocumentWrapper(
const Reference< uno::XComponentContext > & xContext ) :
m_spChart2ModelContact( new Chart2ModelContact( xContext ) ),
m_bUpdateAddIn( true ),
m_bIsDisposed( false )
{
}
ChartDocumentWrapper::~ChartDocumentWrapper()
{
stopAllComponentListening();
}
// ____ XInterface (for new interfaces) ____
uno::Any SAL_CALL ChartDocumentWrapper::queryInterface( const uno::Type& aType )
{
if( m_xDelegator.is())
// calls queryAggregation if the delegator doesn't know aType
return m_xDelegator->queryInterface( aType );
else
return queryAggregation( aType );
}
// ____ chart::XChartDocument (old API wrapper) ____
Reference< drawing::XShape > SAL_CALL ChartDocumentWrapper::getTitle()
{
if( !m_xTitle.is() )
{
ControllerLockGuardUNO aCtrlLockGuard( Reference< frame::XModel >( m_spChart2ModelContact->getChart2Document(), uno::UNO_QUERY ));
m_xTitle = new TitleWrapper( TitleHelper::MAIN_TITLE, m_spChart2ModelContact );
}
return m_xTitle;
}
Reference< drawing::XShape > SAL_CALL ChartDocumentWrapper::getSubTitle()
{
if( !m_xSubTitle.is() )
{
ControllerLockGuardUNO aCtrlLockGuard( Reference< frame::XModel >( m_spChart2ModelContact->getChart2Document(), uno::UNO_QUERY ));
m_xSubTitle = new TitleWrapper( TitleHelper::SUB_TITLE, m_spChart2ModelContact );
}
return m_xSubTitle;
}
Reference< drawing::XShape > SAL_CALL ChartDocumentWrapper::getLegend()
{
if( ! m_xLegend.is())
{
m_xLegend = new LegendWrapper( m_spChart2ModelContact );
}
return m_xLegend;
}
Reference< beans::XPropertySet > SAL_CALL ChartDocumentWrapper::getArea()
{
if( ! m_xArea.is())
{
m_xArea.set( new AreaWrapper( m_spChart2ModelContact ) );
}
return m_xArea;
}
Reference< XDiagram > SAL_CALL ChartDocumentWrapper::getDiagram()
{
if( !m_xDiagram.is() )
{
try
{
m_xDiagram = new DiagramWrapper( m_spChart2ModelContact );
}
catch (const uno::Exception&)
{
DBG_UNHANDLED_EXCEPTION("chart2");
}
}
return m_xDiagram;
}
void SAL_CALL ChartDocumentWrapper::setDiagram( const Reference< XDiagram >& xDiagram )
{
uno::Reference< util::XRefreshable > xAddIn( xDiagram, uno::UNO_QUERY );
if( xAddIn.is() )
{
setAddIn( xAddIn );
}
else if( xDiagram.is() && xDiagram != m_xDiagram )
{
// set new wrapped diagram at new chart. This requires the old
// diagram given as parameter to implement the new interface. If
// this is not possible throw an exception
Reference< chart2::XDiagramProvider > xNewDiaProvider( xDiagram, uno::UNO_QUERY_THROW );
Reference< chart2::XDiagram > xNewDia( xNewDiaProvider->getDiagram());
try
{
Reference< chart2::XChartDocument > xChartDoc( m_spChart2ModelContact->getChart2Document() );
if( xChartDoc.is() )
{
// set the new diagram
xChartDoc->setFirstDiagram( xNewDia );
m_xDiagram = xDiagram;
}
}
catch (const uno::Exception&)
{
DBG_UNHANDLED_EXCEPTION("chart2");
}
}
}
Reference< XChartData > SAL_CALL ChartDocumentWrapper::getData()
{
if( !m_xChartData.is() )
{
m_xChartData.set( new ChartDataWrapper( m_spChart2ModelContact ) );
}
//@todo: check hasInternalDataProvider also in else?
return m_xChartData;
}
void SAL_CALL ChartDocumentWrapper::attachData( const Reference< XChartData >& xNewData )
{
if( !xNewData.is() )
return;
ControllerLockGuardUNO aCtrlLockGuard( Reference< frame::XModel >( m_spChart2ModelContact->getChart2Document(), uno::UNO_QUERY ));
m_xChartData.set( new ChartDataWrapper( m_spChart2ModelContact, xNewData ) );
}
// ____ XModel ____
sal_Bool SAL_CALL ChartDocumentWrapper::attachResource(
const OUString& URL,
const Sequence< beans::PropertyValue >& Arguments )
{
Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
if( xModel.is() )
return xModel->attachResource( URL, Arguments );
return false;
}
OUString SAL_CALL ChartDocumentWrapper::getURL()
{
Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
if( xModel.is() )
return xModel->getURL();
return OUString();
}
Sequence< beans::PropertyValue > SAL_CALL ChartDocumentWrapper::getArgs()
{
Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
if( xModel.is() )
return xModel->getArgs();
return Sequence< beans::PropertyValue >();
}
void SAL_CALL ChartDocumentWrapper::connectController( const Reference< frame::XController >& Controller )
{
Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
if( xModel.is() )
xModel->connectController( Controller );
}
void SAL_CALL ChartDocumentWrapper::disconnectController(
const Reference< frame::XController >& Controller )
{
Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
if( xModel.is() )
xModel->disconnectController( Controller );
}
void SAL_CALL ChartDocumentWrapper::lockControllers()
{
Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
if( xModel.is() )
xModel->lockControllers();
}
void SAL_CALL ChartDocumentWrapper::unlockControllers()
{
Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
if( xModel.is() )
xModel->unlockControllers();
}
sal_Bool SAL_CALL ChartDocumentWrapper::hasControllersLocked()
{
Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
if( xModel.is() )
return xModel->hasControllersLocked();
return false;
}
Reference< frame::XController > SAL_CALL ChartDocumentWrapper::getCurrentController()
{
Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
if( xModel.is() )
return xModel->getCurrentController();
return nullptr;
}
void SAL_CALL ChartDocumentWrapper::setCurrentController(
const Reference< frame::XController >& Controller )
{
Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
if( xModel.is() )
xModel->setCurrentController( Controller );
}
Reference< uno::XInterface > SAL_CALL ChartDocumentWrapper::getCurrentSelection()
{
Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
if( xModel.is() )
return xModel->getCurrentSelection();
return nullptr;
}
// ____ XComponent ____
void SAL_CALL ChartDocumentWrapper::dispose()
{
if( m_bIsDisposed )
throw lang::DisposedException("ChartDocumentWrapper is disposed",
static_cast< ::cppu::OWeakObject* >( this ));
m_bIsDisposed = true;
try
{
Reference< lang::XComponent > xFormerDelegator( m_xDelegator, uno::UNO_QUERY );
DisposeHelper::DisposeAndClear( m_xTitle );
DisposeHelper::DisposeAndClear( m_xSubTitle );
DisposeHelper::DisposeAndClear( m_xLegend );
DisposeHelper::DisposeAndClear( m_xChartData );
DisposeHelper::DisposeAndClear( m_xDiagram );
DisposeHelper::DisposeAndClear( m_xArea );
m_xChartView.set( nullptr );
m_xShapeFactory.set( nullptr );
m_xDelegator.set( nullptr );
clearWrappedPropertySet();
m_spChart2ModelContact->clear();
impl_resetAddIn();
stopAllComponentListening();
try
{
if( xFormerDelegator.is())
xFormerDelegator->dispose();
}
catch (const lang::DisposedException&)
{
// this is ok, don't panic
}
}
catch (const uno::Exception &)
{
DBG_UNHANDLED_EXCEPTION("chart2");
}
}
void ChartDocumentWrapper::impl_resetAddIn()
{
Reference< util::XRefreshable > xAddIn( m_xAddIn );
m_xAddIn.set( nullptr );
if( xAddIn.is() )
{
try
{
//make sure that the add-in does not hold a references to us anymore:
Reference< lang::XComponent > xComp( xAddIn, uno::UNO_QUERY );
if( xComp.is())
xComp->dispose();
else
{
uno::Reference< lang::XInitialization > xInit( xAddIn, uno::UNO_QUERY );
if( xInit.is() )
{
uno::Any aParam;
uno::Reference< css::chart::XChartDocument > xDoc;
aParam <<= xDoc;
uno::Sequence< uno::Any > aSeq( &aParam, 1 );
xInit->initialize( aSeq );
}
}
}
catch (const uno::RuntimeException&)
{
DBG_UNHANDLED_EXCEPTION("chart2");
}
catch (const uno::Exception&)
{
DBG_UNHANDLED_EXCEPTION("chart2");
}
}
}
void ChartDocumentWrapper::setBaseDiagram( const OUString& rBaseDiagram )
{
ControllerLockGuardUNO aCtrlLockGuard( m_spChart2ModelContact->getChartModel() );
m_aBaseDiagram = rBaseDiagram;
uno::Reference< XDiagram > xDiagram( ChartDocumentWrapper::createInstance( rBaseDiagram ), uno::UNO_QUERY );
if( xDiagram.is() )
setDiagram( xDiagram );
}
void ChartDocumentWrapper::setAddIn( const Reference< util::XRefreshable >& xAddIn )
{
if( m_xAddIn == xAddIn )
return;
ControllerLockGuardUNO aCtrlLockGuard( m_spChart2ModelContact->getChartModel() );
impl_resetAddIn();
m_xAddIn = xAddIn;
// initialize AddIn with this as chart document
uno::Reference< lang::XInitialization > xInit( m_xAddIn, uno::UNO_QUERY );
if( xInit.is() )
{
uno::Any aParam;
uno::Reference< XChartDocument > xDoc( static_cast<XChartDocument*>(this), uno::UNO_QUERY );
aParam <<= xDoc;
uno::Sequence< uno::Any > aSeq( &aParam, 1 );
xInit->initialize( aSeq );
}
}
void ChartDocumentWrapper::setUpdateAddIn( bool bUpdateAddIn )
{
m_bUpdateAddIn = bUpdateAddIn;
}
Reference< drawing::XShapes > ChartDocumentWrapper::getAdditionalShapes() const
{
// get additional non-chart shapes for XML export
uno::Reference< drawing::XShapes > xFoundShapes;
uno::Reference< drawing::XDrawPage > xDrawPage( impl_getDrawPage() );
uno::Reference< drawing::XShapes > xDrawPageShapes( xDrawPage, uno::UNO_QUERY );
if( !xDrawPageShapes.is() )
return xFoundShapes;
uno::Reference<drawing::XShapes> xChartRoot( DrawModelWrapper::getChartRootShape( xDrawPage ) );
// iterate 'flat' over all top-level objects
// and determine all that are no chart objects
std::vector< uno::Reference< drawing::XShape > > aShapeVector;
sal_Int32 nSubCount = xDrawPageShapes->getCount();
uno::Reference< drawing::XShape > xShape;
for( sal_Int32 nS = 0; nS < nSubCount; nS++ )
{
if( xDrawPageShapes->getByIndex( nS ) >>= xShape )
{
if( xShape.is() && xChartRoot!=xShape )
aShapeVector.push_back( xShape );
}
}
if( !aShapeVector.empty() )
{
// create a shape collection
xFoundShapes.set( drawing::ShapeCollection::create(
comphelper::getProcessComponentContext()), uno::UNO_QUERY );
OSL_ENSURE( xFoundShapes.is(), "Couldn't create a shape collection!" );
if( xFoundShapes.is())
{
for (auto const& shape : aShapeVector)
xFoundShapes->add(shape);
}
}
return xFoundShapes;
}
void SAL_CALL ChartDocumentWrapper::addEventListener( const Reference< lang::XEventListener >& xListener )
{
Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
if( xModel.is() )
xModel->addEventListener( xListener );
}
void SAL_CALL ChartDocumentWrapper::removeEventListener( const Reference< lang::XEventListener >& aListener )
{
Reference< frame::XModel > xModel( m_spChart2ModelContact->getChartModel() );
if( xModel.is() )
xModel->removeEventListener( aListener );
}
// ____ XDrawPageSupplier ____
uno::Reference< drawing::XDrawPage > SAL_CALL ChartDocumentWrapper::getDrawPage()
{
return impl_getDrawPage();
}
uno::Reference< drawing::XDrawPage > ChartDocumentWrapper::impl_getDrawPage() const
{
return m_spChart2ModelContact->getDrawPage();
}
namespace {
uno::Reference< lang::XMultiServiceFactory > getShapeFactory(const uno::Reference<uno::XInterface>& xChartView)
{
Reference< lang::XUnoTunnel> xUnoTunnel(xChartView,uno::UNO_QUERY);
if(xUnoTunnel.is())
{
ExplicitValueProvider* pProvider = reinterpret_cast<ExplicitValueProvider*>(xUnoTunnel->getSomething(
ExplicitValueProvider::getUnoTunnelId() ));
if( pProvider )
return pProvider->getDrawModelWrapper()->getShapeFactory();
}
return uno::Reference< lang::XMultiServiceFactory >();
}
}
// ____ XMultiServiceFactory ____
uno::Reference< uno::XInterface > SAL_CALL ChartDocumentWrapper::createInstance(
const OUString& aServiceSpecifier )
{
uno::Reference< uno::XInterface > xResult;
Reference< chart2::XChartDocument > xChartDoc( m_spChart2ModelContact->getChart2Document() );
if( !xChartDoc.is() )
return xResult;
bool bServiceFound = false;
tServiceNameMap & rMap = lcl_getStaticServiceNameMap();
tServiceNameMap::const_iterator aIt( rMap.find( aServiceSpecifier ));
if( aIt != rMap.end())
{
bool bCreateDiagram = false;
uno::Reference< lang::XMultiServiceFactory > xManagerFact(
xChartDoc->getChartTypeManager(), uno::UNO_QUERY );
uno::Reference< chart2::XChartTypeTemplate > xTemplate;
switch( (*aIt).second )
{
case SERVICE_NAME_AREA_DIAGRAM:
if( xManagerFact.is())
{
xTemplate.set(
xManagerFact->createInstance("com.sun.star.chart2.template.Area"),
uno::UNO_QUERY );
bCreateDiagram = true;
}
break;
case SERVICE_NAME_BAR_DIAGRAM:
if( xManagerFact.is())
{
// this is for bar and column (the latter is the default if
// no "Vertical=false" property was set)
xTemplate.set(
xManagerFact->createInstance("com.sun.star.chart2.template.Column"),
uno::UNO_QUERY );
bCreateDiagram = true;
}
break;
case SERVICE_NAME_DONUT_DIAGRAM:
if( xManagerFact.is())
{
xTemplate.set(
xManagerFact->createInstance("com.sun.star.chart2.template.Donut"),
uno::UNO_QUERY );
bCreateDiagram = true;
}
break;
case SERVICE_NAME_LINE_DIAGRAM:
if( xManagerFact.is())
{
xTemplate.set(
xManagerFact->createInstance("com.sun.star.chart2.template.Line"),
uno::UNO_QUERY );
bCreateDiagram = true;
}
break;
case SERVICE_NAME_NET_DIAGRAM:
if( xManagerFact.is())
{
xTemplate.set(
xManagerFact->createInstance("com.sun.star.chart2.template.Net"),
uno::UNO_QUERY );
bCreateDiagram = true;
}
break;
case SERVICE_NAME_FILLED_NET_DIAGRAM:
if( xManagerFact.is())
{
xTemplate.set(
xManagerFact->createInstance("com.sun.star.chart2.template.FilledNet"),
uno::UNO_QUERY );
bCreateDiagram = true;
}
break;
case SERVICE_NAME_PIE_DIAGRAM:
if( xManagerFact.is())
{
xTemplate.set(
xManagerFact->createInstance("com.sun.star.chart2.template.Pie"),
uno::UNO_QUERY );
bCreateDiagram = true;
}
break;
case SERVICE_NAME_STOCK_DIAGRAM:
if( xManagerFact.is())
{
xTemplate.set(
xManagerFact->createInstance("com.sun.star.chart2.template.StockLowHighClose"),
uno::UNO_QUERY );
bCreateDiagram = true;
}
break;
case SERVICE_NAME_XY_DIAGRAM:
if( xManagerFact.is())
{
xTemplate.set(
xManagerFact->createInstance("com.sun.star.chart2.template.ScatterLineSymbol"),
uno::UNO_QUERY );
bCreateDiagram = true;
}
break;
case SERVICE_NAME_BUBBLE_DIAGRAM:
if( xManagerFact.is())
{
xTemplate.set(
xManagerFact->createInstance("com.sun.star.chart2.template.Bubble"),
uno::UNO_QUERY );
bCreateDiagram = true;
}
break;
case SERVICE_NAME_DASH_TABLE:
case SERVICE_NAME_GARDIENT_TABLE:
case SERVICE_NAME_HATCH_TABLE:
case SERVICE_NAME_BITMAP_TABLE:
case SERVICE_NAME_TRANSP_GRADIENT_TABLE:
case SERVICE_NAME_MARKER_TABLE:
{
uno::Reference< lang::XMultiServiceFactory > xTableFactory( xChartDoc, uno::UNO_QUERY );
OSL_ENSURE( xTableFactory.get() != this, "new model is expected to implement service factory for gradient table etc" );
if( xTableFactory.is() && xTableFactory.get() != this )
xResult.set( xTableFactory->createInstance( aIt->first ), uno::UNO_QUERY );
}
break;
case SERVICE_NAME_NAMESPACE_MAP:
break;
case SERVICE_NAME_EXPORT_GRAPHIC_STORAGE_RESOLVER:
break;
case SERVICE_NAME_IMPORT_GRAPHIC_STORAGE_RESOLVER:
break;
}
if( bCreateDiagram && xTemplate.is() )
{
try
{
uno::Reference< chart2::XDiagram > xDia( xChartDoc->getFirstDiagram());
if( xDia.is())
{
// locked controllers
Reference< frame::XModel > xModel( xChartDoc, uno::UNO_QUERY );
ControllerLockGuardUNO aCtrlLockGuard( xModel );
Reference< chart2::XDiagram > xDiagram = ChartModelHelper::findDiagram( xModel );
ThreeDLookScheme e3DScheme = ThreeDHelper::detectScheme( xDiagram );
Reference< lang::XMultiServiceFactory > xTemplateManager( xChartDoc->getChartTypeManager(), uno::UNO_QUERY );
DiagramHelper::tTemplateWithServiceName aTemplateWithService(
DiagramHelper::getTemplateForDiagram( xDiagram, xTemplateManager ));
if( aTemplateWithService.first.is())
aTemplateWithService.first->resetStyles( xDiagram );//#i109371#
xTemplate->changeDiagram( xDiagram );
if( AllSettings::GetMathLayoutRTL() )
AxisHelper::setRTLAxisLayout( AxisHelper::getCoordinateSystemByIndex( xDiagram, 0 ) );
ThreeDHelper::setScheme( xDiagram, e3DScheme );
}
else
{
// locked controllers
ControllerLockGuardUNO aCtrlLockGuard( Reference< frame::XModel >( xChartDoc, uno::UNO_QUERY ));
xDia.set( xTemplate->createDiagramByDataSource(
uno::Reference< chart2::data::XDataSource >(),
uno::Sequence< beans::PropertyValue >()));
xChartDoc->setFirstDiagram( xDia );
}
xResult = static_cast< ::cppu::OWeakObject* >( new DiagramWrapper( m_spChart2ModelContact ));
}
catch (const uno::Exception&)
{
DBG_UNHANDLED_EXCEPTION("chart2");
}
}
bServiceFound = true;
}
else if( aServiceSpecifier == "com.sun.star.comp.chart2.DataSeriesWrapper" )
{
Reference< beans::XPropertySet > xDataSeries( new DataSeriesPointWrapper( m_spChart2ModelContact ) );
xResult.set( xDataSeries );
bServiceFound = true;
}
else if( aServiceSpecifier == CHART_VIEW_SERVICE_NAME )
{
if( !m_xChartView.is() )
{
Reference< lang::XMultiServiceFactory > xFact(
m_spChart2ModelContact->m_xContext->getServiceManager(), uno::UNO_QUERY_THROW );
Reference< lang::XInitialization > xViewInit( xFact->createInstance(
CHART_VIEW_SERVICE_NAME ), uno::UNO_QUERY );
if(xViewInit.is())
{
try
{
m_xChartView = xViewInit;
Sequence< Any > aArguments(2);
aArguments[0] <<= Reference<frame::XModel>(this);
aArguments[1] <<= true; // bRefreshAddIn
xViewInit->initialize(aArguments);
}
catch (const uno::Exception&)
{
DBG_UNHANDLED_EXCEPTION("chart2");
}
}
}
xResult.set( m_xChartView );
bServiceFound = true;
}
else
{
// try to create a shape
try
{
if( !m_xShapeFactory.is() && m_xChartView.is() )
{
m_xShapeFactory = getShapeFactory( m_xChartView );
}
else
{
ChartModel* pModel = m_spChart2ModelContact->getModel();
if(pModel)
{
m_xChartView = pModel->getChartView();
m_xShapeFactory = getShapeFactory( m_xChartView );
}
}
if( m_xShapeFactory.is() )
{
xResult = m_xShapeFactory->createInstance( aServiceSpecifier );
bServiceFound = true;
}
}
catch (const uno::Exception&)
{
// couldn't create shape
}
}
// finally, try to create an addin
if( !bServiceFound )
{
try
{
Reference< lang::XMultiServiceFactory > xFact(
m_spChart2ModelContact->m_xContext->getServiceManager(), uno::UNO_QUERY_THROW );
uno::Reference< util::XRefreshable > xAddIn(
xFact->createInstance( aServiceSpecifier ), uno::UNO_QUERY );
if( xAddIn.is() )
{
xResult = xAddIn;
}
}
catch (const uno::Exception&)
{
// couldn't create service
}
}
return xResult;
}
uno::Reference< uno::XInterface > SAL_CALL ChartDocumentWrapper::createInstanceWithArguments(
const OUString& ServiceSpecifier,
const uno::Sequence< uno::Any >& Arguments )
{
OSL_ENSURE( Arguments.getLength(), "createInstanceWithArguments: Warning: Arguments are ignored" );
return createInstance( ServiceSpecifier );
}
uno::Sequence< OUString > SAL_CALL ChartDocumentWrapper::getAvailableServiceNames()
{
return comphelper::mapKeysToSequence( lcl_getStaticServiceNameMap() );
}
// ____ XAggregation ____
void SAL_CALL ChartDocumentWrapper::setDelegator(
const uno::Reference< uno::XInterface >& rDelegator )
{
if( m_bIsDisposed )
{
if( rDelegator.is() )
throw lang::DisposedException("ChartDocumentWrapper is disposed",
static_cast< ::cppu::OWeakObject* >( this ));
return;
}
if( rDelegator.is())
{
m_xDelegator = rDelegator;
m_spChart2ModelContact->setModel( uno::Reference< frame::XModel >(m_xDelegator, uno::UNO_QUERY) );
}
else
{
// this is a sort of dispose() from the new model,so release resources here
try
{
dispose();
}
catch (const uno::Exception&)
{
DBG_UNHANDLED_EXCEPTION("chart2");
}
}
}
uno::Any SAL_CALL ChartDocumentWrapper::queryAggregation( const uno::Type& rType )
{
return ChartDocumentWrapper_Base::queryInterface( rType );
}
// ____ ::utl::OEventListenerAdapter ____
void ChartDocumentWrapper::_disposing( const lang::EventObject& rSource )
{
if( rSource.Source == m_xTitle )
m_xTitle.set( nullptr );
else if( rSource.Source == m_xSubTitle )
m_xSubTitle.set( nullptr );
else if( rSource.Source == m_xLegend )
m_xLegend.set( nullptr );
else if( rSource.Source == m_xChartData )
m_xChartData.set( nullptr );
else if( rSource.Source == m_xDiagram )
m_xDiagram.set( nullptr );
else if( rSource.Source == m_xArea )
m_xArea.set( nullptr );
else if( rSource.Source == m_xAddIn )
m_xAddIn.set( nullptr );
else if( rSource.Source == m_xChartView )
m_xChartView.set( nullptr );
}
// WrappedPropertySet
Reference< beans::XPropertySet > ChartDocumentWrapper::getInnerPropertySet()
{
return nullptr;
}
const Sequence< beans::Property >& ChartDocumentWrapper::getPropertySequence()
{
return *StaticChartDocumentWrapperPropertyArray::get();
}
std::vector< std::unique_ptr<WrappedProperty> > ChartDocumentWrapper::createWrappedProperties()
{
std::vector< std::unique_ptr<WrappedProperty> > aWrappedProperties;
aWrappedProperties.emplace_back( new WrappedDataSourceLabelsInFirstRowProperty( m_spChart2ModelContact ) );
aWrappedProperties.emplace_back( new WrappedDataSourceLabelsInFirstColumnProperty( m_spChart2ModelContact ) );
aWrappedProperties.emplace_back( new WrappedHasLegendProperty( m_spChart2ModelContact ) );
aWrappedProperties.emplace_back( new WrappedHasMainTitleProperty( m_spChart2ModelContact ) );
aWrappedProperties.emplace_back( new WrappedHasSubTitleProperty( m_spChart2ModelContact ) );
aWrappedProperties.emplace_back( new WrappedAddInProperty( *this ) );
aWrappedProperties.emplace_back( new WrappedBaseDiagramProperty( *this ) );
aWrappedProperties.emplace_back( new WrappedAdditionalShapesProperty( *this ) );
aWrappedProperties.emplace_back( new WrappedRefreshAddInAllowedProperty( *this ) );
aWrappedProperties.emplace_back( new WrappedIgnoreProperty("NullDate",Any() ) ); // i99104
aWrappedProperties.emplace_back( new WrappedIgnoreProperty("EnableComplexChartTypes", uno::Any(true) ) );
aWrappedProperties.emplace_back( new WrappedIgnoreProperty("EnableDataTableDialog", uno::Any(true) ) );
return aWrappedProperties;
}
OUString SAL_CALL ChartDocumentWrapper::getImplementationName()
{
return OUString(CHART_CHARTAPIWRAPPER_IMPLEMENTATION_NAME);
}
sal_Bool SAL_CALL ChartDocumentWrapper::supportsService( const OUString& rServiceName )
{
return cppu::supportsService(this, rServiceName);
}
css::uno::Sequence< OUString > SAL_CALL ChartDocumentWrapper::getSupportedServiceNames()
{
return {
"com.sun.star.chart.ChartDocument",
CHART_CHARTAPIWRAPPER_SERVICE_NAME,
"com.sun.star.xml.UserDefinedAttributesSupplier",
"com.sun.star.beans.PropertySet"
};
}
} // namespace wrapper
} // namespace chart
extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
com_sun_star_comp_chart2_ChartDocumentWrapper_get_implementation(css::uno::XComponentContext *context,
css::uno::Sequence<css::uno::Any> const &)
{
return cppu::acquire(new ::chart::wrapper::ChartDocumentWrapper(context));
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V1023 A pointer without owner is added to the 'aWrappedProperties' container by the 'emplace_back' method. A memory leak will occur in case of an exception.
↑ V572 It is odd that the object which was created using 'new' operator is immediately cast to another type.
↑ V1023 A pointer without owner is added to the 'aWrappedProperties' container by the 'emplace_back' method. A memory leak will occur in case of an exception.
↑ V1023 A pointer without owner is added to the 'aWrappedProperties' container by the 'emplace_back' method. A memory leak will occur in case of an exception.
↑ V1023 A pointer without owner is added to the 'aWrappedProperties' container by the 'emplace_back' method. A memory leak will occur in case of an exception.
↑ V1023 A pointer without owner is added to the 'aWrappedProperties' container by the 'emplace_back' method. A memory leak will occur in case of an exception.
↑ V1023 A pointer without owner is added to the 'aWrappedProperties' container by the 'emplace_back' method. A memory leak will occur in case of an exception.
↑ V1023 A pointer without owner is added to the 'aWrappedProperties' container by the 'emplace_back' method. A memory leak will occur in case of an exception.
↑ V1023 A pointer without owner is added to the 'aWrappedProperties' container by the 'emplace_back' method. A memory leak will occur in case of an exception.
↑ V1023 A pointer without owner is added to the 'aWrappedProperties' container by the 'emplace_back' method. A memory leak will occur in case of an exception.
↑ V1023 A pointer without owner is added to the 'aWrappedProperties' container by the 'emplace_back' method. A memory leak will occur in case of an exception.
↑ V1023 A pointer without owner is added to the 'aWrappedProperties' container by the 'emplace_back' method. A memory leak will occur in case of an exception.
↑ V1023 A pointer without owner is added to the 'aWrappedProperties' container by the 'emplace_back' method. A memory leak will occur in case of an exception.