1 files changed, 72 insertions, 127 deletions

diff --git a/chart2/source/tools/DataSourceHelper.cxx b/chart2/source/tools/DataSourceHelper.cxx
index cb74e60eaa54..c0bd10b65543 100644
--- a/chart2/source/tools/DataSourceHelper.cxx
+++ b/chart2/source/tools/DataSourceHelper.cxx
@@ -19,8 +19,9 @@
 
 #include <DataSourceHelper.hxx>
 #include <ChartModel.hxx>
-#include <ChartModelHelper.hxx>
-#include <DiagramHelper.hxx>
+#include <ChartTypeManager.hxx>
+#include <Diagram.hxx>
+#include <DataSeries.hxx>
 #include <DataSeriesHelper.hxx>
 #include <DataSource.hxx>
 #include <ControllerLockGuard.hxx>
@@ -28,15 +29,12 @@
 #include <LabeledDataSequence.hxx>
 #include <unonames.hxx>
 
-#include <com/sun/star/chart2/XChartDocument.hpp>
 #include <com/sun/star/chart2/data/XDataSource.hpp>
 #include <com/sun/star/chart2/data/XLabeledDataSequence.hpp>
 
 #include <com/sun/star/chart/ChartDataRowSource.hpp>
 #include <com/sun/star/chart/ErrorBarStyle.hpp>
-#include <tools/diagnose_ex.h>
-
-#include <iterator>
+#include <comphelper/diagnose_ex.hxx>
 
 namespace chart
 {
@@ -74,20 +72,19 @@ void lcl_addDataSourceRanges(
 
 void lcl_addErrorBarRanges(
     std::vector< OUString > & rOutResult,
-    const uno::Reference< XDataSeries > & xDataSeries )
+    const rtl::Reference< DataSeries > & xDataSeries )
 {
-    uno::Reference< beans::XPropertySet > xSeriesProp( xDataSeries, uno::UNO_QUERY );
-    if( !xSeriesProp.is())
+    if( !xDataSeries.is())
         return;
 
     try
     {
         uno::Reference< beans::XPropertySet > xErrorBarProp;
-        if( ( xSeriesProp->getPropertyValue( CHART_UNONAME_ERRORBAR_Y) >>= xErrorBarProp ) &&
+        if( ( xDataSeries->getPropertyValue( CHART_UNONAME_ERRORBAR_Y) >>= xErrorBarProp ) &&
             xErrorBarProp.is())
         {
             sal_Int32 eStyle = css::chart::ErrorBarStyle::NONE;
-            if( ( xErrorBarProp->getPropertyValue( "ErrorBarStyle") >>= eStyle ) &&
+            if( ( xErrorBarProp->getPropertyValue( u"ErrorBarStyle"_ustr) >>= eStyle ) &&
                 eStyle == css::chart::ErrorBarStyle::FROM_DATA )
             {
                 uno::Reference< data::XDataSource > xErrorBarDataSource( xErrorBarProp, uno::UNO_QUERY );
@@ -96,10 +93,10 @@ void lcl_addErrorBarRanges(
             }
         }
 
-        if( ( xSeriesProp->getPropertyValue(CHART_UNONAME_ERRORBAR_X) >>= xErrorBarProp ) && xErrorBarProp.is())
+        if( ( xDataSeries->getPropertyValue(CHART_UNONAME_ERRORBAR_X) >>= xErrorBarProp ) && xErrorBarProp.is())
         {
             sal_Int32 eStyle = css::chart::ErrorBarStyle::NONE;
-            if( ( xErrorBarProp->getPropertyValue("ErrorBarStyle") >>= eStyle ) &&
+            if( ( xErrorBarProp->getPropertyValue(u"ErrorBarStyle"_ustr) >>= eStyle ) &&
                 eStyle == css::chart::ErrorBarStyle::FROM_DATA )
             {
                 uno::Reference< data::XDataSource > xErrorBarDataSource( xErrorBarProp, uno::UNO_QUERY );
@@ -116,12 +113,6 @@ void lcl_addErrorBarRanges(
 
 } // anonymous namespace
 
-Reference< chart2::data::XDataSource > DataSourceHelper::createDataSource(
-        const Sequence< Reference< chart2::data::XLabeledDataSequence > >& rSequences )
-{
-    return new DataSource(rSequences);
-}
-
 Reference< chart2::data::XDataSequence > DataSourceHelper::createCachedDataSequence()
 {
     return new ::chart::CachedDataSequence();
@@ -132,20 +123,20 @@ Reference< chart2::data::XDataSequence > DataSourceHelper::createCachedDataSeque
     return new ::chart::CachedDataSequence( rSingleText );
 }
 
-Reference< chart2::data::XLabeledDataSequence > DataSourceHelper::createLabeledDataSequence(
+rtl::Reference< LabeledDataSequence > DataSourceHelper::createLabeledDataSequence(
         const Reference< chart2::data::XDataSequence >& xValues ,
         const Reference< chart2::data::XDataSequence >& xLabels )
 {
     return new ::chart::LabeledDataSequence( xValues, xLabels );
 }
 
-Reference< chart2::data::XLabeledDataSequence > DataSourceHelper::createLabeledDataSequence(
+rtl::Reference< LabeledDataSequence > DataSourceHelper::createLabeledDataSequence(
         const Reference< chart2::data::XDataSequence >& xValues )
 {
     return new ::chart::LabeledDataSequence( xValues );
 }
 
-Reference< chart2::data::XLabeledDataSequence > DataSourceHelper::createLabeledDataSequence()
+rtl::Reference< LabeledDataSequence > DataSourceHelper::createLabeledDataSequence()
 {
     return new ::chart::LabeledDataSequence;
 }
@@ -157,18 +148,12 @@ uno::Sequence< beans::PropertyValue > DataSourceHelper::createArguments(
     if( bUseColumns )
         eRowSource = css::chart::ChartDataRowSource_COLUMNS;
 
-    uno::Sequence< beans::PropertyValue > aArguments(3);
-    aArguments[0] = beans::PropertyValue( "DataRowSource"
-        , -1, uno::Any( eRowSource )
-        , beans::PropertyState_DIRECT_VALUE );
-    aArguments[1] = beans::PropertyValue( "FirstCellAsLabel"
-        , -1, uno::Any( bFirstCellAsLabel )
-        , beans::PropertyState_DIRECT_VALUE );
-    aArguments[2] = beans::PropertyValue( "HasCategories"
-        , -1, uno::Any( bHasCategories )
-        , beans::PropertyState_DIRECT_VALUE );
-
-    return aArguments;
+    return
+    {
+        { u"DataRowSource"_ustr, -1, uno::Any( eRowSource), beans::PropertyState_DIRECT_VALUE },
+        { u"FirstCellAsLabel"_ustr, -1, uno::Any( bFirstCellAsLabel ), beans::PropertyState_DIRECT_VALUE },
+        { u"HasCategories"_ustr, -1, uno::Any( bHasCategories ), beans::PropertyState_DIRECT_VALUE }
+    };
 }
 
 uno::Sequence< beans::PropertyValue > DataSourceHelper::createArguments(
@@ -178,15 +163,15 @@ uno::Sequence< beans::PropertyValue > DataSourceHelper::createArguments(
 {
     uno::Sequence< beans::PropertyValue > aArguments( createArguments( bUseColumns, bFirstCellAsLabel, bHasCategories ));
     aArguments.realloc( aArguments.getLength() + 1 );
-    aArguments[aArguments.getLength() - 1] =
-        beans::PropertyValue( "CellRangeRepresentation"
+    aArguments.getArray()[aArguments.getLength() - 1] =
+        beans::PropertyValue( u"CellRangeRepresentation"_ustr
                               , -1, uno::Any( rRangeRepresentation )
                               , beans::PropertyState_DIRECT_VALUE );
     if( rSequenceMapping.hasElements() )
     {
         aArguments.realloc( aArguments.getLength() + 1 );
-        aArguments[aArguments.getLength() - 1] =
-            beans::PropertyValue( "SequenceMapping"
+        aArguments.getArray()[aArguments.getLength() - 1] =
+            beans::PropertyValue( u"SequenceMapping"_ustr
                                 , -1, uno::Any( rSequenceMapping )
                                 , beans::PropertyState_DIRECT_VALUE );
     }
@@ -224,26 +209,30 @@ void DataSourceHelper::readArguments( const uno::Sequence< beans::PropertyValue
     }
 }
 
-uno::Reference< chart2::data::XDataSource > DataSourceHelper::pressUsedDataIntoRectangularFormat(
-        const uno::Reference< chart2::XChartDocument >& xChartDoc )
+rtl::Reference< DataSource > DataSourceHelper::pressUsedDataIntoRectangularFormat(
+        const rtl::Reference< ChartModel >& xChartDoc )
 {
     std::vector< Reference< chart2::data::XLabeledDataSequence > > aResultVector;
 
     //categories are always the first sequence
-    Reference< chart2::XDiagram > xDiagram( xChartDoc->getFirstDiagram());
+    rtl::Reference< Diagram > xDiagram( xChartDoc->getFirstChartDiagram());
 
-    Reference< chart2::data::XLabeledDataSequence > xCategories( DiagramHelper::getCategoriesFromDiagram( xDiagram ) );
+    Reference< chart2::data::XLabeledDataSequence > xCategories;
+    if (xDiagram)
+        xCategories = xDiagram->getCategories();
     if( xCategories.is() )
         aResultVector.push_back( xCategories );
 
-    std::vector< Reference< chart2::XDataSeries > > aSeriesVector( DiagramHelper::getDataSeriesFromDiagram( xDiagram ) );
-    uno::Reference< chart2::data::XDataSource > xSeriesSource(
-        DataSeriesHelper::getDataSource( comphelper::containerToSequence(aSeriesVector) ) );
+    std::vector< rtl::Reference< DataSeries > > aSeriesVector;
+    if (xDiagram)
+        aSeriesVector = xDiagram->getDataSeries();
+    rtl::Reference< ::chart::DataSource > xSeriesSource =
+        DataSeriesHelper::getDataSource( aSeriesVector );
     const Sequence< Reference< chart2::data::XLabeledDataSequence > > aDataSequences( xSeriesSource->getDataSequences() );
 
     //the first x-values is always the next sequence //todo ... other x-values get lost for old format
     Reference< chart2::data::XLabeledDataSequence > xXValues(
-        DataSeriesHelper::getDataSequenceByRole( xSeriesSource, "values-x" ) );
+        DataSeriesHelper::getDataSequenceByRole( xSeriesSource, u"values-x"_ustr ) );
     if( xXValues.is() )
         aResultVector.push_back( xXValues );
 
@@ -255,95 +244,59 @@ uno::Reference< chart2::data::XDataSource > DataSourceHelper::pressUsedDataIntoR
             aResultVector.push_back( labeledData );
     }
 
-    return new DataSource( comphelper::containerToSequence(aResultVector) );
+    return new DataSource( aResultVector );
 }
 
-uno::Sequence< OUString > DataSourceHelper::getUsedDataRanges(
-    const uno::Reference< chart2::XDiagram > & xDiagram )
+std::vector< OUString > DataSourceHelper::getUsedDataRanges(
+    const rtl::Reference< Diagram > & xDiagram )
 {
     std::vector< OUString > aResult;
 
     if( xDiagram.is())
     {
-        uno::Reference< data::XLabeledDataSequence > xCategories( DiagramHelper::getCategoriesFromDiagram( xDiagram ) );
+        uno::Reference< data::XLabeledDataSequence > xCategories( xDiagram->getCategories() );
         if( xCategories.is() )
             lcl_addRanges( aResult, xCategories );
 
-        std::vector< uno::Reference< XDataSeries > > aSeriesVector( DiagramHelper::getDataSeriesFromDiagram( xDiagram ) );
+        std::vector< rtl::Reference< DataSeries > > aSeriesVector( xDiagram->getDataSeries() );
         for (auto const& series : aSeriesVector)
         {
-            uno::Reference< data::XDataSource > xDataSource(series, uno::UNO_QUERY);
-            lcl_addDataSourceRanges( aResult, xDataSource );
+            lcl_addDataSourceRanges( aResult, series );
             lcl_addErrorBarRanges( aResult, series );
         }
     }
 
-    return comphelper::containerToSequence( aResult );
+    return aResult;
 }
 
-uno::Sequence< OUString > DataSourceHelper::getUsedDataRanges( const uno::Reference< frame::XModel > & xChartModel )
+std::vector< OUString > DataSourceHelper::getUsedDataRanges( const rtl::Reference<::chart::ChartModel> & xChartModel )
 {
-    uno::Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( xChartModel ) );
+    rtl::Reference< Diagram > xDiagram( xChartModel->getFirstChartDiagram() );
     return getUsedDataRanges( xDiagram );
 }
 
-uno::Reference< chart2::data::XDataSource > DataSourceHelper::getUsedData(
-    const uno::Reference< chart2::XChartDocument >& xChartDoc )
-{
-    return pressUsedDataIntoRectangularFormat( xChartDoc );
-}
-
-uno::Reference< chart2::data::XDataSource > DataSourceHelper::getUsedData(
-    const uno::Reference< frame::XModel >& xChartModel )
-{
-    std::vector< uno::Reference< chart2::data::XLabeledDataSequence > > aResult;
-
-    uno::Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( xChartModel ) );
-    uno::Reference< data::XLabeledDataSequence > xCategories( DiagramHelper::getCategoriesFromDiagram( xDiagram ) );
-    if( xCategories.is() )
-        aResult.push_back( xCategories );
-
-    std::vector< uno::Reference< XDataSeries > > aSeriesVector( ChartModelHelper::getDataSeries( xChartModel ) );
-    for (auto const& series : aSeriesVector)
-    {
-        uno::Reference< data::XDataSource > xDataSource(series, uno::UNO_QUERY);
-        if( !xDataSource.is() )
-            continue;
-        uno::Sequence< uno::Reference< data::XLabeledDataSequence > > aDataSequences( xDataSource->getDataSequences() );
-        aResult.insert( aResult.end(), aDataSequences.begin(), aDataSequences.end() );
-    }
-
-    return uno::Reference< chart2::data::XDataSource >(
-        new DataSource( comphelper::containerToSequence( aResult )));
-}
-
-uno::Reference< chart2::data::XDataSource > DataSourceHelper::getUsedData(
+rtl::Reference< DataSource > DataSourceHelper::getUsedData(
     ChartModel& rModel )
 {
     std::vector< uno::Reference< chart2::data::XLabeledDataSequence > > aResult;
 
-    uno::Reference< XDiagram > xDiagram( rModel.getFirstDiagram() );
-    uno::Reference< data::XLabeledDataSequence > xCategories( DiagramHelper::getCategoriesFromDiagram( xDiagram ) );
+    rtl::Reference< Diagram > xDiagram =  rModel.getFirstChartDiagram();
+    uno::Reference< chart2::data::XLabeledDataSequence > xCategories( xDiagram->getCategories() );
     if( xCategories.is() )
         aResult.push_back( xCategories );
 
-    std::vector< uno::Reference< XDataSeries > > aSeriesVector( ChartModelHelper::getDataSeries( rModel ) );
+    std::vector< rtl::Reference< DataSeries > > aSeriesVector = rModel.getDataSeries();
     for (auto const& series : aSeriesVector)
     {
-        uno::Reference< data::XDataSource > xDataSource(series, uno::UNO_QUERY);
-        if( !xDataSource.is() )
-            continue;
-        uno::Sequence< uno::Reference< data::XLabeledDataSequence > > aDataSequences( xDataSource->getDataSequences() );
+        const std::vector< uno::Reference< chart2::data::XLabeledDataSequence > > & aDataSequences( series->getDataSequences2() );
         aResult.insert( aResult.end(), aDataSequences.begin(), aDataSequences.end() );
     }
 
-    return uno::Reference< chart2::data::XDataSource >(
-        new DataSource( comphelper::containerToSequence( aResult )));
+    return new DataSource( aResult );
 }
 
 bool DataSourceHelper::detectRangeSegmentation(
-    const uno::Reference<
-        frame::XModel >& xChartModel
+    const rtl::Reference<::chart::ChartModel>& xChartModel
     , OUString& rOutRangeString
     , css::uno::Sequence< sal_Int32 >& rSequenceMapping
     , bool& rOutUseColumns
@@ -352,22 +305,23 @@ bool DataSourceHelper::detectRangeSegmentation(
 {
     bool bSomethingDetected = false;
 
-    uno::Reference< XChartDocument > xChartDocument( xChartModel, uno::UNO_QUERY );
-    if( !xChartDocument.is() )
+    if( !xChartModel.is() )
         return bSomethingDetected;
-    uno::Reference< data::XDataProvider >  xDataProvider( xChartDocument->getDataProvider() );
+    uno::Reference< data::XDataProvider >  xDataProvider( xChartModel->getDataProvider() );
     if( !xDataProvider.is() )
         return bSomethingDetected;
 
     try
     {
         DataSourceHelper::readArguments(
-            xDataProvider->detectArguments( pressUsedDataIntoRectangularFormat( xChartDocument ) ),
+            xDataProvider->detectArguments( pressUsedDataIntoRectangularFormat( xChartModel ) ),
             rOutRangeString, rSequenceMapping, rOutUseColumns, rOutFirstCellAsLabel, rOutHasCategories );
         bSomethingDetected = !rOutRangeString.isEmpty();
 
-        uno::Reference< chart2::data::XLabeledDataSequence > xCategories(
-                    DiagramHelper::getCategoriesFromDiagram( xChartDocument->getFirstDiagram() ));
+        rtl::Reference<Diagram> xDiagram = xChartModel->getFirstChartDiagram();
+        uno::Reference< chart2::data::XLabeledDataSequence > xCategories;
+        if (xDiagram)
+            xCategories = xDiagram->getCategories();
         rOutHasCategories = xCategories.is();
     }
     catch( uno::Exception & )
@@ -378,7 +332,7 @@ bool DataSourceHelper::detectRangeSegmentation(
 }
 
 bool DataSourceHelper::allArgumentsForRectRangeDetected(
-    const uno::Reference< chart2::XChartDocument >& xChartDocument )
+    const rtl::Reference<::chart::ChartModel>& xChartDocument )
 {
     bool bHasDataRowSource = false;
     bool bHasFirstCellAsLabel = false;
@@ -422,30 +376,24 @@ bool DataSourceHelper::allArgumentsForRectRangeDetected(
 }
 
 void DataSourceHelper::setRangeSegmentation(
-            const uno::Reference< frame::XModel >& xChartModel
+            const rtl::Reference<::chart::ChartModel>& xChartModel
             , const css::uno::Sequence< sal_Int32 >& rSequenceMapping
             , bool bUseColumns , bool bFirstCellAsLabel, bool bUseCategories )
 {
-    uno::Reference< XChartDocument > xChartDocument( xChartModel, uno::UNO_QUERY );
-    if( !xChartDocument.is() )
-        return;
-    uno::Reference< data::XDataProvider > xDataProvider( xChartDocument->getDataProvider() );
+    uno::Reference< data::XDataProvider > xDataProvider( xChartModel->getDataProvider() );
     if( !xDataProvider.is() )
         return;
-    uno::Reference< XDiagram > xDiagram( ChartModelHelper::findDiagram( xChartModel ) );
+    rtl::Reference< Diagram > xDiagram( xChartModel->getFirstChartDiagram() );
     if( !xDiagram.is() )
         return;
-    uno::Reference< chart2::XChartTypeManager > xChartTypeManager( xChartDocument->getChartTypeManager() );
+    rtl::Reference< ::chart::ChartTypeManager > xChartTypeManager = xChartModel->getTypeManager();
     if( !xChartTypeManager.is() )
         return;
-    uno::Reference< lang::XMultiServiceFactory > xTemplateFactory( xChartTypeManager, uno::UNO_QUERY );
-    if( !xTemplateFactory.is() )
-        return;
 
     OUString aRangeString;
     bool bDummy;
     uno::Sequence< sal_Int32 > aDummy;
-    readArguments( xDataProvider->detectArguments( pressUsedDataIntoRectangularFormat( xChartDocument )),
+    readArguments( xDataProvider->detectArguments( pressUsedDataIntoRectangularFormat( xChartModel )),
                    aRangeString, aDummy, bDummy, bDummy, bDummy );
 
     uno::Sequence< beans::PropertyValue > aArguments(
@@ -460,10 +408,10 @@ void DataSourceHelper::setRangeSegmentation(
     xDiagram->setDiagramData( xDataSource, aArguments );
 }
 
-Sequence< OUString > DataSourceHelper::getRangesFromLabeledDataSequence(
+std::vector< OUString > DataSourceHelper::getRangesFromLabeledDataSequence(
     const Reference< data::XLabeledDataSequence > & xLSeq )
 {
-    Sequence< OUString > aResult;
+    std::vector< OUString > aResult;
     if( xLSeq.is())
     {
         Reference< data::XDataSequence > xLabel( xLSeq->getLabel());
@@ -473,20 +421,17 @@ Sequence< OUString > DataSourceHelper::getRangesFromLabeledDataSequence(
         {
             if( xValues.is())
             {
-                aResult.realloc( 2 );
-                aResult[0] = xLabel->getSourceRangeRepresentation();
-                aResult[1] = xValues->getSourceRangeRepresentation();
+                aResult = { xLabel->getSourceRangeRepresentation(),
+                            xValues->getSourceRangeRepresentation() };
             }
             else
             {
-                aResult.realloc( 1 );
-                aResult[0] = xLabel->getSourceRangeRepresentation();
+                aResult = { xLabel->getSourceRangeRepresentation() };
             }
         }
         else if( xValues.is())
         {
-            aResult.realloc( 1 );
-            aResult[0] = xValues->getSourceRangeRepresentation();
+            aResult = { xValues->getSourceRangeRepresentation() };
         }
     }
     return aResult;
@@ -505,7 +450,7 @@ OUString DataSourceHelper::getRangeFromValues(
     return aResult;
 }
 
-Sequence< OUString > DataSourceHelper::getRangesFromDataSource( const Reference< data::XDataSource > & xSource )
+std::vector< OUString > DataSourceHelper::getRangesFromDataSource( const Reference< data::XDataSource > & xSource )
 {
     std::vector< OUString > aResult;
     if( xSource.is())
@@ -522,7 +467,7 @@ Sequence< OUString > DataSourceHelper::getRangesFromDataSource( const Reference<
                 aResult.push_back( xValues->getSourceRangeRepresentation());
         }
     }
-    return comphelper::containerToSequence( aResult );
+    return aResult;
 }
 
 } //namespace chart