use ChartModel instead of XModel in a few places

This allows us easier implementation of some advanced features. Mainly
the 4D chartting will now be able to work without several ugly layers of
UNO.

Change-Id: I74d07229eaef921c508f3bab8fae6d6075ad737a

10 files changed, 387 insertions, 148 deletions

diff --git a/chart2/source/tools/AxisHelper.cxx b/chart2/source/tools/AxisHelper.cxx
index 003795bbcbae..cb8c9efab23c 100644
--- a/chart2/source/tools/AxisHelper.cxx
+++ b/chart2/source/tools/AxisHelper.cxx
@@ -96,11 +96,11 @@ bool AxisHelper::isLogarithmic( const Reference< XScaling >& xScaling )
     return bReturn;
 }
 
-chart2::ScaleData AxisHelper::getDateCheckedScale( const Reference< chart2::XAxis >& xAxis, const Reference< frame::XModel >& xChartModel )
+chart2::ScaleData AxisHelper::getDateCheckedScale( const Reference< chart2::XAxis >& xAxis, ChartModel& rModel )
 {
     OSL_ENSURE(xChartModel.is(),"missing chart model");
     ScaleData aScale = xAxis->getScaleData();
-    Reference< chart2::XCoordinateSystem > xCooSys( ChartModelHelper::getFirstCoordinateSystem( xChartModel ) );
+    Reference< chart2::XCoordinateSystem > xCooSys( ChartModelHelper::getFirstCoordinateSystem( rModel ) );
     if( aScale.AutoDateAxis && aScale.AxisType == AxisType::CATEGORY )
     {
         sal_Int32 nDimensionIndex=0; sal_Int32 nAxisIndex=0;
@@ -111,7 +111,7 @@ chart2::ScaleData AxisHelper::getDateCheckedScale( const Reference< chart2::XAxi
     }
     if( aScale.AxisType == AxisType::DATE )
     {
-        ExplicitCategoriesProvider aExplicitCategoriesProvider( xCooSys,xChartModel );
+        ExplicitCategoriesProvider aExplicitCategoriesProvider( xCooSys, rModel );
         if( !aExplicitCategoriesProvider.isDateAxis() )
             aScale.AxisType = AxisType::CATEGORY;
     }
@@ -152,7 +152,9 @@ sal_Int32 AxisHelper::getExplicitNumberFormatKeyForAxis(
         //check whether we have a percent scale -> use percent format
         if( xNumberFormatsSupplier.is() )
         {
-            ScaleData aData = AxisHelper::getDateCheckedScale( xAxis, Reference< frame::XModel >( xNumberFormatsSupplier, uno::UNO_QUERY ) );
+            ChartModel* pModel = dynamic_cast<ChartModel*>( xNumberFormatsSupplier.get() );
+            assert(pModel);
+            ScaleData aData = AxisHelper::getDateCheckedScale( xAxis, *pModel );
             if( aData.AxisType==AxisType::PERCENT )
             {
                 sal_Int32 nPercentFormat = DiagramHelper::getPercentNumberFormat( xNumberFormatsSupplier );
diff --git a/chart2/source/tools/ChartModelHelper.cxx b/chart2/source/tools/ChartModelHelper.cxx
index b49ca02c8d4b..f50c47c4da7a 100644
--- a/chart2/source/tools/ChartModelHelper.cxx
+++ b/chart2/source/tools/ChartModelHelper.cxx
@@ -24,6 +24,7 @@
 #include "ControllerLockGuard.hxx"
 #include "RangeHighlighter.hxx"
 #include "InternalDataProvider.hxx"
+#include "ChartModel.hxx"
 
 #include <com/sun/star/chart/ChartDataRowSource.hpp>
 #include <com/sun/star/chart/XChartDocument.hpp>
@@ -103,6 +104,19 @@ uno::Reference< XDiagram > ChartModelHelper::findDiagram( const uno::Reference<
     return NULL;
 }
 
+uno::Reference< XCoordinateSystem > ChartModelHelper::getFirstCoordinateSystem( ChartModel& rModel )
+{
+    uno::Reference< XCoordinateSystem > XCooSys;
+    uno::Reference< XCoordinateSystemContainer > xCooSysCnt( rModel.getFirstDiagram(), uno::UNO_QUERY );
+    if( xCooSysCnt.is() )
+    {
+        uno::Sequence< uno::Reference< XCoordinateSystem > > aCooSysSeq( xCooSysCnt->getCoordinateSystems() );
+        if( aCooSysSeq.getLength() )
+            XCooSys = aCooSysSeq[0];
+    }
+    return XCooSys;
+}
+
 uno::Reference< XCoordinateSystem > ChartModelHelper::getFirstCoordinateSystem( const uno::Reference< frame::XModel >& xModel )
 {
     uno::Reference< XCoordinateSystem > XCooSys;
@@ -117,6 +131,18 @@ uno::Reference< XCoordinateSystem > ChartModelHelper::getFirstCoordinateSystem(
 }
 
 ::std::vector< uno::Reference< XDataSeries > > ChartModelHelper::getDataSeries(
+    ChartModel& rModel )
+{
+    ::std::vector< uno::Reference< XDataSeries > > aResult;
+
+    uno::Reference< XDiagram > xDiagram = rModel.getFirstDiagram();
+    if( xDiagram.is())
+        aResult = DiagramHelper::getDataSeriesFromDiagram( xDiagram );
+
+    return aResult;
+}
+
+::std::vector< uno::Reference< XDataSeries > > ChartModelHelper::getDataSeries(
     const uno::Reference< XChartDocument > & xChartDoc )
 {
     ::std::vector< uno::Reference< XDataSeries > > aResult;
@@ -202,14 +228,14 @@ bool ChartModelHelper::isIncludeHiddenCells( const uno::Reference< frame::XModel
     return bIncluded;
 }
 
-bool ChartModelHelper::setIncludeHiddenCells( bool bIncludeHiddenCells, const uno::Reference< frame::XModel >& xChartModel )
+bool ChartModelHelper::setIncludeHiddenCells( bool bIncludeHiddenCells, ChartModel& rModel )
 {
     bool bChanged = false;
     try
     {
-        ControllerLockGuard aLockedControllers( xChartModel );
+        ControllerLockGuard aLockedControllers( rModel );
 
-        uno::Reference< beans::XPropertySet > xDiagramProperties( ChartModelHelper::findDiagram(xChartModel), uno::UNO_QUERY );
+        uno::Reference< beans::XPropertySet > xDiagramProperties( rModel.getFirstDiagram(), uno::UNO_QUERY );
         if (xDiagramProperties.is())
         {
             bool bOldValue = bIncludeHiddenCells;
@@ -223,13 +249,9 @@ bool ChartModelHelper::setIncludeHiddenCells( bool bIncludeHiddenCells, const un
 
             try
             {
-                uno::Reference< chart2::XChartDocument > xChartDoc( xChartModel, uno::UNO_QUERY );
-                if( xChartDoc.is() )
-                {
-                    uno::Reference< beans::XPropertySet > xDataProviderProperties( xChartDoc->getDataProvider(), uno::UNO_QUERY );
-                    if( xDataProviderProperties.is() )
-                        xDataProviderProperties->setPropertyValue("IncludeHiddenCells", aNewValue );
-                }
+                uno::Reference< beans::XPropertySet > xDataProviderProperties( rModel.getDataProvider(), uno::UNO_QUERY );
+                if( xDataProviderProperties.is() )
+                    xDataProviderProperties->setPropertyValue("IncludeHiddenCells", aNewValue );
             }
             catch( const beans::UnknownPropertyException& )
             {
@@ -238,7 +260,7 @@ bool ChartModelHelper::setIncludeHiddenCells( bool bIncludeHiddenCells, const un
 
             try
             {
-                uno::Reference< chart2::data::XDataSource > xUsedData( DataSourceHelper::getUsedData( xChartModel ) );
+                uno::Reference< chart2::data::XDataSource > xUsedData( DataSourceHelper::getUsedData( rModel ) );
                 if( xUsedData.is() )
                 {
                     uno::Reference< beans::XPropertySet > xProp;
diff --git a/chart2/source/tools/ControllerLockGuard.cxx b/chart2/source/tools/ControllerLockGuard.cxx
index 9487769a7d26..541b35cc0483 100644
--- a/chart2/source/tools/ControllerLockGuard.cxx
+++ b/chart2/source/tools/ControllerLockGuard.cxx
@@ -18,6 +18,7 @@
  */
 
 #include "ControllerLockGuard.hxx"
+#include "ChartModel.hxx"
 
 using namespace ::com::sun::star;
 
@@ -27,17 +28,26 @@ using ::com::sun::star::uno::Sequence;
 namespace chart
 {
 
-ControllerLockGuard::ControllerLockGuard( const Reference< frame::XModel > & xModel ) :
-        m_xModel( xModel )
+ControllerLockGuardUNO::ControllerLockGuardUNO( const uno::Reference< frame::XModel >& xModel ) :
+        mxModel( xModel )
 {
-    if( m_xModel.is())
-        m_xModel->lockControllers();
+    mxModel->lockControllers();
+}
+
+ControllerLockGuardUNO::~ControllerLockGuardUNO()
+{
+    mxModel->unlockControllers();
+}
+
+ControllerLockGuard::ControllerLockGuard( ChartModel& rModel ) :
+        mrModel( rModel )
+{
+    mrModel.lockControllers();
 }
 
 ControllerLockGuard::~ControllerLockGuard()
 {
-    if( m_xModel.is())
-        m_xModel->unlockControllers();
+    mrModel.unlockControllers();
 }
 
 ControllerLockHelper::ControllerLockHelper( const Reference< frame::XModel > & xModel ) :
diff --git a/chart2/source/tools/DataSourceHelper.cxx b/chart2/source/tools/DataSourceHelper.cxx
index 4c9690fc6054..ccbbc286b142 100644
--- a/chart2/source/tools/DataSourceHelper.cxx
+++ b/chart2/source/tools/DataSourceHelper.cxx
@@ -327,6 +327,32 @@ uno::Reference< chart2::data::XDataSource > DataSourceHelper::getUsedData(
         new DataSource( ContainerHelper::ContainerToSequence( aResult )));
 }
 
+uno::Reference< chart2::data::XDataSource > 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 ) );
+    if( xCategories.is() )
+        aResult.push_back( xCategories );
+
+    ::std::vector< uno::Reference< XDataSeries > > aSeriesVector( ChartModelHelper::getDataSeries( rModel ) );
+    for( ::std::vector< uno::Reference< XDataSeries > >::const_iterator aSeriesIt( aSeriesVector.begin() )
+        ; aSeriesIt != aSeriesVector.end(); ++aSeriesIt )
+    {
+        uno::Reference< data::XDataSource > xDataSource( *aSeriesIt, uno::UNO_QUERY );
+        if( !xDataSource.is() )
+            continue;
+        uno::Sequence< uno::Reference< data::XLabeledDataSequence > > aDataSequences( xDataSource->getDataSequences() );
+        ::std::copy( aDataSequences.getConstArray(), aDataSequences.getConstArray() + aDataSequences.getLength(),
+                     ::std::back_inserter( aResult ));
+    }
+
+    return uno::Reference< chart2::data::XDataSource >(
+        new DataSource( ContainerHelper::ContainerToSequence( aResult )));
+}
+
 bool DataSourceHelper::detectRangeSegmentation(
     const uno::Reference<
         frame::XModel >& xChartModel
@@ -445,7 +471,7 @@ void DataSourceHelper::setRangeSegmentation(
     if( !xDataSource.is() )
         return;
 
-    ControllerLockGuard aCtrlLockGuard( xChartModel );
+    ControllerLockGuardUNO aCtrlLockGuard( xChartModel );
     xDiagram->setDiagramData( xDataSource, aArguments );
 }
 
diff --git a/chart2/source/tools/DiagramHelper.cxx b/chart2/source/tools/DiagramHelper.cxx
index 908ede1aa137..6685fe596cf0 100644
--- a/chart2/source/tools/DiagramHelper.cxx
+++ b/chart2/source/tools/DiagramHelper.cxx
@@ -1002,17 +1002,11 @@ Sequence< OUString > DiagramHelper::generateAutomaticCategoriesFromCooSys( const
 }
 
 Sequence< OUString > DiagramHelper::getExplicitSimpleCategories(
-            const Reference< XChartDocument >& xChartDoc )
+            ChartModel& rModel )
 {
-    Sequence< OUString > aRet;
-    uno::Reference< frame::XModel > xChartModel( xChartDoc, uno::UNO_QUERY );
-    if(xChartModel.is())
-    {
-        uno::Reference< chart2::XCoordinateSystem > xCooSys( ChartModelHelper::getFirstCoordinateSystem( xChartModel ) );
-        ExplicitCategoriesProvider aExplicitCategoriesProvider( xCooSys, xChartModel );
-        aRet = aExplicitCategoriesProvider.getSimpleCategories();
-    }
-    return aRet;
+    uno::Reference< chart2::XCoordinateSystem > xCooSys( ChartModelHelper::getFirstCoordinateSystem( rModel ) );
+    ExplicitCategoriesProvider aExplicitCategoriesProvider( xCooSys, rModel );
+    return aExplicitCategoriesProvider.getSimpleCategories();
 }
 
 namespace
@@ -1117,7 +1111,7 @@ void DiagramHelper::switchToDateCategories( const Reference< XChartDocument >& x
     Reference< frame::XModel > xChartModel( xChartDoc, uno::UNO_QUERY );
     if(xChartModel.is())
     {
-        ControllerLockGuard aCtrlLockGuard( xChartModel );
+        ControllerLockGuardUNO aCtrlLockGuard( xChartModel );
 
         Reference< chart2::XCoordinateSystem > xCooSys( ChartModelHelper::getFirstCoordinateSystem( xChartModel ) );
         if( xCooSys.is() )
@@ -1133,7 +1127,7 @@ void DiagramHelper::switchToTextCategories( const Reference< XChartDocument >& x
     Reference< frame::XModel > xChartModel( xChartDoc, uno::UNO_QUERY );
     if(xChartModel.is())
     {
-        ControllerLockGuard aCtrlLockGuard( xChartModel );
+        ControllerLockGuardUNO aCtrlLockGuard( xChartModel );
 
         Reference< chart2::XCoordinateSystem > xCooSys( ChartModelHelper::getFirstCoordinateSystem( xChartModel ) );
         if( xCooSys.is() )
@@ -1622,7 +1616,7 @@ void lcl_ensureRange0to1( double& rValue )
 bool DiagramHelper::setDiagramPositioning( const uno::Reference< frame::XModel >& xChartModel,
         const awt::Rectangle& rPosRect /*100th mm*/ )
 {
-    ControllerLockGuard aCtrlLockGuard( xChartModel );
+    ControllerLockGuardUNO aCtrlLockGuard( xChartModel );
 
     bool bChanged = false;
     awt::Size aPageSize( ChartModelHelper::getPageSize(xChartModel) );
@@ -1695,28 +1689,22 @@ awt::Rectangle DiagramHelper::getDiagramRectangleFromModel( const uno::Reference
 }
 
 bool DiagramHelper::switchDiagramPositioningToExcludingPositioning(
-    const uno::Reference< frame::XModel >& xChartModel
-    , bool bResetModifiedState, bool bConvertAlsoFromAutoPositioning )
+    ChartModel& rModel, bool bResetModifiedState, bool bConvertAlsoFromAutoPositioning )
 {
     //return true if something was changed
     const SvtSaveOptions::ODFDefaultVersion nCurrentODFVersion( SvtSaveOptions().GetODFDefaultVersion() );
     if( nCurrentODFVersion > SvtSaveOptions::ODFVER_012 )
     {
-        uno::Reference< ::com::sun::star::chart::XChartDocument > xOldDoc( xChartModel, uno::UNO_QUERY ) ;
-        if( xOldDoc.is() )
-        {
-            uno::Reference< ::com::sun::star::chart::XDiagramPositioning > xDiagramPositioning( xOldDoc->getDiagram(), uno::UNO_QUERY );
-            if( xDiagramPositioning.is() && ( bConvertAlsoFromAutoPositioning || !xDiagramPositioning->isAutomaticDiagramPositioning() )
+        uno::Reference< ::com::sun::star::chart::XDiagramPositioning > xDiagramPositioning( rModel.getFirstDiagram(), uno::UNO_QUERY );
+        if( xDiagramPositioning.is() && ( bConvertAlsoFromAutoPositioning || !xDiagramPositioning->isAutomaticDiagramPositioning() )
                 && !xDiagramPositioning->isExcludingDiagramPositioning() )
-            {
-                ControllerLockGuard aCtrlLockGuard( xChartModel );
-                uno::Reference< util::XModifiable > xModifiable( xChartModel, uno::UNO_QUERY );
-                bool bModelWasModified = xModifiable.is() && xModifiable->isModified();
-                xDiagramPositioning->setDiagramPositionExcludingAxes( xDiagramPositioning->calculateDiagramPositionExcludingAxes() );
-                if(bResetModifiedState && !bModelWasModified && xModifiable.is() )
-                    xModifiable->setModified(sal_False);
-                return true;
-            }
+        {
+            ControllerLockGuard aCtrlLockGuard( rModel );
+            bool bModelWasModified = rModel.isModified();
+            xDiagramPositioning->setDiagramPositionExcludingAxes( xDiagramPositioning->calculateDiagramPositionExcludingAxes() );
+            if(bResetModifiedState && !bModelWasModified )
+                rModel.setModified(sal_False);
+            return true;
         }
     }
     return false;
diff --git a/chart2/source/tools/ExplicitCategoriesProvider.cxx b/chart2/source/tools/ExplicitCategoriesProvider.cxx
index 315f25f76048..7d57947a3a27 100644
--- a/chart2/source/tools/ExplicitCategoriesProvider.cxx
+++ b/chart2/source/tools/ExplicitCategoriesProvider.cxx
@@ -31,6 +31,7 @@
 #include <com/sun/star/chart2/AxisType.hpp>
 #include <com/sun/star/util/NumberFormat.hpp>
 #include <com/sun/star/util/XNumberFormatsSupplier.hpp>
+#include <com/sun/star/frame/XModel.hpp>
 
 namespace chart
 {
@@ -42,10 +43,10 @@ using ::com::sun::star::uno::Sequence;
 using ::std::vector;
 
 ExplicitCategoriesProvider::ExplicitCategoriesProvider( const Reference< chart2::XCoordinateSystem >& xCooSysModel
-                                                       , const uno::Reference< frame::XModel >& xChartModel )
+                                                       , ChartModel& rModel )
     : m_bDirty(true)
     , m_xCooSysModel( xCooSysModel )
-    , m_xChartModel( xChartModel )
+    , mrModel(rModel)
     , m_xOriginalCategories()
     , m_bIsExplicitCategoriesInited(false)
     , m_bIsDateAxis(false)
@@ -67,54 +68,50 @@ ExplicitCategoriesProvider::ExplicitCategoriesProvider( const Reference< chart2:
 
         if( m_xOriginalCategories.is() )
         {
-            Reference< chart2::XChartDocument > xChartDoc( xChartModel, uno::UNO_QUERY );
-            if( xChartDoc.is() )
+            uno::Reference< data::XDataProvider > xDataProvider( mrModel.getDataProvider() );
+
+            OUString aCategoriesRange( DataSourceHelper::getRangeFromValues( m_xOriginalCategories ) );
+            if( xDataProvider.is() && !aCategoriesRange.isEmpty() )
             {
-                uno::Reference< data::XDataProvider > xDataProvider( xChartDoc->getDataProvider() );
+                const bool bFirstCellAsLabel = false;
+                const bool bHasCategories = false;
+                const uno::Sequence< sal_Int32 > aSequenceMapping;
 
-                OUString aCategoriesRange( DataSourceHelper::getRangeFromValues( m_xOriginalCategories ) );
-                if( xDataProvider.is() && !aCategoriesRange.isEmpty() )
-                {
-                    const bool bFirstCellAsLabel = false;
-                    const bool bHasCategories = false;
-                    const uno::Sequence< sal_Int32 > aSequenceMapping;
+                uno::Reference< data::XDataSource > xColumnCategoriesSource( xDataProvider->createDataSource(
+                            DataSourceHelper::createArguments( aCategoriesRange, aSequenceMapping, true /*bUseColumns*/
+                                , bFirstCellAsLabel, bHasCategories ) ) );
 
-                    uno::Reference< data::XDataSource > xColumnCategoriesSource( xDataProvider->createDataSource(
-                         DataSourceHelper::createArguments( aCategoriesRange, aSequenceMapping, true /*bUseColumns*/
-                            , bFirstCellAsLabel, bHasCategories ) ) );
+                uno::Reference< data::XDataSource > xRowCategoriesSource( xDataProvider->createDataSource(
+                            DataSourceHelper::createArguments( aCategoriesRange, aSequenceMapping, false /*bUseColumns*/
+                                , bFirstCellAsLabel, bHasCategories ) ) );
 
-                    uno::Reference< data::XDataSource > xRowCategoriesSource( xDataProvider->createDataSource(
-                         DataSourceHelper::createArguments( aCategoriesRange, aSequenceMapping, false /*bUseColumns*/
-                            , bFirstCellAsLabel, bHasCategories ) ) );
+                if( xColumnCategoriesSource.is() &&  xRowCategoriesSource.is() )
+                {
+                    Sequence< Reference< data::XLabeledDataSequence> > aColumns = xColumnCategoriesSource->getDataSequences();
+                    Sequence< Reference< data::XLabeledDataSequence> > aRows = xRowCategoriesSource->getDataSequences();
 
-                    if( xColumnCategoriesSource.is() &&  xRowCategoriesSource.is() )
+                    sal_Int32 nColumnCount = aColumns.getLength();
+                    sal_Int32 nRowCount = aRows.getLength();
+                    if( nColumnCount>1 && nRowCount>1 )
                     {
-                        Sequence< Reference< data::XLabeledDataSequence> > aColumns = xColumnCategoriesSource->getDataSequences();
-                        Sequence< Reference< data::XLabeledDataSequence> > aRows = xRowCategoriesSource->getDataSequences();
-
-                        sal_Int32 nColumnCount = aColumns.getLength();
-                        sal_Int32 nRowCount = aRows.getLength();
-                        if( nColumnCount>1 && nRowCount>1 )
+                        //we have complex categories
+                        //->split them in the direction of the first series
+                        //detect whether the first series is a row or a column
+                        bool bSeriesUsesColumns = true;
+                        ::std::vector< Reference< XDataSeries > > aSeries( ChartModelHelper::getDataSeries( mrModel ) );
+                        if( !aSeries.empty() )
                         {
-                            //we have complex categories
-                            //->split them in the direction of the first series
-                            //detect whether the first series is a row or a column
-                            bool bSeriesUsesColumns = true;
-                            ::std::vector< Reference< XDataSeries > > aSeries( ChartModelHelper::getDataSeries( xChartModel ) );
-                            if( !aSeries.empty() )
-                            {
-                                uno::Reference< data::XDataSource > xSeriesSource( aSeries.front(), uno::UNO_QUERY );
-                                OUString aStringDummy;
-                                bool bDummy;
-                                uno::Sequence< sal_Int32 > aSeqDummy;
-                                DataSourceHelper::readArguments( xDataProvider->detectArguments( xSeriesSource),
-                                               aStringDummy, aSeqDummy, bSeriesUsesColumns, bDummy, bDummy );
-                            }
-                            if( bSeriesUsesColumns )
-                                m_aSplitCategoriesList=aColumns;
-                            else
-                                m_aSplitCategoriesList=aRows;
+                            uno::Reference< data::XDataSource > xSeriesSource( aSeries.front(), uno::UNO_QUERY );
+                            OUString aStringDummy;
+                            bool bDummy;
+                            uno::Sequence< sal_Int32 > aSeqDummy;
+                            DataSourceHelper::readArguments( xDataProvider->detectArguments( xSeriesSource),
+                                    aStringDummy, aSeqDummy, bSeriesUsesColumns, bDummy, bDummy );
                         }
+                        if( bSeriesUsesColumns )
+                            m_aSplitCategoriesList=aColumns;
+                        else
+                            m_aSplitCategoriesList=aRows;
                     }
                 }
             }
@@ -175,30 +172,28 @@ std::vector<sal_Int32> lcl_getLimitingBorders( const std::vector< ComplexCategor
     return aLimitingBorders;
 }
 
-void ExplicitCategoriesProvider::convertCategoryAnysToText( uno::Sequence< OUString >& rOutTexts, const uno::Sequence< uno::Any >& rInAnys, Reference< frame::XModel > xChartModel )
+void ExplicitCategoriesProvider::convertCategoryAnysToText( uno::Sequence< OUString >& rOutTexts, const uno::Sequence< uno::Any >& rInAnys, ChartModel& rModel )
 {
     sal_Int32 nCount = rInAnys.getLength();
     if(!nCount)
         return;
     rOutTexts.realloc(nCount);
-    Reference< util::XNumberFormatsSupplier > xNumberFormatsSupplier( xChartModel, uno::UNO_QUERY );
     Reference< util::XNumberFormats > xNumberFormats;
-    if( xNumberFormatsSupplier.is() )
-         xNumberFormats = Reference< util::XNumberFormats >( xNumberFormatsSupplier->getNumberFormats() );
+    xNumberFormats = Reference< util::XNumberFormats >( rModel.getNumberFormats() );
 
     sal_Int32 nAxisNumberFormat = 0;
-    Reference< XCoordinateSystem > xCooSysModel( ChartModelHelper::getFirstCoordinateSystem( xChartModel ) );
+    Reference< XCoordinateSystem > xCooSysModel( ChartModelHelper::getFirstCoordinateSystem( rModel ) );
     if( xCooSysModel.is() )
     {
         Reference< chart2::XAxis > xAxis( xCooSysModel->getAxisByDimension(0,0) );
         nAxisNumberFormat = AxisHelper::getExplicitNumberFormatKeyForAxis(
-                  xAxis, xCooSysModel, xNumberFormatsSupplier, false );
+                  xAxis, xCooSysModel, rModel.getNumberFormatsSupplier(), false );
     }
 
     sal_Int32 nLabelColor;
     bool bColorChanged = false;
 
-    NumberFormatterWrapper aNumberFormatterWrapper( xNumberFormatsSupplier );
+    NumberFormatterWrapper aNumberFormatterWrapper( rModel.getNumberFormatsSupplier() );
 
     for(sal_Int32 nN=0;nN<nCount;nN++)
     {
@@ -234,9 +229,9 @@ public:
         const ::com::sun::star::uno::Sequence<
             ::com::sun::star::uno::Reference<
                 ::com::sun::star::chart2::data::XLabeledDataSequence> >& rSplitCategoriesList
-        , const Reference< frame::XModel >& xChartModel )
+        , ChartModel& rModel )
         : m_rSplitCategoriesList( rSplitCategoriesList )
-        , m_xChartModel( xChartModel )
+        , mrModel( rModel )
     {}
     virtual ~SplitCategoriesProvider_ForLabeledDataSequences()
     {}
@@ -248,7 +243,7 @@ private:
     const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Reference<
         ::com::sun::star::chart2::data::XLabeledDataSequence> >& m_rSplitCategoriesList;
 
-    Reference< frame::XModel > m_xChartModel;
+    ChartModel& mrModel;
 };
 
 sal_Int32 SplitCategoriesProvider_ForLabeledDataSequences::getLevelCount() const
@@ -263,7 +258,7 @@ uno::Sequence< OUString > SplitCategoriesProvider_ForLabeledDataSequences::getSt
     {
         uno::Reference< data::XDataSequence > xDataSequence( xLabeledDataSequence->getValues() );
         if( xDataSequence.is() )
-            ExplicitCategoriesProvider::convertCategoryAnysToText( aRet, xDataSequence->getData(), m_xChartModel );
+            ExplicitCategoriesProvider::convertCategoryAnysToText( aRet, xDataSequence->getData(), mrModel );
     }
     return aRet;
 }
@@ -420,7 +415,7 @@ struct DatePlusIndexComparator
     }
 };
 
-bool lcl_fillDateCategories( const uno::Reference< data::XDataSequence >& xDataSequence, std::vector< DatePlusIndex >& rDateCategories, bool bIsAutoDate, Reference< util::XNumberFormatsSupplier > xNumberFormatsSupplier )
+bool lcl_fillDateCategories( const uno::Reference< data::XDataSequence >& xDataSequence, std::vector< DatePlusIndex >& rDateCategories, bool bIsAutoDate, ChartModel& rModel )
 {
     bool bOnlyDatesFound = true;
     bool bAnyDataFound = false;
@@ -431,17 +426,15 @@ bool lcl_fillDateCategories( const uno::Reference< data::XDataSequence >& xDataS
         sal_Int32 nCount = aValues.getLength();
         rDateCategories.reserve(nCount);
         Reference< util::XNumberFormats > xNumberFormats;
-        if( xNumberFormatsSupplier.is() )
-             xNumberFormats = Reference< util::XNumberFormats >( xNumberFormatsSupplier->getNumberFormats() );
+        xNumberFormats = Reference< util::XNumberFormats >( rModel.getNumberFormats() );
 
         bool bOwnData = false;
         bool bOwnDataAnddAxisHasAnyFormat = false;
         bool bOwnDataAnddAxisHasDateFormat = false;
-        Reference< chart2::XChartDocument > xChartDoc( xNumberFormatsSupplier, uno::UNO_QUERY );
-        Reference< XCoordinateSystem > xCooSysModel( ChartModelHelper::getFirstCoordinateSystem( Reference< frame::XModel >( xChartDoc, uno::UNO_QUERY ) ) );
-        if( xChartDoc.is() && xCooSysModel.is() )
+        Reference< XCoordinateSystem > xCooSysModel( ChartModelHelper::getFirstCoordinateSystem( rModel ) );
+        if( xCooSysModel.is() )
         {
-            if( xChartDoc->hasInternalDataProvider() )
+            if( rModel.hasInternalDataProvider() )
             {
                 bOwnData = true;
                 Reference< beans::XPropertySet > xAxisProps( xCooSysModel->getAxisByDimension(0,0), uno::UNO_QUERY );
@@ -513,7 +506,7 @@ void ExplicitCategoriesProvider::init()
                 if(m_bIsDateAxis)
                 {
                     if( ChartTypeHelper::isSupportingDateAxis( AxisHelper::getChartTypeByIndex( m_xCooSysModel, 0 ), 2, 0 ) )
-                        m_bIsDateAxis = lcl_fillDateCategories( m_xOriginalCategories->getValues(), m_aDateCategories, m_bIsAutoDate, Reference< util::XNumberFormatsSupplier >( m_xChartModel.get(), uno::UNO_QUERY ) );
+                        m_bIsDateAxis = lcl_fillDateCategories( m_xOriginalCategories->getValues(), m_aDateCategories, m_bIsAutoDate, mrModel );
                     else
                         m_bIsDateAxis = false;
                 }
@@ -541,12 +534,12 @@ Sequence< OUString > ExplicitCategoriesProvider::getSimpleCategories()
             {
                 uno::Reference< data::XDataSequence > xDataSequence( m_xOriginalCategories->getValues() );
                 if( xDataSequence.is() )
-                    ExplicitCategoriesProvider::convertCategoryAnysToText( m_aExplicitCategories, xDataSequence->getData(), m_xChartModel );
+                    ExplicitCategoriesProvider::convertCategoryAnysToText( m_aExplicitCategories, xDataSequence->getData(), mrModel );
             }
             else
             {
                 m_aExplicitCategories = lcl_getExplicitSimpleCategories(
-                    SplitCategoriesProvider_ForLabeledDataSequences( m_aSplitCategoriesList, m_xChartModel ), m_aComplexCats );
+                    SplitCategoriesProvider_ForLabeledDataSequences( m_aSplitCategoriesList, mrModel ), m_aComplexCats );
             }
         }
         if(!m_aExplicitCategories.getLength())
@@ -567,12 +560,12 @@ const std::vector<ComplexCategory>* ExplicitCategoriesProvider::getCategoriesByL
 
 OUString ExplicitCategoriesProvider::getCategoryByIndex(
           const Reference< XCoordinateSystem >& xCooSysModel
-        , const uno::Reference< frame::XModel >& xChartModel
+        , ChartModel& rModel
         , sal_Int32 nIndex )
 {
     if( xCooSysModel.is())
     {
-        ExplicitCategoriesProvider aExplicitCategoriesProvider( xCooSysModel, xChartModel );
+        ExplicitCategoriesProvider aExplicitCategoriesProvider( xCooSysModel, rModel );
         Sequence< OUString > aCategories( aExplicitCategoriesProvider.getSimpleCategories());
         if( nIndex < aCategories.getLength())
             return aCategories[ nIndex ];
diff --git a/chart2/source/tools/InternalDataProvider.cxx b/chart2/source/tools/InternalDataProvider.cxx
index 30d0d52bb332..fe70d7c59066 100644
--- a/chart2/source/tools/InternalDataProvider.cxx
+++ b/chart2/source/tools/InternalDataProvider.cxx
@@ -343,7 +343,9 @@ InternalDataProvider::InternalDataProvider(
             {
                 vector< vector< uno::Any > > aNewCategories;//inner count is level
                 {
-                    ExplicitCategoriesProvider aExplicitCategoriesProvider( ChartModelHelper::getFirstCoordinateSystem(xChartModel), xChartModel );
+                    ChartModel* pModel = dynamic_cast<ChartModel*>(xChartModel.get());
+                    assert(pModel);
+                    ExplicitCategoriesProvider aExplicitCategoriesProvider( ChartModelHelper::getFirstCoordinateSystem(xChartModel), *pModel );
 
                     const Sequence< Reference< chart2::data::XLabeledDataSequence> >& rSplitCategoriesList( aExplicitCategoriesProvider.getSplitCategoriesList() );
                     sal_Int32 nLevelCount = rSplitCategoriesList.getLength();
diff --git a/chart2/source/tools/LegendHelper.cxx b/chart2/source/tools/LegendHelper.cxx
index 9ee10499fe0a..129a7a71d61f 100644
--- a/chart2/source/tools/LegendHelper.cxx
+++ b/chart2/source/tools/LegendHelper.cxx
@@ -32,10 +32,10 @@ using ::com::sun::star::uno::Reference;
 namespace chart
 {
 
-Reference< chart2::XLegend > LegendHelper::showLegend( const Reference< frame::XModel >& xModel
+Reference< chart2::XLegend > LegendHelper::showLegend( ChartModel& rModel
                                                     , const uno::Reference< uno::XComponentContext >& xContext )
 {
-    uno::Reference< chart2::XLegend > xLegend = LegendHelper::getLegend( xModel, xContext, true );
+    uno::Reference< chart2::XLegend > xLegend = LegendHelper::getLegend( rModel, xContext, true );
     uno::Reference< beans::XPropertySet > xProp( xLegend, uno::UNO_QUERY );
     if( xProp.is())
     {
@@ -63,9 +63,9 @@ Reference< chart2::XLegend > LegendHelper::showLegend( const Reference< frame::X
     return xLegend;
 }
 
-void LegendHelper::hideLegend( const Reference< frame::XModel >& xModel )
+void LegendHelper::hideLegend( ChartModel& rModel )
 {
-    uno::Reference< chart2::XLegend > xLegend = LegendHelper::getLegend( xModel, 0, false );
+    uno::Reference< chart2::XLegend > xLegend = LegendHelper::getLegend( rModel, 0, false );
     uno::Reference< beans::XPropertySet > xProp( xLegend, uno::UNO_QUERY );
     if( xProp.is())
     {
@@ -74,38 +74,34 @@ void LegendHelper::hideLegend( const Reference< frame::XModel >& xModel )
 }
 
 uno::Reference< chart2::XLegend > LegendHelper::getLegend(
-      const uno::Reference< frame::XModel >& xModel
+      ChartModel& rModel
     , const uno::Reference< uno::XComponentContext >& xContext
     , bool bCreate )
 {
     uno::Reference< chart2::XLegend > xResult;
 
-    uno::Reference< chart2::XChartDocument > xChartDoc( xModel, uno::UNO_QUERY );
-    if( xChartDoc.is())
+    try
     {
-        try
+        uno::Reference< chart2::XDiagram > xDia( rModel.getFirstDiagram());
+        if( xDia.is() )
         {
-            uno::Reference< chart2::XDiagram > xDia( xChartDoc->getFirstDiagram());
-            if( xDia.is() )
+            xResult.set( xDia->getLegend() );
+            if( bCreate && !xResult.is() && xContext.is() )
             {
-                xResult.set( xDia->getLegend() );
-                if( bCreate && !xResult.is() && xContext.is() )
-                {
-                    xResult.set( xContext->getServiceManager()->createInstanceWithContext(
-                        "com.sun.star.chart2.Legend", xContext ), uno::UNO_QUERY );
-                    xDia->setLegend( xResult );
-                }
-            }
-            else if(bCreate)
-            {
-                OSL_FAIL("need diagram for creation of legend");
+                xResult.set( xContext->getServiceManager()->createInstanceWithContext(
+                            "com.sun.star.chart2.Legend", xContext ), uno::UNO_QUERY );
+                xDia->setLegend( xResult );
             }
         }
-        catch( const uno::Exception & ex )
+        else if(bCreate)
         {
-            ASSERT_EXCEPTION( ex );
+            OSL_FAIL("need diagram for creation of legend");
         }
     }
+    catch( const uno::Exception & ex )
+    {
+        ASSERT_EXCEPTION( ex );
+    }
 
     return xResult;
 }
diff --git a/chart2/source/tools/ObjectIdentifier.cxx b/chart2/source/tools/ObjectIdentifier.cxx
index a5052c938e4f..a6fd0602ebd6 100644
--- a/chart2/source/tools/ObjectIdentifier.cxx
+++ b/chart2/source/tools/ObjectIdentifier.cxx
@@ -327,6 +327,88 @@ bool ObjectIdentifier::operator<( const ObjectIdentifier& rOID ) const
 
 OUString ObjectIdentifier::createClassifiedIdentifierForObject(
           const Reference< uno::XInterface >& xObject
+        , ChartModel& rModel)
+{
+    OUString aRet;
+
+    enum ObjectType eObjectType = OBJECTTYPE_UNKNOWN;
+    OUString aObjectID;
+    OUString aParentParticle;
+    OUString aDragMethodServiceName;
+    OUString aDragParameterString;
+
+    try
+    {
+        //title
+        Reference< XTitle > xTitle( xObject, uno::UNO_QUERY );
+        if( xTitle.is() )
+        {
+            TitleHelper::eTitleType aTitleType;
+            if( TitleHelper::getTitleType( aTitleType, xTitle, rModel ) )
+            {
+                eObjectType = OBJECTTYPE_TITLE;
+                aParentParticle = lcl_getTitleParentParticle( aTitleType );
+                aRet = ObjectIdentifier::createClassifiedIdentifierWithParent(
+                    eObjectType, aObjectID, aParentParticle, aDragMethodServiceName, aDragParameterString );
+            }
+            return aRet;
+
+        }
+
+        //axis
+        Reference< XAxis > xAxis( xObject, uno::UNO_QUERY );
+        if( xAxis.is() )
+        {
+            Reference< XCoordinateSystem > xCooSys( AxisHelper::getCoordinateSystemOfAxis( xAxis, rModel.getFirstDiagram() ) );
+            OUString aCooSysParticle( createParticleForCoordinateSystem( xCooSys, rModel ) );
+            sal_Int32 nDimensionIndex=-1;
+            sal_Int32 nAxisIndex=-1;
+            AxisHelper::getIndicesForAxis( xAxis, xCooSys, nDimensionIndex, nAxisIndex );
+            OUString aAxisParticle( createParticleForAxis( nDimensionIndex, nAxisIndex ) );
+            return createClassifiedIdentifierForParticles( aCooSysParticle, aAxisParticle );
+        }
+
+        //legend
+        Reference< XLegend > xLegend( xObject, uno::UNO_QUERY );
+        if( xLegend.is() )
+        {
+            return createClassifiedIdentifierForParticle( createParticleForLegend( xLegend, rModel ) );
+        }
+
+        //diagram
+        Reference< XDiagram > xDiagram( xObject, uno::UNO_QUERY );
+        if( xDiagram.is() )
+        {
+            return createClassifiedIdentifierForParticle( createParticleForDiagram( xDiagram, rModel ) );
+        }
+
+        //todo
+        //XDataSeries
+        //CooSys
+        //charttype
+        //datapoint?
+        //Gridproperties
+    }
+    catch(const uno::Exception& ex)
+    {
+        ASSERT_EXCEPTION( ex );
+    }
+
+    if( eObjectType != OBJECTTYPE_UNKNOWN )
+    {
+        aRet = ObjectIdentifier::createClassifiedIdentifierWithParent(
+            eObjectType, aObjectID, aParentParticle, aDragMethodServiceName, aDragParameterString );
+    }
+    else
+    {
+        OSL_FAIL("give object could not be identifed in createClassifiedIdentifierForObject");
+    }
+
+    return aRet;
+}
+
+OUString ObjectIdentifier::createClassifiedIdentifierForObject(
+          const Reference< uno::XInterface >& xObject
         , const Reference< frame::XModel >& xChartModel )
 {
     OUString aRet;
@@ -441,6 +523,15 @@ OUString ObjectIdentifier::createClassifiedIdentifierForParticles(
 
 OUString ObjectIdentifier::createParticleForDiagram(
           const Reference< XDiagram >& /*xDiagram*/
+        , ChartModel& /*xChartModel*/ )
+{
+    static OUString aRet("D=0");
+    //todo: if more than one diagram is implemeted, add the correct diagram index here
+    return aRet;
+}
+
+OUString ObjectIdentifier::createParticleForDiagram(
+          const Reference< XDiagram >& /*xDiagram*/
         , const Reference< frame::XModel >& /*xChartModel*/ )
 {
     static OUString aRet("D=0");
@@ -450,6 +541,34 @@ OUString ObjectIdentifier::createParticleForDiagram(
 
 OUString ObjectIdentifier::createParticleForCoordinateSystem(
           const Reference< XCoordinateSystem >& xCooSys
+        , ChartModel& rModel )
+{
+    OUStringBuffer aRet;
+
+    Reference< XDiagram > xDiagram( rModel.getFirstDiagram() );
+    Reference< XCoordinateSystemContainer > xCooSysContainer( xDiagram, uno::UNO_QUERY );
+    if( xCooSysContainer.is() )
+    {
+        sal_Int32 nCooSysIndex = 0;
+        uno::Sequence< Reference< XCoordinateSystem > > aCooSysList( xCooSysContainer->getCoordinateSystems() );
+        for( ; nCooSysIndex < aCooSysList.getLength(); ++nCooSysIndex )
+        {
+            Reference< XCoordinateSystem > xCurrentCooSys( aCooSysList[nCooSysIndex] );
+            if( xCooSys == xCurrentCooSys )
+            {
+                aRet = ObjectIdentifier::createParticleForDiagram( xDiagram, rModel );
+                aRet.appendAscii(":CS=");
+                aRet.append( OUString::number( nCooSysIndex ) );
+                break;
+            }
+        }
+    }
+
+    return aRet.makeStringAndClear();
+}
+
+OUString ObjectIdentifier::createParticleForCoordinateSystem(
+          const Reference< XCoordinateSystem >& xCooSys
         , const Reference< frame::XModel >& xChartModel )
 {
     OUStringBuffer aRet;
@@ -542,6 +661,23 @@ OUString ObjectIdentifier::createParticleForSeries(
 
 OUString ObjectIdentifier::createParticleForLegend(
           const Reference< XLegend >& /*xLegend*/
+        , ChartModel& rModel )
+{
+    OUStringBuffer aRet;
+
+    Reference< XDiagram > xDiagram( rModel.getFirstDiagram() );
+    //todo: if more than one diagram is implemeted, find the correct diagram which is owner of the given legend
+
+    aRet.append( ObjectIdentifier::createParticleForDiagram( xDiagram, rModel ) );
+    aRet.appendAscii(":");
+    aRet.append(getStringForType( OBJECTTYPE_LEGEND ));
+    aRet.appendAscii("=");
+
+    return aRet.makeStringAndClear();
+}
+
+OUString ObjectIdentifier::createParticleForLegend(
+          const Reference< XLegend >& /*xLegend*/
         , const Reference< frame::XModel >& xChartModel )
 {
     OUStringBuffer aRet;
diff --git a/chart2/source/tools/TitleHelper.cxx b/chart2/source/tools/TitleHelper.cxx
index d55837e81ba0..26bffc3459aa 100644
--- a/chart2/source/tools/TitleHelper.cxx
+++ b/chart2/source/tools/TitleHelper.cxx
@@ -33,6 +33,8 @@ using namespace ::com::sun::star;
 using namespace ::com::sun::star::chart2;
 using ::com::sun::star::uno::Reference;
 
+namespace {
+
 uno::Reference< XTitled > lcl_getTitleParentFromDiagram(
       TitleHelper::eTitleType nTitleIndex
     , const uno::Reference< XDiagram >& xDiagram )
@@ -88,18 +90,13 @@ uno::Reference< XTitled > lcl_getTitleParentFromDiagram(
 }
 
 uno::Reference< XTitled > lcl_getTitleParent( TitleHelper::eTitleType nTitleIndex
-                                              , const uno::Reference< frame::XModel >& xModel )
+                                              , const uno::Reference< XDiagram >& xDiagram )
 {
     uno::Reference< XTitled > xResult;
-    uno::Reference< XChartDocument > xChartDoc( xModel, uno::UNO_QUERY );
-    uno::Reference< XDiagram > xDiagram;
-    if( xChartDoc.is())
-        xDiagram.set( xChartDoc->getFirstDiagram());
-
     switch( nTitleIndex )
     {
         case TitleHelper::MAIN_TITLE:
-            xResult.set( xModel, uno::UNO_QUERY );
+            SAL_WARN("chart2", "should not be reached");
             break;
         case TitleHelper::SUB_TITLE:
         case TitleHelper::X_AXIS_TITLE:
@@ -119,10 +116,55 @@ uno::Reference< XTitled > lcl_getTitleParent( TitleHelper::eTitleType nTitleInde
     return xResult;
 }
 
+uno::Reference< XTitled > lcl_getTitleParent( TitleHelper::eTitleType nTitleIndex
+                                              , const uno::Reference< frame::XModel >& xModel )
+{
+    if(nTitleIndex == TitleHelper::MAIN_TITLE)
+    {
+        uno::Reference< XTitled > xTitled( xModel, uno::UNO_QUERY );
+        return xTitled;
+    }
+
+    uno::Reference< XChartDocument > xChartDoc( xModel, uno::UNO_QUERY );
+    uno::Reference< XDiagram > xDiagram;
+
+    if( xChartDoc.is())
+        xDiagram.set( xChartDoc->getFirstDiagram());
+
+    return lcl_getTitleParent( nTitleIndex, xDiagram );
+}
+
+}
+
+uno::Reference< XTitle > TitleHelper::getTitle( TitleHelper::eTitleType nTitleIndex
+                            , ChartModel& rModel )
+{
+    if(nTitleIndex == TitleHelper::MAIN_TITLE)
+        return rModel.getTitleObject();
+
+    uno::Reference< XDiagram > xDiagram( rModel.getFirstDiagram(), uno::UNO_QUERY );
+    uno::Reference< XTitled > xTitled( lcl_getTitleParent( nTitleIndex, xDiagram ) );
+    if( xTitled.is())
+        return xTitled->getTitleObject();
+    return NULL;
+}
+
 uno::Reference< XTitle > TitleHelper::getTitle( TitleHelper::eTitleType nTitleIndex
                             , const uno::Reference< frame::XModel >& xModel )
 {
-    uno::Reference< XTitled > xTitled( lcl_getTitleParent( nTitleIndex, xModel ) );
+    if(nTitleIndex == TitleHelper::MAIN_TITLE)
+    {
+        uno::Reference< XTitled > xTitled( xModel, uno::UNO_QUERY );
+        return xTitled->getTitleObject();
+    }
+
+    uno::Reference< XChartDocument > xChartDoc( xModel, uno::UNO_QUERY );
+    uno::Reference< XDiagram > xDiagram;
+
+    if( xChartDoc.is())
+        xDiagram.set( xChartDoc->getFirstDiagram());
+
+    uno::Reference< XTitled > xTitled( lcl_getTitleParent( nTitleIndex, xDiagram ) );
     if( xTitled.is())
         return xTitled->getTitleObject();
     return NULL;
@@ -335,6 +377,28 @@ void TitleHelper::removeTitle( TitleHelper::eTitleType nTitleIndex
 bool TitleHelper::getTitleType( eTitleType& rType
                     , const ::com::sun::star::uno::Reference<
                         ::com::sun::star::chart2::XTitle >& xTitle
+                    , ChartModel& rModel )
+{
+    if( !xTitle.is() )
+        return false;
+
+    Reference< chart2::XTitle > xCurrentTitle;
+    for( sal_Int32 nTitleType = TITLE_BEGIN; nTitleType < NORMAL_TITLE_END; nTitleType++ )
+    {
+        xCurrentTitle = TitleHelper::getTitle( static_cast<eTitleType>(nTitleType), rModel );
+        if( xCurrentTitle == xTitle )
+        {
+            rType = static_cast<eTitleType>(nTitleType);
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool TitleHelper::getTitleType( eTitleType& rType
+                    , const ::com::sun::star::uno::Reference<
+                        ::com::sun::star::chart2::XTitle >& xTitle
                     , const ::com::sun::star::uno::Reference<
                         ::com::sun::star::frame::XModel >& xModel )
 {