chart2/source/model/template/XYDataInterpreter.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "XYDataInterpreter.hxx"
  21 #include "DataSeries.hxx"
  22 #include "macros.hxx"
  23 #include "DataSeriesHelper.hxx"
  24 #include "CommonConverters.hxx"
  25 #include "ContainerHelper.hxx"
  26 #include <com/sun/star/beans/XPropertySet.hpp>
  27 #include <com/sun/star/chart2/data/XDataSink.hpp>
  28 #include <com/sun/star/util/XCloneable.hpp>
  29
  30 using namespace ::com::sun::star;
  31 using namespace ::com::sun::star::chart2;
  32 using namespace ::std;
  33
  34 using ::com::sun::star::uno::Reference;
  35 using ::com::sun::star::uno::Sequence;
  36
  37 namespace chart
  38 {
  39
  40 XYDataInterpreter::XYDataInterpreter(
  41     const uno::Reference< uno::XComponentContext > & xContext ) :
  42         DataInterpreter( xContext )
  43 {
  44 }
  45
  46 XYDataInterpreter::~XYDataInterpreter()
  47 {
  48 }
  49
  50 // ____ XDataInterpreter ____
  51 chart2::InterpretedData SAL_CALL XYDataInterpreter::interpretDataSource(
  52     const Reference< chart2::data::XDataSource >& xSource,
  53     const Sequence< beans::PropertyValue >& aArguments,
  54     const Sequence< Reference< XDataSeries > >& aSeriesToReUse )
  55     throw (uno::RuntimeException, std::exception)
  56 {
  57     if( ! xSource.is())
  58         return InterpretedData();
  59
  60     Sequence< Reference< data::XLabeledDataSequence > > aData( xSource->getDataSequences() );
  61
  62     Reference< data::XLabeledDataSequence > xValuesX;
  63     vector< Reference< data::XLabeledDataSequence > > aSequencesVec;
  64
  65     Reference< data::XLabeledDataSequence > xCategories;
  66     bool bHasCategories = HasCategories( aArguments, aData );
  67     bool bUseCategoriesAsX = UseCategoriesAsX( aArguments );
  68
  69     // parse data
  70     bool bCategoriesUsed = false;
  71     bool bSetXValues = aData.getLength()>1;
  72     for( sal_Int32 nDataIdx= 0; nDataIdx < aData.getLength(); ++nDataIdx )
  73     {
  74         try
  75         {
  76             if( bHasCategories && ! bCategoriesUsed )
  77             {
  78                 xCategories.set( aData[nDataIdx] );
  79                 if( xCategories.is())
  80                 {
  81                     SetRole( xCategories->getValues(), "categories");
  82                     if( bUseCategoriesAsX )
  83                         bSetXValues = false;
  84                 }
  85                 bCategoriesUsed = true;
  86             }
  87             else if( !xValuesX.is() && bSetXValues )
  88             {
  89                 xValuesX.set( aData[nDataIdx] );
  90                 if( xValuesX.is())
  91                     SetRole( xValuesX->getValues(), "values-x");
  92             }
  93             else
  94             {
  95                 aSequencesVec.push_back( aData[nDataIdx] );
  96                 if( aData[nDataIdx].is())
  97                     SetRole( aData[nDataIdx]->getValues(), "values-y");
  98             }
  99         }
 100         catch( const uno::Exception & ex )
 101         {
 102             ASSERT_EXCEPTION( ex );
 103         }
 104     }
 105
 106     // create DataSeries
 107     vector< Reference< data::XLabeledDataSequence > >::const_iterator
 108           aSequencesVecIt = aSequencesVec.begin();
 109
 110     sal_Int32 nSeriesIndex = 0;
 111     vector< Reference< XDataSeries > > aSeriesVec;
 112     aSeriesVec.reserve( aSequencesVec.size());
 113
 114     Reference< data::XLabeledDataSequence > xClonedXValues = xValuesX;
 115     Reference< util::XCloneable > xCloneable( xValuesX, uno::UNO_QUERY );
 116
 117     for( ;aSequencesVecIt != aSequencesVec.end(); ++aSequencesVecIt, ++nSeriesIndex )
 118     {
 119         vector< Reference< data::XLabeledDataSequence > > aNewData;
 120
 121         if( aSequencesVecIt != aSequencesVec.begin() && xCloneable.is() )
 122             xClonedXValues.set( xCloneable->createClone(), uno::UNO_QUERY );
 123         if( xValuesX.is() )
 124             aNewData.push_back( xClonedXValues );
 125
 126         aNewData.push_back( *aSequencesVecIt );
 127
 128         Reference< XDataSeries > xSeries;
 129         if( nSeriesIndex < aSeriesToReUse.getLength())
 130             xSeries.set( aSeriesToReUse[nSeriesIndex] );
 131         else
 132             xSeries.set( new DataSeries( GetComponentContext() ) );
 133         OSL_ASSERT( xSeries.is() );
 134         Reference< data::XDataSink > xSink( xSeries, uno::UNO_QUERY );
 135         OSL_ASSERT( xSink.is() );
 136         xSink->setData( ContainerHelper::ContainerToSequence( aNewData ) );
 137
 138         aSeriesVec.push_back( xSeries );
 139     }
 140
 141     Sequence< Sequence< Reference< XDataSeries > > > aSeries(1);
 142     aSeries[0] = ContainerHelper::ContainerToSequence( aSeriesVec );
 143     return InterpretedData( aSeries, xCategories );
 144 }
 145
 146 chart2::InterpretedData SAL_CALL XYDataInterpreter::reinterpretDataSeries(
 147     const chart2::InterpretedData& aInterpretedData )
 148     throw (uno::RuntimeException, std::exception)
 149 {
 150     InterpretedData aResult( aInterpretedData );
 151
 152     sal_Int32 i=0;
 153     Sequence< Reference< XDataSeries > > aSeries( FlattenSequence( aInterpretedData.Series ));
 154     const sal_Int32 nCount = aSeries.getLength();
 155     for( ; i<nCount; ++i )
 156     {
 157         try
 158         {
 159             Reference< data::XDataSource > xSeriesSource( aSeries[i], uno::UNO_QUERY_THROW );
 160             Sequence< Reference< data::XLabeledDataSequence > > aNewSequences;
 161
 162             // values-y
 163             Reference< data::XLabeledDataSequence > xValuesY(
 164                 DataSeriesHelper::getDataSequenceByRole( xSeriesSource, "values-y", false ));
 165             Reference< data::XLabeledDataSequence > xValuesX(
 166                 DataSeriesHelper::getDataSequenceByRole( xSeriesSource, "values-x", false ));
 167             // re-use values-... as values-x/values-y
 168             if( ! xValuesX.is() ||
 169                 ! xValuesY.is())
 170             {
 171                 vector< Reference< data::XLabeledDataSequence > > aValueSeqVec(
 172                     DataSeriesHelper::getAllDataSequencesByRole(
 173                         xSeriesSource->getDataSequences(), "values", true ));
 174                 if( xValuesX.is())
 175                     aValueSeqVec.erase( find( aValueSeqVec.begin(), aValueSeqVec.end(), xValuesX ));
 176                 if( xValuesY.is())
 177                     aValueSeqVec.erase( find( aValueSeqVec.begin(), aValueSeqVec.end(), xValuesY ));
 178
 179                 size_t nIndex = 0;
 180                 if( ! xValuesY.is() &&
 181                     aValueSeqVec.size() > nIndex )
 182                 {
 183                     xValuesY.set( aValueSeqVec[nIndex++] );
 184                     if( xValuesY.is())
 185                         SetRole( xValuesY->getValues(), "values-y");
 186                 }
 187
 188                 if( ! xValuesX.is() &&
 189                     aValueSeqVec.size() > nIndex )
 190                 {
 191                     xValuesX.set( aValueSeqVec[nIndex++] );
 192                     if( xValuesX.is())
 193                         SetRole( xValuesY->getValues(), "values-x");
 194                 }
 195             }
 196             if( xValuesY.is())
 197             {
 198                 if( xValuesX.is())
 199                 {
 200                     aNewSequences.realloc(2);
 201                     aNewSequences[0] = xValuesX;
 202                     aNewSequences[1] = xValuesY;
 203                 }
 204                 else
 205                 {
 206                     aNewSequences.realloc(1);
 207                     aNewSequences[0] = xValuesY;
 208                 }
 209             }
 210
 211             Sequence< Reference< data::XLabeledDataSequence > > aSeqs( xSeriesSource->getDataSequences());
 212             if( aSeqs.getLength() != aNewSequences.getLength() )
 213             {
 214 #if OSL_DEBUG_LEVEL > 1
 215                 sal_Int32 j=0;
 216                 for( ; j<aSeqs.getLength(); ++j )
 217                 {
 218                     OSL_ENSURE( aSeqs[j] == xValuesY || aSeqs[j] == xValuesX, "All sequences should be used" );
 219                 }
 220 #endif
 221                 Reference< data::XDataSink > xSink( xSeriesSource, uno::UNO_QUERY_THROW );
 222                 xSink->setData( aNewSequences );
 223             }
 224         }
 225         catch( const uno::Exception & ex )
 226         {
 227             ASSERT_EXCEPTION( ex );
 228         }
 229     }
 230
 231     return aResult;
 232 }
 233
 234 // criterion: all series must have exactly two data::XLabeledDataSequences
 235 sal_Bool SAL_CALL XYDataInterpreter::isDataCompatible(
 236     const chart2::InterpretedData& aInterpretedData )
 237     throw (uno::RuntimeException, std::exception)
 238 {
 239     Sequence< Reference< XDataSeries > > aSeries( FlattenSequence( aInterpretedData.Series ));
 240     for( sal_Int32 i=0; i<aSeries.getLength(); ++i )
 241     {
 242         try
 243         {
 244             Reference< data::XDataSource > xSrc( aSeries[i], uno::UNO_QUERY_THROW );
 245             Sequence< Reference< data::XLabeledDataSequence > > aSeq( xSrc->getDataSequences());
 246             if( aSeq.getLength() != 2 )
 247                 return sal_False;
 248         }
 249         catch( const uno::Exception & ex )
 250         {
 251             ASSERT_EXCEPTION( ex );
 252         }
 253     }
 254
 255     return sal_True;
 256 }
 257
 258 } // namespace chart
 259
 260 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */