use more concrete types in chart2, RegressionCurveModel

Change-Id: I844238da0ce0ce4aea308c652c341efa540149a2
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/129234
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>

11 files changed, 310 insertions, 110 deletions

diff --git a/chart2/source/controller/chartapiwrapper/WrappedStatisticProperties.cxx b/chart2/source/controller/chartapiwrapper/WrappedStatisticProperties.cxx
index bc83ba60df87..b2a54ecac804 100644
--- a/chart2/source/controller/chartapiwrapper/WrappedStatisticProperties.cxx
+++ b/chart2/source/controller/chartapiwrapper/WrappedStatisticProperties.cxx
@@ -21,6 +21,7 @@
 #include "WrappedSeriesOrDiagramProperty.hxx"
 #include <FastPropertyIdRanges.hxx>
 #include <RegressionCurveHelper.hxx>
+#include <RegressionCurveModel.hxx>
 #include <ErrorBar.hxx>
 #include <StatisticsHelper.hxx>
 #include <unonames.hxx>
@@ -906,7 +907,7 @@ Reference< beans::XPropertySet > WrappedStatisticPropertySetProperty::getValueFr
     {
         case PROPERTY_SET_TYPE_REGRESSION:
             if( xRegCnt.is() )
-                xResult.set( RegressionCurveHelper::getFirstCurveNotMeanValueLine( xRegCnt ), uno::UNO_QUERY );
+                xResult = RegressionCurveHelper::getFirstCurveNotMeanValueLine( xRegCnt );
             break;
         case PROPERTY_SET_TYPE_ERROR_BAR:
             if( xSeriesPropertySet.is())
@@ -914,7 +915,7 @@ Reference< beans::XPropertySet > WrappedStatisticPropertySetProperty::getValueFr
             break;
         case PROPERTY_SET_TYPE_MEAN_VALUE:
             if( xRegCnt.is() )
-                xResult.set( RegressionCurveHelper::getMeanValueLine( xRegCnt ), uno::UNO_QUERY );
+                xResult = RegressionCurveHelper::getMeanValueLine( xRegCnt );
             break;
     }
 
diff --git a/chart2/source/controller/dialogs/ObjectNameProvider.cxx b/chart2/source/controller/dialogs/ObjectNameProvider.cxx
index e9d1a7a97692..12fdad6e874d 100644
--- a/chart2/source/controller/dialogs/ObjectNameProvider.cxx
+++ b/chart2/source/controller/dialogs/ObjectNameProvider.cxx
@@ -38,6 +38,7 @@
 #include <NumberFormatterWrapper.hxx>
 #include <RegressionCurveHelper.hxx>
 #include <BaseCoordinateSystem.hxx>
+#include <RegressionCurveModel.hxx>
 #include <rtl/math.hxx>
 #include <rtl/ustring.hxx>
 #include <vcl/settings.hxx>
@@ -559,7 +560,7 @@ OUString ObjectNameProvider::getHelpText( const OUString& rObjectCID, const rtl:
             if( xSeries.is())
             {
                 sal_Int32 nCurveIndex = ObjectIdentifier::getIndexFromParticleOrCID( rObjectCID );
-                Reference< chart2::XRegressionCurve > xCurve( RegressionCurveHelper::getRegressionCurveAtIndex(xSeries, nCurveIndex) );
+                rtl::Reference< RegressionCurveModel > xCurve = RegressionCurveHelper::getRegressionCurveAtIndex(xSeries, nCurveIndex);
                 if( xCurve.is())
                 {
                     try
@@ -575,23 +576,19 @@ OUString ObjectNameProvider::getHelpText( const OUString& rObjectCID, const rtl:
                         const OUString& aNumDecimalSep = rLocaleDataWrapper.getNumDecimalSep();
                         sal_Unicode cDecSeparator = aNumDecimalSep[0];
 
-                        uno::Reference< beans::XPropertySet > xProperties( xCurve, uno::UNO_QUERY );
-                        if ( xProperties.is())
+                        xCurve->getPropertyValue( "PolynomialDegree") >>= aDegree;
+                        xCurve->getPropertyValue( "MovingAveragePeriod") >>= aPeriod;
+                        xCurve->getPropertyValue( "MovingAverageType") >>= aMovingType;
+                        xCurve->getPropertyValue( "ForceIntercept") >>= bForceIntercept;
+                        if (bForceIntercept)
+                                xCurve->getPropertyValue( "InterceptValue") >>= aInterceptValue;
+                        uno::Reference< beans::XPropertySet > xEqProp( xCurve->getEquationProperties());
+                        if( xEqProp.is())
                         {
-                                xProperties->getPropertyValue( "PolynomialDegree") >>= aDegree;
-                                xProperties->getPropertyValue( "MovingAveragePeriod") >>= aPeriod;
-                                xProperties->getPropertyValue( "MovingAverageType") >>= aMovingType;
-                                xProperties->getPropertyValue( "ForceIntercept") >>= bForceIntercept;
-                                if (bForceIntercept)
-                                        xProperties->getPropertyValue( "InterceptValue") >>= aInterceptValue;
-                                uno::Reference< beans::XPropertySet > xEqProp( xCurve->getEquationProperties());
-                                if( xEqProp.is())
-                                {
-                                    if ( !(xEqProp->getPropertyValue( "XName") >>= aXName) )
-                                        aXName = "x";
-                                    if ( !(xEqProp->getPropertyValue( "YName") >>= aYName) )
-                                        aYName = "f(x)";
-                                }
+                            if ( !(xEqProp->getPropertyValue( "XName") >>= aXName) )
+                                aXName = "x";
+                            if ( !(xEqProp->getPropertyValue( "YName") >>= aYName) )
+                                aYName = "f(x)";
                         }
                         xCalculator->setRegressionProperties(aDegree, bForceIntercept, aInterceptValue, 2, aMovingType);
                         xCalculator->setXYNames ( aXName, aYName );
diff --git a/chart2/source/controller/itemsetwrapper/RegressionCurveItemConverter.cxx b/chart2/source/controller/itemsetwrapper/RegressionCurveItemConverter.cxx
index c932278d5dfb..5683b468c588 100644
--- a/chart2/source/controller/itemsetwrapper/RegressionCurveItemConverter.cxx
+++ b/chart2/source/controller/itemsetwrapper/RegressionCurveItemConverter.cxx
@@ -18,6 +18,7 @@
  */
 
 #include <RegressionCurveHelper.hxx>
+#include <RegressionCurveModel.hxx>
 #include <RegressionCurveItemConverter.hxx>
 #include "SchWhichPairs.hxx"
 #include <GraphicPropertyItemConverter.hxx>
diff --git a/chart2/source/controller/itemsetwrapper/StatisticsItemConverter.cxx b/chart2/source/controller/itemsetwrapper/StatisticsItemConverter.cxx
index 681dd81ef56c..12cb196592d5 100644
--- a/chart2/source/controller/itemsetwrapper/StatisticsItemConverter.cxx
+++ b/chart2/source/controller/itemsetwrapper/StatisticsItemConverter.cxx
@@ -20,6 +20,7 @@
 #include <StatisticsItemConverter.hxx>
 #include "SchWhichPairs.hxx"
 #include <RegressionCurveHelper.hxx>
+#include <RegressionCurveModel.hxx>
 #include <ErrorBar.hxx>
 #include <StatisticsHelper.hxx>
 #include <ChartModel.hxx>
@@ -118,8 +119,8 @@ uno::Reference< beans::XPropertySet > lcl_getEquationProperties(
     if( bEquationExists )
     {
         uno::Reference< chart2::XRegressionCurveContainer > xRegCnt( xSeriesPropSet, uno::UNO_QUERY );
-        uno::Reference< chart2::XRegressionCurve > xCurve(
-            ::chart::RegressionCurveHelper::getFirstCurveNotMeanValueLine( xRegCnt ));
+        rtl::Reference< ::chart::RegressionCurveModel > xCurve =
+            ::chart::RegressionCurveHelper::getFirstCurveNotMeanValueLine( xRegCnt );
         if( xCurve.is())
         {
             return xCurve->getEquationProperties();
diff --git a/chart2/source/controller/main/ChartController_Insert.cxx b/chart2/source/controller/main/ChartController_Insert.cxx
index 51bc99bab708..00defbc33582 100644
--- a/chart2/source/controller/main/ChartController_Insert.cxx
+++ b/chart2/source/controller/main/ChartController_Insert.cxx
@@ -53,6 +53,7 @@
 #include <ObjectNameProvider.hxx>
 #include <Legend.hxx>
 #include <LegendHelper.hxx>
+#include <RegressionCurveModel.hxx>
 
 #include <com/sun/star/chart2/XRegressionCurve.hpp>
 #include <com/sun/star/chart2/XRegressionCurveContainer.hpp>
@@ -361,18 +362,16 @@ void ChartController::executeDispatch_InsertTrendline()
             ActionDescriptionProvider::ActionType::Insert, SchResId( STR_OBJECT_CURVE )),
         m_xUndoManager );
 
-    uno::Reference< chart2::XRegressionCurve > xCurve =
+    rtl::Reference< RegressionCurveModel > xCurve =
         RegressionCurveHelper::addRegressionCurve(
             SvxChartRegress::Linear,
             xRegressionCurveContainer );
 
-    uno::Reference< beans::XPropertySet > xProperties( xCurve, uno::UNO_QUERY );
-
-    if( !xProperties.is())
+    if( !xCurve.is())
         return;
 
     wrapper::RegressionCurveItemConverter aItemConverter(
-        xProperties, xRegressionCurveContainer, m_pDrawModelWrapper->getSdrModel().GetItemPool(),
+        xCurve, xRegressionCurveContainer, m_pDrawModelWrapper->getSdrModel().GetItemPool(),
         m_pDrawModelWrapper->getSdrModel(),
         getChartModel() );
 
diff --git a/chart2/source/controller/main/ChartController_Properties.cxx b/chart2/source/controller/main/ChartController_Properties.cxx
index c96abe74ce3e..b094833f317a 100644
--- a/chart2/source/controller/main/ChartController_Properties.cxx
+++ b/chart2/source/controller/main/ChartController_Properties.cxx
@@ -54,6 +54,7 @@
 #include <strings.hrc>
 #include <ReferenceSizeProvider.hxx>
 #include <RegressionCurveHelper.hxx>
+#include <RegressionCurveModel.hxx>
 #include <com/sun/star/chart2/XChartDocument.hpp>
 #include <com/sun/star/chart2/XDataSeries.hpp>
 #include <com/sun/star/chart2/XRegressionCurveContainer.hpp>
diff --git a/chart2/source/controller/main/ChartController_Tools.cxx b/chart2/source/controller/main/ChartController_Tools.cxx
index 9859e816c7d3..dd04d61f0360 100644
--- a/chart2/source/controller/main/ChartController_Tools.cxx
+++ b/chart2/source/controller/main/ChartController_Tools.cxx
@@ -223,7 +223,7 @@ void ChartController::executeDispatch_NewArrangement()
             }
 
             // regression curve equations
-            std::vector< uno::Reference< chart2::XRegressionCurve > > aRegressionCurves =
+            std::vector< rtl::Reference< RegressionCurveModel > > aRegressionCurves =
                 RegressionCurveHelper::getAllRegressionCurvesNotMeanValueLine( xDiagram );
 
             // reset equation position
diff --git a/chart2/source/controller/main/ChartController_Window.cxx b/chart2/source/controller/main/ChartController_Window.cxx
index e489cf757f77..2e9e599e47e7 100644
--- a/chart2/source/controller/main/ChartController_Window.cxx
+++ b/chart2/source/controller/main/ChartController_Window.cxx
@@ -43,6 +43,7 @@
 #include <RelativePositionHelper.hxx>
 #include <chartview/DrawModelWrapper.hxx>
 #include <RegressionCurveHelper.hxx>
+#include <RegressionCurveModel.hxx>
 #include <StatisticsHelper.hxx>
 #include <DataSeries.hxx>
 #include <DataSeriesHelper.hxx>
@@ -1045,9 +1046,9 @@ void ChartController::execute_Command( const CommandEvent& rCEvt )
                 {
                     bool bIsPoint = ( eObjectType == OBJECTTYPE_DATA_POINT );
                     rtl::Reference< DataSeries > xSeries = ObjectIdentifier::getDataSeriesForCID( m_aSelection.getSelectedCID(), getChartModel() );
-                    Reference< XRegressionCurve > xTrendline = RegressionCurveHelper::getFirstCurveNotMeanValueLine( xSeries );
+                    rtl::Reference< RegressionCurveModel > xTrendline = RegressionCurveHelper::getFirstCurveNotMeanValueLine( xSeries );
                     bool bHasEquation = RegressionCurveHelper::hasEquation( xTrendline );
-                    Reference< XRegressionCurve > xMeanValue = RegressionCurveHelper::getMeanValueLine( xSeries );
+                    rtl::Reference< RegressionCurveModel > xMeanValue = RegressionCurveHelper::getMeanValueLine( xSeries );
                     bool bHasYErrorBars = StatisticsHelper::hasErrorBars( xSeries );
                     bool bHasXErrorBars = StatisticsHelper::hasErrorBars( xSeries, false );
                     bool bHasDataLabelsAtSeries = DataSeriesHelper::hasDataLabelsAtSeries( xSeries );
diff --git a/chart2/source/controller/sidebar/ChartSeriesPanel.cxx b/chart2/source/controller/sidebar/ChartSeriesPanel.cxx
index 93e56145b05a..f6ce403a8bc8 100644
--- a/chart2/source/controller/sidebar/ChartSeriesPanel.cxx
+++ b/chart2/source/controller/sidebar/ChartSeriesPanel.cxx
@@ -39,6 +39,7 @@
 #include <DiagramHelper.hxx>
 #include <Diagram.hxx>
 #include <RegressionCurveHelper.hxx>
+#include <RegressionCurveModel.hxx>
 #include <StatisticsHelper.hxx>
 #include <BaseCoordinateSystem.hxx>
 
diff --git a/chart2/source/inc/RegressionCurveHelper.hxx b/chart2/source/inc/RegressionCurveHelper.hxx
index 00a70a5aece4..7d7631cbdfc8 100644
--- a/chart2/source/inc/RegressionCurveHelper.hxx
+++ b/chart2/source/inc/RegressionCurveHelper.hxx
@@ -33,26 +33,35 @@ namespace com::sun::star::chart2 { class XRegressionCurveContainer; }
 namespace com::sun::star::chart2::data { class XDataSource; }
 namespace com::sun::star::frame { class XModel; }
 namespace chart { class ChartModel; }
+namespace chart { class DataSeries; }
 namespace chart { class Diagram; }
+namespace chart { class RegressionCurveModel; }
 
 namespace chart::RegressionCurveHelper
 {
     /// returns a model mean-value line
-    css::uno::Reference<css::chart2::XRegressionCurve> createMeanValueLine();
+    rtl::Reference<::chart::RegressionCurveModel> createMeanValueLine();
 
     /// returns a model regression curve
-    css::uno::Reference<css::chart2::XRegressionCurve>
+    rtl::Reference<::chart::RegressionCurveModel>
         createRegressionCurveByServiceName( std::u16string_view aServiceName );
 
     OOO_DLLPUBLIC_CHARTTOOLS bool hasMeanValueLine(
         const css::uno::Reference<css::chart2::XRegressionCurveContainer> & xRegCnt );
+    OOO_DLLPUBLIC_CHARTTOOLS bool hasMeanValueLine(
+        const rtl::Reference<::chart::DataSeries> & xRegCnt );
 
     OOO_DLLPUBLIC_CHARTTOOLS bool isMeanValueLine(
         const css::uno::Reference<css::chart2::XRegressionCurve> & xRegCurve );
+    OOO_DLLPUBLIC_CHARTTOOLS bool isMeanValueLine(
+        const rtl::Reference<::chart::RegressionCurveModel> & xRegCurve );
 
-    OOO_DLLPUBLIC_CHARTTOOLS css::uno::Reference<css::chart2::XRegressionCurve>
+    OOO_DLLPUBLIC_CHARTTOOLS rtl::Reference<::chart::RegressionCurveModel>
         getMeanValueLine(
             const css::uno::Reference<css::chart2::XRegressionCurveContainer> & xRegCnt );
+    OOO_DLLPUBLIC_CHARTTOOLS rtl::Reference<::chart::RegressionCurveModel>
+        getMeanValueLine(
+            const rtl::Reference<::chart::DataSeries> & xRegCnt );
 
     /** creates a mean-value line and adds it to the container.
 
@@ -62,22 +71,30 @@ namespace chart::RegressionCurveHelper
     OOO_DLLPUBLIC_CHARTTOOLS void addMeanValueLine(
         css::uno::Reference<css::chart2::XRegressionCurveContainer> const & xRegCnt,
         const css::uno::Reference<css::beans::XPropertySet>& xSeriesProp );
+    OOO_DLLPUBLIC_CHARTTOOLS void addMeanValueLine(
+        rtl::Reference<::chart::DataSeries> const & xRegCnt,
+        const css::uno::Reference<css::beans::XPropertySet>& xSeriesProp );
 
     OOO_DLLPUBLIC_CHARTTOOLS void removeMeanValueLine(
         css::uno::Reference<css::chart2::XRegressionCurveContainer> const & xRegCnt );
+    OOO_DLLPUBLIC_CHARTTOOLS void removeMeanValueLine(
+        rtl::Reference<::chart::DataSeries> const & xRegCnt );
 
     /** Returns the first regression curve found that is not of type
         mean-value line
      */
-    OOO_DLLPUBLIC_CHARTTOOLS css::uno::Reference<css::chart2::XRegressionCurve>
+    OOO_DLLPUBLIC_CHARTTOOLS rtl::Reference<::chart::RegressionCurveModel>
         getFirstCurveNotMeanValueLine(
             const css::uno::Reference<css::chart2::XRegressionCurveContainer>& xCurveContainer );
+    OOO_DLLPUBLIC_CHARTTOOLS rtl::Reference<::chart::RegressionCurveModel>
+        getFirstCurveNotMeanValueLine(
+            const rtl::Reference<::chart::DataSeries>& xCurveContainer );
 
     /** Returns the regression curve found at the index provided.
      */
-    OOO_DLLPUBLIC_CHARTTOOLS css::uno::Reference<css::chart2::XRegressionCurve>
+    OOO_DLLPUBLIC_CHARTTOOLS rtl::Reference<::chart::RegressionCurveModel>
         getRegressionCurveAtIndex(
-            const css::uno::Reference<css::chart2::XRegressionCurveContainer>& xCurveContainer,
+            const rtl::Reference<::chart::DataSeries>& xCurveContainer,
             sal_Int32 aIndex);
 
     /** Returns the type of the first regression curve found that is not of type
@@ -85,6 +102,8 @@ namespace chart::RegressionCurveHelper
      */
     OOO_DLLPUBLIC_CHARTTOOLS SvxChartRegress getFirstRegressTypeNotMeanValueLine(
         const css::uno::Reference<css::chart2::XRegressionCurveContainer>& xCurveContainer );
+    OOO_DLLPUBLIC_CHARTTOOLS SvxChartRegress getFirstRegressTypeNotMeanValueLine(
+        const rtl::Reference<::chart::DataSeries>& xCurveContainer );
 
     OOO_DLLPUBLIC_CHARTTOOLS SvxChartRegress getRegressionType(
         const css::uno::Reference<css::chart2::XRegressionCurve>& xCurve );
@@ -94,7 +113,7 @@ namespace chart::RegressionCurveHelper
         @param xEquationProperties is set at the new regression curve as
                equation properties if not null
     */
-    OOO_DLLPUBLIC_CHARTTOOLS css::uno::Reference<css::chart2::XRegressionCurve>
+    OOO_DLLPUBLIC_CHARTTOOLS rtl::Reference<::chart::RegressionCurveModel>
         addRegressionCurve(
             SvxChartRegress eType,
             css::uno::Reference<css::chart2::XRegressionCurveContainer> const & xCurveContainer,
@@ -102,14 +121,22 @@ namespace chart::RegressionCurveHelper
                     css::uno::Reference<css::beans::XPropertySet>(),
             const css::uno::Reference<css::beans::XPropertySet>& xEquationProperties =
                     css::uno::Reference<css::beans::XPropertySet>() );
+    OOO_DLLPUBLIC_CHARTTOOLS rtl::Reference<::chart::RegressionCurveModel>
+        addRegressionCurve(
+            SvxChartRegress eType,
+            rtl::Reference<::chart::DataSeries> const & xCurveContainer,
+            const css::uno::Reference<css::beans::XPropertySet >& xPropertySource =
+                    css::uno::Reference<css::beans::XPropertySet>(),
+            const css::uno::Reference<css::beans::XPropertySet>& xEquationProperties =
+                    css::uno::Reference<css::beans::XPropertySet>() );
 
     OOO_DLLPUBLIC_CHARTTOOLS bool removeAllExceptMeanValueLine(
-        css::uno::Reference<css::chart2::XRegressionCurveContainer> const & xCurveContainer );
+        rtl::Reference<::chart::DataSeries> const & xCurveContainer );
 
     OOO_DLLPUBLIC_CHARTTOOLS void removeEquations(
-        css::uno::Reference<css::chart2::XRegressionCurveContainer> const & xCurveContainer );
+        rtl::Reference<::chart::DataSeries> const & xCurveContainer );
 
-    OOO_DLLPUBLIC_CHARTTOOLS css::uno::Reference<css::chart2::XRegressionCurve>
+    OOO_DLLPUBLIC_CHARTTOOLS rtl::Reference<::chart::RegressionCurveModel>
         changeRegressionCurveType(
             SvxChartRegress eType,
             css::uno::Reference<css::chart2::XRegressionCurveContainer> const & xRegressionCurveContainer,
@@ -161,7 +188,7 @@ namespace chart::RegressionCurveHelper
     OOO_DLLPUBLIC_CHARTTOOLS OUString getRegressionCurveSpecificName(
         const css::uno::Reference<css::chart2::XRegressionCurve>& xCurve );
 
-    OOO_DLLPUBLIC_CHARTTOOLS std::vector<css::uno::Reference<css::chart2::XRegressionCurve> >
+    OOO_DLLPUBLIC_CHARTTOOLS std::vector<rtl::Reference<::chart::RegressionCurveModel> >
         getAllRegressionCurvesNotMeanValueLine(
                 const rtl::Reference<::chart::Diagram>& xDiagram );
 
@@ -170,8 +197,8 @@ namespace chart::RegressionCurveHelper
 
     /// @return the index of the given curve in the given container. -1 if not contained
     OOO_DLLPUBLIC_CHARTTOOLS sal_Int32 getRegressionCurveIndex(
-        const css::uno::Reference<css::chart2::XRegressionCurveContainer>& xContainer,
-        const css::uno::Reference<css::chart2::XRegressionCurve>& xCurve );
+        const rtl::Reference<::chart::DataSeries>& xContainer,
+        const rtl::Reference<::chart::RegressionCurveModel>& xCurve );
 
     OOO_DLLPUBLIC_CHARTTOOLS bool hasEquation(const css::uno::Reference<css::chart2::XRegressionCurve>& xCurve );
 
diff --git a/chart2/source/tools/RegressionCurveHelper.cxx b/chart2/source/tools/RegressionCurveHelper.cxx
index f0d57f732092..ce4481ef8cfb 100644
--- a/chart2/source/tools/RegressionCurveHelper.cxx
+++ b/chart2/source/tools/RegressionCurveHelper.cxx
@@ -90,15 +90,15 @@ OUString lcl_getServiceNameForType(SvxChartRegress eType)
 namespace chart
 {
 
-Reference< XRegressionCurve > RegressionCurveHelper::createMeanValueLine()
+rtl::Reference< RegressionCurveModel > RegressionCurveHelper::createMeanValueLine()
 {
-    return Reference< XRegressionCurve >( new MeanValueRegressionCurve );
+    return new MeanValueRegressionCurve;
 }
 
-Reference< XRegressionCurve > RegressionCurveHelper::createRegressionCurveByServiceName(
+rtl::Reference< RegressionCurveModel > RegressionCurveHelper::createRegressionCurveByServiceName(
     std::u16string_view aServiceName )
 {
-    Reference< XRegressionCurve > xResult;
+    rtl::Reference< RegressionCurveModel > xResult;
 
     // todo: use factory methods with service name
     if( aServiceName == u"com.sun.star.chart2.LinearRegressionCurve" )
@@ -265,6 +265,28 @@ bool RegressionCurveHelper::hasMeanValueLine(
     return false;
 }
 
+bool RegressionCurveHelper::hasMeanValueLine(
+    const rtl::Reference< DataSeries > & xRegCnt )
+{
+    if( !xRegCnt.is())
+        return false;
+
+    try
+    {
+        for( rtl::Reference< RegressionCurveModel > const & curve : xRegCnt->getRegressionCurves2() )
+        {
+            if( isMeanValueLine( curve ))
+                return true;
+        }
+    }
+    catch( const Exception & )
+    {
+        DBG_UNHANDLED_EXCEPTION("chart2");
+    }
+
+    return false;
+}
+
 bool RegressionCurveHelper::isMeanValueLine(
     const uno::Reference< chart2::XRegressionCurve > & xRegCurve )
 {
@@ -274,7 +296,15 @@ bool RegressionCurveHelper::isMeanValueLine(
             "com.sun.star.chart2.MeanValueRegressionCurve";
 }
 
-uno::Reference< chart2::XRegressionCurve >
+bool RegressionCurveHelper::isMeanValueLine(
+    const rtl::Reference< RegressionCurveModel > & xRegCurve )
+{
+    return xRegCurve.is() &&
+        xRegCurve->getServiceName() ==
+            "com.sun.star.chart2.MeanValueRegressionCurve";
+}
+
+rtl::Reference< RegressionCurveModel >
     RegressionCurveHelper::getMeanValueLine(
         const uno::Reference< chart2::XRegressionCurveContainer > & xRegCnt )
 {
@@ -287,6 +317,29 @@ uno::Reference< chart2::XRegressionCurve >
             for( uno::Reference< XRegressionCurve > const & curve : aCurves )
             {
                 if( isMeanValueLine( curve ))
+                    return dynamic_cast<RegressionCurveModel*>(curve.get());
+            }
+        }
+        catch( const Exception & )
+        {
+            DBG_UNHANDLED_EXCEPTION("chart2");
+        }
+    }
+
+    return nullptr;
+}
+
+rtl::Reference< RegressionCurveModel >
+    RegressionCurveHelper::getMeanValueLine(
+        const rtl::Reference< DataSeries > & xRegCnt )
+{
+    if( xRegCnt.is())
+    {
+        try
+        {
+            for( rtl::Reference< RegressionCurveModel > const & curve : xRegCnt->getRegressionCurves2() )
+            {
+                if( isMeanValueLine( curve ))
                     return curve;
             }
         }
@@ -296,7 +349,7 @@ uno::Reference< chart2::XRegressionCurve >
         }
     }
 
-    return uno::Reference< chart2::XRegressionCurve >();
+    return nullptr;
 }
 
 void RegressionCurveHelper::addMeanValueLine(
@@ -322,6 +375,25 @@ void RegressionCurveHelper::addMeanValueLine(
     }
 }
 
+void RegressionCurveHelper::addMeanValueLine(
+    rtl::Reference< DataSeries > const & xRegCnt,
+    const uno::Reference< XPropertySet > & xSeriesProp )
+{
+    if( !xRegCnt.is() ||
+        ::chart::RegressionCurveHelper::hasMeanValueLine( xRegCnt ) )
+        return;
+
+    // todo: use a valid context
+    rtl::Reference< RegressionCurveModel > xCurve( createMeanValueLine() );
+    xRegCnt->addRegressionCurve( xCurve );
+
+    if( xSeriesProp.is())
+    {
+        xCurve->setPropertyValue( "LineColor",
+                                 xSeriesProp->getPropertyValue( "Color"));
+    }
+}
+
 void RegressionCurveHelper::removeMeanValueLine(
     Reference< XRegressionCurveContainer > const & xRegCnt )
 {
@@ -351,13 +423,40 @@ void RegressionCurveHelper::removeMeanValueLine(
     }
 }
 
-uno::Reference< chart2::XRegressionCurve > RegressionCurveHelper::addRegressionCurve(
+void RegressionCurveHelper::removeMeanValueLine(
+    rtl::Reference< DataSeries > const & xRegCnt )
+{
+    if( !xRegCnt.is())
+        return;
+
+    try
+    {
+        for( rtl::Reference< RegressionCurveModel > const & curve : xRegCnt->getRegressionCurves2() )
+        {
+            if( isMeanValueLine( curve ))
+            {
+                xRegCnt->removeRegressionCurve( curve );
+                // attention: the iterator i has become invalid now
+
+                // note: assume that there is only one mean-value curve
+                // to remove multiple mean-value curves remove the break
+                break;
+            }
+        }
+    }
+    catch( const Exception & )
+    {
+        DBG_UNHANDLED_EXCEPTION("chart2");
+    }
+}
+
+rtl::Reference< RegressionCurveModel > RegressionCurveHelper::addRegressionCurve(
     SvxChartRegress eType,
     uno::Reference< XRegressionCurveContainer > const & xRegressionCurveContainer,
     const uno::Reference< beans::XPropertySet >& xPropertySource,
     const uno::Reference< beans::XPropertySet >& xEquationProperties )
 {
-    uno::Reference< chart2::XRegressionCurve > xCurve;
+    rtl::Reference< RegressionCurveModel > xCurve;
 
     if( !xRegressionCurveContainer.is() )
         return xCurve;
@@ -372,24 +471,20 @@ uno::Reference< chart2::XRegressionCurve > RegressionCurveHelper::addRegressionC
     if( !aServiceName.isEmpty())
     {
         // todo: use a valid context
-        xCurve.set( createRegressionCurveByServiceName( aServiceName ) );
+        xCurve = createRegressionCurveByServiceName( aServiceName );
 
         if( xEquationProperties.is())
             xCurve->setEquationProperties( xEquationProperties );
 
-        uno::Reference< beans::XPropertySet > xProperties( xCurve, uno::UNO_QUERY );
-        if( xProperties.is())
+        if( xPropertySource.is())
+            comphelper::copyProperties( xPropertySource, xCurve );
+        else
         {
-            if( xPropertySource.is())
-                comphelper::copyProperties( xPropertySource, xProperties );
-            else
+            uno::Reference< XPropertySet > xSeriesProp( xRegressionCurveContainer, uno::UNO_QUERY );
+            if( xSeriesProp.is())
             {
-                uno::Reference< XPropertySet > xSeriesProp( xRegressionCurveContainer, uno::UNO_QUERY );
-                if( xSeriesProp.is())
-                {
-                    xProperties->setPropertyValue( "LineColor",
-                                             xSeriesProp->getPropertyValue( "Color"));
-                }
+                xCurve->setPropertyValue( "LineColor",
+                                         xSeriesProp->getPropertyValue( "Color"));
             }
         }
     }
@@ -398,67 +493,98 @@ uno::Reference< chart2::XRegressionCurve > RegressionCurveHelper::addRegressionC
     return xCurve;
 }
 
+rtl::Reference< RegressionCurveModel > RegressionCurveHelper::addRegressionCurve(
+    SvxChartRegress eType,
+    rtl::Reference< DataSeries > const & xRegressionCurveContainer,
+    const uno::Reference< beans::XPropertySet >& xPropertySource,
+    const uno::Reference< beans::XPropertySet >& xEquationProperties )
+{
+    rtl::Reference< RegressionCurveModel > xCurve;
+
+    if( !xRegressionCurveContainer.is() )
+        return xCurve;
+
+    if( eType == SvxChartRegress::NONE )
+    {
+        OSL_FAIL("don't create a regression curve of type none");
+        return xCurve;
+    }
+
+    OUString aServiceName( lcl_getServiceNameForType( eType ));
+    if( !aServiceName.isEmpty())
+    {
+        // todo: use a valid context
+        xCurve = createRegressionCurveByServiceName( aServiceName );
+
+        if( xEquationProperties.is())
+            xCurve->setEquationProperties( xEquationProperties );
+
+        if( xPropertySource.is())
+            comphelper::copyProperties( xPropertySource, xCurve );
+        else
+        {
+            xCurve->setPropertyValue( "LineColor",
+                                     xRegressionCurveContainer->getPropertyValue( "Color"));
+        }
+    }
+    xRegressionCurveContainer->addRegressionCurve( xCurve );
+
+    return xCurve;
+}
+
 /** removes all regression curves that are not of type mean value
     and returns true, if anything was removed
  */
 bool RegressionCurveHelper::removeAllExceptMeanValueLine(
-    uno::Reference< chart2::XRegressionCurveContainer > const & xRegCnt )
+    rtl::Reference< DataSeries > const & xRegCnt )
 {
+    if( !xRegCnt.is())
+        return false;
+
     bool bRemovedSomething = false;
-    if( xRegCnt.is())
+    try
     {
-        try
+        std::vector< rtl::Reference< RegressionCurveModel > > aCurvesToDelete;
+        for( rtl::Reference< RegressionCurveModel > const & curve : xRegCnt->getRegressionCurves2() )
         {
-            const uno::Sequence< uno::Reference< chart2::XRegressionCurve > > aCurves(
-                xRegCnt->getRegressionCurves());
-            std::vector< uno::Reference< chart2::XRegressionCurve > > aCurvesToDelete;
-            for( uno::Reference< chart2::XRegressionCurve > const & curve : aCurves )
-            {
-                if( ! isMeanValueLine( curve ))
-                {
-                    aCurvesToDelete.push_back( curve );
-                }
-            }
-
-            for (auto const& curveToDelete : aCurvesToDelete)
+            if( ! isMeanValueLine( curve ))
             {
-                xRegCnt->removeRegressionCurve(curveToDelete);
-                bRemovedSomething = true;
+                aCurvesToDelete.push_back( curve );
             }
         }
-        catch( const uno::Exception & )
+
+        for (auto const& curveToDelete : aCurvesToDelete)
         {
-            DBG_UNHANDLED_EXCEPTION("chart2");
+            xRegCnt->removeRegressionCurve(curveToDelete);
+            bRemovedSomething = true;
         }
     }
+    catch( const uno::Exception & )
+    {
+        DBG_UNHANDLED_EXCEPTION("chart2");
+    }
     return bRemovedSomething;
 }
 
 void RegressionCurveHelper::removeEquations(
-        uno::Reference< chart2::XRegressionCurveContainer > const & xRegCnt )
+        rtl::Reference< DataSeries > const & xRegCnt )
 {
     if( !xRegCnt.is())
         return;
 
     try
     {
-        const uno::Sequence< uno::Reference< chart2::XRegressionCurve > > aCurves(
-            xRegCnt->getRegressionCurves());
-        for( uno::Reference< chart2::XRegressionCurve >  const & curve : aCurves )
+        for( rtl::Reference< RegressionCurveModel >  const & curve : xRegCnt->getRegressionCurves2() )
         {
             if( !isMeanValueLine( curve ) )
             {
-                uno::Reference< chart2::XRegressionCurve > xRegCurve( curve );
-                if( xRegCurve.is() )
+                uno::Reference< beans::XPropertySet > xEqProp( curve->getEquationProperties() ) ;
+                if( xEqProp.is())
                 {
-                    uno::Reference< beans::XPropertySet > xEqProp( xRegCurve->getEquationProperties() ) ;
-                    if( xEqProp.is())
-                    {
-                        xEqProp->setPropertyValue( "ShowEquation", uno::Any( false ));
-                        xEqProp->setPropertyValue( "XName", uno::Any( OUString("x") ));
-                        xEqProp->setPropertyValue( "YName", uno::Any( OUString("f(x) ") ));
-                        xEqProp->setPropertyValue( "ShowCorrelationCoefficient", uno::Any( false ));
-                    }
+                    xEqProp->setPropertyValue( "ShowEquation", uno::Any( false ));
+                    xEqProp->setPropertyValue( "XName", uno::Any( OUString("x") ));
+                    xEqProp->setPropertyValue( "YName", uno::Any( OUString("f(x) ") ));
+                    xEqProp->setPropertyValue( "ShowCorrelationCoefficient", uno::Any( false ));
                 }
             }
         }
@@ -469,7 +595,7 @@ void RegressionCurveHelper::removeEquations(
     }
 }
 
-uno::Reference< XRegressionCurve > RegressionCurveHelper::changeRegressionCurveType(
+rtl::Reference< RegressionCurveModel > RegressionCurveHelper::changeRegressionCurveType(
     SvxChartRegress eType,
     uno::Reference< XRegressionCurveContainer > const & xRegressionCurveContainer,
     uno::Reference< XRegressionCurve > const & xRegressionCurve )
@@ -482,7 +608,7 @@ uno::Reference< XRegressionCurve > RegressionCurveHelper::changeRegressionCurveT
             xRegressionCurve->getEquationProperties());
 }
 
-uno::Reference< chart2::XRegressionCurve > RegressionCurveHelper::getFirstCurveNotMeanValueLine(
+rtl::Reference< RegressionCurveModel > RegressionCurveHelper::getFirstCurveNotMeanValueLine(
     const Reference< XRegressionCurveContainer > & xRegCnt )
 {
     if( !xRegCnt.is())
@@ -496,6 +622,30 @@ uno::Reference< chart2::XRegressionCurve > RegressionCurveHelper::getFirstCurveN
         {
             if( ! isMeanValueLine( curve ))
             {
+                return dynamic_cast<RegressionCurveModel*>(curve.get());
+            }
+        }
+    }
+    catch( const Exception & )
+    {
+        DBG_UNHANDLED_EXCEPTION("chart2");
+    }
+
+    return nullptr;
+}
+
+rtl::Reference< RegressionCurveModel > RegressionCurveHelper::getFirstCurveNotMeanValueLine(
+    const rtl::Reference< DataSeries > & xRegCnt )
+{
+    if( !xRegCnt.is())
+        return nullptr;
+
+    try
+    {
+        for( rtl::Reference< RegressionCurveModel > const & curve : xRegCnt->getRegressionCurves2() )
+        {
+            if( ! isMeanValueLine( curve ))
+            {
                 return curve;
             }
         }
@@ -508,8 +658,8 @@ uno::Reference< chart2::XRegressionCurve > RegressionCurveHelper::getFirstCurveN
     return nullptr;
 }
 
-uno::Reference< chart2::XRegressionCurve > RegressionCurveHelper::getRegressionCurveAtIndex(
-    const Reference< XRegressionCurveContainer >& xCurveContainer,
+rtl::Reference< RegressionCurveModel > RegressionCurveHelper::getRegressionCurveAtIndex(
+    const rtl::Reference< DataSeries >& xCurveContainer,
     sal_Int32 aIndex )
 {
     if( !xCurveContainer.is())
@@ -517,8 +667,8 @@ uno::Reference< chart2::XRegressionCurve > RegressionCurveHelper::getRegressionC
 
     try
     {
-        uno::Sequence< uno::Reference< chart2::XRegressionCurve > > aCurves(xCurveContainer->getRegressionCurves());
-        if(0 <= aIndex && aIndex < aCurves.getLength())
+        const std::vector< rtl::Reference< RegressionCurveModel > > aCurves(xCurveContainer->getRegressionCurves2());
+        if(0 <= aIndex && aIndex < static_cast<sal_Int32>(aCurves.size()))
         {
             if(!isMeanValueLine(aCurves[aIndex]))
                 return aCurves[aIndex];
@@ -606,6 +756,28 @@ SvxChartRegress RegressionCurveHelper::getFirstRegressTypeNotMeanValueLine(
     return eResult;
 }
 
+SvxChartRegress RegressionCurveHelper::getFirstRegressTypeNotMeanValueLine(
+    const rtl::Reference< DataSeries > & xRegCnt )
+{
+    SvxChartRegress eResult = SvxChartRegress::NONE;
+
+    if( xRegCnt.is())
+    {
+        for( rtl::Reference< RegressionCurveModel > const & curve : xRegCnt->getRegressionCurves2() )
+        {
+            SvxChartRegress eType = getRegressionType( curve );
+            if( eType != SvxChartRegress::MeanValue &&
+                eType != SvxChartRegress::Unknown )
+            {
+                eResult = eType;
+                break;
+            }
+        }
+    }
+
+    return eResult;
+}
+
 OUString RegressionCurveHelper::getUINameForRegressionCurve( const Reference< XRegressionCurve >& xRegressionCurve )
 {
     OUString aResult = getRegressionCurveSpecificName(xRegressionCurve);
@@ -687,16 +859,15 @@ OUString RegressionCurveHelper::getRegressionCurveName( const Reference< XRegres
     return aResult;
 }
 
-std::vector< Reference< chart2::XRegressionCurve > >
+std::vector< rtl::Reference< RegressionCurveModel > >
     RegressionCurveHelper::getAllRegressionCurvesNotMeanValueLine(
         const rtl::Reference< Diagram > & xDiagram )
 {
-    std::vector< Reference< chart2::XRegressionCurve > > aResult;
+    std::vector< rtl::Reference< RegressionCurveModel > > aResult;
     std::vector< rtl::Reference< DataSeries > > aSeries( DiagramHelper::getDataSeriesFromDiagram( xDiagram ));
     for (auto const& elem : aSeries)
     {
-        const uno::Sequence< uno::Reference< chart2::XRegressionCurve > > aCurves(elem->getRegressionCurves());
-        for( Reference< XRegressionCurve > const & curve : aCurves )
+        for( rtl::Reference< RegressionCurveModel > const & curve : elem->getRegressionCurves2() )
         {
             if( ! isMeanValueLine( curve ))
                 aResult.push_back( curve );
@@ -726,15 +897,15 @@ void RegressionCurveHelper::resetEquationPosition(
 }
 
 sal_Int32 RegressionCurveHelper::getRegressionCurveIndex(
-    const Reference< chart2::XRegressionCurveContainer >& xContainer,
-    const Reference< chart2::XRegressionCurve >& xCurve )
+    const rtl::Reference< DataSeries >& xContainer,
+    const rtl::Reference< RegressionCurveModel >& xCurve )
 {
     if( xContainer.is())
     {
-        uno::Sequence< uno::Reference< XRegressionCurve > > aCurves(
-            xContainer->getRegressionCurves());
+        const std::vector< rtl::Reference< RegressionCurveModel > > & aCurves(
+            xContainer->getRegressionCurves2());
 
-        for( sal_Int32 i = 0; i < aCurves.getLength(); ++i )
+        for( sal_Int32 i = 0; i < static_cast<sal_Int32>(aCurves.size()); ++i )
         {
             if( xCurve == aCurves[i] )
                 return i;