chartmultiline: #i97893# import categories from multiple lines (fixed), #i82971# display complex categories hierarchically (part1)

19 files changed, 388 insertions, 95 deletions

diff --git a/chart2/source/controller/chartapiwrapper/ChartDataWrapper.cxx b/chart2/source/controller/chartapiwrapper/ChartDataWrapper.cxx
index 8cbb0c5af80c..201bc7aa3a3f 100644
--- a/chart2/source/controller/chartapiwrapper/ChartDataWrapper.cxx
+++ b/chart2/source/controller/chartapiwrapper/ChartDataWrapper.cxx
@@ -493,7 +493,7 @@ void ChartDataWrapper::refreshData()
         // categories
         uno::Sequence< ::rtl::OUString > & rSequence =
                 bUseColumns ? m_aRowDescriptions : m_aColumnDescriptions;
-        rSequence = DiagramHelper::generateAutomaticCategories( xChartDoc );
+        rSequence = DiagramHelper::getExplicitSimpleCategories( xChartDoc );
     }
 }
 
diff --git a/chart2/source/controller/dialogs/ObjectNameProvider.cxx b/chart2/source/controller/dialogs/ObjectNameProvider.cxx
index 24b717adba7f..0b21b891e38e 100644
--- a/chart2/source/controller/dialogs/ObjectNameProvider.cxx
+++ b/chart2/source/controller/dialogs/ObjectNameProvider.cxx
@@ -200,7 +200,7 @@ OUString lcl_getDataPointValueText( const Reference< XDataSeries >& xSeries, sal
 
         replaceParamterInString( aCategory
             , C2U("%CATEGORYVALUE")
-            , ExplicitCategoriesProvider::getCategoryByIndex( xCooSys, nPointIndex )
+            , ExplicitCategoriesProvider::getCategoryByIndex( xCooSys, xChartModel, nPointIndex )
             );
 
         aRet = aCategory;
diff --git a/chart2/source/controller/dialogs/dlg_ObjectProperties.cxx b/chart2/source/controller/dialogs/dlg_ObjectProperties.cxx
index 097c6c1d0107..a7688b1b2505 100644
--- a/chart2/source/controller/dialogs/dlg_ObjectProperties.cxx
+++ b/chart2/source/controller/dialogs/dlg_ObjectProperties.cxx
@@ -207,7 +207,7 @@ void ObjectPropertiesDialogParameter::init( const uno::Reference< frame::XModel
                     ScaleData aScale( xCrossingMainAxis->getScaleData() );
                     m_bIsCrossingAxisIsCategoryAxis = ( chart2::AxisType::CATEGORY == aScale.AxisType  );
                     if( m_bIsCrossingAxisIsCategoryAxis )
-                        m_aCategories = DiagramHelper::generateAutomaticCategories( Reference< chart2::XChartDocument >( xChartModel, uno::UNO_QUERY) );
+                        m_aCategories = DiagramHelper::getExplicitSimpleCategories( Reference< chart2::XChartDocument >( xChartModel, uno::UNO_QUERY) );
                 }
             }
         }
diff --git a/chart2/source/inc/ChartModelHelper.hxx b/chart2/source/inc/ChartModelHelper.hxx
index fa80d00413f7..2ba8bb0fab25 100644
--- a/chart2/source/inc/ChartModelHelper.hxx
+++ b/chart2/source/inc/ChartModelHelper.hxx
@@ -79,6 +79,10 @@ public:
             ::com::sun::star::chart2::XDiagram >
         findDiagram( const ::com::sun::star::uno::Reference< ::com::sun::star::chart2::XChartDocument >& xChartDoc );
 
+    static ::com::sun::star::uno::Reference<
+            ::com::sun::star::chart2::XCoordinateSystem >
+        getFirstCoordinateSystem( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XModel >& xModel );
+
     SAL_DLLPRIVATE static ::std::vector< ::com::sun::star::uno::Reference<
         ::com::sun::star::chart2::XDataSeries > > getDataSeries(
             const ::com::sun::star::uno::Reference<
diff --git a/chart2/source/inc/DataSourceHelper.hxx b/chart2/source/inc/DataSourceHelper.hxx
index 0e3ef93cb3fb..245179293a62 100644
--- a/chart2/source/inc/DataSourceHelper.hxx
+++ b/chart2/source/inc/DataSourceHelper.hxx
@@ -152,6 +152,10 @@ public:
             const ::com::sun::star::uno::Reference<
                 ::com::sun::star::chart2::data::XLabeledDataSequence > & xLSeq );
 
+        SAL_DLLPRIVATE static ::rtl::OUString getRangeFromValues(
+            const ::com::sun::star::uno::Reference<
+                ::com::sun::star::chart2::data::XLabeledDataSequence > & xLSeq );
+
         SAL_DLLPRIVATE static ::com::sun::star::uno::Sequence< ::rtl::OUString > getRangesFromDataSource(
             const ::com::sun::star::uno::Reference<
                 ::com::sun::star::chart2::data::XDataSource > & xSource );
diff --git a/chart2/source/inc/DiagramHelper.hxx b/chart2/source/inc/DiagramHelper.hxx
index 119d206a2937..c5d3eb92cfcd 100644
--- a/chart2/source/inc/DiagramHelper.hxx
+++ b/chart2/source/inc/DiagramHelper.hxx
@@ -226,19 +226,15 @@ public:
                 ::com::sun::star::chart2::XDiagram > & xDiagram );
 
     static ::com::sun::star::uno::Sequence< rtl::OUString >
-        generateAutomaticCategories(
+        getExplicitSimpleCategories(
             const ::com::sun::star::uno::Reference<
                 ::com::sun::star::chart2::XChartDocument > & xChartDoc );
 
     SAL_DLLPRIVATE static ::com::sun::star::uno::Sequence< rtl::OUString >
-        generateAutomaticCategories(
+        generateAutomaticCategoriesFromCooSys(
             const ::com::sun::star::uno::Reference<
                 ::com::sun::star::chart2::XCoordinateSystem > & xCooSys );
 
-    SAL_DLLPRIVATE static void generateAutomaticCategoriesFromChartType(
-            ::com::sun::star::uno::Sequence< rtl::OUString >& rRet,
-            const ::com::sun::star::uno::Reference< ::com::sun::star::chart2::XChartType >& xChartType );
-
     static ::com::sun::star::uno::Reference<
             ::com::sun::star::chart2::XChartType >
         getChartTypeByIndex( const ::com::sun::star::uno::Reference<
diff --git a/chart2/source/inc/ExplicitCategoriesProvider.hxx b/chart2/source/inc/ExplicitCategoriesProvider.hxx
index a6d8926d36ac..965013b2bb6c 100644
--- a/chart2/source/inc/ExplicitCategoriesProvider.hxx
+++ b/chart2/source/inc/ExplicitCategoriesProvider.hxx
@@ -41,14 +41,14 @@
 namespace chart
 {
 
-class OOO_DLLPUBLIC_CHARTTOOLS ExplicitCategoriesProvider :
-        public ::cppu::WeakImplHelper1<
-        ::com::sun::star::chart2::data::XTextualDataSequence
-        >
+class OOO_DLLPUBLIC_CHARTTOOLS ExplicitCategoriesProvider
 {
 public:
     ExplicitCategoriesProvider( const ::com::sun::star::uno::Reference<
-                       ::com::sun::star::chart2::XCoordinateSystem >& xCooSysModel );
+                        ::com::sun::star::chart2::XCoordinateSystem >& xCooSysModel
+                       , const ::com::sun::star::uno::Reference<
+                        ::com::sun::star::frame::XModel >& xChartModel
+                       );
     SAL_DLLPRIVATE virtual ~ExplicitCategoriesProvider();
 
     //XTextualDataSequence
@@ -56,9 +56,14 @@ public:
         throw (::com::sun::star::uno::RuntimeException);
 
     static ::rtl::OUString getCategoryByIndex(
-        const ::com::sun::star::uno::Reference<
-            ::com::sun::star::chart2::XCoordinateSystem >& xCooSysModel,
-        sal_Int32 nIndex );
+          const ::com::sun::star::uno::Reference<
+            ::com::sun::star::chart2::XCoordinateSystem >& xCooSysModel
+        , const ::com::sun::star::uno::Reference<
+            ::com::sun::star::frame::XModel >& xChartModel
+        , sal_Int32 nIndex );
+
+    bool hasComplexCategories() const;
+    sal_Int32 getCategoryLevelCount() const;
 
 private: //member
     ::com::sun::star::uno::Sequence< ::rtl::OUString > m_aExplicitCategories;
@@ -67,7 +72,9 @@ private: //member
     ::com::sun::star::uno::WeakReference<
         ::com::sun::star::chart2::XCoordinateSystem > m_xCooSysModel;
     ::com::sun::star::uno::Reference<
-        ::com::sun::star::chart2::data::XLabeledDataSequence> m_xCategories;
+        ::com::sun::star::chart2::data::XLabeledDataSequence> m_xOriginalCategories;
+    ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Reference<
+        ::com::sun::star::chart2::data::XLabeledDataSequence> > m_aSplitCategoriesList;
 };
 
 } //  namespace chart
diff --git a/chart2/source/tools/ChartModelHelper.cxx b/chart2/source/tools/ChartModelHelper.cxx
index 2d6ce7cbfd9d..d994b335e4ef 100644
--- a/chart2/source/tools/ChartModelHelper.cxx
+++ b/chart2/source/tools/ChartModelHelper.cxx
@@ -115,6 +115,20 @@ uno::Reference< XDiagram > ChartModelHelper::findDiagram( const uno::Reference<
     return NULL;
 }
 
+//static
+uno::Reference< XCoordinateSystem > ChartModelHelper::getFirstCoordinateSystem( const uno::Reference< frame::XModel >& xModel )
+{
+    uno::Reference< XCoordinateSystem > XCooSys;
+    uno::Reference< XCoordinateSystemContainer > xCooSysCnt( ChartModelHelper::findDiagram( xModel ), uno::UNO_QUERY );
+    if( xCooSysCnt.is() )
+    {
+        uno::Sequence< uno::Reference< XCoordinateSystem > > aCooSysSeq( xCooSysCnt->getCoordinateSystems() );
+        if( aCooSysSeq.getLength() )
+            XCooSys = aCooSysSeq[0];
+    }
+    return XCooSys;
+}
+
 // static
 ::std::vector< uno::Reference< XDataSeries > > ChartModelHelper::getDataSeries(
     const uno::Reference< XChartDocument > & xChartDoc )
diff --git a/chart2/source/tools/DataSourceHelper.cxx b/chart2/source/tools/DataSourceHelper.cxx
index 13765f60ed20..2b71e814037a 100644
--- a/chart2/source/tools/DataSourceHelper.cxx
+++ b/chart2/source/tools/DataSourceHelper.cxx
@@ -517,6 +517,19 @@ Sequence< OUString > DataSourceHelper::getRangesFromLabeledDataSequence(
     return aResult;
 }
 
+OUString DataSourceHelper::getRangeFromValues(
+    const Reference< data::XLabeledDataSequence > & xLSeq )
+{
+    OUString aResult;
+    if( xLSeq.is() )
+    {
+        Reference< data::XDataSequence > xValues( xLSeq->getValues() );
+        if( xValues.is() )
+            aResult = xValues->getSourceRangeRepresentation();
+    }
+    return aResult;
+}
+
 Sequence< OUString > DataSourceHelper::getRangesFromDataSource( const Reference< data::XDataSource > & xSource )
 {
     ::std::vector< OUString > aResult;
diff --git a/chart2/source/tools/DiagramHelper.cxx b/chart2/source/tools/DiagramHelper.cxx
index 448145351790..552c2b5304b5 100644
--- a/chart2/source/tools/DiagramHelper.cxx
+++ b/chart2/source/tools/DiagramHelper.cxx
@@ -38,7 +38,9 @@
 #include "AxisHelper.hxx"
 #include "ContainerHelper.hxx"
 #include "ChartTypeHelper.hxx"
+#include "ChartModelHelper.hxx"
 #include "CommonConverters.hxx"
+#include "ExplicitCategoriesProvider.hxx"
 #include "servicenames_charttypes.hxx"
 
 #include <com/sun/star/chart/MissingValueTreatment.hpp>
@@ -958,8 +960,7 @@ Reference< data::XLabeledDataSequence >
     return xResult;
 }
 
-//static
-void DiagramHelper::generateAutomaticCategoriesFromChartType(
+void lcl_generateAutomaticCategoriesFromChartType(
             Sequence< rtl::OUString >& rRet,
             const Reference< XChartType >& xChartType )
 {
@@ -989,52 +990,42 @@ void DiagramHelper::generateAutomaticCategoriesFromChartType(
     }
 }
 
-//static
-Sequence< rtl::OUString > DiagramHelper::generateAutomaticCategories(
-            const Reference< XChartDocument >& xChartDoc )
+Sequence< rtl::OUString > DiagramHelper::generateAutomaticCategoriesFromCooSys( const Reference< XCoordinateSystem > & xCooSys )
 {
     Sequence< rtl::OUString > aRet;
-    if(xChartDoc.is())
+
+    Reference< XChartTypeContainer > xTypeCntr( xCooSys, uno::UNO_QUERY );
+    if( xTypeCntr.is() )
     {
-        uno::Reference< chart2::XDiagram > xDia( xChartDoc->getFirstDiagram() );
-        if(xDia.is())
+        Sequence< Reference< XChartType > > aChartTypes( xTypeCntr->getChartTypes() );
+        for( sal_Int32 nN=0; nN<aChartTypes.getLength(); nN++ )
         {
-            Reference< data::XLabeledDataSequence > xCategories( DiagramHelper::getCategoriesFromDiagram( xDia ) );
-            if( xCategories.is() )
-                aRet = DataSequenceToStringSequence(xCategories->getValues());
-            if( !aRet.getLength() )
-            {
-                if( !aRet.getLength() )
-                {
-                    Reference< XCoordinateSystemContainer > xCooSysCnt( xDia, uno::UNO_QUERY );
-                    if( xCooSysCnt.is() )
-                    {
-                        Sequence< Reference< XCoordinateSystem > > aCooSysSeq( xCooSysCnt->getCoordinateSystems() );
-                        if( aCooSysSeq.getLength() )
-                            aRet = DiagramHelper::generateAutomaticCategories( aCooSysSeq[0] );
-                    }
-                }
-            }
+            lcl_generateAutomaticCategoriesFromChartType( aRet, aChartTypes[nN] );
+            if( aRet.getLength() )
+                return aRet;
         }
     }
     return aRet;
 }
 
 //static
-Sequence< rtl::OUString > DiagramHelper::generateAutomaticCategories(
-            const Reference< XCoordinateSystem > & xCooSys )
+Sequence< rtl::OUString > DiagramHelper::getExplicitSimpleCategories(
+            const Reference< XChartDocument >& xChartDoc )
 {
     Sequence< rtl::OUString > aRet;
-
-    Reference< XChartTypeContainer > xTypeCntr( xCooSys, uno::UNO_QUERY );
-    if( xTypeCntr.is() )
+    uno::Reference< frame::XModel > xChartModel( xChartDoc, uno::UNO_QUERY );
+    if(xChartModel.is())
     {
-        Sequence< Reference< XChartType > > aChartTypes( xTypeCntr->getChartTypes() );
-        for( sal_Int32 nN=0; nN<aChartTypes.getLength(); nN++ )
+        uno::Reference< chart2::XDiagram > xDia( xChartDoc->getFirstDiagram() );
+        uno::Reference< chart2::XCoordinateSystem > xCooSys( ChartModelHelper::getFirstCoordinateSystem( xChartModel ) );
+        if(xDia.is())
         {
-            DiagramHelper::generateAutomaticCategoriesFromChartType( aRet, aChartTypes[nN] );
-            if( aRet.getLength() )
-                return aRet;
+            Reference< data::XLabeledDataSequence > xCategories( DiagramHelper::getCategoriesFromDiagram( xDia ) );
+            if( xCategories.is() )
+            {
+                ExplicitCategoriesProvider aExplicitCategoriesProvider( xCooSys, xChartModel );
+                aRet = aExplicitCategoriesProvider.getTextualData();
+            }
         }
     }
     return aRet;
diff --git a/chart2/source/tools/ExplicitCategoriesProvider.cxx b/chart2/source/tools/ExplicitCategoriesProvider.cxx
index 0bf6e8bd9e2d..64137a20ebb2 100644
--- a/chart2/source/tools/ExplicitCategoriesProvider.cxx
+++ b/chart2/source/tools/ExplicitCategoriesProvider.cxx
@@ -34,6 +34,10 @@
 #include "ExplicitCategoriesProvider.hxx"
 #include "DiagramHelper.hxx"
 #include "CommonConverters.hxx"
+#include "DataSourceHelper.hxx"
+#include "ChartModelHelper.hxx"
+#include "ContainerHelper.hxx"
+#include "macros.hxx"
 
 //.............................................................................
 namespace chart
@@ -46,16 +50,78 @@ using ::com::sun::star::uno::Reference;
 using ::com::sun::star::uno::Sequence;
 using rtl::OUString;
 
-ExplicitCategoriesProvider::ExplicitCategoriesProvider( const Reference< chart2::XCoordinateSystem >& xCooSysModel )
+ExplicitCategoriesProvider::ExplicitCategoriesProvider( const Reference< chart2::XCoordinateSystem >& xCooSysModel
+                                                       , const uno::Reference< frame::XModel >& xChartModel )
     : m_bDirty(true)
     , m_xCooSysModel( xCooSysModel )
-    , m_xCategories()
+    , m_xOriginalCategories()
 {
     if( xCooSysModel.is() )
     {
         uno::Reference< XAxis > xAxis( xCooSysModel->getAxisByDimension(0,0) );
         if( xAxis.is() )
-            m_xCategories = xAxis->getScaleData().Categories;
+            m_xOriginalCategories = xAxis->getScaleData().Categories;
+    }
+
+    if( m_xOriginalCategories.is() )
+    {
+        Reference< chart2::XChartDocument > xChartDoc( xChartModel, uno::UNO_QUERY );
+        if( xChartDoc.is() )
+        {
+            uno::Reference< data::XDataProvider > xDataProvider( xChartDoc->getDataProvider() );
+
+            if( xDataProvider.is() && !xChartDoc->hasInternalDataProvider() )
+            {
+                OUString aCatgoriesRange( DataSourceHelper::getRangeFromValues( m_xOriginalCategories ) );
+                const bool bFirstCellAsLabel = false;
+                const bool bHasCategories = false;
+                const uno::Sequence< sal_Int32 > aSequenceMapping;
+
+                uno::Reference< data::XDataSource > xColumnCategoriesSource( xDataProvider->createDataSource(
+                     DataSourceHelper::createArguments( aCatgoriesRange, aSequenceMapping, true /*bUseColumns*/
+                        , bFirstCellAsLabel, bHasCategories ) ) );
+
+                uno::Reference< data::XDataSource > xRowCategoriesSource( xDataProvider->createDataSource(
+                     DataSourceHelper::createArguments( aCatgoriesRange, aSequenceMapping, false /*bUseColumns*/
+                        , bFirstCellAsLabel, bHasCategories ) ) );
+
+                if( xColumnCategoriesSource.is() &&  xRowCategoriesSource.is() )
+                {
+                    Sequence< Reference< data::XLabeledDataSequence> > aColumns = xColumnCategoriesSource->getDataSequences();
+                    Sequence< Reference< data::XLabeledDataSequence> > aRows = xRowCategoriesSource->getDataSequences();
+                        //m_aSplitCategoriesList;
+
+                    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( xChartModel ) );
+                        if( !aSeries.empty() )
+                        {
+                            uno::Reference< data::XDataSource > xSeriesSource( aSeries.front(), uno::UNO_QUERY );
+                            ::rtl::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;
+                    }
+                }
+            }
+        }
+        if( !m_aSplitCategoriesList.getLength() )
+        {
+            m_aSplitCategoriesList.realloc(1);
+            m_aSplitCategoriesList[0]=m_xOriginalCategories;
+        }
     }
 }
 
@@ -63,15 +129,203 @@ ExplicitCategoriesProvider::~ExplicitCategoriesProvider()
 {
 }
 
+bool ExplicitCategoriesProvider::hasComplexCategories() const
+{
+    return m_aSplitCategoriesList.getLength() > 1;
+}
+
+sal_Int32 ExplicitCategoriesProvider::getCategoryLevelCount() const
+{
+    sal_Int32 nCount = m_aSplitCategoriesList.getLength();
+    if(!nCount)
+        nCount = 1;
+    return nCount;
+}
+
+struct ComplexCategory
+{
+    OUString Text;
+    sal_Int32 Count;
+
+    ComplexCategory( const OUString& rText, sal_Int32 nCount ) : Text( rText ), Count (nCount)
+    {}
+};
+
+std::vector<sal_Int32> lcl_getLimitingBorders( const std::vector< ComplexCategory >& rComplexCategories )
+{
+    std::vector<sal_Int32> aLimitingBorders;
+    std::vector< ComplexCategory >::const_iterator aIt( rComplexCategories.begin() );
+    std::vector< ComplexCategory >::const_iterator aEnd( rComplexCategories.end() );
+    sal_Int32 nBorderIndex = 0; /*border below the index*/
+    for( ; aIt != aEnd; ++aIt )
+    {
+        ComplexCategory aComplexCategory(*aIt);
+        nBorderIndex += aComplexCategory.Count;
+        aLimitingBorders.push_back(nBorderIndex);
+    }
+    return aLimitingBorders;
+}
+
+std::vector< ComplexCategory > lcl_DataSequenceToComplexCategoryVector(
+    const uno::Reference< data::XDataSequence >& xDataSequence
+    , const std::vector<sal_Int32>& rLimitingBorders )
+{
+    std::vector< ComplexCategory > aResult;
+    OSL_ASSERT( xDataSequence.is());
+    if(!xDataSequence.is())
+        return aResult;
+
+    uno::Sequence< rtl::OUString > aStrings;
+    uno::Reference< data::XTextualDataSequence > xTextualDataSequence( xDataSequence, uno::UNO_QUERY );
+    if( xTextualDataSequence.is() )
+    {
+        aStrings = xTextualDataSequence->getTextualData();
+    }
+    else
+    {
+        uno::Sequence< uno::Any > aValues = xDataSequence->getData();
+        aStrings.realloc(aValues.getLength());
+
+        for(sal_Int32 nN=aValues.getLength();nN--;)
+            aValues[nN] >>= aStrings[nN];
+    }
+    sal_Int32 nMaxCount = aStrings.getLength();
+    OUString aPrevious;
+    sal_Int32 nCurrentCount=0;
+    for( sal_Int32 nN=0; nN<nMaxCount; nN++ )
+    {
+        OUString aCurrent = aStrings[nN];
+        if( ::std::find( rLimitingBorders.begin(), rLimitingBorders.end(), nN ) != rLimitingBorders.end() )
+        {
+            aResult.push_back( ComplexCategory(aPrevious,nCurrentCount) );
+            nCurrentCount=1;
+            aPrevious = aCurrent;
+        }
+        else
+        {
+            if( aCurrent.getLength() && aPrevious != aCurrent )
+            {
+                if( aPrevious.getLength() )
+                {
+                    aResult.push_back( ComplexCategory(aPrevious,nCurrentCount) );
+                    nCurrentCount=1;
+                }
+                else
+                    nCurrentCount++;
+                aPrevious = aCurrent;
+            }
+            else
+                nCurrentCount++;
+        }
+    }
+    if( nCurrentCount )
+        aResult.push_back( ComplexCategory(aPrevious,nCurrentCount) );
+
+    return aResult;
+}
+
+sal_Int32 lcl_getCategoryCount( std::vector< ComplexCategory >& rComplexCategories )
+{
+    sal_Int32 nCount = 0;
+    std::vector< ComplexCategory >::iterator aIt( rComplexCategories.begin() );
+    std::vector< ComplexCategory >::const_iterator aEnd( rComplexCategories.end() );
+    for( ; aIt != aEnd; ++aIt )
+        nCount+=aIt->Count;
+    return nCount;
+}
+
 //XTextualDataSequence
 Sequence< ::rtl::OUString > SAL_CALL ExplicitCategoriesProvider::getTextualData() throw( uno::RuntimeException)
 {
     if( m_bDirty )
     {
-        if( m_xCategories.is() )
-            m_aExplicitCategories = DataSequenceToStringSequence(m_xCategories->getValues());
+        if( m_xOriginalCategories.is() )
+        {
+            if( !hasComplexCategories() )
+                m_aExplicitCategories = DataSequenceToStringSequence(m_xOriginalCategories->getValues());
+            else
+            {
+                std::vector< std::vector< ComplexCategory > > aComplexCats;//not one per index
+
+                //std::vector< std::vector< rtl::OUString > > aCats;
+                sal_Int32 nLCount = m_aSplitCategoriesList.getLength();
+                for( sal_Int32 nL = 0; nL < nLCount; nL++ )
+                {
+                    Reference< data::XLabeledDataSequence > xLabeledDataSequence( m_aSplitCategoriesList[nL] );
+                    if(xLabeledDataSequence.is())
+                    {
+                        std::vector<sal_Int32> aLimitingBorders;
+                        if(nL>0)
+                            aLimitingBorders = lcl_getLimitingBorders( aComplexCats.back() );
+                        aComplexCats.push_back( lcl_DataSequenceToComplexCategoryVector( xLabeledDataSequence->getValues(), aLimitingBorders ) );
+                        //aCats.push_back( ContainerHelper::SequenceToVector( DataSequenceToStringSequence(xLabeledDataSequence->getValues() ) ) );
+                    }
+                }
+
+                std::vector< std::vector< ComplexCategory > >::iterator aOuterIt( aComplexCats.begin() );
+                std::vector< std::vector< ComplexCategory > >::const_iterator aOuterEnd( aComplexCats.end() );
+
+                //ensure that the category count is the same on each level
+                sal_Int32 nMaxCategoryCount = 0;
+                {
+                    for( aOuterIt=aComplexCats.begin(); aOuterIt != aOuterEnd; ++aOuterIt )
+                    {
+                        sal_Int32 nCurrentCount = lcl_getCategoryCount( *aOuterIt );
+                        nMaxCategoryCount = std::max( nCurrentCount, nMaxCategoryCount );
+                    }
+                    for( aOuterIt=aComplexCats.begin(); aOuterIt != aOuterEnd; ++aOuterIt )
+                    {
+                        sal_Int32 nCurrentCount = lcl_getCategoryCount( *aOuterIt );
+                        if( nCurrentCount< nMaxCategoryCount )
+                        {
+                            ComplexCategory& rComplexCategory = aOuterIt->back();
+                            rComplexCategory.Count += (nMaxCategoryCount-nCurrentCount);
+                        }
+                    }
+                }
+
+                //create a list with an element for every index
+                std::vector< std::vector< ComplexCategory > > aComplexCatsPerIndex;
+                for( aOuterIt=aComplexCats.begin() ; aOuterIt != aOuterEnd; ++aOuterIt )
+                {
+                    std::vector< ComplexCategory > aSingleLevel;
+                    std::vector< ComplexCategory >::iterator aIt( aOuterIt->begin() );
+                    std::vector< ComplexCategory >::const_iterator aEnd( aOuterIt->end() );
+                    for( ; aIt != aEnd; ++aIt )
+                    {
+                        ComplexCategory aComplexCategory( *aIt );
+                        sal_Int32 nCount = aComplexCategory.Count;
+                        while( nCount-- )
+                            aSingleLevel.push_back(aComplexCategory);
+                    }
+                    aComplexCatsPerIndex.push_back( aSingleLevel );
+                }
+
+                if(nMaxCategoryCount)
+                {
+                    m_aExplicitCategories.realloc(nMaxCategoryCount);
+                    aOuterEnd = aComplexCatsPerIndex.end();
+                    OUString aSpace(C2U(" "));
+                    for(sal_Int32 nN=0; nN<nMaxCategoryCount; nN++)
+                    {
+                        OUString aText;
+                        for( aOuterIt=aComplexCatsPerIndex.begin() ; aOuterIt != aOuterEnd; ++aOuterIt )
+                        {
+                            OUString aAddText = (*aOuterIt)[nN].Text;
+                            if( aAddText.getLength() )
+                            {
+                                if(aText.getLength())
+                                    aText += aSpace;
+                                aText += aAddText;
+                            }
+                        }
+                        m_aExplicitCategories[nN]=aText;
+                    }
+                }
+            }
+        }
         if(!m_aExplicitCategories.getLength())
-            m_aExplicitCategories = DiagramHelper::generateAutomaticCategories( uno::Reference< chart2::XCoordinateSystem >( m_xCooSysModel.get(), uno::UNO_QUERY ) );
+            m_aExplicitCategories = DiagramHelper::generateAutomaticCategoriesFromCooSys( m_xCooSysModel );
         m_bDirty = false;
     }
     return m_aExplicitCategories;
@@ -79,18 +333,16 @@ Sequence< ::rtl::OUString > SAL_CALL ExplicitCategoriesProvider::getTextualData(
 
 // static
 OUString ExplicitCategoriesProvider::getCategoryByIndex(
-        const Reference< XCoordinateSystem >& xCooSysModel,
-        sal_Int32 nIndex )
+          const Reference< XCoordinateSystem >& xCooSysModel
+        , const uno::Reference< frame::XModel >& xChartModel
+        , sal_Int32 nIndex )
 {
     if( xCooSysModel.is())
     {
-        Reference< XTextualDataSequence > xTemp( new ExplicitCategoriesProvider( xCooSysModel ));
-        if( xTemp.is())
-        {
-            Sequence< OUString > aCategories( xTemp->getTextualData());
-            if( nIndex < aCategories.getLength())
-                return aCategories[ nIndex ];
-        }
+        ExplicitCategoriesProvider aExplicitCategoriesProvider( xCooSysModel, xChartModel );
+        Sequence< OUString > aCategories( aExplicitCategoriesProvider.getTextualData());
+        if( nIndex < aCategories.getLength())
+            return aCategories[ nIndex ];
     }
     return OUString();
 }
diff --git a/chart2/source/view/axes/VAxisBase.cxx b/chart2/source/view/axes/VAxisBase.cxx
index da2f01523a97..be24262e8801 100644
--- a/chart2/source/view/axes/VAxisBase.cxx
+++ b/chart2/source/view/axes/VAxisBase.cxx
@@ -82,20 +82,26 @@ void SAL_CALL VAxisBase::initAxisLabelProperties( const ::com::sun::star::awt::S
     if( !m_aAxisProperties.m_bDisplayLabels )
         return;
 
-    if( AxisType::CATEGORY==m_aAxisProperties.m_nAxisType
-        || AxisType::SERIES==m_aAxisProperties.m_nAxisType )
+    if( AxisType::SERIES==m_aAxisProperties.m_nAxisType )
     {
         if( m_aAxisProperties.m_xAxisTextProvider.is() )
             m_aTextLabels = m_aAxisProperties.m_xAxisTextProvider->getTextualData();
 
         m_bUseTextLabels = true;
-        if( m_aTextLabels.getLength() == 1 && AxisType::SERIES==m_aAxisProperties.m_nAxisType )
+        if( m_aTextLabels.getLength() == 1 )
         {
             //don't show a single series name
             m_aAxisProperties.m_bDisplayLabels = false;
             return;
         }
     }
+    else if( AxisType::CATEGORY==m_aAxisProperties.m_nAxisType )
+    {
+        if( m_aAxisProperties.m_pExplicitCategoriesProvider )
+            m_aTextLabels = m_aAxisProperties.m_pExplicitCategoriesProvider->getTextualData();
+
+        m_bUseTextLabels = true;
+    }
 
     m_aAxisLabelProperties.nNumberFormatKey = m_aAxisProperties.m_nNumberFormatKey;
     m_aAxisLabelProperties.init(m_aAxisProperties.m_xAxisModel);
diff --git a/chart2/source/view/axes/VAxisProperties.cxx b/chart2/source/view/axes/VAxisProperties.cxx
index 27ca8d2188e3..eea2b2eb47f2 100644
--- a/chart2/source/view/axes/VAxisProperties.cxx
+++ b/chart2/source/view/axes/VAxisProperties.cxx
@@ -161,7 +161,7 @@ TickmarkProperties AxisProperties::getBiggestTickmarkProperties()
 //--------------------------------------------------------------------------
 
 AxisProperties::AxisProperties( const uno::Reference< XAxis >& xAxisModel
-                              , const uno::Reference< data::XTextualDataSequence >& xAxisTextProvider )
+                              , ExplicitCategoriesProvider* pExplicitCategoriesProvider )
     : m_xAxisModel(xAxisModel)
     , m_nDimensionIndex(0)
     , m_bIsMainAxis(true)
@@ -186,7 +186,8 @@ AxisProperties::AxisProperties( const uno::Reference< XAxis >& xAxisModel
     , m_aLineProperties()
     //for category axes
     , m_nAxisType(AxisType::REALNUMBER)
-    , m_xAxisTextProvider(xAxisTextProvider)
+    , m_pExplicitCategoriesProvider(pExplicitCategoriesProvider)
+    , m_xAxisTextProvider(0)
     , m_bTickmarksAtIndicatedValue(false)
 {
 }
@@ -216,6 +217,7 @@ AxisProperties::AxisProperties( const AxisProperties& rAxisProperties )
     , m_aLineProperties( rAxisProperties.m_aLineProperties )
     //for category axes
     , m_nAxisType( rAxisProperties.m_nAxisType )
+    , m_pExplicitCategoriesProvider( rAxisProperties.m_pExplicitCategoriesProvider )
     , m_xAxisTextProvider( rAxisProperties.m_xAxisTextProvider )
     , m_bTickmarksAtIndicatedValue( rAxisProperties.m_bTickmarksAtIndicatedValue )
 {
diff --git a/chart2/source/view/axes/VAxisProperties.hxx b/chart2/source/view/axes/VAxisProperties.hxx
index 61f2477c7681..56ef075bfdb2 100644
--- a/chart2/source/view/axes/VAxisProperties.hxx
+++ b/chart2/source/view/axes/VAxisProperties.hxx
@@ -33,6 +33,7 @@
 #include "TickmarkProperties.hxx"
 #include "PlottingPositionHelper.hxx"
 #include "LabelAlignment.hxx"
+#include "ExplicitCategoriesProvider.hxx"
 
 #include <com/sun/star/chart/ChartAxisLabelPosition.hpp>
 #include <com/sun/star/chart/ChartAxisMarkPosition.hpp>
@@ -137,6 +138,7 @@ struct AxisProperties
 
     //for category axes ->
     sal_Int32                                        m_nAxisType;//REALNUMBER, CATEGORY etc. type ::com::sun::star::chart2::AxisType
+    ExplicitCategoriesProvider* m_pExplicitCategoriesProvider;/*no ownership here*/
     ::com::sun::star::uno::Reference<
         ::com::sun::star::chart2::data::XTextualDataSequence >
                                                     m_xAxisTextProvider; //for categries or series names
@@ -147,8 +149,7 @@ struct AxisProperties
     //methods:
 
     AxisProperties( const ::com::sun::star::uno::Reference< ::com::sun::star::chart2::XAxis >& xAxisModel
-                  , const ::com::sun::star::uno::Reference<
-                        ::com::sun::star::chart2::data::XTextualDataSequence >& xAxisTextProvider );
+                  , ExplicitCategoriesProvider* pExplicitCategoriesProvider );
     AxisProperties( const AxisProperties& rAxisProperties );
     virtual ~AxisProperties();
     virtual void init(bool bCartesian=false);//init from model data (m_xAxisModel)
diff --git a/chart2/source/view/axes/VCoordinateSystem.cxx b/chart2/source/view/axes/VCoordinateSystem.cxx
index 47cc6de405f7..af8cfc228ee7 100644
--- a/chart2/source/view/axes/VCoordinateSystem.cxx
+++ b/chart2/source/view/axes/VCoordinateSystem.cxx
@@ -97,7 +97,7 @@ VCoordinateSystem::VCoordinateSystem( const Reference< XCoordinateSystem >& xCoo
     , m_aMergedMinimumAndMaximumSupplier()
     , m_aExplicitScales(3)
     , m_aExplicitIncrements(3)
-    , m_aExplicitCategoriesProvider( new ExplicitCategoriesProvider( m_xCooSysModel ) )
+    , m_apExplicitCategoriesProvider(NULL)
 {
     if( !m_xCooSysModel.is() || m_xCooSysModel->getDimension()<3 )
     {
@@ -264,10 +264,14 @@ void VCoordinateSystem::impl_adjustDimensionAndIndex( sal_Int32& rDimensionIndex
         rAxisIndex = 0;
 }
 
+void VCoordinateSystem::setExplicitCategoriesProvider( ExplicitCategoriesProvider* pExplicitCategoriesProvider /*takes ownership*/ )
+{
+    m_apExplicitCategoriesProvider = ::std::auto_ptr< ExplicitCategoriesProvider >(pExplicitCategoriesProvider);
+}
 
-Reference< data::XTextualDataSequence > VCoordinateSystem::getExplicitCategoriesProvider()
+ExplicitCategoriesProvider* VCoordinateSystem::getExplicitCategoriesProvider()
 {
-    return m_aExplicitCategoriesProvider.getRef();
+    return m_apExplicitCategoriesProvider.get();
 }
 
 Sequence< ExplicitScaleData > VCoordinateSystem::getExplicitScales( sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex ) const
diff --git a/chart2/source/view/charttypes/VSeriesPlotter.cxx b/chart2/source/view/charttypes/VSeriesPlotter.cxx
index c8f473d226d0..f1f9d0ce8ce6 100644
--- a/chart2/source/view/charttypes/VSeriesPlotter.cxx
+++ b/chart2/source/view/charttypes/VSeriesPlotter.cxx
@@ -159,7 +159,7 @@ VSeriesPlotter::VSeriesPlotter( const uno::Reference<XChartType>& xChartTypeMode
         , m_aZSlots()
         , m_bCategoryXAxis(bCategoryXAxis)
         , m_xColorScheme()
-        , m_xExplicitCategoriesProvider()
+        , m_pExplicitCategoriesProvider(0)
         , m_bPointsWereSkipped(false)
 {
     DBG_ASSERT(m_xChartTypeModel.is(),"no XChartType available in view, fallback to default values may be wrong");
@@ -480,9 +480,9 @@ uno::Reference< drawing::XShape > VSeriesPlotter::createDataLabel( const uno::Re
         {
             if(pLabel->ShowCategoryName)
             {
-                if( m_xExplicitCategoriesProvider.is() )
+                if( m_pExplicitCategoriesProvider )
                 {
-                    Sequence< OUString > aCategories( m_xExplicitCategoriesProvider->getTextualData() );
+                    Sequence< OUString > aCategories( m_pExplicitCategoriesProvider->getTextualData() );
                     if( nPointIndex >= 0 && nPointIndex < aCategories.getLength() )
                     {
                         aText.append( aCategories[nPointIndex] );
@@ -1356,9 +1356,9 @@ void VSeriesPlotter::setColorScheme( const uno::Reference< XColorScheme >& xColo
     m_xColorScheme = xColorScheme;
 }
 
-void VSeriesPlotter::setExplicitCategoriesProvider( const uno::Reference< data::XTextualDataSequence >& xExplicitCategoriesProvider )
+void VSeriesPlotter::setExplicitCategoriesProvider( ExplicitCategoriesProvider* pExplicitCategoriesProvider )
 {
-    m_xExplicitCategoriesProvider = xExplicitCategoriesProvider;
+    m_pExplicitCategoriesProvider = pExplicitCategoriesProvider;
 }
 
 sal_Int32 VDataSeriesGroup::getPointCount() const
@@ -1929,8 +1929,8 @@ std::vector< ViewLegendEntry > SAL_CALL VSeriesPlotter::createLegendEntriesForSe
         if( bVaryColorsByPoint )
         {
             Sequence< OUString > aCategoryNames;
-            if( m_xExplicitCategoriesProvider.is() )
-                aCategoryNames = m_xExplicitCategoriesProvider->getTextualData();
+            if( m_pExplicitCategoriesProvider )
+                aCategoryNames = m_pExplicitCategoriesProvider->getTextualData();
 
             for( sal_Int32 nIdx=0; nIdx<aCategoryNames.getLength(); ++nIdx )
             {
diff --git a/chart2/source/view/inc/VCoordinateSystem.hxx b/chart2/source/view/inc/VCoordinateSystem.hxx
index 111b1cb02f99..1cb1fb6f9732 100644
--- a/chart2/source/view/inc/VCoordinateSystem.hxx
+++ b/chart2/source/view/inc/VCoordinateSystem.hxx
@@ -33,11 +33,11 @@
 #include "MinimumAndMaximumSupplier.hxx"
 #include "ScaleAutomatism.hxx"
 #include "ThreeDHelper.hxx"
+#include "ExplicitCategoriesProvider.hxx"
 
 #include <com/sun/star/chart2/ExplicitIncrementData.hpp>
 #include <com/sun/star/chart2/ExplicitScaleData.hpp>
 #include <com/sun/star/chart2/XCoordinateSystem.hpp>
-#include <com/sun/star/chart2/data/XTextualDataSequence.hpp>
 #include "comphelper/implementationreference.hxx"
 #include <com/sun/star/awt/Rectangle.hpp>
 #include <com/sun/star/drawing/HomogenMatrix.hpp>
@@ -54,8 +54,6 @@ namespace chart
 {
 //.............................................................................
 
-class ExplicitCategoriesProvider;
-
 //-----------------------------------------------------------------------------
 /**
 */
@@ -90,7 +88,9 @@ public:
 
     ::com::sun::star::chart2::ExplicitScaleData getExplicitScale( sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex ) const;
     ::com::sun::star::chart2::ExplicitIncrementData getExplicitIncrement( sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex ) const;
-    ::com::sun::star::uno::Reference< ::com::sun::star::chart2::data::XTextualDataSequence > getExplicitCategoriesProvider();
+
+    void setExplicitCategoriesProvider( ExplicitCategoriesProvider* /*takes ownership*/ );
+    ExplicitCategoriesProvider* getExplicitCategoriesProvider();
 
     // returns a coplete scale set for a given dimension and index; for example if nDimensionIndex==1 and nAxisIndex==2 you get returned the secondary x axis, main y axis and main z axis
     ::com::sun::star::uno::Sequence< ::com::sun::star::chart2::ExplicitScaleData > getExplicitScales( sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex ) const;
@@ -206,8 +206,7 @@ private:
     tFullExplicitScaleMap       m_aSecondaryExplicitScales;
     tFullExplicitIncrementMap   m_aSecondaryExplicitIncrements;
 
-    comphelper::ImplementationReference< ExplicitCategoriesProvider, ::com::sun::star::chart2::data::XTextualDataSequence >
-                                m_aExplicitCategoriesProvider;
+    ::std::auto_ptr< ExplicitCategoriesProvider > m_apExplicitCategoriesProvider;
 };
 
 //.............................................................................
diff --git a/chart2/source/view/inc/VSeriesPlotter.hxx b/chart2/source/view/inc/VSeriesPlotter.hxx
index e94ef6c68687..10a2c6e9dfa2 100644
--- a/chart2/source/view/inc/VSeriesPlotter.hxx
+++ b/chart2/source/view/inc/VSeriesPlotter.hxx
@@ -35,9 +35,9 @@
 #include "LabelAlignment.hxx"
 #include "MinimumAndMaximumSupplier.hxx"
 #include "LegendEntryProvider.hxx"
+#include "ExplicitCategoriesProvider.hxx"
 #include <com/sun/star/chart2/LegendSymbolStyle.hpp>
 #include <com/sun/star/chart2/XChartType.hpp>
-#include <com/sun/star/chart2/data/XTextualDataSequence.hpp>
 #include <com/sun/star/drawing/Direction3D.hpp>
 
 
@@ -278,8 +278,7 @@ public:
     void setColorScheme( const ::com::sun::star::uno::Reference<
                         ::com::sun::star::chart2::XColorScheme >& xColorScheme );
 
-    void setExplicitCategoriesProvider( const ::com::sun::star::uno::Reference<
-                        ::com::sun::star::chart2::data::XTextualDataSequence >& xExplicitCategoriesProvider );
+    void setExplicitCategoriesProvider( ExplicitCategoriesProvider* pExplicitCategoriesProvider );
 
     //get series names for the z axis labels
     ::com::sun::star::uno::Sequence< rtl::OUString > getSeriesNames() const;
@@ -434,8 +433,7 @@ protected: //member
     ::com::sun::star::uno::Reference<
             ::com::sun::star::chart2::XColorScheme >    m_xColorScheme;
 
-    ::com::sun::star::uno::Reference<
-            ::com::sun::star::chart2::data::XTextualDataSequence >    m_xExplicitCategoriesProvider;
+    ExplicitCategoriesProvider*    m_pExplicitCategoriesProvider;
 
     //better performance for big data
     ::com::sun::star::uno::Sequence< sal_Int32 >    m_aCoordinateSystemResolution;
diff --git a/chart2/source/view/main/ChartView.cxx b/chart2/source/view/main/ChartView.cxx
index dfd57f9bce92..8da5c2772493 100644
--- a/chart2/source/view/main/ChartView.cxx
+++ b/chart2/source/view/main/ChartView.cxx
@@ -425,6 +425,8 @@ VCoordinateSystem* addCooSysToList( std::vector< VCoordinateSystem* >& rVCooSysL
             rtl::OUString aCooSysParticle( ObjectIdentifier::createParticleForCoordinateSystem( xCooSys, xChartModel ) );
             pVCooSys->setParticle(aCooSysParticle);
 
+            pVCooSys->setExplicitCategoriesProvider( new ExplicitCategoriesProvider(xCooSys,xChartModel) );
+
             rVCooSysList.push_back( pVCooSys );
         }
     }