chart2/source/model/template/XYDataInterpreter.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: XYDataInterpreter.cxx,v $
  10  * $Revision: 1.3 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_chart2.hxx"
  33
  34 #include "XYDataInterpreter.hxx"
  35 #include "DataSeries.hxx"
  36 #include "macros.hxx"
  37 #include "DataSeriesHelper.hxx"
  38 #include "CommonConverters.hxx"
  39 #include "ContainerHelper.hxx"
  40 #include <com/sun/star/beans/XPropertySet.hpp>
  41 #include <com/sun/star/chart2/data/XDataSink.hpp>
  42 #include <com/sun/star/util/XCloneable.hpp>
  43
  44 using namespace ::com::sun::star;
  45 using namespace ::com::sun::star::chart2;
  46 using namespace ::std;
  47
  48 using ::com::sun::star::uno::Reference;
  49 using ::com::sun::star::uno::Sequence;
  50 using ::rtl::OUString;
  51
  52 namespace chart
  53 {
  54
  55 XYDataInterpreter::XYDataInterpreter(
  56     const uno::Reference< uno::XComponentContext > & xContext ) :
  57         DataInterpreter( xContext )
  58 {
  59 }
  60
  61 XYDataInterpreter::~XYDataInterpreter()
  62 {
  63 }
  64
  65 // ____ XDataInterpreter ____
  66 chart2::InterpretedData SAL_CALL XYDataInterpreter::interpretDataSource(
  67     const Reference< chart2::data::XDataSource >& xSource,
  68     const Sequence< beans::PropertyValue >& aArguments,
  69     const Sequence< Reference< XDataSeries > >& aSeriesToReUse )
  70     throw (uno::RuntimeException)
  71 {
  72     if( ! xSource.is())
  73         return InterpretedData();
  74
  75     Sequence< Reference< data::XLabeledDataSequence > > aData( xSource->getDataSequences() );
  76
  77     Reference< data::XLabeledDataSequence > xValuesX;
  78     vector< Reference< data::XLabeledDataSequence > > aSequencesVec;
  79
  80     Reference< data::XLabeledDataSequence > xCategories;
  81     // check for categories. If true, the the categories bet parked in the axis scale, but not used via setting the Axistype to Not CATEGORY
  82     bool bHasCategories = HasCategories( aArguments, aData );
  83
  84     // parse data
  85     Sequence< Reference< data::XLabeledDataSequence > > aUnusedData;
  86
  87     bool bCategoriesUsed = false;
  88     for( sal_Int32 nDataIdx= 0; nDataIdx < aData.getLength(); ++nDataIdx )
  89     {
  90         try
  91         {
  92             if( bHasCategories && ! bCategoriesUsed )
  93             {
  94                 xCategories.set( aData[nDataIdx] );
  95                 if( xCategories.is())
  96                     SetRole( xCategories->getValues(), C2U("categories"));
  97                 bCategoriesUsed = true;
  98             }
  99             else if( !xValuesX.is() && (aData.getLength()>(bCategoriesUsed?2:1)) )
 100             {
 101                 xValuesX.set( aData[nDataIdx] );
 102                 if( xValuesX.is())
 103                     SetRole( xValuesX->getValues(), C2U("values-x"));
 104             }
 105             else
 106             {
 107                 aSequencesVec.push_back( aData[nDataIdx] );
 108                 if( aData[nDataIdx].is())
 109                     SetRole( aData[nDataIdx]->getValues(), C2U("values-y"));
 110             }
 111         }
 112         catch( uno::Exception & ex )
 113         {
 114             ASSERT_EXCEPTION( ex );
 115         }
 116     }
 117
 118     // create DataSeries
 119     vector< Reference< data::XLabeledDataSequence > >::const_iterator
 120           aSequencesVecIt = aSequencesVec.begin();
 121
 122     sal_Int32 nSeriesIndex = 0;
 123     vector< Reference< XDataSeries > > aSeriesVec;
 124     aSeriesVec.reserve( aSequencesVec.size());
 125
 126     Reference< data::XLabeledDataSequence > xClonedXValues = xValuesX;
 127     Reference< util::XCloneable > xCloneable( xValuesX, uno::UNO_QUERY );
 128
 129     for( ;aSequencesVecIt != aSequencesVec.end(); ++aSequencesVecIt, ++nSeriesIndex )
 130     {
 131         Sequence< Reference< data::XLabeledDataSequence > > aNewData(xValuesX.is()?2:1);
 132         if( aSequencesVecIt != aSequencesVec.begin() &&
 133             xCloneable.is() )
 134         {
 135             xClonedXValues.set( xCloneable->createClone(), uno::UNO_QUERY );
 136         }
 137
 138         if( xValuesX.is() )
 139         {
 140             aNewData[0] = xClonedXValues;
 141             aNewData[1] = (*aSequencesVecIt);
 142         }
 143         else
 144         {
 145             aNewData[0] = (*aSequencesVecIt);
 146         }
 147
 148         Reference< XDataSeries > xSeries;
 149         if( nSeriesIndex < aSeriesToReUse.getLength())
 150             xSeries.set( aSeriesToReUse[nSeriesIndex] );
 151         else
 152             xSeries.set( new DataSeries( GetComponentContext() ) );
 153         OSL_ASSERT( xSeries.is() );
 154         Reference< data::XDataSink > xSink( xSeries, uno::UNO_QUERY );
 155         OSL_ASSERT( xSink.is() );
 156         xSink->setData( aNewData );
 157
 158         aSeriesVec.push_back( xSeries );
 159     }
 160
 161     Sequence< Sequence< Reference< XDataSeries > > > aSeries(1);
 162     aSeries[0] = ContainerHelper::ContainerToSequence( aSeriesVec );
 163     return InterpretedData( aSeries, xCategories, aUnusedData );
 164 }
 165
 166 chart2::InterpretedData SAL_CALL XYDataInterpreter::reinterpretDataSeries(
 167     const chart2::InterpretedData& aInterpretedData )
 168     throw (uno::RuntimeException)
 169 {
 170     InterpretedData aResult( aInterpretedData );
 171     vector< Reference< data::XLabeledDataSequence > > aUnused(
 172         ContainerHelper::SequenceToVector( aInterpretedData.UnusedData ));
 173
 174     sal_Int32 i=0;
 175     Sequence< Reference< XDataSeries > > aSeries( FlattenSequence( aInterpretedData.Series ));
 176     const sal_Int32 nCount = aSeries.getLength();
 177     for( ; i<nCount; ++i )
 178     {
 179         try
 180         {
 181             Reference< data::XDataSource > xSeriesSource( aSeries[i], uno::UNO_QUERY_THROW );
 182             Sequence< Reference< data::XLabeledDataSequence > > aNewSequences;
 183
 184             // values-y
 185             Reference< data::XLabeledDataSequence > xValuesY(
 186                 DataSeriesHelper::getDataSequenceByRole( xSeriesSource, C2U("values-y"), false ));
 187             Reference< data::XLabeledDataSequence > xValuesX(
 188                 DataSeriesHelper::getDataSequenceByRole( xSeriesSource, C2U("values-x"), false ));
 189             // re-use values-... as values-x/values-y
 190             if( ! xValuesX.is() ||
 191                 ! xValuesY.is())
 192             {
 193                 vector< Reference< data::XLabeledDataSequence > > aValueSeqVec(
 194                     DataSeriesHelper::getAllDataSequencesByRole(
 195                         xSeriesSource->getDataSequences(), C2U("values"), true ));
 196                 if( xValuesX.is())
 197                     aValueSeqVec.erase( find( aValueSeqVec.begin(), aValueSeqVec.end(), xValuesX ));
 198                 if( xValuesY.is())
 199                     aValueSeqVec.erase( find( aValueSeqVec.begin(), aValueSeqVec.end(), xValuesY ));
 200
 201                 size_t nIndex = 0;
 202                 if( ! xValuesY.is() &&
 203                     aValueSeqVec.size() > nIndex )
 204                 {
 205                     xValuesY.set( aValueSeqVec[nIndex++] );
 206                     if( xValuesY.is())
 207                         SetRole( xValuesY->getValues(), C2U("values-y"));
 208                 }
 209
 210                 if( ! xValuesX.is() &&
 211                     aValueSeqVec.size() > nIndex )
 212                 {
 213                     xValuesX.set( aValueSeqVec[nIndex++] );
 214                     if( xValuesX.is())
 215                         SetRole( xValuesY->getValues(), C2U("values-x"));
 216                 }
 217             }
 218             if( xValuesY.is())
 219             {
 220                 if( xValuesX.is())
 221                 {
 222                     aNewSequences.realloc(2);
 223                     aNewSequences[0] = xValuesX;
 224                     aNewSequences[1] = xValuesY;
 225                 }
 226                 else
 227                 {
 228                     aNewSequences.realloc(1);
 229                     aNewSequences[0] = xValuesY;
 230                 }
 231             }
 232
 233             Sequence< Reference< data::XLabeledDataSequence > > aSeqs( xSeriesSource->getDataSequences());
 234             if( aSeqs.getLength() != aNewSequences.getLength() )
 235             {
 236                 sal_Int32 j=0;
 237                 for( ; j<aSeqs.getLength(); ++j )
 238                 {
 239                     if( aSeqs[j] != xValuesY &&
 240                         aSeqs[j] != xValuesX )
 241                         aUnused.push_back( aSeqs[j] );
 242                 }
 243                 Reference< data::XDataSink > xSink( xSeriesSource, uno::UNO_QUERY_THROW );
 244                 xSink->setData( aNewSequences );
 245                 aResult.UnusedData = ContainerHelper::ContainerToSequence( aUnused );
 246             }
 247         }
 248         catch( uno::Exception & ex )
 249         {
 250             ASSERT_EXCEPTION( ex );
 251         }
 252     }
 253
 254     return aResult;
 255 }
 256
 257 // criterion: all series must have exactly two data::XLabeledDataSequences
 258 sal_Bool SAL_CALL XYDataInterpreter::isDataCompatible(
 259     const chart2::InterpretedData& aInterpretedData )
 260     throw (uno::RuntimeException)
 261 {
 262     Sequence< Reference< XDataSeries > > aSeries( FlattenSequence( aInterpretedData.Series ));
 263     for( sal_Int32 i=0; i<aSeries.getLength(); ++i )
 264     {
 265         try
 266         {
 267             Reference< data::XDataSource > xSrc( aSeries[i], uno::UNO_QUERY_THROW );
 268             Sequence< Reference< data::XLabeledDataSequence > > aSeq( xSrc->getDataSequences());
 269             if( aSeq.getLength() != 2 )
 270                 return sal_False;
 271         }
 272         catch( uno::Exception & ex )
 273         {
 274             ASSERT_EXCEPTION( ex );
 275         }
 276     }
 277
 278     return sal_True;
 279 }
 280
 281 } // namespace chart