chart2/source/view/main/VDataSeries.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: VDataSeries.cxx,v $
  10  * $Revision: 1.32.8.2 $
  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 #include "VDataSeries.hxx"
  34 #include "ObjectIdentifier.hxx"
  35 #include "macros.hxx"
  36 #include "CommonConverters.hxx"
  37 #include "LabelPositionHelper.hxx"
  38 #include "ChartTypeHelper.hxx"
  39 #include "ContainerHelper.hxx"
  40 #include "DataSeriesHelper.hxx"
  41 #include "RegressionCurveHelper.hxx"
  42
  43 #include <com/sun/star/chart/MissingValueTreatment.hpp>
  44 #include <com/sun/star/chart2/Symbol.hpp>
  45
  46 //#include "CommonConverters.hxx"
  47 #include <rtl/math.hxx>
  48 #include <tools/debug.hxx>
  49 #include <com/sun/star/beans/XPropertySet.hpp>
  50 #include <com/sun/star/beans/XPropertyState.hpp>
  51 #include <com/sun/star/drawing/LineStyle.hpp>
  52 #include <com/sun/star/drawing/TextVerticalAdjust.hpp>
  53 #include <com/sun/star/drawing/TextHorizontalAdjust.hpp>
  54 #include <com/sun/star/text/WritingMode.hpp>
  55 #include <com/sun/star/chart2/data/XDataSource.hpp>
  56
  57 //.............................................................................
  58 namespace chart
  59 {
  60 //.............................................................................
  61 using namespace ::com::sun::star;
  62 using namespace ::com::sun::star::chart2;
  63 using ::com::sun::star::uno::Reference;
  64
  65 void VDataSequence::init( const uno::Reference< data::XDataSequence >& xModel )
  66 {
  67     Model = xModel;
  68     Doubles = DataSequenceToDoubleSequence( xModel );
  69 }
  70
  71 bool VDataSequence::is() const
  72 {
  73     return Model.is();
  74 }
  75 void VDataSequence::clear()
  76 {
  77     Model = NULL;
  78     Doubles.realloc(0);
  79 }
  80
  81 double VDataSequence::getValue( sal_Int32 index ) const
  82 {
  83     if( 0<=index && index<Doubles.getLength() )
  84         return Doubles[index];
  85     else
  86     {
  87         double fNan;
  88         ::rtl::math::setNan( & fNan );
  89         return fNan;
  90     }
  91 }
  92
  93 sal_Int32 VDataSequence::detectNumberFormatKey( sal_Int32 index ) const
  94 {
  95     sal_Int32 nNumberFormatKey = -1;
  96
  97     // -1 is allowed and means a key for the whole sequence
  98     if( -1<=index && index<Doubles.getLength() &&
  99         Model.is())
 100     {
 101         nNumberFormatKey = Model->getNumberFormatKeyByIndex( index );
 102     }
 103
 104     return nNumberFormatKey;
 105 }
 106
 107 sal_Int32 VDataSequence::getLength() const
 108 {
 109     return Doubles.getLength();
 110 }
 111
 112 namespace
 113 {
 114 struct lcl_LessXOfPoint
 115 {
 116     inline bool operator() ( const std::vector< double >& first,
 117                              const std::vector< double >& second )
 118     {
 119         if( first.size() > 0 && second.size() > 0 )
 120         {
 121             return first[0]<second[0];
 122         }
 123         return false;
 124     }
 125 };
 126
 127 void lcl_clearIfNoValuesButTextIsContained( VDataSequence& rData, const uno::Reference<data::XDataSequence>& xDataSequence )
 128 {
 129     //#i71686#, #i101968#, #i102428#
 130     sal_Int32 nCount = rData.Doubles.getLength();
 131     for( sal_Int32 i = 0; i < nCount; ++i )
 132     {
 133         if( !::rtl::math::isNan( rData.Doubles[i] ) )
 134             return;
 135     }
 136     //no double value is countained
 137     //is there any text?
 138     uno::Sequence< rtl::OUString > aStrings( DataSequenceToStringSequence( xDataSequence ) );
 139     sal_Int32 nTextCount = aStrings.getLength();
 140     for( sal_Int32 j = 0; j < nTextCount; ++j )
 141     {
 142         if( aStrings[j].getLength() )
 143         {
 144             rData.clear();
 145             return;
 146         }
 147     }
 148     //no content at all
 149 }
 150
 151 void lcl_maybeReplaceNanWithZero( double& rfValue, sal_Int32 nMissingValueTreatment )
 152 {
 153     if( nMissingValueTreatment == ::com::sun::star::chart::MissingValueTreatment::USE_ZERO
 154         && (::rtl::math::isNan(rfValue) || ::rtl::math::isInf(rfValue)) )
 155             rfValue = 0.0;
 156 }
 157
 158 }
 159
 160 VDataSeries::VDataSeries( const uno::Reference< XDataSeries >& xDataSeries )
 161     : m_nPolygonIndex(0)
 162     , m_fLogicMinX(0.0)
 163     , m_fLogicMaxX(0.0)
 164     , m_fLogicZPos(0.0)
 165     , m_xGroupShape(NULL)
 166     , m_xLabelsGroupShape(NULL)
 167     , m_xErrorBarsGroupShape(NULL)
 168     , m_xFrontSubGroupShape(NULL)
 169     , m_xBackSubGroupShape(NULL)
 170     , m_xDataSeries(xDataSeries)
 171     , m_aDataSequences()
 172     , m_nPointCount(0)
 173
 174     , m_aValues_X()
 175     , m_aValues_Y()
 176     , m_aValues_Z()
 177     , m_aValues_Y_Min()
 178     , m_aValues_Y_Max()
 179     , m_aValues_Y_First()
 180     , m_aValues_Y_Last()
 181     , m_aValues_Bubble_Size()
 182     , m_pValueSequenceForDataLabelNumberFormatDetection(&m_aValues_Y)
 183
 184     , m_fYMeanValue(1.0)
 185
 186     , m_aAttributedDataPointIndexList()
 187
 188     , m_eStackingDirection(StackingDirection_NO_STACKING)
 189     , m_nAxisIndex(0)
 190     , m_bConnectBars(sal_False)
 191     , m_bGroupBarsPerAxis(sal_True)
 192     , m_nStartingAngle(90)
 193
 194     , m_aSeriesParticle()
 195     , m_aCID()
 196     , m_aPointCID_Stub()
 197     , m_aLabelCID_Stub()
 198
 199     , m_nGlobalSeriesIndex(0)
 200
 201     , m_apLabel_Series(NULL)
 202     , m_apLabelPropNames_Series(NULL)
 203     , m_apLabelPropValues_Series(NULL)
 204     , m_apSymbolProperties_Series(NULL)
 205
 206     , m_apLabel_AttributedPoint(NULL)
 207     , m_apLabelPropNames_AttributedPoint(NULL)
 208     , m_apLabelPropValues_AttributedPoint(NULL)
 209     , m_apSymbolProperties_AttributedPoint(NULL)
 210     , m_apSymbolProperties_InvisibleSymbolForSelection(NULL)
 211     , m_nCurrentAttributedPoint(-1)
 212     , m_nMissingValueTreatment(::com::sun::star::chart::MissingValueTreatment::LEAVE_GAP)
 213     , m_bAllowPercentValueInDataLabel(false)
 214 {
 215     ::rtl::math::setNan( & m_fYMeanValue );
 216
 217     uno::Reference<data::XDataSource> xDataSource =
 218             uno::Reference<data::XDataSource>( xDataSeries, uno::UNO_QUERY );
 219
 220     m_aDataSequences = xDataSource->getDataSequences();
 221
 222     for(sal_Int32 nN = m_aDataSequences.getLength();nN--;)
 223     {
 224         if(!m_aDataSequences[nN].is())
 225             continue;
 226         uno::Reference<data::XDataSequence>  xDataSequence( m_aDataSequences[nN]->getValues());
 227         uno::Reference<beans::XPropertySet> xProp(xDataSequence, uno::UNO_QUERY );
 228         if( xProp.is())
 229         {
 230             try
 231             {
 232                 uno::Any aARole = xProp->getPropertyValue( C2U( "Role" ) );
 233                 rtl::OUString aRole;
 234                 aARole >>= aRole;
 235
 236                 if( aRole.equals(C2U("values-x")) )
 237                 {
 238                     m_aValues_X.init( xDataSequence );
 239                     lcl_clearIfNoValuesButTextIsContained( m_aValues_X, xDataSequence );
 240                 }
 241                 else if( aRole.equals(C2U("values-y")) )
 242                     m_aValues_Y.init( xDataSequence );
 243                 else if( aRole.equals(C2U("values-min")) )
 244                     m_aValues_Y_Min.init( xDataSequence );
 245                 else if( aRole.equals(C2U("values-max")) )
 246                     m_aValues_Y_Max.init( xDataSequence );
 247                 else if( aRole.equals(C2U("values-first")) )
 248                     m_aValues_Y_First.init( xDataSequence );
 249                 else if( aRole.equals(C2U("values-last")) )
 250                     m_aValues_Y_Last.init( xDataSequence );
 251                 else if( aRole.equals(C2U("values-size")) )
 252                     m_aValues_Bubble_Size.init( xDataSequence );
 253             }
 254             catch( uno::Exception& e )
 255             {
 256                 ASSERT_EXCEPTION( e );
 257             }
 258         }
 259     }
 260
 261     //determine the point count
 262     m_nPointCount = m_aValues_Y.getLength();
 263     {
 264         if( m_nPointCount < m_aValues_Bubble_Size.getLength() )
 265             m_nPointCount = m_aValues_Bubble_Size.getLength();
 266         if( m_nPointCount < m_aValues_Y_Min.getLength() )
 267             m_nPointCount = m_aValues_Y_Min.getLength();
 268         if( m_nPointCount < m_aValues_Y_Max.getLength() )
 269             m_nPointCount = m_aValues_Y_Max.getLength();
 270         if( m_nPointCount < m_aValues_Y_First.getLength() )
 271             m_nPointCount = m_aValues_Y_First.getLength();
 272         if( m_nPointCount < m_aValues_Y_Last.getLength() )
 273             m_nPointCount = m_aValues_Y_Last.getLength();
 274     }
 275
 276     uno::Reference<beans::XPropertySet> xProp(xDataSeries, uno::UNO_QUERY );
 277     if( xProp.is())
 278     {
 279         try
 280         {
 281             //get AttributedDataPoints
 282             xProp->getPropertyValue( C2U( "AttributedDataPoints" ) ) >>= m_aAttributedDataPointIndexList;
 283
 284             xProp->getPropertyValue( C2U( "StackingDirection" ) ) >>= m_eStackingDirection;
 285
 286             xProp->getPropertyValue( C2U( "AttachedAxisIndex" ) ) >>= m_nAxisIndex;
 287             if(m_nAxisIndex<0)
 288                 m_nAxisIndex=0;
 289         }
 290         catch( uno::Exception& e )
 291         {
 292             ASSERT_EXCEPTION( e );
 293         }
 294     }
 295 }
 296
 297 VDataSeries::~VDataSeries()
 298 {
 299 }
 300
 301 void VDataSeries::doSortByXValues()
 302 {
 303     if( m_aValues_X.is() && m_aValues_X.Doubles.getLength() )
 304     {
 305         //prepare a vector vor sorting
 306         std::vector< ::std::vector< double > > aTmp;//outer vector are points, inner vector are the different values of athe point
 307         double fNan;
 308         ::rtl::math::setNan( & fNan );
 309         sal_Int32 nPointIndex = 0;
 310         for( nPointIndex=0; nPointIndex < m_nPointCount; nPointIndex++ )
 311         {
 312             std::vector< double > aSinglePoint;
 313             aSinglePoint.push_back( (nPointIndex < m_aValues_X.Doubles.getLength()) ? m_aValues_X.Doubles[nPointIndex] : fNan );
 314             aSinglePoint.push_back( (nPointIndex < m_aValues_Y.Doubles.getLength()) ? m_aValues_Y.Doubles[nPointIndex] : fNan );
 315             aTmp.push_back( aSinglePoint );
 316         }
 317
 318         //do sort
 319         std::sort( aTmp.begin(), aTmp.end(), lcl_LessXOfPoint() );
 320
 321         //fill the sorted points back to the mambers
 322         m_aValues_X.Doubles.realloc( m_nPointCount );
 323         m_aValues_Y.Doubles.realloc( m_nPointCount );
 324
 325         for( nPointIndex=0; nPointIndex < m_nPointCount; nPointIndex++ )
 326         {
 327             m_aValues_X.Doubles[nPointIndex]=aTmp[nPointIndex][0];
 328             m_aValues_Y.Doubles[nPointIndex]=aTmp[nPointIndex][1];
 329         }
 330     }
 331 }
 332
 333 uno::Reference< XDataSeries > VDataSeries::getModel() const
 334 {
 335     return m_xDataSeries;
 336 }
 337
 338 void VDataSeries::releaseShapes()
 339 {
 340     m_xGroupShape.set(0);
 341     m_xLabelsGroupShape.set(0);
 342     m_xErrorBarsGroupShape.set(0);
 343     m_xFrontSubGroupShape.set(0);
 344     m_xBackSubGroupShape.set(0);
 345
 346     m_aPolyPolygonShape3D.SequenceX.realloc(0);
 347     m_aPolyPolygonShape3D.SequenceY.realloc(0);
 348     m_aPolyPolygonShape3D.SequenceZ.realloc(0);
 349     m_nPolygonIndex = 0;
 350 }
 351
 352 void VDataSeries::setCategoryXAxis()
 353 {
 354     m_aValues_X.clear();
 355     m_bAllowPercentValueInDataLabel = true;
 356 }
 357
 358 void VDataSeries::setGlobalSeriesIndex( sal_Int32 nGlobalSeriesIndex )
 359 {
 360     m_nGlobalSeriesIndex = nGlobalSeriesIndex;
 361 }
 362
 363 void VDataSeries::setParticle( const rtl::OUString& rSeriesParticle )
 364 {
 365     m_aSeriesParticle = rSeriesParticle;
 366
 367     //get CID
 368     m_aCID = ObjectIdentifier::createClassifiedIdentifierForParticle( m_aSeriesParticle );
 369     m_aPointCID_Stub = ObjectIdentifier::createSeriesSubObjectStub( OBJECTTYPE_DATA_POINT, m_aSeriesParticle );
 370
 371     m_aLabelCID_Stub = ObjectIdentifier::createClassifiedIdentifierWithParent(
 372                         OBJECTTYPE_DATA_LABEL, ::rtl::OUString(), getLabelsCID() );
 373 }
 374 rtl::OUString VDataSeries::getSeriesParticle() const
 375 {
 376     return m_aSeriesParticle;
 377 }
 378 rtl::OUString VDataSeries::getCID() const
 379 {
 380     return m_aCID;
 381 }
 382 rtl::OUString VDataSeries::getPointCID_Stub() const
 383 {
 384     return m_aPointCID_Stub;
 385 }
 386 rtl::OUString VDataSeries::getErrorBarsCID() const
 387 {
 388     rtl::OUString aChildParticle( ObjectIdentifier::getStringForType( OBJECTTYPE_DATA_ERRORS ) );
 389     aChildParticle+=(C2U("="));
 390
 391     return ObjectIdentifier::createClassifiedIdentifierForParticles(
 392             m_aSeriesParticle, aChildParticle );
 393 }
 394 rtl::OUString VDataSeries::getLabelsCID() const
 395 {
 396     rtl::OUString aChildParticle( ObjectIdentifier::getStringForType( OBJECTTYPE_DATA_LABELS ) );
 397     aChildParticle+=(C2U("="));
 398
 399     return ObjectIdentifier::createClassifiedIdentifierForParticles(
 400             m_aSeriesParticle, aChildParticle );
 401 }
 402 rtl::OUString VDataSeries::getLabelCID_Stub() const
 403 {
 404     return m_aLabelCID_Stub;
 405 }
 406 rtl::OUString VDataSeries::getDataCurveCID( sal_Int32 nCurveIndex, bool bAverageLine ) const
 407 {
 408     rtl::OUString aRet;
 409     aRet = ObjectIdentifier::createDataCurveCID( m_aSeriesParticle, nCurveIndex, bAverageLine );
 410     return aRet;
 411 }
 412
 413 rtl::OUString VDataSeries::getDataCurveEquationCID( sal_Int32 nCurveIndex ) const
 414 {
 415     rtl::OUString aRet;
 416     aRet = ObjectIdentifier::createDataCurveEquationCID( m_aSeriesParticle, nCurveIndex );
 417     return aRet;
 418 }
 419 void VDataSeries::setPageReferenceSize( const awt::Size & rPageRefSize )
 420 {
 421     m_aReferenceSize = rPageRefSize;
 422 }
 423
 424 StackingDirection VDataSeries::getStackingDirection() const
 425 {
 426     return m_eStackingDirection;
 427 }
 428 sal_Int32 VDataSeries::getAttachedAxisIndex() const
 429 {
 430     return m_nAxisIndex;
 431 }
 432 void VDataSeries::setConnectBars( sal_Bool bConnectBars )
 433 {
 434     m_bConnectBars = bConnectBars;
 435 }
 436 sal_Bool VDataSeries::getConnectBars() const
 437 {
 438     return m_bConnectBars;
 439 }
 440 void VDataSeries::setGroupBarsPerAxis( sal_Bool bGroupBarsPerAxis )
 441 {
 442     m_bGroupBarsPerAxis = bGroupBarsPerAxis;
 443 }
 444 sal_Bool VDataSeries::getGroupBarsPerAxis() const
 445 {
 446     return m_bGroupBarsPerAxis;
 447 }
 448
 449 void VDataSeries::setStartingAngle( sal_Int32 nStartingAngle )
 450 {
 451     m_nStartingAngle = nStartingAngle;
 452 }
 453 sal_Int32 VDataSeries::getStartingAngle() const
 454 {
 455     return m_nStartingAngle;
 456 }
 457
 458 void VDataSeries::setAttachedAxisIndex( sal_Int32 nAttachedAxisIndex )
 459 {
 460     if( nAttachedAxisIndex < 0 )
 461         nAttachedAxisIndex = 0;
 462     m_nAxisIndex = nAttachedAxisIndex;
 463 }
 464
 465 sal_Int32 VDataSeries::getTotalPointCount() const
 466 {
 467     return m_nPointCount;
 468 }
 469
 470 double VDataSeries::getXValue( sal_Int32 index ) const
 471 {
 472     double fRet = 0.0;
 473     if(m_aValues_X.is())
 474     {
 475         if( 0<=index && index<m_aValues_X.getLength() )
 476             fRet = m_aValues_X.Doubles[index];
 477         else
 478             ::rtl::math::setNan( &fRet );
 479     }
 480     else
 481     {
 482         // #i70133# always return correct X position - needed for short data series
 483         if( 0<=index /*&& index < m_nPointCount*/ )
 484             fRet = index+1;//first category (index 0) matches with real number 1.0
 485         else
 486             ::rtl::math::setNan( &fRet );
 487     }
 488     lcl_maybeReplaceNanWithZero( fRet, getMissingValueTreatment() );
 489     return fRet;
 490 }
 491
 492 double VDataSeries::getYValue( sal_Int32 index ) const
 493 {
 494     double fRet = 0.0;
 495     if(m_aValues_Y.is())
 496     {
 497         if( 0<=index && index<m_aValues_Y.getLength() )
 498             fRet = m_aValues_Y.Doubles[index];
 499         else
 500             ::rtl::math::setNan( &fRet );
 501     }
 502     else
 503     {
 504         // #i70133# always return correct X position - needed for short data series
 505         if( 0<=index /*&& index < m_nPointCount*/ )
 506             fRet = index+1;//first category (index 0) matches with real number 1.0
 507         else
 508             ::rtl::math::setNan( &fRet );
 509     }
 510     lcl_maybeReplaceNanWithZero( fRet, getMissingValueTreatment() );
 511     return fRet;
 512 }
 513
 514 double VDataSeries::getY_Min( sal_Int32 index ) const
 515 {
 516     return m_aValues_Y_Min.getValue( index );
 517 }
 518 double VDataSeries::getY_Max( sal_Int32 index ) const
 519 {
 520     return m_aValues_Y_Max.getValue( index );
 521 }
 522 double VDataSeries::getY_First( sal_Int32 index ) const
 523 {
 524     return m_aValues_Y_First.getValue( index );
 525 }
 526 double VDataSeries::getY_Last( sal_Int32 index ) const
 527 {
 528     return m_aValues_Y_Last.getValue( index );
 529 }
 530 double VDataSeries::getBubble_Size( sal_Int32 index ) const
 531 {
 532     return m_aValues_Bubble_Size.getValue( index );
 533 }
 534
 535 bool VDataSeries::hasExplicitNumberFormat( sal_Int32 nPointIndex, bool bForPercentage ) const
 536 {
 537     rtl::OUString aPropName( bForPercentage ? C2U( "PercentageNumberFormat" ) : C2U( "NumberFormat" ) );
 538     bool bHasNumberFormat = false;
 539     uno::Reference< beans::XPropertySet > xPointProp( this->getPropertiesOfPoint( nPointIndex ));
 540     sal_Int32 nNumberFormat = -1;
 541     if( xPointProp.is() && (xPointProp->getPropertyValue(aPropName) >>= nNumberFormat) )
 542         bHasNumberFormat = true;
 543     return bHasNumberFormat;
 544 }
 545 sal_Int32 VDataSeries::getExplicitNumberFormat( sal_Int32 nPointIndex, bool bForPercentage ) const
 546 {
 547     rtl::OUString aPropName( bForPercentage ? C2U( "PercentageNumberFormat" ) : C2U( "NumberFormat" ) );
 548     sal_Int32 nNumberFormat = -1;
 549     uno::Reference< beans::XPropertySet > xPointProp( this->getPropertiesOfPoint( nPointIndex ));
 550     if( xPointProp.is() )
 551         xPointProp->getPropertyValue(aPropName) >>= nNumberFormat;
 552     return nNumberFormat;
 553 }
 554 void VDataSeries::setRoleOfSequenceForDataLabelNumberFormatDetection( const rtl::OUString& rRole )
 555 {
 556     if( rRole.equals(C2U("values-y")) )
 557         m_pValueSequenceForDataLabelNumberFormatDetection = &m_aValues_Y;
 558     else if( rRole.equals(C2U("values-size")) )
 559         m_pValueSequenceForDataLabelNumberFormatDetection = &m_aValues_Bubble_Size;
 560     else if( rRole.equals(C2U("values-min")) )
 561         m_pValueSequenceForDataLabelNumberFormatDetection = &m_aValues_Y_Min;
 562     else if( rRole.equals(C2U("values-max")) )
 563         m_pValueSequenceForDataLabelNumberFormatDetection = &m_aValues_Y_Max;
 564     else if( rRole.equals(C2U("values-first")) )
 565         m_pValueSequenceForDataLabelNumberFormatDetection = &m_aValues_Y_First;
 566     else if( rRole.equals(C2U("values-last")) )
 567         m_pValueSequenceForDataLabelNumberFormatDetection = &m_aValues_Y_Last;
 568     else if( rRole.equals(C2U("values-x")) )
 569         m_pValueSequenceForDataLabelNumberFormatDetection = &m_aValues_X;
 570 }
 571 bool VDataSeries::shouldLabelNumberFormatKeyBeDetectedFromYAxis() const
 572 {
 573     if( m_pValueSequenceForDataLabelNumberFormatDetection == &m_aValues_Bubble_Size )
 574         return false;
 575     else if( m_pValueSequenceForDataLabelNumberFormatDetection == &m_aValues_X )
 576         return false;
 577     return true;
 578 }
 579 sal_Int32 VDataSeries::detectNumberFormatKey( sal_Int32 index ) const
 580 {
 581     sal_Int32 nRet = 0;
 582     if( m_pValueSequenceForDataLabelNumberFormatDetection )
 583         nRet = m_pValueSequenceForDataLabelNumberFormatDetection->detectNumberFormatKey( index );
 584     return nRet;
 585 }
 586
 587 sal_Int32 VDataSeries::getLabelPlacement( sal_Int32 nPointIndex, const uno::Reference< chart2::XChartType >& xChartType, sal_Int32 nDimensionCount, sal_Bool bSwapXAndY ) const
 588 {
 589     sal_Int32 nLabelPlacement=0;
 590     try
 591     {
 592         uno::Reference< beans::XPropertySet > xPointProps( this->getPropertiesOfPoint( nPointIndex ) );
 593         if( xPointProps.is() )
 594             xPointProps->getPropertyValue( C2U( "LabelPlacement" ) ) >>= nLabelPlacement;
 595
 596         //ensure that the set label placement is supported by this charttype
 597
 598         uno::Sequence < sal_Int32 > aAvailablePlacements( ChartTypeHelper::getSupportedLabelPlacements(
 599                 xChartType, nDimensionCount, bSwapXAndY, m_xDataSeries ) );
 600
 601         for( sal_Int32 nN = 0; nN < aAvailablePlacements.getLength(); nN++ )
 602             if( aAvailablePlacements[nN] == nLabelPlacement )
 603                 return nLabelPlacement; //ok
 604
 605         //otherwise use the first supported one
 606         if( aAvailablePlacements.getLength() )
 607         {
 608             nLabelPlacement = aAvailablePlacements[0];
 609             return nLabelPlacement;
 610         }
 611
 612         DBG_ERROR("no label placement supported");
 613     }
 614     catch( uno::Exception& e )
 615     {
 616         ASSERT_EXCEPTION( e );
 617     }
 618     return nLabelPlacement;
 619 }
 620
 621 double VDataSeries::getMinimumofAllDifferentYValues( sal_Int32 index ) const
 622 {
 623     double fY = getYValue( index );
 624     double fY_Min = getY_Min( index );
 625     double fY_Max = getY_Max( index );
 626     double fY_First = getY_First( index );
 627     double fY_Last = getY_Last( index );
 628
 629     double fMin=0.0;
 630     ::rtl::math::setInf(&fMin, false);
 631     if(fMin>fY)
 632         fMin=fY;
 633     if(fMin>fY_First)
 634         fMin=fY_First;
 635     if(fMin>fY_Last)
 636         fMin=fY_Last;
 637     if(fMin>fY_Min)
 638         fMin=fY_Min;
 639     if(fMin>fY_Max)
 640         fMin=fY_Max;
 641
 642     if( ::rtl::math::isInf(fMin) )
 643         ::rtl::math::setNan(&fMin);
 644
 645     return fMin;
 646 }
 647
 648 double VDataSeries::getMaximumofAllDifferentYValues( sal_Int32 index ) const
 649 {
 650     double fY = getYValue( index );
 651     double fY_Min = getY_Min( index );
 652     double fY_Max = getY_Max( index );
 653     double fY_First = getY_First( index );
 654     double fY_Last = getY_Last( index );
 655
 656     double fMax=0.0;
 657     ::rtl::math::setInf(&fMax, true);
 658     if(fMax<fY)
 659         fMax=fY;
 660     if(fMax<fY_First)
 661         fMax=fY_First;
 662     if(fMax<fY_Last)
 663         fMax=fY_Last;
 664     if(fMax<fY_Min)
 665         fMax=fY_Min;
 666     if(fMax<fY_Max)
 667         fMax=fY_Max;
 668
 669     if( ::rtl::math::isInf(fMax) )
 670         ::rtl::math::setNan(&fMax);
 671
 672     return fMax;
 673 }
 674
 675 uno::Sequence< double > VDataSeries::getAllX() const
 676 {
 677     if(!m_aValues_X.is() && !m_aValues_X.getLength() && m_nPointCount)
 678     {
 679         //init x values from category indexes
 680         //first category (index 0) matches with real number 1.0
 681         m_aValues_X.Doubles.realloc( m_nPointCount );
 682         for(sal_Int32 nN=m_aValues_X.getLength();nN--;)
 683             m_aValues_X.Doubles[nN] = nN+1;
 684     }
 685     return m_aValues_X.Doubles;
 686 }
 687
 688 uno::Sequence< double > VDataSeries::getAllY() const
 689 {
 690     if(!m_aValues_Y.is() && !m_aValues_Y.getLength() && m_nPointCount)
 691     {
 692         //init y values from indexes
 693         //first y-value (index 0) matches with real number 1.0
 694         m_aValues_Y.Doubles.realloc( m_nPointCount );
 695         for(sal_Int32 nN=m_aValues_Y.getLength();nN--;)
 696             m_aValues_Y.Doubles[nN] = nN+1;
 697     }
 698     return m_aValues_Y.Doubles;
 699 }
 700
 701 double VDataSeries::getYMeanValue() const
 702 {
 703     if( ::rtl::math::isNan( m_fYMeanValue ) )
 704     {
 705         uno::Reference< XRegressionCurveCalculator > xCalculator( RegressionCurveHelper::createRegressionCurveCalculatorByServiceName( C2U("com.sun.star.chart2.MeanValueRegressionCurve") ) );
 706         uno::Sequence< double > aXValuesDummy;
 707         xCalculator->recalculateRegression( aXValuesDummy, getAllY() );
 708         double fXDummy = 1.0;
 709         m_fYMeanValue = xCalculator->getCurveValue( fXDummy );
 710     }
 711     return m_fYMeanValue;
 712 }
 713
 714 ::std::auto_ptr< Symbol > getSymbolPropertiesFromPropertySet(
 715         const uno::Reference< beans::XPropertySet >& xProp )
 716 {
 717     ::std::auto_ptr< Symbol > apSymbolProps( new Symbol() );
 718     try
 719     {
 720         if( xProp->getPropertyValue( C2U( "Symbol" ) ) >>= *apSymbolProps )
 721         {
 722             // border of symbols always black
 723             apSymbolProps->BorderColor = 0x000000;
 724             //use main color to fill symbols
 725             xProp->getPropertyValue( C2U( "Color" ) ) >>= apSymbolProps->FillColor;
 726         }
 727         else
 728             apSymbolProps.reset();
 729     }
 730     catch( uno::Exception &e)
 731     {
 732         ASSERT_EXCEPTION( e );
 733     }
 734     return apSymbolProps;
 735 }
 736
 737 Symbol* VDataSeries::getSymbolProperties( sal_Int32 index ) const
 738 {
 739     Symbol* pRet=NULL;
 740     if( isAttributedDataPoint( index ) )
 741     {
 742         adaptPointCache( index );
 743         if(!m_apSymbolProperties_AttributedPoint.get())
 744             m_apSymbolProperties_AttributedPoint = getSymbolPropertiesFromPropertySet( this->getPropertiesOfPoint( index ) );
 745         pRet = m_apSymbolProperties_AttributedPoint.get();
 746         //if a single data point does not have symbols but the dataseries itself has symbols
 747         //we create an invisible symbol shape to enable selection of that point
 748         if( !pRet || pRet->Style == SymbolStyle_NONE )
 749         {
 750             if(!m_apSymbolProperties_Series.get())
 751                 m_apSymbolProperties_Series = getSymbolPropertiesFromPropertySet( this->getPropertiesOfSeries() );
 752             if( m_apSymbolProperties_Series.get() && m_apSymbolProperties_Series->Style != SymbolStyle_NONE )
 753             {
 754                 if(!m_apSymbolProperties_InvisibleSymbolForSelection.get())
 755                 {
 756                     m_apSymbolProperties_InvisibleSymbolForSelection = ::std::auto_ptr< Symbol >( new Symbol() );
 757                     m_apSymbolProperties_InvisibleSymbolForSelection->Style = SymbolStyle_STANDARD;
 758                     m_apSymbolProperties_InvisibleSymbolForSelection->StandardSymbol = 0;//square
 759                     m_apSymbolProperties_InvisibleSymbolForSelection->Size = m_apSymbolProperties_Series->Size;
 760                     m_apSymbolProperties_InvisibleSymbolForSelection->BorderColor = 0xff000000;//invisible
 761                     m_apSymbolProperties_InvisibleSymbolForSelection->FillColor = 0xff000000;//invisible
 762                 }
 763                 pRet = m_apSymbolProperties_InvisibleSymbolForSelection.get();
 764             }
 765         }
 766     }
 767     else
 768     {
 769         if(!m_apSymbolProperties_Series.get())
 770             m_apSymbolProperties_Series = getSymbolPropertiesFromPropertySet( this->getPropertiesOfSeries() );
 771         pRet = m_apSymbolProperties_Series.get();
 772     }
 773
 774     if( pRet && pRet->Style == SymbolStyle_AUTO )
 775     {
 776         pRet->Style = SymbolStyle_STANDARD;
 777
 778         sal_Int32 nIndex = m_nGlobalSeriesIndex;
 779         if(m_aValues_X.is())
 780             nIndex++;
 781         pRet->StandardSymbol = nIndex;
 782     }
 783
 784     return pRet;
 785 }
 786
 787 uno::Reference< beans::XPropertySet > VDataSeries::getYErrorBarProperties( sal_Int32 index ) const
 788 {
 789     uno::Reference< beans::XPropertySet > xErrorBarProp;
 790
 791     uno::Reference< beans::XPropertySet > xPointProp( this->getPropertiesOfPoint( index ));
 792     if( xPointProp.is() )
 793         xPointProp->getPropertyValue( C2U( "ErrorBarY" )) >>= xErrorBarProp;
 794     return xErrorBarProp;
 795 }
 796
 797 bool VDataSeries::hasPointOwnColor( sal_Int32 index ) const
 798 {
 799     if( !isAttributedDataPoint(index) )
 800         return false;
 801
 802     try
 803     {
 804         uno::Reference< beans::XPropertyState > xPointState( this->getPropertiesOfPoint(index), uno::UNO_QUERY_THROW );
 805         return (xPointState->getPropertyState( C2U("Color")) != beans::PropertyState_DEFAULT_VALUE );
 806     }
 807     catch( uno::Exception& e)
 808     {
 809         ASSERT_EXCEPTION( e );
 810     }
 811     return false;
 812 }
 813
 814 bool VDataSeries::isAttributedDataPoint( sal_Int32 index ) const
 815 {
 816     //returns true if the data point assigned by the given index has set it's own properties
 817     if( index>=m_nPointCount || m_nPointCount==0)
 818         return false;
 819     for(sal_Int32 nN=m_aAttributedDataPointIndexList.getLength();nN--;)
 820     {
 821         if(index==m_aAttributedDataPointIndexList[nN])
 822             return true;
 823     }
 824     return false;
 825 }
 826
 827 bool VDataSeries::isVaryColorsByPoint() const
 828 {
 829     bool bVaryColorsByPoint = false;
 830     Reference< beans::XPropertySet > xSeriesProp( this->getPropertiesOfSeries() );
 831     if( xSeriesProp.is() )
 832         xSeriesProp->getPropertyValue( C2U("VaryColorsByPoint") ) >>= bVaryColorsByPoint;
 833     return bVaryColorsByPoint;
 834 }
 835
 836 uno::Reference< beans::XPropertySet > VDataSeries::getPropertiesOfPoint( sal_Int32 index ) const
 837 {
 838     if( isAttributedDataPoint( index ) )
 839         return m_xDataSeries->getDataPointByIndex(index);
 840     return this->getPropertiesOfSeries();
 841 }
 842
 843 uno::Reference< beans::XPropertySet > VDataSeries::getPropertiesOfSeries() const
 844 {
 845     return  uno::Reference<beans::XPropertySet>(m_xDataSeries, uno::UNO_QUERY );
 846 }
 847
 848 ::std::auto_ptr< DataPointLabel > getDataPointLabelFromPropertySet(
 849         const uno::Reference< beans::XPropertySet >& xProp )
 850 {
 851     ::std::auto_ptr< DataPointLabel > apLabel( new DataPointLabel() );
 852     try
 853     {
 854         if( !(xProp->getPropertyValue( C2U( "Label" ) ) >>= *apLabel) )
 855             apLabel.reset();
 856     }
 857     catch( uno::Exception &e)
 858     {
 859         ASSERT_EXCEPTION( e );
 860     }
 861     return apLabel;
 862 }
 863
 864 void VDataSeries::adaptPointCache( sal_Int32 nNewPointIndex ) const
 865 {
 866     if( m_nCurrentAttributedPoint != nNewPointIndex )
 867     {
 868         m_apLabel_AttributedPoint.reset();
 869         m_apLabelPropNames_AttributedPoint.reset();
 870         m_apLabelPropValues_AttributedPoint.reset();
 871         m_apSymbolProperties_AttributedPoint.reset();
 872         m_nCurrentAttributedPoint = nNewPointIndex;
 873     }
 874 }
 875
 876 DataPointLabel* VDataSeries::getDataPointLabel( sal_Int32 index ) const
 877 {
 878     DataPointLabel* pRet = NULL;
 879     if( isAttributedDataPoint( index ) )
 880     {
 881         adaptPointCache( index );
 882         if( !m_apLabel_AttributedPoint.get() )
 883             m_apLabel_AttributedPoint = getDataPointLabelFromPropertySet( this->getPropertiesOfPoint( index ) );
 884         pRet = m_apLabel_AttributedPoint.get();
 885     }
 886     else
 887     {
 888         if(!m_apLabel_Series.get())
 889             m_apLabel_Series = getDataPointLabelFromPropertySet( this->getPropertiesOfPoint( index ) );
 890         pRet = m_apLabel_Series.get();
 891     }
 892     if( !m_bAllowPercentValueInDataLabel )
 893     {
 894         if( pRet )
 895             pRet->ShowNumberInPercent = false;
 896     }
 897     return pRet;
 898 }
 899
 900 DataPointLabel* VDataSeries::getDataPointLabelIfLabel( sal_Int32 index ) const
 901 {
 902     DataPointLabel* pLabel = this->getDataPointLabel( index );
 903     if( !pLabel || (!pLabel->ShowNumber && !pLabel->ShowNumberInPercent
 904         && !pLabel->ShowCategoryName ) )
 905         return 0;
 906     return pLabel;
 907 }
 908
 909 bool VDataSeries::getTextLabelMultiPropertyLists( sal_Int32 index
 910     , tNameSequence*& pPropNames
 911     , tAnySequence*& pPropValues ) const
 912 {
 913     pPropNames = NULL; pPropValues = NULL;
 914     uno::Reference< beans::XPropertySet > xTextProp;
 915     bool bDoDynamicFontResize = false;
 916     if( isAttributedDataPoint( index ) )
 917     {
 918         adaptPointCache( index );
 919         if(!m_apLabelPropValues_AttributedPoint.get())
 920         {
 921             pPropNames = new tNameSequence();
 922             pPropValues = new tAnySequence();
 923             xTextProp.set( this->getPropertiesOfPoint( index ));
 924             PropertyMapper::getTextLabelMultiPropertyLists( xTextProp, *pPropNames, *pPropValues );
 925             m_apLabelPropNames_AttributedPoint = ::std::auto_ptr< tNameSequence >(pPropNames);
 926             m_apLabelPropValues_AttributedPoint = ::std::auto_ptr< tAnySequence >(pPropValues);
 927             bDoDynamicFontResize = true;
 928         }
 929         pPropNames = m_apLabelPropNames_AttributedPoint.get();
 930         pPropValues = m_apLabelPropValues_AttributedPoint.get();
 931     }
 932     else
 933     {
 934         if(!m_apLabelPropValues_Series.get())
 935         {
 936             pPropNames = new tNameSequence();
 937             pPropValues = new tAnySequence();
 938             xTextProp.set( this->getPropertiesOfPoint( index ));
 939             PropertyMapper::getTextLabelMultiPropertyLists( xTextProp, *pPropNames, *pPropValues );
 940             m_apLabelPropNames_Series = ::std::auto_ptr< tNameSequence >(pPropNames);
 941             m_apLabelPropValues_Series = ::std::auto_ptr< tAnySequence >(pPropValues);
 942             bDoDynamicFontResize = true;
 943         }
 944         pPropNames = m_apLabelPropNames_Series.get();
 945         pPropValues = m_apLabelPropValues_Series.get();
 946     }
 947
 948     if( bDoDynamicFontResize &&
 949         pPropNames && pPropValues &&
 950         xTextProp.is())
 951     {
 952         LabelPositionHelper::doDynamicFontResize( *pPropValues, *pPropNames, xTextProp, m_aReferenceSize );
 953     }
 954     if(pPropNames&&pPropValues)
 955         return true;
 956     return false;
 957 }
 958
 959 void VDataSeries::setMissingValueTreatment( sal_Int32 nMissingValueTreatment )
 960 {
 961     m_nMissingValueTreatment = nMissingValueTreatment;
 962 }
 963
 964 sal_Int32 VDataSeries::getMissingValueTreatment() const
 965 {
 966     return m_nMissingValueTreatment;
 967 }
 968
 969 //.............................................................................
 970 } //namespace chart
 971 //.............................................................................