| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_chartmodel.hxx" | |
| #include "DataInterpreter.hxx" | |
| #include "DataSeries.hxx" | |
| #include "DataSourceHelper.hxx" | |
| #include "DataSeriesHelper.hxx" | |
| #include "macros.hxx" | |
| #include "CommonConverters.hxx" | |
| #include "ContainerHelper.hxx" | |
| #include <com/sun/star/beans/XPropertySet.hpp> | |
| #include <com/sun/star/chart2/data/XDataSink.hpp> | |
| #include <vector> | |
| #include <algorithm> | |
| #include <iterator> | |
| using namespace ::com::sun::star; | |
| using namespace ::com::sun::star::chart2; | |
| using namespace ::std; | |
| using namespace ::chart::ContainerHelper; | |
| using ::com::sun::star::uno::Reference; | |
| using ::com::sun::star::uno::Sequence; | |
| using ::rtl::OUString; | |
| #if OSL_DEBUG_LEVEL > 1 | |
| namespace | |
| { | |
| void lcl_ShowDataSource( const Reference< data::XDataSource > & xSource ); | |
| } | |
| #endif | |
| namespace chart | |
| { | |
| DataInterpreter::DataInterpreter( | |
| const Reference< uno::XComponentContext > & xContext ) : | |
| m_xContext( xContext ) | |
| {} | |
| DataInterpreter::~DataInterpreter() | |
| {} | |
| Reference< uno::XComponentContext > DataInterpreter::GetComponentContext() const | |
| { | |
| return m_xContext; | |
| } | |
| // ____ XDataInterpreter ____ | |
| InterpretedData SAL_CALL DataInterpreter::interpretDataSource( | |
| const Reference< data::XDataSource >& xSource, | |
| const Sequence< beans::PropertyValue >& aArguments, | |
| const Sequence< Reference< XDataSeries > >& aSeriesToReUse ) | |
| { | |
| if( ! xSource.is()) | |
| return InterpretedData(); | |
| #if OSL_DEBUG_LEVEL > 2 | |
| lcl_ShowDataSource( xSource ); | |
| #endif | |
| Sequence< Reference< data::XLabeledDataSequence > > aData( xSource->getDataSequences() ); | |
| Reference< data::XLabeledDataSequence > xCategories; | |
| vector< Reference< data::XLabeledDataSequence > > aSequencesVec; | |
| // check if we should use categories | |
| bool bHasCategories( HasCategories( aArguments, aData )); | |
| // parse data | |
| bool bCategoriesUsed = false; | |
| for( sal_Int32 i=0; i < aData.getLength(); ++i ) | |
| { | |
| try | |
| { | |
| if( bHasCategories && ! bCategoriesUsed ) | |
| { | |
| xCategories.set( aData[i] ); | |
| if( xCategories.is()) | |
| SetRole( xCategories->getValues(), C2U("categories")); | |
| bCategoriesUsed = true; | |
| } | |
| else | |
| { | |
| aSequencesVec.push_back( aData[i] ); | |
| if( aData[i].is()) | |
| SetRole( aData[i]->getValues(), C2U("values-y")); | |
| } | |
| } | |
| catch( uno::Exception & ex ) | |
| { | |
| ASSERT_EXCEPTION( ex ); | |
| } | |
| } | |
| // create DataSeries | |
| vector< Reference< data::XLabeledDataSequence > >::const_iterator | |
| aSequencesVecIt = aSequencesVec.begin(); | |
| sal_Int32 nSeriesIndex = 0; | |
| vector< Reference< XDataSeries > > aSeriesVec; | |
| aSeriesVec.reserve( aSequencesVec.size()); | |
| for( ;aSequencesVecIt != aSequencesVec.end(); ++aSequencesVecIt, ++nSeriesIndex ) | |
| { | |
| Sequence< Reference< data::XLabeledDataSequence > > aNewData( & (*aSequencesVecIt), 1 ); | |
| Reference< XDataSeries > xSeries; | |
| if( nSeriesIndex < aSeriesToReUse.getLength()) | |
| xSeries.set( aSeriesToReUse[nSeriesIndex] ); | |
| else | |
| xSeries.set( new DataSeries( GetComponentContext() )); | |
| OSL_ASSERT( xSeries.is() ); | |
| Reference< data::XDataSink > xSink( xSeries, uno::UNO_QUERY ); | |
| OSL_ASSERT( xSink.is() ); | |
| xSink->setData( aNewData ); | |
| aSeriesVec.push_back( xSeries ); | |
| } | |
| Sequence< Sequence< Reference< XDataSeries > > > aSeries(1); | |
| aSeries[0] = ContainerToSequence( aSeriesVec ); | |
| return InterpretedData( aSeries, xCategories ); | |
| } | |
| InterpretedData SAL_CALL DataInterpreter::reinterpretDataSeries( | |
| const InterpretedData& aInterpretedData ) | |
| { | |
| InterpretedData aResult( aInterpretedData ); | |
| sal_Int32 i=0; | |
| Sequence< Reference< XDataSeries > > aSeries( FlattenSequence( aInterpretedData.Series )); | |
| const sal_Int32 nCount = aSeries.getLength(); | |
| for( ; i<nCount; ++i ) | |
| { | |
| try | |
| { | |
| Reference< data::XDataSource > xSeriesSource( aSeries[i], uno::UNO_QUERY_THROW ); | |
| Sequence< Reference< data::XLabeledDataSequence > > aNewSequences; | |
| // values-y | |
| Reference< data::XLabeledDataSequence > xValuesY( | |
| DataSeriesHelper::getDataSequenceByRole( xSeriesSource, C2U("values-y"), false )); | |
| // re-use values-... as values-y | |
| if( ! xValuesY.is()) | |
| { | |
| xValuesY.set( | |
| DataSeriesHelper::getDataSequenceByRole( xSeriesSource, C2U("values"), true )); | |
| if( xValuesY.is()) | |
| SetRole( xValuesY->getValues(), C2U("values-y")); | |
| } | |
| if( xValuesY.is()) | |
| { | |
| aNewSequences.realloc(1); | |
| aNewSequences[0] = xValuesY; | |
| } | |
| Sequence< Reference< data::XLabeledDataSequence > > aSeqs( xSeriesSource->getDataSequences()); | |
| if( aSeqs.getLength() != aNewSequences.getLength() ) | |
| { | |
| #if OSL_DEBUG_LEVEL > 1 | |
| sal_Int32 j=0; | |
| for( ; j<aSeqs.getLength(); ++j ) | |
| { | |
| OSL_ENSURE( aSeqs[j] == xValuesY, "All sequences should be used" ); | |
| } | |
| #endif | |
| Reference< data::XDataSink > xSink( xSeriesSource, uno::UNO_QUERY_THROW ); | |
| xSink->setData( aNewSequences ); | |
| } | |
| } | |
| catch( uno::Exception & ex ) | |
| { | |
| ASSERT_EXCEPTION( ex ); | |
| } | |
| } | |
| return aResult; | |
| } | |
| // criterion: all series must have exactly one data::XLabeledDataSequence | |
| sal_Bool SAL_CALL DataInterpreter::isDataCompatible( | |
| const chart2::InterpretedData& aInterpretedData ) | |
| { | |
| Sequence< Reference< XDataSeries > > aSeries( FlattenSequence( aInterpretedData.Series )); | |
| for( sal_Int32 i=0; i<aSeries.getLength(); ++i ) | |
| { | |
| try | |
| { | |
| Reference< data::XDataSource > xSrc( aSeries[i], uno::UNO_QUERY_THROW ); | |
| Sequence< Reference< data::XLabeledDataSequence > > aSeq( xSrc->getDataSequences()); | |
| if( aSeq.getLength() != 1 ) | |
| return sal_False; | |
| } | |
| catch( uno::Exception & ex ) | |
| { | |
| ASSERT_EXCEPTION( ex ); | |
| } | |
| } | |
| return sal_True; | |
| } | |
| namespace | |
| { | |
| struct lcl_LabeledSequenceEquals : public unary_function< Reference< data::XLabeledDataSequence >, bool > | |
| { | |
| lcl_LabeledSequenceEquals( const Reference< data::XLabeledDataSequence > & xLSeqToCmp ) : | |
| m_bHasLabels ( false ), | |
| m_bHasValues ( false ) | |
| { | |
| if( xLSeqToCmp.is()) | |
| { | |
| Reference< data::XDataSequence > xSeq( xLSeqToCmp->getValues()); | |
| if( xSeq.is()) | |
| { | |
| m_bHasValues = true; | |
| m_aValuesRangeRep = xSeq->getSourceRangeRepresentation(); | |
| } | |
| xSeq.set( xLSeqToCmp->getLabel()); | |
| if( xSeq.is()) | |
| { | |
| m_bHasLabels = true; | |
| m_aLabelRangeRep = xSeq->getSourceRangeRepresentation(); | |
| } | |
| } | |
| } | |
| bool operator() ( const Reference< data::XLabeledDataSequence > & xSeq ) | |
| { | |
| if( ! xSeq.is()) | |
| return false; | |
| Reference< data::XDataSequence > xSeqValues( xSeq->getValues() ); | |
| Reference< data::XDataSequence > xSeqLabels( xSeq->getLabel() ); | |
| bool bHasValues = xSeqValues.is(); | |
| bool bHasLabels = xSeqLabels.is(); | |
| return ( ( (m_bHasValues == bHasValues) && | |
| (!bHasValues || m_aValuesRangeRep.equals( xSeqValues->getSourceRangeRepresentation())) ) && | |
| ( (m_bHasLabels == bHasLabels) && | |
| (!bHasLabels || m_aLabelRangeRep.equals( xSeqLabels->getSourceRangeRepresentation())) ) | |
| ); | |
| } | |
| private: | |
| bool m_bHasLabels; | |
| bool m_bHasValues; | |
| OUString m_aValuesRangeRep; | |
| OUString m_aLabelRangeRep; | |
| }; | |
| } // anonymous namespace | |
| Reference< data::XDataSource > SAL_CALL DataInterpreter::mergeInterpretedData( | |
| const InterpretedData& aInterpretedData ) | |
| { | |
| vector< Reference< data::XLabeledDataSequence > > aResultVec; | |
| aResultVec.reserve( aInterpretedData.Series.getLength() + | |
| 1 // categories | |
| ); | |
| if( aInterpretedData.Categories.is()) | |
| aResultVec.push_back( aInterpretedData.Categories ); | |
| Sequence< Reference< XDataSeries > > aSeries( FlattenSequence( aInterpretedData.Series )); | |
| for( sal_Int32 nSeriesIdx=0; nSeriesIdx<aSeries.getLength(); ++nSeriesIdx ) | |
| { | |
| try | |
| { | |
| Reference< data::XDataSource > xSrc( aSeries[nSeriesIdx], uno::UNO_QUERY_THROW ); | |
| Sequence< Reference< data::XLabeledDataSequence > > aSeq( xSrc->getDataSequences()); | |
| // add all sequences of data series | |
| for( sal_Int32 nSeqIdx=0; nSeqIdx<aSeq.getLength(); ++nSeqIdx ) | |
| { | |
| Reference< data::XLabeledDataSequence > xAdd( aSeq[nSeqIdx] ); | |
| // only add if sequence is not yet in the result | |
| if( find_if( aResultVec.begin(), aResultVec.end(), | |
| lcl_LabeledSequenceEquals( xAdd )) == aResultVec.end()) | |
| { | |
| aResultVec.push_back( xAdd ); | |
| } | |
| } | |
| } | |
| catch( uno::Exception & ex ) | |
| { | |
| ASSERT_EXCEPTION( ex ); | |
| } | |
| } | |
| return Reference< data::XDataSource >( DataSourceHelper::createDataSource( ContainerToSequence( aResultVec ) ) ); | |
| } | |
| // convenience methods | |
| OUString DataInterpreter::GetRole( const Reference< data::XDataSequence > & xSeq ) | |
| { | |
| OUString aResult; | |
| if( ! xSeq.is()) | |
| return aResult; | |
| try | |
| { | |
| Reference< beans::XPropertySet > xProp( xSeq, uno::UNO_QUERY_THROW ); | |
| xProp->getPropertyValue( C2U("Role")) >>= aResult; | |
| } | |
| catch( uno::Exception & ex ) | |
| { | |
| ASSERT_EXCEPTION( ex ); | |
| } | |
| return aResult; | |
| } | |
| void DataInterpreter::SetRole( const Reference< data::XDataSequence > & xSeq, const OUString & rRole ) | |
| { | |
| if( ! xSeq.is()) | |
| return; | |
| try | |
| { | |
| Reference< beans::XPropertySet > xProp( xSeq, uno::UNO_QUERY_THROW ); | |
| xProp->setPropertyValue( C2U("Role"), uno::makeAny( rRole )); | |
| } | |
| catch( uno::Exception & ex ) | |
| { | |
| ASSERT_EXCEPTION( ex ); | |
| } | |
| } | |
| uno::Any DataInterpreter::GetProperty( | |
| const Sequence< beans::PropertyValue > & aArguments, | |
| const OUString & rName ) | |
| { | |
| for( sal_Int32 i=aArguments.getLength(); i--; ) | |
| { | |
| if( aArguments[i].Name.equals( rName )) | |
| return aArguments[i].Value; | |
| } | |
| return uno::Any(); | |
| } | |
| bool DataInterpreter::HasCategories( | |
| const Sequence< beans::PropertyValue > & rArguments, | |
| const Sequence< Reference< data::XLabeledDataSequence > > & rData ) | |
| { | |
| bool bHasCategories = false; | |
| if( rArguments.getLength() > 0 ) | |
| GetProperty( rArguments, C2U(("HasCategories"))) >>= bHasCategories; | |
| for( sal_Int32 nLSeqIdx=0; ! bHasCategories && nLSeqIdx<rData.getLength(); ++nLSeqIdx ) | |
| bHasCategories = ( rData[nLSeqIdx].is() && | |
| GetRole( rData[nLSeqIdx]->getValues()).equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("categories"))); | |
| return bHasCategories; | |
| } | |
| bool DataInterpreter::UseCategoriesAsX( const Sequence< beans::PropertyValue > & rArguments ) | |
| { | |
| bool bUseCategoriesAsX = true; | |
| if( rArguments.getLength() > 0 ) | |
| GetProperty( rArguments, C2U(("UseCategoriesAsX"))) >>= bUseCategoriesAsX; | |
| return bUseCategoriesAsX; | |
| } | |
| // ------------------------------------------------------------ | |
| Sequence< OUString > DataInterpreter::getSupportedServiceNames_Static() | |
| { | |
| Sequence< OUString > aServices( 1 ); | |
| aServices[0] = C2U( "com.sun.star.chart2.DataInterpreter" ); | |
| return aServices; | |
| } | |
| // implement XServiceInfo methods basing upon getSupportedServiceNames_Static | |
| APPHELPER_XSERVICEINFO_IMPL( DataInterpreter, C2U("com.sun.star.comp.chart2.DataInterpreter")); | |
| } // namespace chart | |
| #if OSL_DEBUG_LEVEL > 1 | |
| namespace | |
| { | |
| void lcl_ShowDataSource( const Reference< data::XDataSource > & xSource ) | |
| { | |
| if( ! xSource.is()) | |
| return; | |
| OSL_TRACE( "DataSource in DataInterpreter:" ); | |
| Sequence< Reference< data::XLabeledDataSequence > > aSequences( xSource->getDataSequences()); | |
| Reference< beans::XPropertySet > xProp; | |
| OUString aId; | |
| const sal_Int32 nMax = aSequences.getLength(); | |
| for( sal_Int32 k = 0; k < nMax; ++k ) | |
| { | |
| if( aSequences[k].is()) | |
| { | |
| OUString aSourceRepr(C2U("<none>")); | |
| if( aSequences[k]->getValues().is()) | |
| aSourceRepr = aSequences[k]->getValues()->getSourceRangeRepresentation(); | |
| xProp.set( aSequences[k]->getValues(), uno::UNO_QUERY ); | |
| if( xProp.is() && | |
| ( xProp->getPropertyValue( C2U( "Role" )) >>= aId )) | |
| { | |
| OSL_TRACE( " <data sequence %d> Role: %s, Source: %s", k, U2C( aId ), U2C( aSourceRepr )); | |
| } | |
| else | |
| { | |
| OSL_TRACE( " <data sequence %d> unknown Role, Source: %s", k, U2C( aSourceRepr ) ); | |
| } | |
| aSourceRepr = C2U("<none>"); | |
| if( aSequences[k]->getLabel().is()) | |
| aSourceRepr = OUString( aSequences[k]->getLabel()->getSourceRangeRepresentation()); | |
| xProp.set( aSequences[k]->getLabel(), uno::UNO_QUERY ); | |
| if( xProp.is() && | |
| ( xProp->getPropertyValue( C2U( "Role" )) >>= aId )) | |
| { | |
| OSL_TRACE( " <data sequence label %d> Role: %s, Source: %s", k, U2C( aId ), U2C( aSourceRepr )); | |
| } | |
| else | |
| { | |
| OSL_TRACE( " <data sequence label %d> unknown Role, Source: %s", k, U2C( aSourceRepr ) ); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| #endif |