chart2/source/view/axes/VCartesianAxis.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: VCartesianAxis.cxx,v $
  10  * $Revision: 1.12 $
  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 <basegfx/numeric/ftools.hxx>
  34
  35 #include "VCartesianAxis.hxx"
  36 #include "PlottingPositionHelper.hxx"
  37 #include "ShapeFactory.hxx"
  38 #include "CommonConverters.hxx"
  39 #include "macros.hxx"
  40 #include "ViewDefines.hxx"
  41 #include "PropertyMapper.hxx"
  42 #include "chartview/NumberFormatterWrapper.hxx"
  43 #include "LabelPositionHelper.hxx"
  44 #include "TrueGuard.hxx"
  45 #include "BaseGFXHelper.hxx"
  46 #include "AxisHelper.hxx"
  47
  48 #include <rtl/math.hxx>
  49 #include <tools/color.hxx>
  50 #include <tools/debug.hxx>
  51 #include <com/sun/star/text/XText.hpp>
  52 #include <com/sun/star/text/WritingMode2.hpp>
  53 #include <svx/unoprnms.hxx>
  54
  55 #include <algorithm>
  56 #include <memory>
  57
  58 //.............................................................................
  59 namespace chart
  60 {
  61 //.............................................................................
  62 using namespace ::com::sun::star;
  63 using namespace ::com::sun::star::chart2;
  64 using namespace ::rtl::math;
  65 using ::com::sun::star::uno::Reference;
  66
  67 //-----------------------------------------------------------------------------
  68 //-----------------------------------------------------------------------------
  69 //-----------------------------------------------------------------------------
  70
  71 VCartesianAxis::VCartesianAxis( const AxisProperties& rAxisProperties
  72             , const Reference< util::XNumberFormatsSupplier >& xNumberFormatsSupplier
  73             , sal_Int32 nDimensionIndex, sal_Int32 nDimensionCount
  74             , PlottingPositionHelper* pPosHelper )//takes ownership
  75             : VAxisBase( nDimensionIndex, nDimensionCount, rAxisProperties, xNumberFormatsSupplier )
  76 {
  77     if( pPosHelper )
  78         m_pPosHelper = pPosHelper;
  79     else
  80         m_pPosHelper = new PlottingPositionHelper();
  81 }
  82
  83 VCartesianAxis::~VCartesianAxis()
  84 {
  85     delete m_pPosHelper;
  86     m_pPosHelper = NULL;
  87 }
  88
  89 //-----------------------------------------------------------------------------
  90 //-----------------------------------------------------------------------------
  91
  92 Reference< drawing::XShape > createSingleLabel(
  93             const Reference< lang::XMultiServiceFactory>& xShapeFactory
  94           , const Reference< drawing::XShapes >& xTarget
  95           , const awt::Point& rAnchorScreenPosition2D
  96           , const rtl::OUString& rLabel
  97           , const AxisLabelProperties& rAxisLabelProperties
  98           , const AxisProperties& rAxisProperties
  99           , const tNameSequence& rPropNames
 100           , const tAnySequence& rPropValues
 101           )
 102 {
 103     if(!rLabel.getLength())
 104         return 0;
 105
 106     // #i78696# use mathematically correct rotation now
 107     const double fRotationAnglePi(rAxisLabelProperties.fRotationAngleDegree * (F_PI / -180.0));
 108     uno::Any aATransformation = ShapeFactory::makeTransformation( rAnchorScreenPosition2D, fRotationAnglePi );
 109     rtl::OUString aLabel = ShapeFactory::getStackedString( rLabel, rAxisLabelProperties.bStackCharacters );
 110
 111     Reference< drawing::XShape > xShape2DText = ShapeFactory(xShapeFactory)
 112                     .createText( xTarget, aLabel, rPropNames, rPropValues, aATransformation );
 113
 114     //correctPositionForRotation
 115     LabelPositionHelper::correctPositionForRotation( xShape2DText
 116         , rAxisProperties.m_aLabelAlignment, rAxisLabelProperties.fRotationAngleDegree, false );
 117
 118     return xShape2DText;
 119 }
 120
 121 bool lcl_doesShapeOverlapWithTickmark( const Reference< drawing::XShape >& xShape
 122                        , double fRotationAngleDegree
 123                        , const basegfx::B2DVector& rTickScreenPosition
 124                        , TickmarkHelper_2D* pTickmarkHelper )
 125 {
 126     if(!xShape.is())
 127         return false;
 128
 129     ::basegfx::B2IRectangle aShapeRect = BaseGFXHelper::makeRectangle(xShape->getPosition(),ShapeFactory::getSizeAfterRotation( xShape, fRotationAngleDegree ));
 130
 131     if( pTickmarkHelper->isVerticalAxis() )
 132     {
 133         return ( (rTickScreenPosition.getY() >= aShapeRect.getMinY())
 134             && (rTickScreenPosition.getY() <= aShapeRect.getMaxY()) );
 135     }
 136     if( pTickmarkHelper->isHorizontalAxis() )
 137     {
 138         return ( (rTickScreenPosition.getX() >= aShapeRect.getMinX())
 139             && (rTickScreenPosition.getX() <= aShapeRect.getMaxX()) );
 140     }
 141
 142     basegfx::B2IVector aPosition(
 143         static_cast<sal_Int32>( rTickScreenPosition.getX() )
 144         , static_cast<sal_Int32>( rTickScreenPosition.getY() ) );
 145     return aShapeRect.isInside(aPosition);
 146 }
 147
 148 bool doesOverlap( const Reference< drawing::XShape >& xShape1
 149                 , const Reference< drawing::XShape >& xShape2
 150                 , double fRotationAngleDegree )
 151 {
 152     if( !xShape1.is() || !xShape2.is() )
 153         return false;
 154
 155     ::basegfx::B2IRectangle aRect1( BaseGFXHelper::makeRectangle(xShape1->getPosition(),ShapeFactory::getSizeAfterRotation( xShape1, fRotationAngleDegree )));
 156     ::basegfx::B2IRectangle aRect2( BaseGFXHelper::makeRectangle(xShape2->getPosition(),ShapeFactory::getSizeAfterRotation( xShape2, fRotationAngleDegree )));
 157     return aRect1.overlaps(aRect2);
 158 }
 159
 160 void removeShapesAtWrongRythm( TickIter& rIter
 161                               , sal_Int32 nCorrectRhythm
 162                               , sal_Int32 nMaxTickToCheck
 163                               , const Reference< drawing::XShapes >& xTarget )
 164 {
 165     sal_Int32 nTick = 0;
 166     for( TickInfo* pTickInfo = rIter.firstInfo()
 167         ; pTickInfo && nTick <= nMaxTickToCheck
 168         ; pTickInfo = rIter.nextInfo(), nTick++ )
 169     {
 170         //remove labels which does not fit into the rythm
 171         if( nTick%nCorrectRhythm != 0)
 172         {
 173             if(pTickInfo->xTextShape.is())
 174             {
 175                 xTarget->remove(pTickInfo->xTextShape);
 176                 pTickInfo->xTextShape = NULL;
 177             }
 178         }
 179     }
 180 }
 181
 182 class LabelIterator : private TickIter
 183 {
 184     //this Iterator iterates over existing text labels
 185
 186     //if the labels are staggered and bInnerLine is true
 187     //we iterate only through the labels which are lying more inside the diagram
 188
 189     //if the labels are staggered and bInnerLine is false
 190     //we iterate only through the labels which are lying more outside the diagram
 191
 192     //if the labels are not staggered
 193     //we iterate through all labels
 194
 195 public:
 196     LabelIterator( ::std::vector< ::std::vector< TickInfo > >& rTickInfos
 197             , const ::com::sun::star::chart2::ExplicitIncrementData& rIncrement
 198             , const AxisLabelStaggering eAxisLabelStaggering
 199             , bool bInnerLine
 200             , sal_Int32 nMinDepth=0, sal_Int32 nMaxDepth=-1 );
 201
 202     virtual TickInfo*   firstInfo();
 203     virtual TickInfo*   nextInfo();
 204
 205 private: //methods
 206     LabelIterator();
 207
 208 private: //member
 209     const AxisLabelStaggering   m_eAxisLabelStaggering;
 210     bool        m_bInnerLine;
 211 };
 212
 213 LabelIterator::LabelIterator( ::std::vector< ::std::vector< TickInfo > >& rTickInfos
 214             , const ::com::sun::star::chart2::ExplicitIncrementData& rIncrement
 215             , const AxisLabelStaggering eAxisLabelStaggering
 216             , bool bInnerLine
 217             , sal_Int32 nMinDepth, sal_Int32 nMaxDepth )
 218             : TickIter( rTickInfos, rIncrement, nMinDepth, nMaxDepth )
 219             , m_eAxisLabelStaggering(eAxisLabelStaggering)
 220             , m_bInnerLine(bInnerLine)
 221 {
 222 }
 223
 224 TickInfo* LabelIterator::firstInfo()
 225 {
 226     TickInfo* pTickInfo = TickIter::firstInfo();
 227     while( pTickInfo && !pTickInfo->xTextShape.is() )
 228         pTickInfo = TickIter::nextInfo();
 229     if(!pTickInfo)
 230         return NULL;
 231     if( (STAGGER_EVEN==m_eAxisLabelStaggering && m_bInnerLine)
 232         ||
 233         (STAGGER_ODD==m_eAxisLabelStaggering && !m_bInnerLine)
 234         )
 235     {
 236         //skip first label
 237         do
 238             pTickInfo = TickIter::nextInfo();
 239         while( pTickInfo && !pTickInfo->xTextShape.is() );
 240     }
 241     if(!pTickInfo)
 242         return NULL;
 243     return pTickInfo;
 244 }
 245
 246 TickInfo* LabelIterator::nextInfo()
 247 {
 248     TickInfo* pTickInfo = NULL;
 249     //get next label
 250     do
 251         pTickInfo = TickIter::nextInfo();
 252     while( pTickInfo && !pTickInfo->xTextShape.is() );
 253
 254     if(  STAGGER_EVEN==m_eAxisLabelStaggering
 255       || STAGGER_ODD==m_eAxisLabelStaggering )
 256     {
 257         //skip one label
 258         do
 259             pTickInfo = TickIter::nextInfo();
 260         while( pTickInfo && !pTickInfo->xTextShape.is() );
 261     }
 262     return pTickInfo;
 263 }
 264
 265 B2DVector lcl_getStaggerDistance( LabelIterator& rIter, const B2DVector& rDistanceTickToText )
 266 {
 267     //calculates the height or width of the first line of labels
 268     //thus the second line of labels needs to be shifted for that distance
 269
 270     B2DVector aRet(0,0);
 271
 272     sal_Int32 nDistanceTickToText = static_cast<sal_Int32>( rDistanceTickToText.getLength() );
 273     if( nDistanceTickToText==0.0)
 274         return aRet;
 275
 276     B2DVector aStaggerDirection(rDistanceTickToText);
 277     aStaggerDirection.normalize();
 278
 279     sal_Int32 nDistance=0;
 280     Reference< drawing::XShape >  xShape2DText(NULL);
 281     for( TickInfo* pTickInfo = rIter.firstInfo()
 282         ; pTickInfo
 283         ; pTickInfo = rIter.nextInfo() )
 284     {
 285         xShape2DText = pTickInfo->xTextShape;
 286         DBG_ASSERT(xShape2DText.is(),"LabelIterator does not work correctly");
 287
 288         awt::Size aSize  = xShape2DText->getSize();
 289         if(fabs(aStaggerDirection.getX())>fabs(aStaggerDirection.getY()))
 290             nDistance = ::std::max(nDistance,aSize.Width);
 291         else
 292             nDistance = ::std::max(nDistance,aSize.Height);
 293     }
 294
 295     aRet = aStaggerDirection*nDistance;
 296
 297     //add extra distance for vertical distance
 298     if(fabs(aStaggerDirection.getX())>fabs(aStaggerDirection.getY()))
 299         aRet += rDistanceTickToText;
 300
 301     return aRet;
 302 }
 303
 304 void lcl_correctPositionForStaggering( LabelIterator& rIter, const B2DVector& rStaggerDistance )
 305 {
 306     if(rStaggerDistance.getLength()==0.0)
 307         return;
 308     Reference< drawing::XShape >  xShape2DText(NULL);
 309     for( TickInfo* pTickInfo = rIter.firstInfo()
 310         ; pTickInfo
 311         ; pTickInfo = rIter.nextInfo() )
 312     {
 313         xShape2DText = pTickInfo->xTextShape;
 314         DBG_ASSERT(xShape2DText.is(),"LabelIterator does not work correctly");
 315
 316         awt::Point aPos  = xShape2DText->getPosition();
 317         aPos.X += static_cast<sal_Int32>(rStaggerDistance.getX());
 318         aPos.Y += static_cast<sal_Int32>(rStaggerDistance.getY());
 319         xShape2DText->setPosition( aPos );
 320     }
 321 }
 322
 323 class MaxLabelTickIter : public TickIter
 324 {
 325     //iterate over first two and last two labels and the longest label
 326 public:
 327     MaxLabelTickIter( ::std::vector< ::std::vector< TickInfo > >& rTickInfos
 328             , const ::com::sun::star::chart2::ExplicitIncrementData& rIncrement
 329             , sal_Int32 nLongestLabelIndex );
 330     virtual ~MaxLabelTickIter();
 331
 332     virtual TickInfo*   nextInfo();
 333
 334 private:
 335     sal_Int32 m_nLongestLabelIndex;
 336 };
 337
 338 MaxLabelTickIter::MaxLabelTickIter( ::std::vector< ::std::vector< TickInfo > >& rTickInfos
 339             , const ::com::sun::star::chart2::ExplicitIncrementData& rIncrement
 340             , sal_Int32 nLongestLabelIndex )
 341             : TickIter( rTickInfos, rIncrement, 0//nMinDepth
 342                                                 , 0//nMaxDepth
 343                                                 )
 344             , m_nLongestLabelIndex( nLongestLabelIndex )
 345 {
 346     sal_Int32 nMaxIndex = getMaxIndex();
 347
 348     //ensure correct value:
 349     if( m_nLongestLabelIndex<0 || m_nLongestLabelIndex>nMaxIndex)
 350         m_nLongestLabelIndex = 0;
 351
 352     //last label is checked anyhow
 353     if( m_nLongestLabelIndex==nMaxIndex )
 354         m_nLongestLabelIndex = 0;
 355     //label before last is checked anyhow
 356     if( m_nLongestLabelIndex+1==nMaxIndex )
 357         m_nLongestLabelIndex = 0;
 358 }
 359 MaxLabelTickIter::~MaxLabelTickIter()
 360 {
 361 }
 362
 363 TickInfo* MaxLabelTickIter::nextInfo()
 364 {
 365     sal_Int32 nCurrentPos = getCurrentIndex();
 366     sal_Int32 nMaxIndex = getMaxIndex();
 367     if( nCurrentPos>0 )
 368     {
 369         if( m_nLongestLabelIndex>1 && nCurrentPos<m_nLongestLabelIndex  )
 370             gotoIndex( m_nLongestLabelIndex-1 ) ;
 371         else
 372         {
 373             if( nMaxIndex>3 && nCurrentPos<nMaxIndex-1 )
 374                 gotoIndex( nMaxIndex-2 );
 375             else if( nMaxIndex>2 && nCurrentPos<nMaxIndex )
 376                 gotoIndex( nMaxIndex-1 );
 377         }
 378     }
 379
 380     return TickIter::nextInfo();
 381 }
 382
 383 bool VCartesianAxis::isBreakOfLabelsAllowed( const AxisLabelProperties& rAxisLabelProperties
 384                                                      , TickmarkHelper_2D* pTickmarkHelper )
 385 {
 386     if( m_aTextLabels.getLength() > 100 )
 387         return false;
 388     if( !rAxisLabelProperties.bLineBreakAllowed )
 389         return false;
 390     if( rAxisLabelProperties.bStackCharacters )
 391         return false;
 392     //no break for value axis
 393     if( !m_bUseTextLabels )
 394         return false;
 395     if( !::rtl::math::approxEqual( rAxisLabelProperties.fRotationAngleDegree, 0.0 ) )
 396         return false;
 397     //break only for horizontal axis
 398     if( pTickmarkHelper )
 399         return pTickmarkHelper->isHorizontalAxis();
 400     return false;
 401 }
 402
 403 bool VCartesianAxis::isAutoStaggeringOfLabelsAllowed( const AxisLabelProperties& rAxisLabelProperties
 404                                                      , TickmarkHelper_2D* pTickmarkHelper )
 405 {
 406     if( rAxisLabelProperties.eStaggering != STAGGER_AUTO )
 407         return false;
 408     if( rAxisLabelProperties.bOverlapAllowed )
 409         return false;
 410     if( rAxisLabelProperties.bLineBreakAllowed ) //auto line break or auto staggering, doing both automatisms they may conflict...
 411         return false;
 412     if( !::rtl::math::approxEqual( rAxisLabelProperties.fRotationAngleDegree, 0.0 ) )
 413         return false;
 414     //automatic staggering only for horizontal axis with horizontal text
 415     //or vertical axis with vertical text
 416     if( pTickmarkHelper )
 417     {
 418         if( pTickmarkHelper->isHorizontalAxis() )
 419             return !rAxisLabelProperties.bStackCharacters;
 420         if( pTickmarkHelper->isVerticalAxis() )
 421             return rAxisLabelProperties.bStackCharacters;
 422     }
 423     return false;
 424 }
 425
 426 bool VCartesianAxis::createTextShapes(
 427                        const Reference< drawing::XShapes >& xTarget
 428                      , TickIter& rTickIter
 429                      , AxisLabelProperties& rAxisLabelProperties
 430                      , TickmarkHelper_2D* pTickmarkHelper )
 431 {
 432     //returns true if the text shapes have been created succesfully
 433     //otherwise false - in this case the AxisLabelProperties have changed
 434     //and contain new instructions for the next try for text shape creation
 435
 436     uno::Sequence< rtl::OUString >* pCategories = m_bUseTextLabels? &m_aTextLabels : 0;
 437
 438     Reference< XScaling > xInverseScaling( NULL );
 439     if( m_aScale.Scaling.is() )
 440         xInverseScaling = m_aScale.Scaling->getInverseScaling();
 441
 442     FixedNumberFormatter aFixedNumberFormatter(
 443                 m_xNumberFormatsSupplier, rAxisLabelProperties.nNumberFormatKey );
 444
 445     B2DVector aTextToTickDistance( pTickmarkHelper->getDistanceAxisTickToText( m_aAxisProperties ) );
 446
 447     TickInfo* pPreviousVisibleTickInfo = NULL;
 448     TickInfo* pPREPreviousVisibleTickInfo = NULL;
 449     TickInfo* pLastVisibleNeighbourTickInfo = NULL;
 450     bool bIsStaggered = rAxisLabelProperties.getIsStaggered();
 451     sal_Int32 nLimitedSpace = -1;
 452     if( isBreakOfLabelsAllowed( rAxisLabelProperties, pTickmarkHelper ) )
 453     {
 454         nLimitedSpace = TickmarkHelper_2D::getTickScreenDistance( rTickIter );
 455         if( bIsStaggered )
 456             nLimitedSpace *= 2;
 457
 458         if( nLimitedSpace > 0 )
 459         { //reduce space for a small amount to have a visible distance between the labels:
 460             sal_Int32 nReduce = (nLimitedSpace*5)/100;
 461             if(!nReduce)
 462                 nReduce = 1;
 463             nLimitedSpace -= nReduce;
 464         }
 465         //maybe @todo in future:
 466         //if the labeled tickmarks are not equidistant [this is not considered to be a relevant case so far]
 467         //the limited space maybe needs to be calculated for each tickmark seperatly
 468         //or the staggering could be ignored in that case
 469     }
 470
 471     //------------------------------------------------
 472     //prepare properties for multipropertyset-interface of shape
 473     tNameSequence aPropNames;
 474     tAnySequence aPropValues;
 475
 476     Reference< beans::XPropertySet > xProps( m_aAxisProperties.m_xAxisModel, uno::UNO_QUERY );
 477     PropertyMapper::getTextLabelMultiPropertyLists( xProps, aPropNames, aPropValues, false
 478         , nLimitedSpace, fabs(aTextToTickDistance.getX()) > fabs(aTextToTickDistance.getY()) );
 479     LabelPositionHelper::doDynamicFontResize( aPropValues, aPropNames, xProps
 480         , m_aAxisLabelProperties.m_aFontReferenceSize );
 481     LabelPositionHelper::changeTextAdjustment( aPropValues, aPropNames, m_aAxisProperties.m_aLabelAlignment );
 482
 483     uno::Any* pColorAny = PropertyMapper::getValuePointer(aPropValues,aPropNames,C2U("CharColor"));
 484     sal_Int32 nColor = Color( COL_AUTO ).GetColor();
 485     if(pColorAny)
 486         *pColorAny >>= nColor;
 487     //------------------------------------------------
 488
 489     sal_Int32 nTick = 0;
 490     for( TickInfo* pTickInfo = rTickIter.firstInfo()
 491         ; pTickInfo
 492         ; pTickInfo = rTickIter.nextInfo(), nTick++ )
 493     {
 494         pLastVisibleNeighbourTickInfo = bIsStaggered ?
 495                     pPREPreviousVisibleTickInfo : pPreviousVisibleTickInfo;
 496
 497         //don't create labels which does not fit into the rythm
 498         if( nTick%rAxisLabelProperties.nRhythm != 0)
 499             continue;
 500
 501         //don't create labels for invisible ticks
 502         if( !pTickInfo->bPaintIt )
 503             continue;
 504
 505         //if NO OVERLAP -> don't create labels where the tick overlaps
 506         //with the text of the last neighbour tickmark
 507         if( pLastVisibleNeighbourTickInfo && !rAxisLabelProperties.bOverlapAllowed )
 508         {
 509             if( lcl_doesShapeOverlapWithTickmark( pLastVisibleNeighbourTickInfo->xTextShape
 510                        , rAxisLabelProperties.fRotationAngleDegree
 511                        , pTickInfo->aTickScreenPosition, pTickmarkHelper ) )
 512             {
 513                 bool bOverlapAlsoAfterSwitchingOnAutoStaggering = true;
 514                 if( !bIsStaggered && isAutoStaggeringOfLabelsAllowed( rAxisLabelProperties, pTickmarkHelper ) )
 515                 {
 516                     bIsStaggered = true;
 517                     rAxisLabelProperties.eStaggering = STAGGER_EVEN;
 518                     pLastVisibleNeighbourTickInfo = pPREPreviousVisibleTickInfo;
 519                     if( !pLastVisibleNeighbourTickInfo ||
 520                         !lcl_doesShapeOverlapWithTickmark( pLastVisibleNeighbourTickInfo->xTextShape
 521                                 , rAxisLabelProperties.fRotationAngleDegree
 522                                 , pTickInfo->aTickScreenPosition, pTickmarkHelper ) )
 523                         bOverlapAlsoAfterSwitchingOnAutoStaggering = false;
 524                 }
 525                 if( bOverlapAlsoAfterSwitchingOnAutoStaggering )
 526                 {
 527                     if( rAxisLabelProperties.bRhythmIsFix )
 528                         continue;
 529                     rAxisLabelProperties.nRhythm++;
 530                     TickIter aRemoveIter( m_aAllTickInfos, m_aIncrement, 0, 0 );
 531                     removeShapesAtWrongRythm( aRemoveIter, rAxisLabelProperties.nRhythm, nTick, xTarget );
 532                     return false;
 533                 }
 534             }
 535         }
 536
 537         pTickInfo->updateUnscaledValue( xInverseScaling );
 538
 539         bool bHasExtraColor=false;
 540         sal_Int32 nExtraColor=0;
 541
 542         rtl::OUString aLabel;
 543         if(pCategories)
 544         {
 545             sal_Int32 nIndex = static_cast< sal_Int32 >(pTickInfo->fUnscaledTickValue) - 1; //first category (index 0) matches with real number 1.0
 546             if( nIndex>=0 && nIndex<pCategories->getLength() )
 547                 aLabel = (*pCategories)[nIndex];
 548         }
 549         else
 550             aLabel = aFixedNumberFormatter.getFormattedString( pTickInfo->fUnscaledTickValue, nExtraColor, bHasExtraColor );
 551
 552         if(pColorAny)
 553             *pColorAny = uno::makeAny(bHasExtraColor?nExtraColor:nColor);
 554
 555         B2DVector aTickScreenPos2D( pTickInfo->aTickScreenPosition );
 556         aTickScreenPos2D += aTextToTickDistance;
 557         awt::Point aAnchorScreenPosition2D(
 558             static_cast<sal_Int32>(aTickScreenPos2D.getX())
 559             ,static_cast<sal_Int32>(aTickScreenPos2D.getY()));
 560
 561         //create single label
 562         if(!pTickInfo->xTextShape.is())
 563             pTickInfo->xTextShape = createSingleLabel( m_xShapeFactory, xTarget
 564                                     , aAnchorScreenPosition2D, aLabel
 565                                     , rAxisLabelProperties, m_aAxisProperties
 566                                     , aPropNames, aPropValues );
 567         if(!pTickInfo->xTextShape.is())
 568             continue;
 569
 570         recordMaximumTextSize( pTickInfo->xTextShape, rAxisLabelProperties.fRotationAngleDegree );
 571
 572         //if NO OVERLAP -> remove overlapping shapes
 573         if( pLastVisibleNeighbourTickInfo && !rAxisLabelProperties.bOverlapAllowed )
 574         {
 575             if( doesOverlap( pLastVisibleNeighbourTickInfo->xTextShape, pTickInfo->xTextShape, m_aAxisLabelProperties.fRotationAngleDegree ) )
 576             {
 577                 bool bOverlapAlsoAfterSwitchingOnAutoStaggering = true;
 578                 if( !bIsStaggered && isAutoStaggeringOfLabelsAllowed( rAxisLabelProperties, pTickmarkHelper ) )
 579                 {
 580                     bIsStaggered = true;
 581                     rAxisLabelProperties.eStaggering = STAGGER_EVEN;
 582                     pLastVisibleNeighbourTickInfo = pPREPreviousVisibleTickInfo;
 583                     if( !pLastVisibleNeighbourTickInfo ||
 584                         !lcl_doesShapeOverlapWithTickmark( pLastVisibleNeighbourTickInfo->xTextShape
 585                             , rAxisLabelProperties.fRotationAngleDegree
 586                             , pTickInfo->aTickScreenPosition, pTickmarkHelper ) )
 587                         bOverlapAlsoAfterSwitchingOnAutoStaggering = false;
 588                 }
 589                 if( bOverlapAlsoAfterSwitchingOnAutoStaggering )
 590                 {
 591                     if( rAxisLabelProperties.bRhythmIsFix )
 592                     {
 593                         xTarget->remove(pTickInfo->xTextShape);
 594                         pTickInfo->xTextShape = NULL;
 595                         continue;
 596                     }
 597                     rAxisLabelProperties.nRhythm++;
 598                     TickIter aRemoveIter( m_aAllTickInfos, m_aIncrement, 0, 0 );
 599                     removeShapesAtWrongRythm( aRemoveIter, rAxisLabelProperties.nRhythm, nTick, xTarget );
 600                     return false;
 601                 }
 602             }
 603         }
 604
 605         pPREPreviousVisibleTickInfo = pPreviousVisibleTickInfo;
 606         pPreviousVisibleTickInfo = pTickInfo;
 607     }
 608     return true;
 609 }
 610
 611 drawing::PointSequenceSequence lcl_makePointSequence( B2DVector& rStart, B2DVector& rEnd )
 612 {
 613     drawing::PointSequenceSequence aPoints(1);
 614     aPoints[0].realloc(2);
 615     aPoints[0][0].X = static_cast<sal_Int32>(rStart.getX());
 616     aPoints[0][0].Y = static_cast<sal_Int32>(rStart.getY());
 617     aPoints[0][1].X = static_cast<sal_Int32>(rEnd.getX());
 618     aPoints[0][1].Y = static_cast<sal_Int32>(rEnd.getY());
 619     return aPoints;
 620 }
 621
 622 double VCartesianAxis::getLogicValueWhereMainLineCrossesOtherAxis() const
 623 {
 624     double fMin = (m_nDimensionIndex==1) ? m_pPosHelper->getLogicMinX() : m_pPosHelper->getLogicMinY();
 625     double fMax = (m_nDimensionIndex==1) ? m_pPosHelper->getLogicMaxX() : m_pPosHelper->getLogicMaxY();
 626
 627     double fCrossesOtherAxis;
 628     if(m_aAxisProperties.m_pfMainLinePositionAtOtherAxis)
 629         fCrossesOtherAxis = *m_aAxisProperties.m_pfMainLinePositionAtOtherAxis;
 630     else
 631     {
 632         if( ::com::sun::star::chart::ChartAxisPosition_END == m_aAxisProperties.m_eCrossoverType )
 633             fCrossesOtherAxis = fMax;
 634         else
 635             fCrossesOtherAxis = fMin;
 636     }
 637     return fCrossesOtherAxis;
 638 }
 639
 640 double VCartesianAxis::getLogicValueWhereLabelLineCrossesOtherAxis() const
 641 {
 642     double fMin = (m_nDimensionIndex==1) ? m_pPosHelper->getLogicMinX() : m_pPosHelper->getLogicMinY();
 643     double fMax = (m_nDimensionIndex==1) ? m_pPosHelper->getLogicMaxX() : m_pPosHelper->getLogicMaxY();
 644
 645     double fCrossesOtherAxis;
 646     if( ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_START == m_aAxisProperties.m_eLabelPos )
 647         fCrossesOtherAxis = fMin;
 648     else if( ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_END == m_aAxisProperties.m_eLabelPos )
 649         fCrossesOtherAxis = fMax;
 650     else
 651         fCrossesOtherAxis = getLogicValueWhereMainLineCrossesOtherAxis();
 652     return fCrossesOtherAxis;
 653 }
 654
 655 bool VCartesianAxis::getLogicValueWhereExtraLineCrossesOtherAxis( double& fCrossesOtherAxis ) const
 656 {
 657     if( !m_aAxisProperties.m_pfExrtaLinePositionAtOtherAxis )
 658         return false;
 659     double fMin = (m_nDimensionIndex==1) ? m_pPosHelper->getLogicMinX() : m_pPosHelper->getLogicMinY();
 660     double fMax = (m_nDimensionIndex==1) ? m_pPosHelper->getLogicMaxX() : m_pPosHelper->getLogicMaxY();
 661     if( *m_aAxisProperties.m_pfExrtaLinePositionAtOtherAxis <= fMin
 662         || *m_aAxisProperties.m_pfExrtaLinePositionAtOtherAxis >= fMax )
 663         return false;
 664     fCrossesOtherAxis = *m_aAxisProperties.m_pfExrtaLinePositionAtOtherAxis;
 665     return true;
 666 }
 667
 668 B2DVector VCartesianAxis::getScreenPosition( double fLogicX, double fLogicY, double fLogicZ ) const
 669 {
 670     B2DVector aRet(0,0);
 671
 672     if( m_pPosHelper )
 673     {
 674         drawing::Position3D aScenePos = m_pPosHelper->transformLogicToScene( fLogicX, fLogicY, fLogicZ, true );
 675         if(3==m_nDimension)
 676         {
 677             if( m_xLogicTarget.is() && m_pPosHelper && m_pShapeFactory )
 678             {
 679                 tPropertyNameMap aDummyPropertyNameMap;
 680                 Reference< drawing::XShape > xShape3DAnchor = m_pShapeFactory->createCube( m_xLogicTarget
 681                         , aScenePos,drawing::Direction3D(1,1,1), 0, 0, aDummyPropertyNameMap);
 682                 awt::Point a2DPos = xShape3DAnchor->getPosition(); //get 2D position from xShape3DAnchor
 683                 m_xLogicTarget->remove(xShape3DAnchor);
 684                 aRet.setX( a2DPos.X );
 685                 aRet.setY( a2DPos.Y );
 686             }
 687             else
 688             {
 689                 DBG_ERROR("cannot calculate scrren position in VCartesianAxis::getScreenPosition");
 690             }
 691         }
 692         else
 693         {
 694             aRet.setX( aScenePos.PositionX );
 695             aRet.setY( aScenePos.PositionY );
 696         }
 697     }
 698
 699     return aRet;
 700 }
 701
 702 VCartesianAxis::ScreenPosAndLogicPos VCartesianAxis::getScreenPosAndLogicPos( double fLogicX_, double fLogicY_, double fLogicZ_ ) const
 703 {
 704     ScreenPosAndLogicPos aRet;
 705     aRet.fLogicX = fLogicX_;
 706     aRet.fLogicY = fLogicY_;
 707     aRet.fLogicZ = fLogicZ_;
 708     aRet.aScreenPos = getScreenPosition( fLogicX_, fLogicY_, fLogicZ_ );
 709     return aRet;
 710 }
 711
 712 typedef ::std::vector< VCartesianAxis::ScreenPosAndLogicPos > tScreenPosAndLogicPosList;
 713 struct lcl_LessXPos : ::std::binary_function< VCartesianAxis::ScreenPosAndLogicPos, VCartesianAxis::ScreenPosAndLogicPos, bool >
 714 {
 715     inline bool operator() ( const VCartesianAxis::ScreenPosAndLogicPos& rPos1, const VCartesianAxis::ScreenPosAndLogicPos& rPos2 )
 716     {
 717         return ( rPos1.aScreenPos.getX() < rPos2.aScreenPos.getX() );
 718     }
 719 };
 720
 721 struct lcl_GreaterYPos : ::std::binary_function< VCartesianAxis::ScreenPosAndLogicPos, VCartesianAxis::ScreenPosAndLogicPos, bool >
 722 {
 723     inline bool operator() ( const VCartesianAxis::ScreenPosAndLogicPos& rPos1, const VCartesianAxis::ScreenPosAndLogicPos& rPos2 )
 724     {
 725         return ( rPos1.aScreenPos.getY() > rPos2.aScreenPos.getY() );
 726     }
 727 };
 728
 729 void VCartesianAxis::get2DAxisMainLine( B2DVector& rStart, B2DVector& rEnd, double fCrossesOtherAxis )
 730 {
 731     //m_aAxisProperties might get updated and changed here because
 732     //    the label alignmant and inner direction sign depends exactly of the choice of the axis line position which is made here in this method
 733
 734     double fMinX = m_pPosHelper->getLogicMinX();
 735     double fMinY = m_pPosHelper->getLogicMinY();
 736     double fMinZ = m_pPosHelper->getLogicMinZ();
 737     double fMaxX = m_pPosHelper->getLogicMaxX();
 738     double fMaxY = m_pPosHelper->getLogicMaxY();
 739     double fMaxZ = m_pPosHelper->getLogicMaxZ();
 740
 741     double fXStart = fMinX;
 742     double fYStart = fMinY;
 743     double fZStart = fMinZ;
 744     double fXEnd = fXStart;
 745     double fYEnd = fYStart;
 746     double fZEnd = fZStart;
 747
 748     double fXOnXPlane = fMinX;
 749     double fXOther = fMaxX;
 750     int nDifferentValue = !m_pPosHelper->isMathematicalOrientationX() ? -1 : 1;
 751     if( !m_pPosHelper->isSwapXAndY() )
 752         nDifferentValue *= (CuboidPlanePosition_Left != m_eLeftWallPos) ? -1 : 1;
 753     else
 754         nDifferentValue *= (CuboidPlanePosition_Bottom != m_eBottomPos) ? -1 : 1;
 755     if( nDifferentValue<0 )
 756     {
 757         fXOnXPlane = fMaxX;
 758         fXOther = fMinX;
 759     }
 760
 761     double fYOnYPlane = fMinY;
 762     double fYOther = fMaxY;
 763     nDifferentValue = !m_pPosHelper->isMathematicalOrientationY() ? -1 : 1;
 764     if( !m_pPosHelper->isSwapXAndY() )
 765         nDifferentValue *= (CuboidPlanePosition_Bottom != m_eBottomPos) ? -1 : 1;
 766     else
 767         nDifferentValue *= (CuboidPlanePosition_Left != m_eLeftWallPos) ? -1 : 1;
 768     if( nDifferentValue<0 )
 769     {
 770         fYOnYPlane = fMaxY;
 771         fYOther = fMinY;
 772     }
 773
 774     double fZOnZPlane = fMaxZ;
 775     double fZOther = fMinZ;
 776     nDifferentValue = !m_pPosHelper->isMathematicalOrientationZ() ? -1 : 1;
 777     nDifferentValue *= (CuboidPlanePosition_Back != m_eBackWallPos) ? -1 : 1;
 778     if( nDifferentValue<0 )
 779     {
 780         fZOnZPlane = fMinZ;
 781         fZOther = fMaxZ;
 782     }
 783
 784     if( 0==m_nDimensionIndex ) //x-axis
 785     {
 786         if( fCrossesOtherAxis < fMinY )
 787             fCrossesOtherAxis = fMinY;
 788         else if( fCrossesOtherAxis > fMaxY )
 789             fCrossesOtherAxis = fMaxY;
 790
 791         fYStart = fYEnd = fCrossesOtherAxis;
 792         fXEnd=m_pPosHelper->getLogicMaxX();
 793
 794         if(3==m_nDimension)
 795         {
 796             if( AxisHelper::isAxisPositioningEnabled() )
 797             {
 798                 if( ::rtl::math::approxEqual( fYOther, fYStart) )
 799                     fZStart = fZEnd = fZOnZPlane;
 800                 else
 801                     fZStart = fZEnd = fZOther;
 802             }
 803             else
 804             {
 805                 rStart = getScreenPosition( fXStart, fYStart, fZStart );
 806                 rEnd = getScreenPosition( fXEnd, fYEnd, fZEnd );
 807
 808                 double fDeltaX = rEnd.getX() - rStart.getX();
 809                 double fDeltaY = rEnd.getY() - rStart.getY();
 810
 811                 //only those points are candidates which are lying on exactly one wall as these are outer edges
 812                 tScreenPosAndLogicPosList aPosList;
 813                 aPosList.push_back( getScreenPosAndLogicPos( fMinX, fYOnYPlane, fZOther ) );
 814                 aPosList.push_back( getScreenPosAndLogicPos( fMinX, fYOther, fZOnZPlane ) );
 815
 816                 if( fabs(fDeltaY) > fabs(fDeltaX)  )
 817                 {
 818                     m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_LEFT;
 819                     //choose most left positions
 820                     ::std::sort( aPosList.begin(), aPosList.end(), lcl_LessXPos() );
 821                     m_aAxisProperties.m_fLabelDirectionSign = fDeltaY<0 ? -1 : 1;
 822                 }
 823                 else
 824                 {
 825                     m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_BOTTOM;
 826                     //choose most bottom positions
 827                     ::std::sort( aPosList.begin(), aPosList.end(), lcl_GreaterYPos() );
 828                     m_aAxisProperties.m_fLabelDirectionSign = fDeltaX<0 ? -1 : 1;
 829                 }
 830                 ScreenPosAndLogicPos aBestPos( aPosList[0] );
 831                 fYStart = fYEnd = aBestPos.fLogicY;
 832                 fZStart = fZEnd = aBestPos.fLogicZ;
 833                 if( !m_pPosHelper->isMathematicalOrientationX() )
 834                     m_aAxisProperties.m_fLabelDirectionSign *= -1;
 835             }
 836         }//end 3D x axis
 837     }
 838     else if( 1==m_nDimensionIndex ) //y-axis
 839     {
 840         if( fCrossesOtherAxis < fMinX )
 841             fCrossesOtherAxis = fMinX;
 842         else if( fCrossesOtherAxis > fMaxX )
 843             fCrossesOtherAxis = fMaxX;
 844
 845         fXStart = fXEnd = fCrossesOtherAxis;
 846         fYEnd=m_pPosHelper->getLogicMaxY();
 847
 848         if(3==m_nDimension)
 849         {
 850             if( AxisHelper::isAxisPositioningEnabled() )
 851             {
 852                 if( ::rtl::math::approxEqual( fXOther, fXStart) )
 853                     fZStart = fZEnd = fZOnZPlane;
 854                 else
 855                     fZStart = fZEnd = fZOther;
 856             }
 857             else
 858             {
 859                 rStart = getScreenPosition( fXStart, fYStart, fZStart );
 860                 rEnd = getScreenPosition( fXEnd, fYEnd, fZEnd );
 861
 862                 double fDeltaX = rEnd.getX() - rStart.getX();
 863                 double fDeltaY = rEnd.getY() - rStart.getY();
 864
 865                 //only those points are candidates which are lying on exactly one wall as these are outer edges
 866                 tScreenPosAndLogicPosList aPosList;
 867                 aPosList.push_back( getScreenPosAndLogicPos( fXOnXPlane, fMinY, fZOther ) );
 868                 aPosList.push_back( getScreenPosAndLogicPos( fXOther, fMinY, fZOnZPlane ) );
 869
 870                 if( fabs(fDeltaY) > fabs(fDeltaX)  )
 871                 {
 872                     m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_LEFT;
 873                     //choose most left positions
 874                     ::std::sort( aPosList.begin(), aPosList.end(), lcl_LessXPos() );
 875                     m_aAxisProperties.m_fLabelDirectionSign = fDeltaY<0 ? -1 : 1;
 876                 }
 877                 else
 878                 {
 879                     m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_BOTTOM;
 880                     //choose most bottom positions
 881                     ::std::sort( aPosList.begin(), aPosList.end(), lcl_GreaterYPos() );
 882                     m_aAxisProperties.m_fLabelDirectionSign = fDeltaX<0 ? -1 : 1;
 883                 }
 884                 ScreenPosAndLogicPos aBestPos( aPosList[0] );
 885                 fXStart = fXEnd = aBestPos.fLogicX;
 886                 fZStart = fZEnd = aBestPos.fLogicZ;
 887                 if( !m_pPosHelper->isMathematicalOrientationY() )
 888                     m_aAxisProperties.m_fLabelDirectionSign *= -1;
 889             }
 890         }//end 3D y axis
 891     }
 892     else //z-axis
 893     {
 894         fZEnd = m_pPosHelper->getLogicMaxZ();
 895         if( AxisHelper::isAxisPositioningEnabled() )
 896         {
 897             if( !m_aAxisProperties.m_bSwapXAndY )
 898             {
 899                 if( fCrossesOtherAxis < fMinY )
 900                     fCrossesOtherAxis = fMinY;
 901                 else if( fCrossesOtherAxis > fMaxY )
 902                     fCrossesOtherAxis = fMaxY;
 903                 fYStart = fYEnd = fCrossesOtherAxis;
 904
 905                 if( ::rtl::math::approxEqual( fYOther, fYStart) )
 906                     fXStart = fXEnd = fXOnXPlane;
 907                 else
 908                     fXStart = fXEnd = fXOther;
 909             }
 910             else
 911             {
 912                 if( fCrossesOtherAxis < fMinX )
 913                     fCrossesOtherAxis = fMinX;
 914                 else if( fCrossesOtherAxis > fMaxX )
 915                     fCrossesOtherAxis = fMaxX;
 916                 fXStart = fXEnd = fCrossesOtherAxis;
 917
 918                 if( ::rtl::math::approxEqual( fXOther, fXStart) )
 919                     fYStart = fYEnd = fYOnYPlane;
 920                 else
 921                     fYStart = fYEnd = fYOther;
 922             }
 923         }
 924         else
 925         {
 926             if( !m_pPosHelper->isSwapXAndY() )
 927             {
 928                 fXStart = fXEnd = m_pPosHelper->isMathematicalOrientationX() ? m_pPosHelper->getLogicMaxX() : m_pPosHelper->getLogicMinX();
 929                 fYStart = fYEnd = m_pPosHelper->isMathematicalOrientationY() ? m_pPosHelper->getLogicMinY() : m_pPosHelper->getLogicMaxY();
 930             }
 931             else
 932             {
 933                 fXStart = fXEnd = m_pPosHelper->isMathematicalOrientationX() ? m_pPosHelper->getLogicMinX() : m_pPosHelper->getLogicMaxX();
 934                 fYStart = fYEnd = m_pPosHelper->isMathematicalOrientationY() ? m_pPosHelper->getLogicMaxY() : m_pPosHelper->getLogicMinY();
 935             }
 936
 937             if(3==m_nDimension)
 938             {
 939                 rStart = getScreenPosition( fXStart, fYStart, fZStart );
 940                 rEnd = getScreenPosition( fXEnd, fYEnd, fZEnd );
 941
 942                 double fDeltaX = rEnd.getX() - rStart.getX();
 943
 944                 //only those points are candidates which are lying on exactly one wall as these are outer edges
 945                 tScreenPosAndLogicPosList aPosList;
 946                 aPosList.push_back( getScreenPosAndLogicPos( fXOther, fYOnYPlane, fMinZ ) );
 947                 aPosList.push_back( getScreenPosAndLogicPos( fXOnXPlane, fYOther, fMinZ ) );
 948
 949                 ::std::sort( aPosList.begin(), aPosList.end(), lcl_GreaterYPos() );
 950                 ScreenPosAndLogicPos aBestPos( aPosList[0] );
 951                 ScreenPosAndLogicPos aNotSoGoodPos( aPosList[1] );
 952
 953                 //choose most bottom positions
 954                 if( !::rtl::math::approxEqual( fDeltaX, 0.0 ) ) // prefere left-right algnments
 955                 {
 956                     if( aBestPos.aScreenPos.getX() > aNotSoGoodPos.aScreenPos.getX() )
 957                         m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_RIGHT;
 958                     else
 959                          m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_LEFT;
 960                 }
 961                 else
 962                 {
 963                     if( aBestPos.aScreenPos.getY() > aNotSoGoodPos.aScreenPos.getY() )
 964                         m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_BOTTOM;
 965                     else
 966                          m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_TOP;
 967                 }
 968
 969                 m_aAxisProperties.m_fLabelDirectionSign = fDeltaX<0 ? -1 : 1;
 970                 if( !m_pPosHelper->isMathematicalOrientationZ() )
 971                     m_aAxisProperties.m_fLabelDirectionSign *= -1;
 972
 973                 fXStart = fXEnd = aBestPos.fLogicX;
 974                 fYStart = fYEnd = aBestPos.fLogicY;
 975             }
 976         }//end 3D z axis
 977     }
 978
 979     rStart = getScreenPosition( fXStart, fYStart, fZStart );
 980     rEnd = getScreenPosition( fXEnd, fYEnd, fZEnd );
 981
 982     if(3==m_nDimension && !AxisHelper::isAxisPositioningEnabled() )
 983         m_aAxisProperties.m_fInnerDirectionSign = m_aAxisProperties.m_fLabelDirectionSign;//to behave like before
 984
 985     if(3==m_nDimension && AxisHelper::isAxisPositioningEnabled() )
 986     {
 987         double fDeltaX = rEnd.getX() - rStart.getX();
 988         double fDeltaY = rEnd.getY() - rStart.getY();
 989
 990         if( 2==m_nDimensionIndex )
 991         {
 992             if( m_eLeftWallPos != CuboidPlanePosition_Left )
 993             {
 994                 m_aAxisProperties.m_fLabelDirectionSign *= -1.0;
 995                 m_aAxisProperties.m_fInnerDirectionSign *= -1.0;
 996             }
 997
 998             m_aAxisProperties.m_aLabelAlignment =
 999                 ( m_aAxisProperties.m_fLabelDirectionSign<0 ) ?
1000                     LABEL_ALIGN_LEFT :  LABEL_ALIGN_RIGHT;
1001
1002             if( ( fDeltaY<0 && m_aScale.Orientation == AxisOrientation_REVERSE ) ||
1003                 ( fDeltaY>0 && m_aScale.Orientation == AxisOrientation_MATHEMATICAL ) )
1004                 m_aAxisProperties.m_aLabelAlignment =
1005                     ( m_aAxisProperties.m_aLabelAlignment==LABEL_ALIGN_RIGHT ) ?
1006                         LABEL_ALIGN_LEFT :  LABEL_ALIGN_RIGHT;
1007         }
1008         else if( fabs(fDeltaY) > fabs(fDeltaX) )
1009         {
1010             if( m_eBackWallPos != CuboidPlanePosition_Back )
1011             {
1012                 m_aAxisProperties.m_fLabelDirectionSign *= -1.0;
1013                 m_aAxisProperties.m_fInnerDirectionSign *= -1.0;
1014             }
1015
1016             m_aAxisProperties.m_aLabelAlignment =
1017                 ( m_aAxisProperties.m_fLabelDirectionSign<0 ) ?
1018                     LABEL_ALIGN_LEFT :  LABEL_ALIGN_RIGHT;
1019
1020             if( ( fDeltaY<0 && m_aScale.Orientation == AxisOrientation_REVERSE ) ||
1021                 ( fDeltaY>0 && m_aScale.Orientation == AxisOrientation_MATHEMATICAL ) )
1022                 m_aAxisProperties.m_aLabelAlignment =
1023                     ( m_aAxisProperties.m_aLabelAlignment==LABEL_ALIGN_RIGHT ) ?
1024                         LABEL_ALIGN_LEFT :  LABEL_ALIGN_RIGHT;
1025         }
1026         else
1027         {
1028             if( m_eBackWallPos != CuboidPlanePosition_Back )
1029             {
1030                 m_aAxisProperties.m_fLabelDirectionSign *= -1.0;
1031                 m_aAxisProperties.m_fInnerDirectionSign *= -1.0;
1032             }
1033
1034             m_aAxisProperties.m_aLabelAlignment =
1035                 ( m_aAxisProperties.m_fLabelDirectionSign<0 ) ?
1036                     LABEL_ALIGN_TOP : LABEL_ALIGN_BOTTOM;
1037
1038             if( ( fDeltaX>0 && m_aScale.Orientation == AxisOrientation_REVERSE ) ||
1039                 ( fDeltaX<0 && m_aScale.Orientation == AxisOrientation_MATHEMATICAL ) )
1040                 m_aAxisProperties.m_aLabelAlignment =
1041                     ( m_aAxisProperties.m_aLabelAlignment==LABEL_ALIGN_TOP ) ?
1042                         LABEL_ALIGN_BOTTOM : LABEL_ALIGN_TOP;
1043         }
1044     }
1045 }
1046
1047 TickmarkHelper* VCartesianAxis::createTickmarkHelper()
1048 {
1049     return createTickmarkHelper2D();
1050 }
1051
1052 TickmarkHelper_2D* VCartesianAxis::createTickmarkHelper2D()
1053 {
1054     B2DVector aStart, aEnd;
1055     this->get2DAxisMainLine( aStart, aEnd, this->getLogicValueWhereMainLineCrossesOtherAxis() );
1056
1057     B2DVector aLabelLineStart, aLabelLineEnd;
1058     this->get2DAxisMainLine( aLabelLineStart, aLabelLineEnd, this->getLogicValueWhereLabelLineCrossesOtherAxis() );
1059
1060     return new TickmarkHelper_2D( m_aScale, m_aIncrement, aStart, aEnd, aLabelLineStart-aStart );
1061 }
1062
1063 sal_Int32 VCartesianAxis::estimateMaximumAutoMainIncrementCount()
1064 {
1065     sal_Int32 nRet = 10;
1066
1067     if( m_nMaximumTextWidthSoFar==0 && m_nMaximumTextHeightSoFar==0 )
1068         return nRet;
1069
1070     B2DVector aStart, aEnd;
1071     this->get2DAxisMainLine( aStart, aEnd, this->getLogicValueWhereMainLineCrossesOtherAxis() );
1072
1073     sal_Int32 nMaxHeight = static_cast<sal_Int32>(fabs(aEnd.getY()-aStart.getY()));
1074     sal_Int32 nMaxWidth = static_cast<sal_Int32>(fabs(aEnd.getX()-aStart.getX()));
1075
1076     sal_Int32 nTotalAvailable = nMaxHeight;
1077     sal_Int32 nSingleNeeded = m_nMaximumTextHeightSoFar;
1078
1079     //for horizontal axis:
1080     if( (m_nDimensionIndex == 0 && !m_aAxisProperties.m_bSwapXAndY)
1081         || (m_nDimensionIndex == 1 && m_aAxisProperties.m_bSwapXAndY) )
1082     {
1083         nTotalAvailable = nMaxWidth;
1084         nSingleNeeded = m_nMaximumTextWidthSoFar;
1085     }
1086
1087     if( nSingleNeeded>0 )
1088         nRet = nTotalAvailable/nSingleNeeded;
1089
1090     return nRet;
1091 }
1092
1093 void VCartesianAxis::doStaggeringOfLabels( const AxisLabelProperties& rAxisLabelProperties, TickmarkHelper_2D* pTickmarkHelper2D )
1094 {
1095     if( !pTickmarkHelper2D )
1096         return;
1097
1098     if( rAxisLabelProperties.getIsStaggered() )
1099     {
1100         LabelIterator aInnerIter( m_aAllTickInfos, m_aIncrement
1101             , rAxisLabelProperties.eStaggering, true, 0, 0 );
1102         LabelIterator aOuterIter( m_aAllTickInfos, m_aIncrement
1103             , rAxisLabelProperties.eStaggering, false, 0, 0 );
1104
1105         lcl_correctPositionForStaggering( aOuterIter
1106             , lcl_getStaggerDistance( aInnerIter
1107                 , pTickmarkHelper2D->getDistanceAxisTickToText( m_aAxisProperties ) ) );
1108     }
1109 }
1110
1111 void SAL_CALL VCartesianAxis::createLabels()
1112 {
1113     if( !prepareShapeCreation() )
1114         return;
1115
1116     //-----------------------------------------
1117     //create labels
1118     if( m_aAxisProperties.m_bDisplayLabels )
1119     {
1120         std::auto_ptr< TickmarkHelper_2D > apTickmarkHelper2D( this->createTickmarkHelper2D() );
1121         TickmarkHelper_2D* pTickmarkHelper2D = apTickmarkHelper2D.get();
1122         if( !pTickmarkHelper2D )
1123             return;
1124
1125         //-----------------------------------------
1126         //get the transformed screen values for all tickmarks in aAllTickInfos
1127         pTickmarkHelper2D->updateScreenValues( m_aAllTickInfos );
1128         //-----------------------------------------
1129         //'hide' tickmarks with identical screen values in aAllTickInfos
1130         pTickmarkHelper2D->hideIdenticalScreenValues( m_aAllTickInfos );
1131
1132         TickIter aRemoveIter( m_aAllTickInfos, m_aIncrement, 0, 0 );
1133         removeTextShapesFromTicks( aRemoveIter, m_xTextTarget );
1134
1135         //create tick mark text shapes
1136         TickIter aTickIter( m_aAllTickInfos, m_aIncrement, 0, 0 );
1137         while( !createTextShapes( m_xTextTarget, aTickIter
1138                         , m_aAxisLabelProperties, pTickmarkHelper2D ) )
1139         {
1140         };
1141
1142         doStaggeringOfLabels( m_aAxisLabelProperties, pTickmarkHelper2D );
1143     }
1144 }
1145
1146 void SAL_CALL VCartesianAxis::createMaximumLabels()
1147 {
1148     TrueGuard aRecordMaximumTextSize(m_bRecordMaximumTextSize);
1149
1150     if( !prepareShapeCreation() )
1151         return;
1152
1153     //-----------------------------------------
1154     //create labels
1155     if( m_aAxisProperties.m_bDisplayLabels )
1156     {
1157         std::auto_ptr< TickmarkHelper_2D > apTickmarkHelper2D( this->createTickmarkHelper2D() );
1158         TickmarkHelper_2D* pTickmarkHelper2D = apTickmarkHelper2D.get();
1159         if( !pTickmarkHelper2D )
1160             return;
1161
1162         //-----------------------------------------
1163         //get the transformed screen values for all tickmarks in aAllTickInfos
1164         pTickmarkHelper2D->updateScreenValues( m_aAllTickInfos );
1165
1166         //create tick mark text shapes
1167         //@todo: iterate through all tick depth wich should be labeled
1168
1169         sal_Int32 nLongestLabelIndex = m_bUseTextLabels
1170             ? this->getIndexOfLongestLabel( m_aTextLabels ) : 0;
1171         MaxLabelTickIter aTickIter( m_aAllTickInfos, m_aIncrement, nLongestLabelIndex );
1172         AxisLabelProperties aAxisLabelProperties( m_aAxisLabelProperties );
1173         if( isAutoStaggeringOfLabelsAllowed( aAxisLabelProperties, pTickmarkHelper2D ) )
1174             aAxisLabelProperties.eStaggering = STAGGER_EVEN;
1175         aAxisLabelProperties.bOverlapAllowed = true;
1176         aAxisLabelProperties.bLineBreakAllowed = false;
1177         while( !createTextShapes( m_xTextTarget, aTickIter
1178                         , aAxisLabelProperties, pTickmarkHelper2D ) )
1179         {
1180         };
1181
1182         doStaggeringOfLabels( aAxisLabelProperties, pTickmarkHelper2D );
1183     }
1184 }
1185
1186 void SAL_CALL VCartesianAxis::updatePositions()
1187 {
1188     //-----------------------------------------
1189     //update positions of labels
1190     if( m_aAxisProperties.m_bDisplayLabels )
1191     {
1192         std::auto_ptr< TickmarkHelper_2D > apTickmarkHelper2D( this->createTickmarkHelper2D() );
1193         TickmarkHelper_2D* pTickmarkHelper2D = apTickmarkHelper2D.get();
1194         if( !pTickmarkHelper2D )
1195             return;
1196
1197         //-----------------------------------------
1198         //update positions of all existing text shapes
1199         pTickmarkHelper2D->updateScreenValues( m_aAllTickInfos );
1200
1201         TickIter aTickIter( m_aAllTickInfos, m_aIncrement, 0, 0 );
1202
1203         Reference< drawing::XShape > xShape2DText;
1204         for( TickInfo* pTickInfo = aTickIter.firstInfo()
1205             ; pTickInfo; pTickInfo = aTickIter.nextInfo() )
1206         {
1207             if( !pTickInfo )
1208                 continue;
1209
1210             xShape2DText = pTickInfo->xTextShape;
1211             if( xShape2DText.is() )
1212             {
1213                 B2DVector aTextToTickDistance( pTickmarkHelper2D->getDistanceAxisTickToText( m_aAxisProperties ) );
1214                 B2DVector aTickScreenPos2D( pTickInfo->aTickScreenPosition );
1215                 aTickScreenPos2D += aTextToTickDistance;
1216                 awt::Point aAnchorScreenPosition2D(
1217                     static_cast<sal_Int32>(aTickScreenPos2D.getX())
1218                     ,static_cast<sal_Int32>(aTickScreenPos2D.getY()));
1219
1220                 // #i78696# use mathematically correct rotation now
1221                 const double fRotationAnglePi(m_aAxisLabelProperties.fRotationAngleDegree * (F_PI / -180.0));
1222                 uno::Any aATransformation = ShapeFactory::makeTransformation(aAnchorScreenPosition2D, fRotationAnglePi);
1223
1224                 //set new position
1225                 uno::Reference< beans::XPropertySet > xProp( xShape2DText, uno::UNO_QUERY );
1226                 if( xProp.is() )
1227                 {
1228                     try
1229                     {
1230                         xProp->setPropertyValue( C2U( "Transformation" ), aATransformation );
1231                     }
1232                     catch( uno::Exception& e )
1233                     {
1234                         ASSERT_EXCEPTION( e );
1235                     }
1236                 }
1237
1238                 //correctPositionForRotation
1239                 LabelPositionHelper::correctPositionForRotation( xShape2DText
1240                     , m_aAxisProperties.m_aLabelAlignment, m_aAxisLabelProperties.fRotationAngleDegree, false );
1241             }
1242         }
1243
1244         doStaggeringOfLabels( m_aAxisLabelProperties, pTickmarkHelper2D );
1245     }
1246 }
1247
1248 void SAL_CALL VCartesianAxis::createShapes()
1249 {
1250     if( !prepareShapeCreation() )
1251         return;
1252
1253     std::auto_ptr< TickmarkHelper_2D > apTickmarkHelper2D( this->createTickmarkHelper2D() );
1254     TickmarkHelper_2D* pTickmarkHelper2D = apTickmarkHelper2D.get();
1255     if( !pTickmarkHelper2D )
1256         return;
1257
1258     //-----------------------------------------
1259     //create tick mark line shapes
1260     if(2==m_nDimension)
1261     {
1262         ::std::vector< ::std::vector< TickInfo > > aAllShiftedTickInfos;
1263         if( m_aIncrement.ShiftedPosition )
1264         {
1265             pTickmarkHelper2D->getAllTicksShifted( aAllShiftedTickInfos );
1266             pTickmarkHelper2D->updateScreenValues( aAllShiftedTickInfos );
1267             pTickmarkHelper2D->hideIdenticalScreenValues( aAllShiftedTickInfos );
1268         }
1269         ::std::vector< ::std::vector< TickInfo > >& rAllTickInfos = m_aIncrement.ShiftedPosition ? aAllShiftedTickInfos : m_aAllTickInfos;
1270
1271         ::std::vector< ::std::vector< TickInfo > >::iterator aDepthIter             = rAllTickInfos.begin();
1272         const ::std::vector< ::std::vector< TickInfo > >::const_iterator aDepthEnd  = rAllTickInfos.end();
1273
1274         if(aDepthIter == aDepthEnd)//no tickmarks at all
1275             return;
1276
1277         sal_Int32 nTickmarkPropertiesCount = m_aAxisProperties.m_aTickmarkPropertiesList.size();
1278         for( sal_Int32 nDepth=0
1279             ; aDepthIter != aDepthEnd && nDepth < nTickmarkPropertiesCount
1280             ; aDepthIter++, nDepth++ )
1281         {
1282             const TickmarkProperties& rTickmarkProperties = m_aAxisProperties.m_aTickmarkPropertiesList[nDepth];
1283
1284             sal_Int32 nPointCount = (*aDepthIter).size();
1285             drawing::PointSequenceSequence aPoints(2*nPointCount);
1286
1287             ::std::vector< TickInfo >::const_iterator       aTickIter = (*aDepthIter).begin();
1288             const ::std::vector< TickInfo >::const_iterator aTickEnd  = (*aDepthIter).end();
1289             sal_Int32 nN = 0;
1290             for( ; aTickIter != aTickEnd; aTickIter++ )
1291             {
1292                 if( !(*aTickIter).bPaintIt )
1293                     continue;
1294
1295                 bool bTicksAtLabels = ( m_aAxisProperties.m_eTickmarkPos != ::com::sun::star::chart::ChartAxisMarkPosition_AT_AXIS );
1296                 double fInnerDirectionSign = m_aAxisProperties.m_fInnerDirectionSign;
1297                 if( bTicksAtLabels && m_aAxisProperties.m_eLabelPos == ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_END )
1298                     fInnerDirectionSign *= -1.0;
1299                 apTickmarkHelper2D->addPointSequenceForTickLine( aPoints, nN++, (*aTickIter).fScaledTickValue
1300                     , fInnerDirectionSign , rTickmarkProperties, bTicksAtLabels );
1301                 if( m_aAxisProperties.m_eTickmarkPos == ::com::sun::star::chart::ChartAxisMarkPosition_AT_LABELS_AND_AXIS )
1302                     apTickmarkHelper2D->addPointSequenceForTickLine( aPoints, nN++, (*aTickIter).fScaledTickValue
1303                         , m_aAxisProperties.m_fInnerDirectionSign, rTickmarkProperties, !bTicksAtLabels );
1304             }
1305             aPoints.realloc(nN);
1306             m_pShapeFactory->createLine2D( m_xGroupShape_Shapes, aPoints
1307                                         , &rTickmarkProperties.aLineProperties );
1308         }
1309         //-----------------------------------------
1310         //create axis main lines
1311         //it serves also as the handle shape for the axis selection
1312         {
1313             drawing::PointSequenceSequence aPoints(1);
1314             apTickmarkHelper2D->createPointSequenceForAxisMainLine( aPoints );
1315             Reference< drawing::XShape > xShape = m_pShapeFactory->createLine2D(
1316                     m_xGroupShape_Shapes, aPoints
1317                     , &m_aAxisProperties.m_aLineProperties );
1318             //because of this name this line will be used for marking the axis
1319             m_pShapeFactory->setShapeName( xShape, C2U("MarkHandles") );
1320         }
1321         //-----------------------------------------
1322         //create an additional line at NULL
1323         if( !AxisHelper::isAxisPositioningEnabled() )
1324         {
1325             double fExtraLineCrossesOtherAxis;
1326             if( getLogicValueWhereExtraLineCrossesOtherAxis(fExtraLineCrossesOtherAxis) )
1327             {
1328                 B2DVector aStart, aEnd;
1329                 this->get2DAxisMainLine( aStart, aEnd, fExtraLineCrossesOtherAxis );
1330                 drawing::PointSequenceSequence aPoints( lcl_makePointSequence(aStart,aEnd) );
1331                 Reference< drawing::XShape > xShape = m_pShapeFactory->createLine2D(
1332                         m_xGroupShape_Shapes, aPoints, &m_aAxisProperties.m_aLineProperties );
1333             }
1334         }
1335     }
1336
1337     //createLabels();
1338 }
1339
1340 //.............................................................................
1341 } //namespace chart
1342 //.............................................................................