chart2/source/tools/AxisHelper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_chart2.hxx"
  30
  31 #include "AxisHelper.hxx"
  32 #include "DiagramHelper.hxx"
  33 #include "ChartTypeHelper.hxx"
  34 #include "macros.hxx"
  35 #include "AxisIndexDefines.hxx"
  36 #include "LineProperties.hxx"
  37 #include "ContainerHelper.hxx"
  38 #include "servicenames_coosystems.hxx"
  39 #include "DataSeriesHelper.hxx"
  40 #include "Scaling.hxx"
  41
  42 #include <unotools/saveopt.hxx>
  43
  44 #include <com/sun/star/chart/ChartAxisPosition.hpp>
  45
  46 #include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
  47 #include <com/sun/star/chart2/XChartTypeContainer.hpp>
  48 #include <com/sun/star/chart2/XDataSeriesContainer.hpp>
  49 #include <com/sun/star/chart2/data/XDataSource.hpp>
  50
  51 // header for class OUStringBuffer
  52 #include <rtl/ustrbuf.hxx>
  53 #include <com/sun/star/util/XCloneable.hpp>
  54 #include <com/sun/star/lang/XServiceName.hpp>
  55
  56 #include <map>
  57
  58 //.............................................................................
  59 namespace chart
  60 {
  61 //.............................................................................
  62 using namespace ::com::sun::star;
  63 using namespace ::com::sun::star::chart2;
  64 using ::com::sun::star::uno::Reference;
  65 using ::com::sun::star::uno::Sequence;
  66
  67 //static
  68 Reference< chart2::XScaling > AxisHelper::createLinearScaling()
  69 {
  70     return new LinearScaling( 1.0, 0.0 );
  71 }
  72
  73 //static
  74 Reference< chart2::XScaling > AxisHelper::createLogarithmicScaling( double fBase )
  75 {
  76     return new LogarithmicScaling( fBase );
  77 }
  78
  79 //static
  80 ScaleData AxisHelper::createDefaultScale()
  81 {
  82     ScaleData aScaleData;
  83     aScaleData.AxisType = chart2::AxisType::REALNUMBER;
  84     Sequence< SubIncrement > aSubIncrements(1);
  85     aSubIncrements[0] = SubIncrement();
  86     aScaleData.IncrementData.SubIncrements = aSubIncrements;
  87     return aScaleData;
  88 }
  89
  90 //static
  91 void AxisHelper::removeExplicitScaling( ScaleData& rScaleData )
  92 {
  93     uno::Any aEmpty;
  94     rScaleData.Minimum = rScaleData.Maximum = rScaleData.Origin = aEmpty;
  95     rScaleData.Scaling = 0;
  96 }
  97
  98 //static
  99 bool AxisHelper::isLogarithmic( const Reference< XScaling >& xScaling )
 100 {
 101     bool bReturn = false;
 102     Reference< lang::XServiceName > xServiceName( xScaling, uno::UNO_QUERY );
 103     bReturn =( xServiceName.is() && (xServiceName->getServiceName()).equals(
 104               C2U( "com.sun.star.chart2.LogarithmicScaling" )));
 105     return bReturn;
 106 }
 107
 108 //static
 109 Reference< XAxis > AxisHelper::createAxis(
 110           sal_Int32 nDimensionIndex
 111         , sal_Int32 nAxisIndex // 0==main or 1==secondary axis
 112         , const Reference< XCoordinateSystem >& xCooSys
 113         , const Reference< uno::XComponentContext > & xContext
 114         , ReferenceSizeProvider * pRefSizeProvider )
 115 {
 116     if( !xContext.is() || !xCooSys.is() )
 117         return NULL;
 118     if( nDimensionIndex >= xCooSys->getDimension() )
 119         return NULL;
 120
 121     Reference< XAxis > xAxis( xContext->getServiceManager()->createInstanceWithContext(
 122                     C2U( "com.sun.star.chart2.Axis" ), xContext ), uno::UNO_QUERY );
 123
 124     OSL_ASSERT( xAxis.is());
 125     if( xAxis.is())
 126     {
 127         xCooSys->setAxisByDimension( nDimensionIndex, xAxis, nAxisIndex );
 128
 129         if( nAxisIndex>0 )//when inserting secondary axes copy some things from the main axis
 130         {
 131             ::com::sun::star::chart::ChartAxisPosition eNewAxisPos( ::com::sun::star::chart::ChartAxisPosition_END );
 132
 133             Reference< XAxis > xMainAxis( xCooSys->getAxisByDimension( nDimensionIndex, 0 ) );
 134             if( xMainAxis.is() )
 135             {
 136                 ScaleData aScale = xAxis->getScaleData();
 137                 ScaleData aMainScale = xMainAxis->getScaleData();
 138
 139                 aScale.AxisType = aMainScale.AxisType;
 140                 aScale.Categories = aMainScale.Categories;
 141                 aScale.Orientation = aMainScale.Orientation;
 142
 143                 xAxis->setScaleData( aScale );
 144
 145                 //ensure that the second axis is not placed on the main axis
 146                 Reference< beans::XPropertySet > xMainProp( xMainAxis, uno::UNO_QUERY );
 147                 if( xMainProp.is() )
 148                 {
 149                     ::com::sun::star::chart::ChartAxisPosition eMainAxisPos( ::com::sun::star::chart::ChartAxisPosition_ZERO );
 150                     xMainProp->getPropertyValue(C2U( "CrossoverPosition" )) >>= eMainAxisPos;
 151                     if( ::com::sun::star::chart::ChartAxisPosition_END == eMainAxisPos )
 152                         eNewAxisPos = ::com::sun::star::chart::ChartAxisPosition_START;
 153                 }
 154             }
 155
 156             Reference< beans::XPropertySet > xProp( xAxis, uno::UNO_QUERY );
 157             if( xProp.is() )
 158                 xProp->setPropertyValue(C2U( "CrossoverPosition" ), uno::makeAny(eNewAxisPos) );
 159         }
 160
 161         Reference< beans::XPropertySet > xProp( xAxis, uno::UNO_QUERY );
 162         if( xProp.is() ) try
 163         {
 164             // set correct initial AutoScale
 165             if( pRefSizeProvider )
 166                 pRefSizeProvider->setValuesAtPropertySet( xProp );
 167         }
 168         catch( uno::Exception& e )
 169         {
 170             ASSERT_EXCEPTION( e );
 171         }
 172     }
 173     return xAxis;
 174 }
 175
 176 //static
 177 Reference< XAxis > AxisHelper::createAxis( sal_Int32 nDimensionIndex, bool bMainAxis
 178                 , const Reference< chart2::XDiagram >& xDiagram
 179                 , const Reference< uno::XComponentContext >& xContext
 180                 , ReferenceSizeProvider * pRefSizeProvider )
 181 {
 182     OSL_ENSURE( xContext.is(), "need a context to create an axis" );
 183     if( !xContext.is() )
 184         return NULL;
 185
 186     sal_Int32 nAxisIndex = bMainAxis ? MAIN_AXIS_INDEX : SECONDARY_AXIS_INDEX;
 187     sal_Int32 nCooSysIndex = 0;
 188     Reference< XCoordinateSystem > xCooSys = AxisHelper::getCoordinateSystemByIndex( xDiagram, nCooSysIndex );
 189
 190     // create axis
 191     return AxisHelper::createAxis(
 192         nDimensionIndex, nAxisIndex, xCooSys, xContext, pRefSizeProvider );
 193 }
 194
 195 //static
 196 void AxisHelper::showAxis( sal_Int32 nDimensionIndex, bool bMainAxis
 197                 , const Reference< chart2::XDiagram >& xDiagram
 198                 , const Reference< uno::XComponentContext >& xContext
 199                 , ReferenceSizeProvider * pRefSizeProvider )
 200 {
 201     if( !xDiagram.is() )
 202         return;
 203
 204     bool bNewAxisCreated = false;
 205     Reference< XAxis > xAxis( AxisHelper::getAxis( nDimensionIndex, bMainAxis, xDiagram ) );
 206     if( !xAxis.is() && xContext.is() )
 207     {
 208         // create axis
 209         bNewAxisCreated = true;
 210         xAxis.set( AxisHelper::createAxis( nDimensionIndex, bMainAxis, xDiagram, xContext, pRefSizeProvider ) );
 211     }
 212
 213     OSL_ASSERT( xAxis.is());
 214     if( !bNewAxisCreated ) //default is true already if created
 215         AxisHelper::makeAxisVisible( xAxis );
 216 }
 217
 218 //static
 219 void AxisHelper::showGrid( sal_Int32 nDimensionIndex, sal_Int32 nCooSysIndex, bool bMainGrid
 220                 , const Reference< XDiagram >& xDiagram
 221                 , const Reference< uno::XComponentContext >& /*xContext*/ )
 222 {
 223     if( !xDiagram.is() )
 224         return;
 225
 226     Reference< XCoordinateSystem > xCooSys = AxisHelper::getCoordinateSystemByIndex( xDiagram, nCooSysIndex );
 227     if(!xCooSys.is())
 228         return;
 229
 230     Reference< XAxis > xAxis( AxisHelper::getAxis( nDimensionIndex, MAIN_AXIS_INDEX, xCooSys ) );
 231     if(!xAxis.is())
 232     {
 233         //hhhh todo create axis without axis visibility
 234     }
 235     if(!xAxis.is())
 236         return;
 237
 238     if( bMainGrid )
 239         AxisHelper::makeGridVisible( xAxis->getGridProperties() );
 240     else
 241     {
 242         Sequence< Reference< beans::XPropertySet > > aSubGrids( xAxis->getSubGridProperties() );
 243         for( sal_Int32 nN=0; nN<aSubGrids.getLength(); nN++)
 244             AxisHelper::makeGridVisible( aSubGrids[nN] );
 245     }
 246 }
 247
 248 //static
 249 void AxisHelper::makeAxisVisible( const Reference< XAxis >& xAxis )
 250 {
 251     Reference< beans::XPropertySet > xProps( xAxis, uno::UNO_QUERY );
 252     if( xProps.is() )
 253     {
 254         xProps->setPropertyValue( C2U( "Show" ), uno::makeAny( sal_True ) );
 255         LineProperties::SetLineVisible( xProps );
 256         xProps->setPropertyValue( C2U( "DisplayLabels" ), uno::makeAny( sal_True ) );
 257     }
 258 }
 259
 260 //static
 261 void AxisHelper::makeGridVisible( const Reference< beans::XPropertySet >& xGridProperties )
 262 {
 263     if( xGridProperties.is() )
 264     {
 265         xGridProperties->setPropertyValue( C2U( "Show" ), uno::makeAny( sal_True ) );
 266         LineProperties::SetLineVisible( xGridProperties );
 267     }
 268 }
 269
 270 //static
 271 void AxisHelper::hideAxis( sal_Int32 nDimensionIndex, bool bMainAxis
 272                 , const Reference< XDiagram >& xDiagram )
 273 {
 274     AxisHelper::makeAxisInvisible( AxisHelper::getAxis( nDimensionIndex, bMainAxis, xDiagram ) );
 275 }
 276
 277 //static
 278 void AxisHelper::makeAxisInvisible( const Reference< XAxis >& xAxis )
 279 {
 280     Reference< beans::XPropertySet > xProps( xAxis, uno::UNO_QUERY );
 281     if( xProps.is() )
 282     {
 283         xProps->setPropertyValue( C2U( "Show" ), uno::makeAny( sal_False ) );
 284     }
 285 }
 286
 287 //static
 288 void AxisHelper::hideAxisIfNoDataIsAttached( const Reference< XAxis >& xAxis, const Reference< XDiagram >& xDiagram )
 289 {
 290     //axis is hidden if no data is attached anymore but data is available
 291     bool bOtherSeriesAttachedToThisAxis = false;
 292     ::std::vector< Reference< chart2::XDataSeries > > aSeriesVector( DiagramHelper::getDataSeriesFromDiagram( xDiagram ) );
 293     ::std::vector< Reference< chart2::XDataSeries > >::const_iterator aIt = aSeriesVector.begin();
 294     for( ; aIt != aSeriesVector.end(); ++aIt)
 295     {
 296         uno::Reference< chart2::XAxis > xCurrentAxis( DiagramHelper::getAttachedAxis( *aIt, xDiagram ), uno::UNO_QUERY );
 297         if( xCurrentAxis==xAxis )
 298         {
 299             bOtherSeriesAttachedToThisAxis = true;
 300             break;
 301         }
 302     }
 303     if(!bOtherSeriesAttachedToThisAxis && !aSeriesVector.empty() )
 304         AxisHelper::makeAxisInvisible( xAxis );
 305 }
 306
 307 void AxisHelper::hideGrid( sal_Int32 nDimensionIndex, sal_Int32 nCooSysIndex, bool bMainGrid
 308                 , const Reference< XDiagram >& xDiagram )
 309 {
 310     if( !xDiagram.is() )
 311         return;
 312
 313     Reference< XCoordinateSystem > xCooSys = AxisHelper::getCoordinateSystemByIndex( xDiagram, nCooSysIndex );
 314     if(!xCooSys.is())
 315         return;
 316
 317     Reference< XAxis > xAxis( AxisHelper::getAxis( nDimensionIndex, MAIN_AXIS_INDEX, xCooSys ) );
 318     if(!xAxis.is())
 319         return;
 320
 321     if( bMainGrid )
 322         AxisHelper::makeGridInvisible( xAxis->getGridProperties() );
 323     else
 324     {
 325         Sequence< Reference< beans::XPropertySet > > aSubGrids( xAxis->getSubGridProperties() );
 326         for( sal_Int32 nN=0; nN<aSubGrids.getLength(); nN++)
 327             AxisHelper::makeGridInvisible( aSubGrids[nN] );
 328     }
 329 }
 330
 331 //static
 332 void AxisHelper::makeGridInvisible( const Reference< beans::XPropertySet >& xGridProperties )
 333 {
 334     if( xGridProperties.is() )
 335     {
 336         xGridProperties->setPropertyValue( C2U( "Show" ), uno::makeAny( sal_False ) );
 337     }
 338 }
 339
 340 sal_Bool AxisHelper::isGridShown( sal_Int32 nDimensionIndex, sal_Int32 nCooSysIndex, bool bMainGrid
 341                 , const Reference< ::com::sun::star::chart2::XDiagram >& xDiagram )
 342 {
 343     sal_Bool bRet = false;
 344
 345     Reference< XCoordinateSystem > xCooSys = AxisHelper::getCoordinateSystemByIndex( xDiagram, nCooSysIndex );
 346     if(!xCooSys.is())
 347         return bRet;
 348
 349     Reference< XAxis > xAxis( AxisHelper::getAxis( nDimensionIndex, MAIN_AXIS_INDEX, xCooSys ) );
 350     if(!xAxis.is())
 351         return bRet;
 352
 353     if( bMainGrid )
 354         bRet = AxisHelper::isGridVisible( xAxis->getGridProperties() );
 355     else
 356     {
 357         Sequence< Reference< beans::XPropertySet > > aSubGrids( xAxis->getSubGridProperties() );
 358         if( aSubGrids.getLength() )
 359             bRet = AxisHelper::isGridVisible( aSubGrids[0] );
 360     }
 361
 362     return bRet;
 363 }
 364
 365 //static
 366 Reference< XCoordinateSystem > AxisHelper::getCoordinateSystemByIndex(
 367     const Reference< XDiagram >& xDiagram, sal_Int32 nIndex )
 368 {
 369     Reference< XCoordinateSystemContainer > xCooSysContainer( xDiagram, uno::UNO_QUERY );
 370     if(!xCooSysContainer.is())
 371         return NULL;
 372     Sequence< Reference< XCoordinateSystem > > aCooSysList = xCooSysContainer->getCoordinateSystems();
 373     if(0<=nIndex && nIndex<aCooSysList.getLength())
 374         return aCooSysList[nIndex];
 375     return NULL;
 376 }
 377
 378 //static
 379 Reference< XAxis > AxisHelper::getAxis( sal_Int32 nDimensionIndex, bool bMainAxis
 380             , const Reference< XDiagram >& xDiagram )
 381 {
 382     Reference< XAxis > xRet;
 383     try
 384     {
 385         Reference< XCoordinateSystem > xCooSys = AxisHelper::getCoordinateSystemByIndex( xDiagram, 0 );
 386         xRet.set( AxisHelper::getAxis( nDimensionIndex, bMainAxis ? 0 : 1, xCooSys ) );
 387     }
 388     catch( const uno::Exception & )
 389     {
 390     }
 391     return xRet;
 392 }
 393
 394 //static
 395 Reference< XAxis > AxisHelper::getAxis( sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex
 396             , const Reference< XCoordinateSystem >& xCooSys )
 397 {
 398     Reference< XAxis > xRet;
 399     try
 400     {
 401         if( xCooSys.is() )
 402             xRet.set( xCooSys->getAxisByDimension( nDimensionIndex, nAxisIndex ) );
 403     }
 404     catch( const uno::Exception & )
 405     {
 406     }
 407     return xRet;
 408 }
 409
 410 //static
 411 Reference< XAxis > AxisHelper::getCrossingMainAxis( const Reference< XAxis >& xAxis
 412             , const Reference< XCoordinateSystem >& xCooSys )
 413 {
 414     sal_Int32 nDimensionIndex = 0;
 415     sal_Int32 nAxisIndex = 0;
 416     AxisHelper::getIndicesForAxis( xAxis, xCooSys, nDimensionIndex, nAxisIndex );
 417     if( 2==nDimensionIndex )
 418     {
 419         nDimensionIndex=1;
 420         bool bSwapXY = false;
 421         Reference< beans::XPropertySet > xCooSysProp( xCooSys, uno::UNO_QUERY );
 422         if( xCooSysProp.is() && (xCooSysProp->getPropertyValue( C2U("SwapXAndYAxis") ) >>= bSwapXY) && bSwapXY )
 423             nDimensionIndex=0;
 424     }
 425     else if( 1==nDimensionIndex )
 426         nDimensionIndex=0;
 427     else
 428         nDimensionIndex=1;
 429     return AxisHelper::getAxis( nDimensionIndex, 0, xCooSys );
 430 }
 431
 432 //static
 433 Reference< XAxis > AxisHelper::getParallelAxis( const Reference< XAxis >& xAxis
 434             , const Reference< XDiagram >& xDiagram )
 435 {
 436     try
 437     {
 438         sal_Int32 nCooSysIndex=-1;
 439         sal_Int32 nDimensionIndex=-1;
 440         sal_Int32 nAxisIndex=-1;
 441         if( getIndicesForAxis( xAxis, xDiagram, nCooSysIndex, nDimensionIndex, nAxisIndex ) )
 442         {
 443             sal_Int32 nParallelAxisIndex = (nAxisIndex==1) ?0 :1;
 444             return getAxis( nDimensionIndex, nParallelAxisIndex, getCoordinateSystemByIndex( xDiagram, nCooSysIndex ) );
 445         }
 446     }
 447     catch( uno::RuntimeException& )
 448     {
 449     }
 450     return 0;
 451 }
 452
 453 sal_Bool AxisHelper::isAxisShown( sal_Int32 nDimensionIndex, bool bMainAxis
 454             , const Reference< XDiagram >& xDiagram )
 455 {
 456     return AxisHelper::isAxisVisible( AxisHelper::getAxis( nDimensionIndex, bMainAxis, xDiagram ) );
 457 }
 458
 459 //static
 460 sal_Bool AxisHelper::isAxisVisible( const Reference< XAxis >& xAxis )
 461 {
 462     sal_Bool bRet = false;
 463
 464     Reference< beans::XPropertySet > xProps( xAxis, uno::UNO_QUERY );
 465     if( xProps.is() )
 466     {
 467         xProps->getPropertyValue( C2U( "Show" ) ) >>= bRet;
 468         bRet = bRet && ( LineProperties::IsLineVisible( xProps )
 469             || areAxisLabelsVisible( xProps ) );
 470     }
 471
 472     return bRet;
 473 }
 474
 475 sal_Bool AxisHelper::areAxisLabelsVisible( const Reference< beans::XPropertySet >& xAxisProperties )
 476 {
 477     sal_Bool bRet = false;
 478     if( xAxisProperties.is() )
 479     {
 480         xAxisProperties->getPropertyValue( C2U( "DisplayLabels" ) ) >>= bRet;
 481     }
 482     return bRet;
 483 }
 484
 485 //static
 486 sal_Bool AxisHelper::isGridVisible( const Reference< beans::XPropertySet >& xGridProperies )
 487 {
 488     sal_Bool bRet = false;
 489
 490     if( xGridProperies.is() )
 491     {
 492         xGridProperies->getPropertyValue( C2U( "Show" ) ) >>= bRet;
 493         bRet = bRet && LineProperties::IsLineVisible( xGridProperies );
 494     }
 495
 496     return bRet;
 497 }
 498
 499 //static
 500 Reference< beans::XPropertySet > AxisHelper::getGridProperties(
 501             const Reference< XCoordinateSystem >& xCooSys
 502         , sal_Int32 nDimensionIndex, sal_Int32 nAxisIndex, sal_Int32 nSubGridIndex )
 503 {
 504     Reference< beans::XPropertySet > xRet;
 505
 506     Reference< XAxis > xAxis( AxisHelper::getAxis( nDimensionIndex, nAxisIndex, xCooSys ) );
 507     if( xAxis.is() )
 508     {
 509         if( nSubGridIndex<0 )
 510             xRet.set( xAxis->getGridProperties() );
 511         else
 512         {
 513             Sequence< Reference< beans::XPropertySet > > aSubGrids( xAxis->getSubGridProperties() );
 514             if( nSubGridIndex >= 0 && nSubGridIndex < aSubGrids.getLength() )
 515                 xRet.set( aSubGrids[nSubGridIndex] );
 516         }
 517     }
 518
 519     return xRet;
 520 }
 521
 522 //static
 523 sal_Int32 AxisHelper::getDimensionIndexOfAxis(
 524               const Reference< XAxis >& xAxis
 525             , const Reference< XDiagram >& xDiagram )
 526 {
 527     sal_Int32 nDimensionIndex = -1;
 528     sal_Int32 nCooSysIndex = -1;
 529     sal_Int32 nAxisIndex = -1;
 530     AxisHelper::getIndicesForAxis( xAxis, xDiagram, nCooSysIndex , nDimensionIndex, nAxisIndex );
 531     return nDimensionIndex;
 532 }
 533
 534 //static
 535 bool AxisHelper::getIndicesForAxis(
 536               const Reference< XAxis >& xAxis
 537             , const Reference< XCoordinateSystem >& xCooSys
 538             , sal_Int32& rOutDimensionIndex, sal_Int32& rOutAxisIndex )
 539 {
 540     //returns true if indices are found
 541
 542     rOutDimensionIndex = -1;
 543     rOutAxisIndex = -1;
 544
 545     if( xCooSys.is() && xAxis.is() )
 546     {
 547         Reference< XAxis > xCurrentAxis;
 548         sal_Int32 nDimensionCount( xCooSys->getDimension() );
 549         for( sal_Int32 nDimensionIndex = 0; nDimensionIndex < nDimensionCount; nDimensionIndex++ )
 550         {
 551             sal_Int32 nMaxAxisIndex = xCooSys->getMaximumAxisIndexByDimension(nDimensionIndex);
 552             for( sal_Int32 nAxisIndex = 0; nAxisIndex <= nMaxAxisIndex; nAxisIndex++ )
 553             {
 554                  xCurrentAxis = xCooSys->getAxisByDimension(nDimensionIndex,nAxisIndex);
 555                  if( xCurrentAxis == xAxis )
 556                  {
 557                      rOutDimensionIndex = nDimensionIndex;
 558                      rOutAxisIndex = nAxisIndex;
 559                      return true;
 560                  }
 561             }
 562         }
 563     }
 564     return false;
 565 }
 566
 567 //static
 568 bool AxisHelper::getIndicesForAxis( const Reference< XAxis >& xAxis, const Reference< XDiagram >& xDiagram
 569             , sal_Int32& rOutCooSysIndex, sal_Int32& rOutDimensionIndex, sal_Int32& rOutAxisIndex )
 570 {
 571     //returns true if indices are found
 572
 573     rOutCooSysIndex = -1;
 574     rOutDimensionIndex = -1;
 575     rOutAxisIndex = -1;
 576
 577     Reference< XCoordinateSystemContainer > xCooSysContainer( xDiagram, uno::UNO_QUERY );
 578     if(xCooSysContainer.is())
 579     {
 580         Sequence< Reference< XCoordinateSystem > > aCooSysList = xCooSysContainer->getCoordinateSystems();
 581         for( sal_Int32 nC=0; nC<aCooSysList.getLength(); ++nC )
 582         {
 583             if( AxisHelper::getIndicesForAxis( xAxis, aCooSysList[nC], rOutDimensionIndex, rOutAxisIndex ) )
 584             {
 585                 rOutCooSysIndex = nC;
 586                 return true;
 587             }
 588         }
 589     }
 590
 591     return false;
 592 }
 593
 594 //static
 595 std::vector< Reference< XAxis > > AxisHelper::getAllAxesOfCoordinateSystem(
 596       const Reference< XCoordinateSystem >& xCooSys
 597     , bool bOnlyVisible /* = false */ )
 598 {
 599     std::vector< Reference< XAxis > > aAxisVector;
 600
 601     if(xCooSys.is())
 602     {
 603         sal_Int32 nDimensionIndex = 0;
 604         sal_Int32 nMaxDimensionIndex = xCooSys->getDimension() -1;
 605         if( nMaxDimensionIndex>=0 )
 606         {
 607             for(nDimensionIndex=0; nDimensionIndex<=nMaxDimensionIndex; ++nDimensionIndex)
 608             {
 609                 const sal_Int32 nMaximumAxisIndex = xCooSys->getMaximumAxisIndexByDimension(nDimensionIndex);
 610                 for(sal_Int32 nAxisIndex=0; nAxisIndex<=nMaximumAxisIndex; ++nAxisIndex)
 611                 {
 612                     try
 613                     {
 614                         Reference< XAxis > xAxis( xCooSys->getAxisByDimension( nDimensionIndex, nAxisIndex ) );
 615                         bool bAddAxis = true;
 616                         if( xAxis.is() )
 617                         {
 618                             if( bOnlyVisible )
 619                             {
 620                                 Reference< beans::XPropertySet > xAxisProp( xAxis, uno::UNO_QUERY );
 621                                 if( !xAxisProp.is() ||
 622                                     !(xAxisProp->getPropertyValue( C2U("Show")) >>= bAddAxis) )
 623                                     bAddAxis = false;
 624                             }
 625                             if( bAddAxis )
 626                                 aAxisVector.push_back( xAxis );
 627                         }
 628                     }
 629                     catch( const uno::Exception & ex )
 630                     {
 631                         ASSERT_EXCEPTION( ex );
 632                     }
 633                 }
 634             }
 635         }
 636     }
 637
 638     return aAxisVector;
 639 }
 640
 641 //static
 642 Sequence< Reference< XAxis > > AxisHelper::getAllAxesOfDiagram(
 643       const Reference< XDiagram >& xDiagram
 644     , bool bOnlyVisible )
 645 {
 646     std::vector< Reference< XAxis > > aAxisVector;
 647
 648     Reference< XCoordinateSystemContainer > xCooSysContainer( xDiagram, uno::UNO_QUERY );
 649     if(xCooSysContainer.is())
 650     {
 651         Sequence< Reference< XCoordinateSystem > > aCooSysList = xCooSysContainer->getCoordinateSystems();
 652         sal_Int32 nC = 0;
 653         for( nC=0; nC<aCooSysList.getLength(); ++nC )
 654         {
 655             std::vector< Reference< XAxis > > aAxesPerCooSys( AxisHelper::getAllAxesOfCoordinateSystem( aCooSysList[nC], bOnlyVisible ) );
 656             aAxisVector.insert( aAxisVector.end(), aAxesPerCooSys.begin(), aAxesPerCooSys.end() );
 657         }
 658     }
 659
 660     return ContainerHelper::ContainerToSequence( aAxisVector );
 661 }
 662
 663 //static
 664 Sequence< Reference< beans::XPropertySet > > AxisHelper::getAllGrids( const Reference< XDiagram >& xDiagram )
 665 {
 666     Sequence< Reference< XAxis > > aAllAxes( AxisHelper::getAllAxesOfDiagram( xDiagram ) );
 667     std::vector< Reference< beans::XPropertySet > > aGridVector;
 668
 669     sal_Int32 nA = 0;
 670     for( nA=0; nA<aAllAxes.getLength(); ++nA )
 671     {
 672         Reference< XAxis > xAxis( aAllAxes[nA] );
 673         if(!xAxis.is())
 674             continue;
 675         Reference< beans::XPropertySet > xGridProperties( xAxis->getGridProperties() );
 676         if( xGridProperties.is() )
 677             aGridVector.push_back( xGridProperties );
 678
 679         Sequence< Reference< beans::XPropertySet > > aSubGrids( xAxis->getSubGridProperties() );;
 680         sal_Int32 nSubGrid = 0;
 681         for( nSubGrid = 0; nSubGrid < aSubGrids.getLength(); ++nSubGrid )
 682         {
 683             Reference< beans::XPropertySet > xSubGrid( aSubGrids[nSubGrid] );
 684             if( xSubGrid.is() )
 685                 aGridVector.push_back( xSubGrid );
 686         }
 687     }
 688
 689     return ContainerHelper::ContainerToSequence( aGridVector );
 690 }
 691
 692 //static
 693 void AxisHelper::getAxisOrGridPossibilities( Sequence< sal_Bool >& rPossibilityList
 694         , const Reference< XDiagram>& xDiagram, sal_Bool bAxis )
 695 {
 696     rPossibilityList.realloc(6);
 697
 698     sal_Int32 nDimensionCount = DiagramHelper::getDimension( xDiagram );
 699
 700     //set possibilities:
 701     sal_Int32 nIndex=0;
 702     Reference< XChartType > xChartType = DiagramHelper::getChartTypeByIndex( xDiagram, 0 );
 703     for(nIndex=0;nIndex<3;nIndex++)
 704         rPossibilityList[nIndex]=ChartTypeHelper::isSupportingMainAxis(xChartType,nDimensionCount,nIndex);
 705     for(nIndex=3;nIndex<6;nIndex++)
 706         if( bAxis )
 707             rPossibilityList[nIndex]=ChartTypeHelper::isSupportingSecondaryAxis(xChartType,nDimensionCount,nIndex-3);
 708         else
 709             rPossibilityList[nIndex] = rPossibilityList[nIndex-3];
 710 }
 711
 712 //static
 713 bool AxisHelper::isSecondaryYAxisNeeded( const Reference< XCoordinateSystem >& xCooSys )
 714 {
 715     Reference< chart2::XChartTypeContainer > xCTCnt( xCooSys, uno::UNO_QUERY );
 716     if( xCTCnt.is() )
 717     {
 718         Sequence< Reference< chart2::XChartType > > aChartTypes( xCTCnt->getChartTypes() );
 719         for( sal_Int32 i=0; i<aChartTypes.getLength(); ++i )
 720         {
 721             Reference< XDataSeriesContainer > xSeriesContainer( aChartTypes[i] , uno::UNO_QUERY );
 722             if( !xSeriesContainer.is() )
 723                     continue;
 724
 725             Sequence< Reference< XDataSeries > > aSeriesList( xSeriesContainer->getDataSeries() );
 726             for( sal_Int32 nS = aSeriesList.getLength(); nS-- ; )
 727             {
 728                 Reference< beans::XPropertySet > xProp( aSeriesList[nS], uno::UNO_QUERY );
 729                 if(xProp.is())
 730                 {
 731                     sal_Int32 nAttachedAxisIndex = 0;
 732                     if( ( xProp->getPropertyValue( C2U( "AttachedAxisIndex" ) ) >>= nAttachedAxisIndex ) && nAttachedAxisIndex>0 )
 733                         return true;
 734                 }
 735             }
 736         }
 737     }
 738     return false;
 739 }
 740
 741 //static
 742 bool AxisHelper::shouldAxisBeDisplayed( const Reference< XAxis >& xAxis
 743                                        , const Reference< XCoordinateSystem >& xCooSys )
 744 {
 745     bool bRet = false;
 746
 747     if( xAxis.is() && xCooSys.is() )
 748     {
 749         sal_Int32 nDimensionIndex=-1;
 750         sal_Int32 nAxisIndex=-1;
 751         if( AxisHelper::getIndicesForAxis( xAxis, xCooSys, nDimensionIndex, nAxisIndex ) )
 752         {
 753             sal_Int32 nDimensionCount = xCooSys->getDimension();
 754             Reference< XChartType > xChartType( AxisHelper::getChartTypeByIndex( xCooSys, 0 ) );
 755
 756             bool bMainAxis = (nAxisIndex==MAIN_AXIS_INDEX);
 757             if( bMainAxis )
 758                 bRet = ChartTypeHelper::isSupportingMainAxis(xChartType,nDimensionCount,nDimensionIndex);
 759             else
 760                 bRet = ChartTypeHelper::isSupportingSecondaryAxis(xChartType,nDimensionCount,nDimensionIndex);
 761         }
 762     }
 763
 764     return bRet;
 765 }
 766
 767 //static
 768 void AxisHelper::getAxisOrGridExcistence( Sequence< sal_Bool >& rExistenceList
 769         , const Reference< XDiagram>& xDiagram, sal_Bool bAxis )
 770 {
 771     rExistenceList.realloc(6);
 772
 773     if(bAxis)
 774     {
 775         sal_Int32 nN;
 776         Reference< XAxis > xAxis;
 777         for(nN=0;nN<3;nN++)
 778             rExistenceList[nN] = AxisHelper::isAxisShown( nN, true, xDiagram );
 779         for(nN=3;nN<6;nN++)
 780             rExistenceList[nN] = AxisHelper::isAxisShown( nN%3, false, xDiagram );
 781     }
 782     else
 783     {
 784         sal_Int32 nN;
 785
 786         for(nN=0;nN<3;nN++)
 787             rExistenceList[nN] = AxisHelper::isGridShown( nN, 0, true, xDiagram );
 788         for(nN=3;nN<6;nN++)
 789             rExistenceList[nN] = AxisHelper::isGridShown( nN%3, 0, false, xDiagram );
 790     }
 791 }
 792
 793 //static
 794 bool AxisHelper::changeVisibilityOfAxes( const Reference< XDiagram >& xDiagram
 795                         , const Sequence< sal_Bool >& rOldExistenceList
 796                         , const Sequence< sal_Bool >& rNewExistenceList
 797                         , const Reference< uno::XComponentContext >& xContext
 798                         , ReferenceSizeProvider * pRefSizeProvider )
 799 {
 800     bool bChanged = false;
 801     for(sal_Int32 nN=0;nN<6;nN++)
 802     {
 803         if(rOldExistenceList[nN]!=rNewExistenceList[nN])
 804         {
 805             bChanged = true;
 806             if(rNewExistenceList[nN])
 807             {
 808                 AxisHelper::showAxis( nN%3, nN<3, xDiagram, xContext, pRefSizeProvider );
 809             }
 810             else
 811                 AxisHelper::hideAxis( nN%3, nN<3, xDiagram );
 812         }
 813     }
 814     return bChanged;
 815 }
 816
 817 //static
 818 bool AxisHelper::changeVisibilityOfGrids( const Reference< XDiagram >& xDiagram
 819                         , const Sequence< sal_Bool >& rOldExistenceList
 820                         , const Sequence< sal_Bool >& rNewExistenceList
 821                         , const Reference< uno::XComponentContext >& xContext )
 822 {
 823     bool bChanged = false;
 824     for(sal_Int32 nN=0;nN<6;nN++)
 825     {
 826         if(rOldExistenceList[nN]!=rNewExistenceList[nN])
 827         {
 828             bChanged = true;
 829             if(rNewExistenceList[nN])
 830                 AxisHelper::showGrid( nN%3, 0, nN<3, xDiagram, xContext );
 831             else
 832                 AxisHelper::hideGrid( nN%3, 0, nN<3, xDiagram );
 833         }
 834     }
 835     return bChanged;
 836 }
 837
 838 //static
 839 Reference< XCoordinateSystem > AxisHelper::getCoordinateSystemOfAxis(
 840               const Reference< XAxis >& xAxis
 841             , const Reference< XDiagram >& xDiagram )
 842 {
 843     Reference< XCoordinateSystem > xRet;
 844
 845     Reference< XCoordinateSystemContainer > xCooSysContainer( xDiagram, uno::UNO_QUERY );
 846     if( xCooSysContainer.is() )
 847     {
 848         Reference< XCoordinateSystem > xCooSys;
 849         Sequence< Reference< XCoordinateSystem > > aCooSysList( xCooSysContainer->getCoordinateSystems() );
 850         for( sal_Int32 nCooSysIndex = 0; nCooSysIndex < aCooSysList.getLength(); ++nCooSysIndex )
 851         {
 852             xCooSys = aCooSysList[nCooSysIndex];
 853             std::vector< Reference< XAxis > > aAllAxis( AxisHelper::getAllAxesOfCoordinateSystem( xCooSys ) );
 854
 855             ::std::vector< Reference< XAxis > >::iterator aFound =
 856                   ::std::find( aAllAxis.begin(), aAllAxis.end(), xAxis );
 857             if( aFound != aAllAxis.end())
 858             {
 859                 xRet.set( xCooSys );
 860                 break;
 861             }
 862         }
 863     }
 864     return xRet;
 865 }
 866
 867 Reference< XChartType > AxisHelper::getChartTypeByIndex( const Reference< XCoordinateSystem >& xCooSys, sal_Int32 nIndex )
 868 {
 869     Reference< XChartType > xChartType;
 870
 871     Reference< XChartTypeContainer > xChartTypeContainer( xCooSys, uno::UNO_QUERY );
 872     if( xChartTypeContainer.is() )
 873     {
 874         Sequence< Reference< XChartType > > aChartTypeList( xChartTypeContainer->getChartTypes() );
 875         if( nIndex >= 0 && nIndex < aChartTypeList.getLength() )
 876             xChartType.set( aChartTypeList[nIndex] );
 877     }
 878
 879     return xChartType;
 880 }
 881
 882 void AxisHelper::setRTLAxisLayout( const Reference< XCoordinateSystem >& xCooSys )
 883 {
 884     if( xCooSys.is() )
 885     {
 886         bool bCartesian = xCooSys->getViewServiceName().equals( CHART2_COOSYSTEM_CARTESIAN_VIEW_SERVICE_NAME );
 887         if( bCartesian )
 888         {
 889             bool bVertical = false;
 890             Reference< beans::XPropertySet > xCooSysProp( xCooSys, uno::UNO_QUERY );
 891             if( xCooSysProp.is() )
 892                 xCooSysProp->getPropertyValue( C2U("SwapXAndYAxis") ) >>= bVertical;
 893
 894             sal_Int32 nHorizontalAxisDimension = bVertical ? 1 : 0;
 895             sal_Int32 nVerticalAxisDimension = bVertical ? 0 : 1;
 896
 897             try
 898             {
 899                 //reverse direction for horizontal main axis
 900                 Reference< chart2::XAxis > xHorizontalMainAxis( AxisHelper::getAxis( nHorizontalAxisDimension, MAIN_AXIS_INDEX, xCooSys ) );
 901                 if( xHorizontalMainAxis.is() )
 902                 {
 903                     chart2::ScaleData aScale = xHorizontalMainAxis->getScaleData();
 904                     aScale.Orientation = chart2::AxisOrientation_REVERSE;
 905                     xHorizontalMainAxis->setScaleData(aScale);
 906                 }
 907
 908                 //mathematical direction for vertical main axis
 909                 Reference< chart2::XAxis > xVerticalMainAxis( AxisHelper::getAxis( nVerticalAxisDimension, MAIN_AXIS_INDEX, xCooSys ) );
 910                 if( xVerticalMainAxis.is() )
 911                 {
 912                     chart2::ScaleData aScale = xVerticalMainAxis->getScaleData();
 913                     aScale.Orientation = chart2::AxisOrientation_MATHEMATICAL;
 914                     xVerticalMainAxis->setScaleData(aScale);
 915                 }
 916             }
 917             catch( uno::Exception & ex )
 918             {
 919                 ASSERT_EXCEPTION( ex );
 920             }
 921
 922             try
 923             {
 924                 //reverse direction for horizontal secondary axis
 925                 Reference< chart2::XAxis > xHorizontalSecondaryAxis( AxisHelper::getAxis( nHorizontalAxisDimension, SECONDARY_AXIS_INDEX, xCooSys ) );
 926                 if( xHorizontalSecondaryAxis.is() )
 927                 {
 928                     chart2::ScaleData aScale = xHorizontalSecondaryAxis->getScaleData();
 929                     aScale.Orientation = chart2::AxisOrientation_REVERSE;
 930                     xHorizontalSecondaryAxis->setScaleData(aScale);
 931                 }
 932
 933                 //mathematical direction for vertical secondary axis
 934                 Reference< chart2::XAxis > xVerticalSecondaryAxis( AxisHelper::getAxis( nVerticalAxisDimension, SECONDARY_AXIS_INDEX, xCooSys ) );
 935                 if( xVerticalSecondaryAxis.is() )
 936                 {
 937                     chart2::ScaleData aScale = xVerticalSecondaryAxis->getScaleData();
 938                     aScale.Orientation = chart2::AxisOrientation_MATHEMATICAL;
 939                     xVerticalSecondaryAxis->setScaleData(aScale);
 940                 }
 941             }
 942             catch( uno::Exception & ex )
 943             {
 944                 ASSERT_EXCEPTION( ex );
 945             }
 946         }
 947     }
 948 }
 949
 950 Reference< XChartType > AxisHelper::getFirstChartTypeWithSeriesAttachedToAxisIndex( const Reference< chart2::XDiagram >& xDiagram, const sal_Int32 nAttachedAxisIndex )
 951 {
 952     Reference< XChartType > xChartType;
 953     ::std::vector< Reference< XDataSeries > > aSeriesVector( DiagramHelper::getDataSeriesFromDiagram( xDiagram ) );
 954     ::std::vector< Reference< XDataSeries > >::const_iterator aIter = aSeriesVector.begin();
 955     for( ; aIter != aSeriesVector.end(); aIter++ )
 956     {
 957         sal_Int32 nCurrentIndex = DataSeriesHelper::getAttachedAxisIndex( *aIter );
 958         if( nAttachedAxisIndex == nCurrentIndex )
 959         {
 960             xChartType = DiagramHelper::getChartTypeOfSeries( xDiagram, *aIter );
 961             if(xChartType.is())
 962                 break;
 963         }
 964     }
 965     return xChartType;
 966 }
 967
 968 bool AxisHelper::isAxisPositioningEnabled()
 969 {
 970     const SvtSaveOptions::ODFDefaultVersion nCurrentVersion( SvtSaveOptions().GetODFDefaultVersion() );
 971     return nCurrentVersion >= SvtSaveOptions::ODFVER_012;
 972 }
 973
 974 //.............................................................................
 975 } //namespace chart
 976 //.............................................................................