office-gobmx/chart2/source/tools/ExplicitCategoriesProvider.cxx
Sebastian Spaeth 63bb42ab7d Add vim/emacs modelines to all source files
Fixes #fdo30794
Based on bin/add-modelines script (originally posted in mail
1286706307.1871.1399280959@webmail.messagingengine.com)

Signed-off-by: Sebastian Spaeth <Sebastian@SSpaeth.de>
2010-10-13 10:57:18 +02:00

425 lines
16 KiB
C++

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_chart2.hxx"
#include "ExplicitCategoriesProvider.hxx"
#include "DiagramHelper.hxx"
#include "CommonConverters.hxx"
#include "DataSourceHelper.hxx"
#include "ChartModelHelper.hxx"
#include "ContainerHelper.hxx"
#include "macros.hxx"
//.............................................................................
namespace chart
{
//.............................................................................
using namespace ::com::sun::star;
using namespace ::com::sun::star::chart2;
using ::com::sun::star::uno::Reference;
using ::com::sun::star::uno::Sequence;
using ::rtl::OUString;
using ::std::vector;
ExplicitCategoriesProvider::ExplicitCategoriesProvider( const Reference< chart2::XCoordinateSystem >& xCooSysModel
, const uno::Reference< frame::XModel >& xChartModel )
: m_bDirty(true)
, m_xCooSysModel( xCooSysModel )
, m_xOriginalCategories()
{
try
{
if( xCooSysModel.is() )
{
uno::Reference< XAxis > xAxis( xCooSysModel->getAxisByDimension(0,0) );
if( xAxis.is() )
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() )
{
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();
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;
}
}
}
catch( const uno::Exception & ex )
{
ASSERT_EXCEPTION( ex );
}
}
ExplicitCategoriesProvider::~ExplicitCategoriesProvider()
{
}
const Sequence< Reference< data::XLabeledDataSequence> >& ExplicitCategoriesProvider::getSplitCategoriesList()
{
return m_aSplitCategoriesList;
}
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;
}
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;
}
uno::Sequence< rtl::OUString > lcl_DataToStringSequence( const uno::Reference< data::XDataSequence >& xDataSequence )
{
uno::Sequence< rtl::OUString > aStrings;
OSL_ASSERT( xDataSequence.is());
if( !xDataSequence.is() )
return 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];
}
return aStrings;
}
SplitCategoriesProvider::~SplitCategoriesProvider()
{
}
class SplitCategoriesProvider_ForLabeledDataSequences : public SplitCategoriesProvider
{
public:
explicit SplitCategoriesProvider_ForLabeledDataSequences( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Reference<
::com::sun::star::chart2::data::XLabeledDataSequence> >& rSplitCategoriesList )
: m_rSplitCategoriesList( rSplitCategoriesList )
{}
virtual ~SplitCategoriesProvider_ForLabeledDataSequences()
{}
virtual sal_Int32 getLevelCount() const;
virtual uno::Sequence< rtl::OUString > getStringsForLevel( sal_Int32 nIndex ) const;
private:
const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Reference<
::com::sun::star::chart2::data::XLabeledDataSequence> >& m_rSplitCategoriesList;
};
sal_Int32 SplitCategoriesProvider_ForLabeledDataSequences::getLevelCount() const
{
return m_rSplitCategoriesList.getLength();
}
uno::Sequence< rtl::OUString > SplitCategoriesProvider_ForLabeledDataSequences::getStringsForLevel( sal_Int32 nLevel ) const
{
uno::Sequence< rtl::OUString > aRet;
Reference< data::XLabeledDataSequence > xLabeledDataSequence( m_rSplitCategoriesList[nLevel] );
if( xLabeledDataSequence.is() )
aRet = lcl_DataToStringSequence( xLabeledDataSequence->getValues() );
return aRet;
}
std::vector< ComplexCategory > lcl_DataSequenceToComplexCategoryVector(
const uno::Sequence< rtl::OUString >& rStrings
, const std::vector<sal_Int32>& rLimitingBorders, bool bCreateSingleCategories )
{
std::vector< ComplexCategory > aResult;
sal_Int32 nMaxCount = rStrings.getLength();
OUString aPrevious;
sal_Int32 nCurrentCount=0;
for( sal_Int32 nN=0; nN<nMaxCount; nN++ )
{
OUString aCurrent = rStrings[nN];
if( bCreateSingleCategories || ::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 )
{
aResult.push_back( ComplexCategory(aPrevious,nCurrentCount) );
nCurrentCount=1;
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;
}
Sequence< OUString > lcl_getExplicitSimpleCategories(
const SplitCategoriesProvider& rSplitCategoriesProvider,
::std::vector< ::std::vector< ComplexCategory > >& rComplexCats )
{
Sequence< OUString > aRet;
rComplexCats.clear();
sal_Int32 nLCount = rSplitCategoriesProvider.getLevelCount();
for( sal_Int32 nL = 0; nL < nLCount; nL++ )
{
std::vector<sal_Int32> aLimitingBorders;
if(nL>0)
aLimitingBorders = lcl_getLimitingBorders( rComplexCats.back() );
rComplexCats.push_back( lcl_DataSequenceToComplexCategoryVector(
rSplitCategoriesProvider.getStringsForLevel(nL), aLimitingBorders, nL==(nLCount-1) ) );
}
std::vector< std::vector< ComplexCategory > >::iterator aOuterIt( rComplexCats.begin() );
std::vector< std::vector< ComplexCategory > >::const_iterator aOuterEnd( rComplexCats.end() );
//ensure that the category count is the same on each level
sal_Int32 nMaxCategoryCount = 0;
{
for( aOuterIt=rComplexCats.begin(); aOuterIt != aOuterEnd; ++aOuterIt )
{
sal_Int32 nCurrentCount = lcl_getCategoryCount( *aOuterIt );
nMaxCategoryCount = std::max( nCurrentCount, nMaxCategoryCount );
}
for( aOuterIt=rComplexCats.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=rComplexCats.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)
{
aRet.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;
}
}
aRet[nN]=aText;
}
}
return aRet;
}
//static
Sequence< OUString > ExplicitCategoriesProvider::getExplicitSimpleCategories(
const SplitCategoriesProvider& rSplitCategoriesProvider )
{
vector< vector< ComplexCategory > > aComplexCats;
return lcl_getExplicitSimpleCategories( rSplitCategoriesProvider, aComplexCats );
}
void ExplicitCategoriesProvider::init()
{
if( m_bDirty )
{
m_aExplicitCategories.realloc(0);
m_aComplexCats.clear();//not one per index
if( m_xOriginalCategories.is() )
{
if( !hasComplexCategories() )
m_aExplicitCategories = DataSequenceToStringSequence(m_xOriginalCategories->getValues());
else
m_aExplicitCategories = lcl_getExplicitSimpleCategories(
SplitCategoriesProvider_ForLabeledDataSequences( m_aSplitCategoriesList ), m_aComplexCats );
}
if(!m_aExplicitCategories.getLength())
m_aExplicitCategories = DiagramHelper::generateAutomaticCategoriesFromCooSys( m_xCooSysModel );
m_bDirty = false;
}
}
Sequence< ::rtl::OUString > ExplicitCategoriesProvider::getSimpleCategories()
{
init();
return m_aExplicitCategories;
}
std::vector< ComplexCategory > ExplicitCategoriesProvider::getCategoriesByLevel( sal_Int32 nLevel )
{
std::vector< ComplexCategory > aRet;
init();
sal_Int32 nMaxIndex = m_aComplexCats.size()-1;
if( nLevel >= 0 && nLevel <= nMaxIndex )
aRet = m_aComplexCats[nMaxIndex-nLevel];
return aRet;
}
// static
OUString ExplicitCategoriesProvider::getCategoryByIndex(
const Reference< XCoordinateSystem >& xCooSysModel
, const uno::Reference< frame::XModel >& xChartModel
, sal_Int32 nIndex )
{
if( xCooSysModel.is())
{
ExplicitCategoriesProvider aExplicitCategoriesProvider( xCooSysModel, xChartModel );
Sequence< OUString > aCategories( aExplicitCategoriesProvider.getSimpleCategories());
if( nIndex < aCategories.getLength())
return aCategories[ nIndex ];
}
return OUString();
}
//.............................................................................
} //namespace chart
//.............................................................................
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */