chart2/source/view/axes/Tickmarks.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "Tickmarks.hxx"
  21 #include "Tickmarks_Equidistant.hxx"
  22 #include "Tickmarks_Dates.hxx"
  23 #include <ViewDefines.hxx>
  24 #include <rtl/math.hxx>
  25
  26 using namespace ::com::sun::star;
  27 using namespace ::rtl::math;
  28 using ::basegfx::B2DVector;
  29
  30 namespace chart {
  31
  32 TickInfo::TickInfo( const uno::Reference<chart2::XScaling>& xInverse )
  33 : fScaledTickValue( 0.0 )
  34 , xInverseScaling( xInverse )
  35 , aTickScreenPosition(0.0,0.0)
  36 , bPaintIt( true )
  37 , xTextShape( nullptr )
  38 , nFactorForLimitedTextWidth(1)
  39 {
  40 }
  41
  42 double TickInfo::getUnscaledTickValue() const
  43 {
  44     if( xInverseScaling.is() )
  45         return xInverseScaling->doScaling( fScaledTickValue );
  46     else
  47         return fScaledTickValue;
  48 }
  49
  50 sal_Int32 TickInfo::getScreenDistanceBetweenTicks( const TickInfo& rOherTickInfo ) const
  51 {
  52     //return the positive distance between the two first tickmarks in screen values
  53
  54     B2DVector aDistance = rOherTickInfo.aTickScreenPosition - aTickScreenPosition;
  55     sal_Int32 nRet = static_cast<sal_Int32>(aDistance.getLength());
  56     if(nRet<0)
  57         nRet *= -1;
  58     return nRet;
  59 }
  60
  61 PureTickIter::PureTickIter( TickInfoArrayType& rTickInfoVector )
  62             : m_rTickVector(rTickInfoVector)
  63             , m_aTickIter(m_rTickVector.begin())
  64 {
  65 }
  66 PureTickIter::~PureTickIter()
  67 {
  68 }
  69 TickInfo* PureTickIter::firstInfo()
  70 {
  71     m_aTickIter = m_rTickVector.begin();
  72     if(m_aTickIter!=m_rTickVector.end())
  73         return &*m_aTickIter;
  74     return nullptr;
  75 }
  76 TickInfo* PureTickIter::nextInfo()
  77 {
  78     if(m_aTickIter!=m_rTickVector.end())
  79     {
  80         ++m_aTickIter;
  81         if(m_aTickIter!=m_rTickVector.end())
  82             return &*m_aTickIter;
  83     }
  84     return nullptr;
  85 }
  86
  87 TickFactory::TickFactory(
  88           const ExplicitScaleData& rScale, const ExplicitIncrementData& rIncrement )
  89             : m_rScale( rScale )
  90             , m_rIncrement( rIncrement )
  91             , m_xInverseScaling(nullptr)
  92 {
  93     //@todo: make sure that the scale is valid for the scaling
  94
  95     if( m_rScale.Scaling.is() )
  96     {
  97         m_xInverseScaling = m_rScale.Scaling->getInverseScaling();
  98         OSL_ENSURE( m_xInverseScaling.is(), "each Scaling needs to return a inverse Scaling" );
  99     }
 100
 101     m_fScaledVisibleMin = m_rScale.Minimum;
 102     if( m_xInverseScaling.is() )
 103         m_fScaledVisibleMin = m_rScale.Scaling->doScaling(m_fScaledVisibleMin);
 104
 105     m_fScaledVisibleMax = m_rScale.Maximum;
 106     if( m_xInverseScaling.is() )
 107         m_fScaledVisibleMax = m_rScale.Scaling->doScaling(m_fScaledVisibleMax);
 108 }
 109
 110 TickFactory::~TickFactory()
 111 {
 112 }
 113
 114 bool TickFactory::isDateAxis() const
 115 {
 116     return m_rScale.AxisType == chart2::AxisType::DATE;
 117 }
 118
 119 void TickFactory::getAllTicks( TickInfoArraysType& rAllTickInfos ) const
 120 {
 121     if( isDateAxis() )
 122         DateTickFactory( m_rScale, m_rIncrement ).getAllTicks( rAllTickInfos );
 123     else
 124         EquidistantTickFactory( m_rScale, m_rIncrement ).getAllTicks( rAllTickInfos );
 125 }
 126
 127 void TickFactory::getAllTicksShifted( TickInfoArraysType& rAllTickInfos ) const
 128 {
 129     if( isDateAxis() )
 130         DateTickFactory( m_rScale, m_rIncrement ).getAllTicksShifted( rAllTickInfos );
 131     else
 132         EquidistantTickFactory( m_rScale, m_rIncrement ).getAllTicksShifted( rAllTickInfos );
 133 }
 134
 135 // ___TickFactory_2D___
 136 TickFactory2D::TickFactory2D(
 137           const ExplicitScaleData& rScale, const ExplicitIncrementData& rIncrement
 138           //, double fStretch_SceneToScreen, double fOffset_SceneToScreen )
 139           , const B2DVector& rStartScreenPos, const B2DVector& rEndScreenPos
 140           , const B2DVector& rAxisLineToLabelLineShift )
 141           : TickFactory( rScale, rIncrement )
 142           , m_aAxisStartScreenPosition2D(rStartScreenPos)
 143           , m_aAxisEndScreenPosition2D(rEndScreenPos)
 144           , m_aAxisLineToLabelLineShift(rAxisLineToLabelLineShift)
 145           , m_fStretch_LogicToScreen(1.0)
 146           , m_fOffset_LogicToScreen(0.0)
 147 {
 148     double fWidthY = m_fScaledVisibleMax - m_fScaledVisibleMin;
 149     if (m_rScale.Orientation == chart2::AxisOrientation_MATHEMATICAL)
 150     {
 151         m_fStretch_LogicToScreen = 1.0/fWidthY;
 152         m_fOffset_LogicToScreen = -m_fScaledVisibleMin;
 153     }
 154     else
 155     {
 156         B2DVector aSwap(m_aAxisStartScreenPosition2D);
 157         m_aAxisStartScreenPosition2D = m_aAxisEndScreenPosition2D;
 158         m_aAxisEndScreenPosition2D = aSwap;
 159
 160         m_fStretch_LogicToScreen = -1.0/fWidthY;
 161         m_fOffset_LogicToScreen = -m_fScaledVisibleMax;
 162     }
 163 }
 164
 165 TickFactory2D::~TickFactory2D()
 166 {
 167 }
 168
 169 bool TickFactory2D::isHorizontalAxis() const
 170 {
 171     // check trivial cases:
 172     if ( m_aAxisStartScreenPosition2D.getY() == m_aAxisEndScreenPosition2D.getY() )
 173         return true;
 174     if ( m_aAxisStartScreenPosition2D.getX() == m_aAxisEndScreenPosition2D.getX() )
 175         return false;
 176
 177     // for skew axes compare angle with horizontal vector
 178     double fInclination = std::abs(B2DVector(m_aAxisEndScreenPosition2D-m_aAxisStartScreenPosition2D).angle(B2DVector(1.0, 0.0)));
 179     return fInclination < F_PI4 || fInclination > (F_PI-F_PI4);
 180 }
 181 bool TickFactory2D::isVerticalAxis() const
 182 {
 183     // check trivial cases:
 184     if ( m_aAxisStartScreenPosition2D.getX() == m_aAxisEndScreenPosition2D.getX() )
 185         return true;
 186     if ( m_aAxisStartScreenPosition2D.getY() == m_aAxisEndScreenPosition2D.getY() )
 187         return false;
 188
 189     // for skew axes compare angle with vertical vector
 190     double fInclination = std::abs(B2DVector(m_aAxisEndScreenPosition2D-m_aAxisStartScreenPosition2D).angle(B2DVector(0.0, -1.0)));
 191     return fInclination < F_PI4 || fInclination > (F_PI-F_PI4);
 192 }
 193 //static
 194 sal_Int32 TickFactory2D::getTickScreenDistance( TickIter& rIter )
 195 {
 196     //return the positive distance between the two first tickmarks in screen values
 197     //if there are less than two tickmarks -1 is returned
 198
 199     const TickInfo* pFirstTickInfo = rIter.firstInfo();
 200     const TickInfo* pSecondTickInfo = rIter.nextInfo();
 201     if(!pSecondTickInfo  || !pFirstTickInfo)
 202         return -1;
 203
 204     return pFirstTickInfo->getScreenDistanceBetweenTicks( *pSecondTickInfo );
 205 }
 206
 207 B2DVector TickFactory2D::getTickScreenPosition2D( double fScaledLogicTickValue ) const
 208 {
 209     B2DVector aRet(m_aAxisStartScreenPosition2D);
 210     aRet += (m_aAxisEndScreenPosition2D-m_aAxisStartScreenPosition2D)
 211                 *((fScaledLogicTickValue+m_fOffset_LogicToScreen)*m_fStretch_LogicToScreen);
 212     return aRet;
 213 }
 214
 215 void TickFactory2D::addPointSequenceForTickLine( drawing::PointSequenceSequence& rPoints
 216                                 , sal_Int32 nSequenceIndex
 217                                 , double fScaledLogicTickValue, double fInnerDirectionSign
 218                                 , const TickmarkProperties& rTickmarkProperties
 219                                 , bool bPlaceAtLabels ) const
 220 {
 221     if( fInnerDirectionSign==0.0 )
 222         fInnerDirectionSign = 1.0;
 223
 224     B2DVector aTickScreenPosition = getTickScreenPosition2D(fScaledLogicTickValue);
 225     if( bPlaceAtLabels )
 226         aTickScreenPosition += m_aAxisLineToLabelLineShift;
 227
 228     B2DVector aMainDirection = m_aAxisEndScreenPosition2D-m_aAxisStartScreenPosition2D;
 229     aMainDirection.normalize();
 230     B2DVector aOrthoDirection(-aMainDirection.getY(),aMainDirection.getX());
 231     aOrthoDirection *= fInnerDirectionSign;
 232     aOrthoDirection.normalize();
 233
 234     B2DVector aStart = aTickScreenPosition + aOrthoDirection*rTickmarkProperties.RelativePos;
 235     B2DVector aEnd = aStart - aOrthoDirection*rTickmarkProperties.Length;
 236
 237     rPoints[nSequenceIndex].realloc(2);
 238     rPoints[nSequenceIndex][0].X = static_cast<sal_Int32>(aStart.getX());
 239     rPoints[nSequenceIndex][0].Y = static_cast<sal_Int32>(aStart.getY());
 240     rPoints[nSequenceIndex][1].X = static_cast<sal_Int32>(aEnd.getX());
 241     rPoints[nSequenceIndex][1].Y = static_cast<sal_Int32>(aEnd.getY());
 242 }
 243
 244 B2DVector TickFactory2D::getDistanceAxisTickToText( const AxisProperties& rAxisProperties, bool bIncludeFarAwayDistanceIfSo, bool bIncludeSpaceBetweenTickAndText ) const
 245 {
 246     bool bFarAwayLabels = false;
 247     if( rAxisProperties.m_eLabelPos == css::chart::ChartAxisLabelPosition_OUTSIDE_START
 248         || rAxisProperties.m_eLabelPos == css::chart::ChartAxisLabelPosition_OUTSIDE_END )
 249         bFarAwayLabels = true;
 250
 251     double fInnerDirectionSign = rAxisProperties.maLabelAlignment.mfInnerTickDirection;
 252     if( fInnerDirectionSign==0.0 )
 253         fInnerDirectionSign = 1.0;
 254
 255     B2DVector aMainDirection = m_aAxisEndScreenPosition2D-m_aAxisStartScreenPosition2D;
 256     aMainDirection.normalize();
 257     B2DVector aOrthoDirection(-aMainDirection.getY(),aMainDirection.getX());
 258     aOrthoDirection *= fInnerDirectionSign;
 259     aOrthoDirection.normalize();
 260
 261     B2DVector aStart(0,0), aEnd(0,0);
 262     if( bFarAwayLabels )
 263     {
 264         TickmarkProperties aProps( AxisProperties::getBiggestTickmarkProperties() );
 265         aStart = aOrthoDirection*aProps.RelativePos;
 266         aEnd = aStart - aOrthoDirection*aProps.Length;
 267     }
 268     else
 269     {
 270         for( sal_Int32 nN=rAxisProperties.m_aTickmarkPropertiesList.size();nN--;)
 271         {
 272             const TickmarkProperties& rProps = rAxisProperties.m_aTickmarkPropertiesList[nN];
 273             B2DVector aNewStart = aOrthoDirection*rProps.RelativePos;
 274             B2DVector aNewEnd = aNewStart - aOrthoDirection*rProps.Length;
 275             if(aNewStart.getLength()>aStart.getLength())
 276                 aStart=aNewStart;
 277             if(aNewEnd.getLength()>aEnd.getLength())
 278                 aEnd=aNewEnd;
 279         }
 280     }
 281
 282     B2DVector aLabelDirection(aStart);
 283     if (rAxisProperties.maLabelAlignment.mfInnerTickDirection != rAxisProperties.maLabelAlignment.mfLabelDirection)
 284         aLabelDirection = aEnd;
 285
 286     B2DVector aOrthoLabelDirection(aOrthoDirection);
 287     if (rAxisProperties.maLabelAlignment.mfInnerTickDirection != rAxisProperties.maLabelAlignment.mfLabelDirection)
 288         aOrthoLabelDirection*=-1.0;
 289     aOrthoLabelDirection.normalize();
 290     if( bIncludeSpaceBetweenTickAndText )
 291         aLabelDirection += aOrthoLabelDirection*AXIS2D_TICKLABELSPACING;
 292     if( bFarAwayLabels && bIncludeFarAwayDistanceIfSo )
 293         aLabelDirection += m_aAxisLineToLabelLineShift;
 294     return aLabelDirection;
 295 }
 296
 297 void TickFactory2D::createPointSequenceForAxisMainLine( drawing::PointSequenceSequence& rPoints ) const
 298 {
 299     rPoints[0].realloc(2);
 300     rPoints[0][0].X = static_cast<sal_Int32>(m_aAxisStartScreenPosition2D.getX());
 301     rPoints[0][0].Y = static_cast<sal_Int32>(m_aAxisStartScreenPosition2D.getY());
 302     rPoints[0][1].X = static_cast<sal_Int32>(m_aAxisEndScreenPosition2D.getX());
 303     rPoints[0][1].Y = static_cast<sal_Int32>(m_aAxisEndScreenPosition2D.getY());
 304 }
 305
 306 void TickFactory2D::updateScreenValues( TickInfoArraysType& rAllTickInfos ) const
 307 {
 308     //get the transformed screen values for all tickmarks in rAllTickInfos
 309     for (auto & tickInfos : rAllTickInfos)
 310     {
 311         for (auto & tickInfo : tickInfos)
 312         {
 313             tickInfo.aTickScreenPosition =
 314                 getTickScreenPosition2D(tickInfo.fScaledTickValue);
 315         }
 316     }
 317 }
 318
 319 } //namespace chart
 320
 321 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */