15 files changed, 935 insertions, 40 deletions

diff --git a/chart2/source/view/axes/TickmarkHelper.cxx b/chart2/source/view/axes/TickmarkHelper.cxx
new file mode 100644
index 000000000000..f4f717722bed
--- /dev/null
+++ b/chart2/source/view/axes/TickmarkHelper.cxx
@@ -0,0 +1,934 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org.  If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_chart2.hxx"
+#include "TickmarkHelper.hxx"
+#include "ViewDefines.hxx"
+#include <rtl/math.hxx>
+#include <tools/debug.hxx>
+#include <memory>
+
+//.............................................................................
+namespace chart
+{
+//.............................................................................
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::chart2;
+using namespace ::rtl::math;
+using ::basegfx::B2DVector;
+
+TickInfo::TickInfo()
+: fScaledTickValue( 0.0 )
+, fUnscaledTickValue( 0.0 )
+, aTickScreenPosition(0.0,0.0)
+, bPaintIt( true )
+, xTextShape( NULL )
+, nFactorForLimitedTextWidth(1)
+{
+}
+
+void TickInfo::updateUnscaledValue( const uno::Reference< XScaling >& xInverseScaling )
+{
+    if( xInverseScaling.is() )
+        this->fUnscaledTickValue = xInverseScaling->doScaling( this->fScaledTickValue );
+    else
+        this->fUnscaledTickValue = this->fScaledTickValue;
+}
+
+sal_Int32 TickInfo::getScreenDistanceBetweenTicks( const TickInfo& rOherTickInfo ) const
+{
+    //return the positive distance between the two first tickmarks in screen values
+
+    B2DVector aDistance = rOherTickInfo.aTickScreenPosition - aTickScreenPosition;
+    sal_Int32 nRet = static_cast<sal_Int32>(aDistance.getLength());
+    if(nRet<0)
+        nRet *= -1;
+    return nRet;
+}
+
+PureTickIter::PureTickIter( ::std::vector< TickInfo >& rTickInfoVector )
+            : m_rTickVector(rTickInfoVector)
+            , m_aTickIter(m_rTickVector.begin())
+{
+}
+PureTickIter::~PureTickIter()
+{
+}
+TickInfo* PureTickIter::firstInfo()
+{
+    m_aTickIter = m_rTickVector.begin();
+    if(m_aTickIter!=m_rTickVector.end())
+        return &*m_aTickIter;
+    return 0;
+}
+TickInfo* PureTickIter::nextInfo()
+{
+    m_aTickIter++;
+    if(m_aTickIter!=m_rTickVector.end())
+        return &*m_aTickIter;
+    return 0;
+}
+
+EquidistantTickIter::EquidistantTickIter( const uno::Sequence< uno::Sequence< double > >& rTicks
+                   , const ExplicitIncrementData& rIncrement
+                   , sal_Int32 nMinDepth, sal_Int32 nMaxDepth )
+                : m_pSimpleTicks(&rTicks)
+                , m_pInfoTicks(0)
+                , m_rIncrement(rIncrement)
+                , m_nMinDepth(0), m_nMaxDepth(0)
+                , m_nTickCount(0), m_pnPositions(NULL)
+                , m_pnPreParentCount(NULL), m_pbIntervalFinished(NULL)
+                , m_nCurrentDepth(-1), m_nCurrentPos(-1), m_fCurrentValue( 0.0 )
+{
+    initIter( nMinDepth, nMaxDepth );
+}
+
+EquidistantTickIter::EquidistantTickIter( ::std::vector< ::std::vector< TickInfo > >& rTicks
+                   , const ExplicitIncrementData& rIncrement
+                   , sal_Int32 nMinDepth, sal_Int32 nMaxDepth )
+                : m_pSimpleTicks(NULL)
+                , m_pInfoTicks(&rTicks)
+                , m_rIncrement(rIncrement)
+                , m_nMinDepth(0), m_nMaxDepth(0)
+                , m_nTickCount(0), m_pnPositions(NULL)
+                , m_pnPreParentCount(NULL), m_pbIntervalFinished(NULL)
+                , m_nCurrentDepth(-1), m_nCurrentPos(-1), m_fCurrentValue( 0.0 )
+{
+    initIter( nMinDepth, nMaxDepth );
+}
+
+void EquidistantTickIter::initIter( sal_Int32 /*nMinDepth*/, sal_Int32 nMaxDepth )
+{
+    m_nMaxDepth = nMaxDepth;
+    if(nMaxDepth<0 || m_nMaxDepth>getMaxDepth())
+        m_nMaxDepth=getMaxDepth();
+
+    sal_Int32 nDepth = 0;
+    for( nDepth = 0; nDepth<=m_nMaxDepth ;nDepth++ )
+        m_nTickCount += getTickCount(nDepth);
+
+    if(!m_nTickCount)
+        return;
+
+    m_pnPositions      = new sal_Int32[m_nMaxDepth+1];
+
+    m_pnPreParentCount = new sal_Int32[m_nMaxDepth+1];
+    m_pbIntervalFinished = new bool[m_nMaxDepth+1];
+    m_pnPreParentCount[0] = 0;
+    m_pbIntervalFinished[0] = false;
+    double fParentValue = getTickValue(0,0);
+    for( nDepth = 1; nDepth<=m_nMaxDepth ;nDepth++ )
+    {
+        m_pbIntervalFinished[nDepth] = false;
+
+        sal_Int32 nPreParentCount = 0;
+        sal_Int32 nCount = getTickCount(nDepth);
+        for(sal_Int32 nN = 0; nN<nCount; nN++)
+        {
+            if(getTickValue(nDepth,nN) < fParentValue)
+                nPreParentCount++;
+            else
+                break;
+        }
+        m_pnPreParentCount[nDepth] = nPreParentCount;
+        if(nCount)
+        {
+            double fNextParentValue = getTickValue(nDepth,0);
+            if( fNextParentValue < fParentValue )
+                fParentValue = fNextParentValue;
+        }
+    }
+}
+
+EquidistantTickIter::~EquidistantTickIter()
+{
+    delete[] m_pnPositions;
+    delete[] m_pnPreParentCount;
+    delete[] m_pbIntervalFinished;
+}
+
+sal_Int32 EquidistantTickIter::getStartDepth() const
+{
+    //find the depth of the first visible tickmark:
+    //it is the depth of the smallest value
+    sal_Int32 nReturnDepth=0;
+    double fMinValue = DBL_MAX;
+    for(sal_Int32 nDepth = 0; nDepth<=m_nMaxDepth ;nDepth++ )
+    {
+        sal_Int32 nCount = getTickCount(nDepth);
+        if( !nCount )
+            continue;
+        double fThisValue = getTickValue(nDepth,0);
+        if(fThisValue<fMinValue)
+        {
+            nReturnDepth = nDepth;
+            fMinValue = fThisValue;
+        }
+    }
+    return nReturnDepth;
+}
+
+double* EquidistantTickIter::firstValue()
+{
+    if( gotoFirst() )
+    {
+        m_fCurrentValue = getTickValue(m_nCurrentDepth, m_pnPositions[m_nCurrentDepth]);
+        return &m_fCurrentValue;
+    }
+    return NULL;
+}
+
+TickInfo* EquidistantTickIter::firstInfo()
+{
+    if( m_pInfoTicks && gotoFirst() )
+        return &(*m_pInfoTicks)[m_nCurrentDepth][m_pnPositions[m_nCurrentDepth]];
+    return NULL;
+}
+
+sal_Int32 EquidistantTickIter::getIntervalCount( sal_Int32 nDepth )
+{
+    if(nDepth>m_rIncrement.SubIncrements.getLength() || nDepth<0)
+        return 0;
+
+    if(!nDepth)
+        return m_nTickCount;
+
+    return m_rIncrement.SubIncrements[nDepth-1].IntervalCount;
+}
+
+bool EquidistantTickIter::isAtLastPartTick()
+{
+    if(!m_nCurrentDepth)
+        return false;
+    sal_Int32 nIntervalCount = getIntervalCount( m_nCurrentDepth );
+    if(!nIntervalCount || nIntervalCount == 1)
+        return true;
+    if( m_pbIntervalFinished[m_nCurrentDepth] )
+        return false;
+    sal_Int32 nPos = m_pnPositions[m_nCurrentDepth]+1;
+    if(m_pnPreParentCount[m_nCurrentDepth])
+        nPos += nIntervalCount-1 - m_pnPreParentCount[m_nCurrentDepth];
+    bool bRet = nPos && nPos % (nIntervalCount-1) == 0;
+    if(!nPos && !m_pnPreParentCount[m_nCurrentDepth]
+             && m_pnPositions[m_nCurrentDepth-1]==-1 )
+         bRet = true;
+    return bRet;
+}
+
+bool EquidistantTickIter::gotoFirst()
+{
+    if( m_nMaxDepth<0 )
+        return false;
+    if( !m_nTickCount )
+        return false;
+
+    for(sal_Int32 nDepth = 0; nDepth<=m_nMaxDepth ;nDepth++ )
+        m_pnPositions[nDepth] = -1;
+
+    m_nCurrentPos   = 0;
+    m_nCurrentDepth = getStartDepth();
+    m_pnPositions[m_nCurrentDepth] = 0;
+    return true;
+}
+
+bool EquidistantTickIter::gotoNext()
+{
+    if( m_nCurrentPos < 0 )
+        return false;
+    m_nCurrentPos++;
+
+    if( m_nCurrentPos >= m_nTickCount )
+        return false;
+
+    if( m_nCurrentDepth==m_nMaxDepth && isAtLastPartTick() )
+    {
+        do
+        {
+            m_pbIntervalFinished[m_nCurrentDepth] = true;
+            m_nCurrentDepth--;
+        }
+        while( m_nCurrentDepth && isAtLastPartTick() );
+    }
+    else if( m_nCurrentDepth<m_nMaxDepth )
+    {
+        do
+        {
+            m_nCurrentDepth++;
+        }
+        while( m_nCurrentDepth<m_nMaxDepth );
+    }
+    m_pbIntervalFinished[m_nCurrentDepth] = false;
+    m_pnPositions[m_nCurrentDepth] = m_pnPositions[m_nCurrentDepth]+1;
+    return true;
+}
+
+bool EquidistantTickIter::gotoIndex( sal_Int32 nTickIndex )
+{
+    if( nTickIndex < 0 )
+        return false;
+    if( nTickIndex >= m_nTickCount )
+        return false;
+
+    if( nTickIndex < m_nCurrentPos )
+        if( !gotoFirst() )
+            return false;
+
+    while( nTickIndex > m_nCurrentPos )
+        if( !gotoNext() )
+            return false;
+
+    return true;
+}
+
+sal_Int32 EquidistantTickIter::getCurrentIndex() const
+{
+    return m_nCurrentPos;
+}
+sal_Int32 EquidistantTickIter::getMaxIndex() const
+{
+    return m_nTickCount-1;
+}
+
+double* EquidistantTickIter::nextValue()
+{
+    if( gotoNext() )
+    {
+        m_fCurrentValue = getTickValue(m_nCurrentDepth, m_pnPositions[m_nCurrentDepth]);
+        return &m_fCurrentValue;
+    }
+    return NULL;
+}
+
+TickInfo* EquidistantTickIter::nextInfo()
+{
+    if( m_pInfoTicks && gotoNext() &&
+        static_cast< sal_Int32 >(
+            (*m_pInfoTicks)[m_nCurrentDepth].size()) > m_pnPositions[m_nCurrentDepth] )
+    {
+        return &(*m_pInfoTicks)[m_nCurrentDepth][m_pnPositions[m_nCurrentDepth]];
+    }
+    return NULL;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+double TickmarkHelper::getMinimumAtIncrement( double fMin, const ExplicitIncrementData& rIncrement )
+{
+    //the returned value will be <= fMin and on a Major Tick given by rIncrement
+    if(rIncrement.Distance<=0.0)
+        return fMin;
+
+    double fRet = rIncrement.BaseValue +
+        floor( approxSub( fMin, rIncrement.BaseValue )
+                    / rIncrement.Distance)
+            *rIncrement.Distance;
+
+    if( fRet > fMin )
+    {
+        if( !approxEqual(fRet, fMin) )
+            fRet -= rIncrement.Distance;
+    }
+    return fRet;
+}
+double TickmarkHelper::getMaximumAtIncrement( double fMax, const ExplicitIncrementData& rIncrement )
+{
+    //the returned value will be >= fMax and on a Major Tick given by rIncrement
+    if(rIncrement.Distance<=0.0)
+        return fMax;
+
+    double fRet = rIncrement.BaseValue +
+        floor( approxSub( fMax, rIncrement.BaseValue )
+                    / rIncrement.Distance)
+            *rIncrement.Distance;
+
+    if( fRet < fMax )
+    {
+        if( !approxEqual(fRet, fMax) )
+            fRet += rIncrement.Distance;
+    }
+    return fRet;
+}
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+TickmarkHelper::TickmarkHelper(
+          const ExplicitScaleData& rScale, const ExplicitIncrementData& rIncrement )
+            : m_rScale( rScale )
+            , m_rIncrement( rIncrement )
+            , m_xInverseScaling(NULL)
+            , m_pfCurrentValues(NULL)
+{
+    //@todo: make sure that the scale is valid for the scaling
+
+    m_pfCurrentValues = new double[getTickDepth()];
+
+    if( m_rScale.Scaling.is() )
+    {
+        m_xInverseScaling = m_rScale.Scaling->getInverseScaling();
+        DBG_ASSERT( m_xInverseScaling.is(), "each Scaling needs to return a inverse Scaling" );
+    }
+
+    double fMin = m_fScaledVisibleMin = m_rScale.Minimum;
+    if( m_xInverseScaling.is() )
+    {
+        m_fScaledVisibleMin = m_rScale.Scaling->doScaling(m_fScaledVisibleMin);
+        if(m_rIncrement.PostEquidistant )
+            fMin = m_fScaledVisibleMin;
+    }
+
+    double fMax = m_fScaledVisibleMax = m_rScale.Maximum;
+    if( m_xInverseScaling.is() )
+    {
+        m_fScaledVisibleMax = m_rScale.Scaling->doScaling(m_fScaledVisibleMax);
+        if(m_rIncrement.PostEquidistant )
+            fMax = m_fScaledVisibleMax;
+    }
+
+    //--
+    m_fOuterMajorTickBorderMin = TickmarkHelper::getMinimumAtIncrement( fMin, m_rIncrement );
+    m_fOuterMajorTickBorderMax = TickmarkHelper::getMaximumAtIncrement( fMax, m_rIncrement );
+    //--
+
+    m_fOuterMajorTickBorderMin_Scaled = m_fOuterMajorTickBorderMin;
+    m_fOuterMajorTickBorderMax_Scaled = m_fOuterMajorTickBorderMax;
+    if(!m_rIncrement.PostEquidistant && m_xInverseScaling.is() )
+    {
+        m_fOuterMajorTickBorderMin_Scaled = m_rScale.Scaling->doScaling(m_fOuterMajorTickBorderMin);
+        m_fOuterMajorTickBorderMax_Scaled = m_rScale.Scaling->doScaling(m_fOuterMajorTickBorderMax);
+
+        //check validity of new range: m_fOuterMajorTickBorderMin <-> m_fOuterMajorTickBorderMax
+        //it is assumed here, that the original range in the given Scale is valid
+        if( !rtl::math::isFinite(m_fOuterMajorTickBorderMin_Scaled) )
+        {
+            m_fOuterMajorTickBorderMin += m_rIncrement.Distance;
+            m_fOuterMajorTickBorderMin_Scaled = m_rScale.Scaling->doScaling(m_fOuterMajorTickBorderMin);
+        }
+        if( !rtl::math::isFinite(m_fOuterMajorTickBorderMax_Scaled) )
+        {
+            m_fOuterMajorTickBorderMax -= m_rIncrement.Distance;
+            m_fOuterMajorTickBorderMax_Scaled = m_rScale.Scaling->doScaling(m_fOuterMajorTickBorderMax);
+        }
+    }
+}
+
+TickmarkHelper* TickmarkHelper::createShiftedTickmarkHelper() const
+{
+    ExplicitIncrementData aShiftedIncrement( m_rIncrement );
+    aShiftedIncrement.BaseValue = m_rIncrement.BaseValue-m_rIncrement.Distance/2.0;
+    return new TickmarkHelper( m_rScale, aShiftedIncrement );
+}
+
+TickmarkHelper::~TickmarkHelper()
+{
+    delete[] m_pfCurrentValues;
+}
+
+sal_Int32 TickmarkHelper::getTickDepth() const
+{
+    return m_rIncrement.SubIncrements.getLength() + 1;
+}
+
+sal_Int32 TickmarkHelper::getMaxTickCount( sal_Int32 nDepth ) const
+{
+    //return the maximum amount of ticks
+    //possibly open intervals at the two ends of the region are handled as if they were completely visible
+    //(this is necessary for calculating the sub ticks at the borders correctly)
+
+    if( nDepth >= getTickDepth() )
+        return 0;
+    if( m_fOuterMajorTickBorderMax < m_fOuterMajorTickBorderMin )
+        return 0;
+    if( m_rIncrement.Distance<=0.0)
+        return 0;
+
+    double fSub;
+    if(m_rIncrement.PostEquidistant  )
+        fSub = approxSub( m_fScaledVisibleMax, m_fScaledVisibleMin );
+    else
+        fSub = approxSub( m_rScale.Maximum, m_rScale.Minimum );
+
+    if (!isFinite(fSub))
+        return 0;
+
+    sal_Int32 nIntervalCount = static_cast<sal_Int32>( fSub / m_rIncrement.Distance );
+
+    nIntervalCount+=3;
+    for(sal_Int32 nN=0; nN<nDepth-1; nN++)
+    {
+        if( m_rIncrement.SubIncrements[nN].IntervalCount>1 )
+            nIntervalCount *= m_rIncrement.SubIncrements[nN].IntervalCount;
+    }
+
+    sal_Int32 nTickCount = nIntervalCount;
+    if(nDepth>0 && m_rIncrement.SubIncrements[nDepth-1].IntervalCount>1)
+        nTickCount = nIntervalCount * (m_rIncrement.SubIncrements[nDepth-1].IntervalCount-1);
+
+    return nTickCount;
+}
+
+double* TickmarkHelper::getMajorTick( sal_Int32 nTick ) const
+{
+    m_pfCurrentValues[0] = m_fOuterMajorTickBorderMin + nTick*m_rIncrement.Distance;
+
+    if(m_pfCurrentValues[0]>m_fOuterMajorTickBorderMax)
+    {
+        if( !approxEqual(m_pfCurrentValues[0],m_fOuterMajorTickBorderMax) )
+            return NULL;
+    }
+    if(m_pfCurrentValues[0]<m_fOuterMajorTickBorderMin)
+    {
+        if( !approxEqual(m_pfCurrentValues[0],m_fOuterMajorTickBorderMin) )
+            return NULL;
+    }
+
+    //return always the value after scaling
+    if(!m_rIncrement.PostEquidistant && m_xInverseScaling.is() )
+        m_pfCurrentValues[0] = m_rScale.Scaling->doScaling( m_pfCurrentValues[0] );
+
+    return &m_pfCurrentValues[0];
+}
+
+double* TickmarkHelper::getMinorTick( sal_Int32 nTick, sal_Int32 nDepth
+                            , double fStartParentTick, double fNextParentTick ) const
+{
+    //check validity of arguments
+    {
+        //DBG_ASSERT( fStartParentTick < fNextParentTick, "fStartParentTick >= fNextParentTick");
+        if(fStartParentTick >= fNextParentTick)
+            return NULL;
+        if(nDepth>m_rIncrement.SubIncrements.getLength() || nDepth<=0)
+            return NULL;
+
+        //subticks are only calculated if they are laying between parent ticks:
+        if(nTick<=0)
+            return NULL;
+        if(nTick>=m_rIncrement.SubIncrements[nDepth-1].IntervalCount)
+            return NULL;
+    }
+
+    bool    bPostEquidistant = m_rIncrement.SubIncrements[nDepth-1].PostEquidistant;
+
+    double fAdaptedStartParent = fStartParentTick;
+    double fAdaptedNextParent  = fNextParentTick;
+
+    if( !bPostEquidistant && m_xInverseScaling.is() )
+    {
+        fAdaptedStartParent = m_xInverseScaling->doScaling(fStartParentTick);
+        fAdaptedNextParent  = m_xInverseScaling->doScaling(fNextParentTick);
+    }
+
+    double fDistance = (fAdaptedNextParent - fAdaptedStartParent)/m_rIncrement.SubIncrements[nDepth-1].IntervalCount;
+
+    m_pfCurrentValues[nDepth] = fAdaptedStartParent + nTick*fDistance;
+
+    //return always the value after scaling
+    if(!bPostEquidistant && m_xInverseScaling.is() )
+        m_pfCurrentValues[nDepth] = m_rScale.Scaling->doScaling( m_pfCurrentValues[nDepth] );
+
+    if( !isWithinOuterBorder( m_pfCurrentValues[nDepth] ) )
+        return NULL;
+
+    return &m_pfCurrentValues[nDepth];
+}
+
+bool TickmarkHelper::isWithinOuterBorder( double fScaledValue ) const
+{
+    if(fScaledValue>m_fOuterMajorTickBorderMax_Scaled)
+        return false;
+    if(fScaledValue<m_fOuterMajorTickBorderMin_Scaled)
+        return false;
+
+    return true;
+}
+
+
+bool TickmarkHelper::isVisible( double fScaledValue ) const
+{
+    if(fScaledValue>m_fScaledVisibleMax)
+    {
+        if( !approxEqual(fScaledValue,m_fScaledVisibleMax) )
+            return false;
+    }
+    if(fScaledValue<m_fScaledVisibleMin)
+    {
+        if( !approxEqual(fScaledValue,m_fScaledVisibleMin) )
+            return false;
+    }
+    return true;
+}
+
+void TickmarkHelper::getAllTicks( ::std::vector< ::std::vector< TickInfo > >& rAllTickInfos ) const
+{
+    uno::Sequence< uno::Sequence< double > > aAllTicks;
+
+    //create point sequences for each tick depth
+    sal_Int32 nDepthCount = this->getTickDepth();
+    sal_Int32 nMaxMajorTickCount = this->getMaxTickCount( 0 );
+
+    aAllTicks.realloc(nDepthCount);
+    aAllTicks[0].realloc(nMaxMajorTickCount);
+
+    sal_Int32 nRealMajorTickCount = 0;
+    double* pValue = NULL;
+    for( sal_Int32 nMajorTick=0; nMajorTick<nMaxMajorTickCount; nMajorTick++ )
+    {
+        pValue = this->getMajorTick( nMajorTick );
+        if(!pValue)
+            continue;
+        aAllTicks[0][nRealMajorTickCount] = *pValue;
+        nRealMajorTickCount++;
+    }
+    if(!nRealMajorTickCount)
+        return;
+    aAllTicks[0].realloc(nRealMajorTickCount);
+
+    if(nDepthCount>0)
+        this->addSubTicks( 1, aAllTicks );
+
+    //so far we have added all ticks between the outer major tick marks
+    //this was necessary to create sub ticks correctly
+    //now we reduce all ticks to the visible ones that lie between the real borders
+    sal_Int32 nDepth = 0;
+    sal_Int32 nTick = 0;
+    for( nDepth = 0; nDepth < nDepthCount; nDepth++)
+    {
+        sal_Int32 nInvisibleAtLowerBorder = 0;
+        sal_Int32 nInvisibleAtUpperBorder = 0;
+        //we need only to check all ticks within the first major interval at each border
+        sal_Int32 nCheckCount = 1;
+        for(sal_Int32 nN=0; nN<nDepth; nN++)
+        {
+            if( m_rIncrement.SubIncrements[nN].IntervalCount>1 )
+                nCheckCount *= m_rIncrement.SubIncrements[nN].IntervalCount;
+        }
+        uno::Sequence< double >& rTicks = aAllTicks[nDepth];
+        sal_Int32 nCount = rTicks.getLength();
+        //check lower border
+        for( nTick=0; nTick<nCheckCount && nTick<nCount; nTick++)
+        {
+            if( !isVisible( rTicks[nTick] ) )
+                nInvisibleAtLowerBorder++;
+        }
+        //check upper border
+        for( nTick=nCount-1; nTick>nCount-1-nCheckCount && nTick>=0; nTick--)
+        {
+            if( !isVisible( rTicks[nTick] ) )
+                nInvisibleAtUpperBorder++;
+        }
+        //resize sequence
+        if( !nInvisibleAtLowerBorder && !nInvisibleAtUpperBorder)
+            continue;
+        if( !nInvisibleAtLowerBorder )
+            rTicks.realloc(nCount-nInvisibleAtUpperBorder);
+        else
+        {
+            sal_Int32 nNewCount = nCount-nInvisibleAtUpperBorder-nInvisibleAtLowerBorder;
+            if(nNewCount<0)
+                nNewCount=0;
+
+            uno::Sequence< double > aOldTicks(rTicks);
+            rTicks.realloc(nNewCount);
+            for(nTick = 0; nTick<nNewCount; nTick++)
+                rTicks[nTick] = aOldTicks[nInvisibleAtLowerBorder+nTick];
+        }
+    }
+
+    //fill return value
+    rAllTickInfos.resize(aAllTicks.getLength());
+    for( nDepth=0 ;nDepth<aAllTicks.getLength(); nDepth++ )
+    {
+        sal_Int32 nCount = aAllTicks[nDepth].getLength();
+        rAllTickInfos[nDepth].resize( nCount );
+        for(sal_Int32 nN = 0; nN<nCount; nN++)
+        {
+            rAllTickInfos[nDepth][nN].fScaledTickValue = aAllTicks[nDepth][nN];
+        }
+    }
+}
+
+void TickmarkHelper::getAllTicksShifted( ::std::vector< ::std::vector< TickInfo > >& rAllTickInfos ) const
+{
+    std::auto_ptr< TickmarkHelper > apShiftedTickmarkHelper( createShiftedTickmarkHelper() );
+    apShiftedTickmarkHelper->getAllTicks( rAllTickInfos );
+}
+
+void TickmarkHelper::addSubTicks( sal_Int32 nDepth, uno::Sequence< uno::Sequence< double > >& rParentTicks ) const
+{
+    EquidistantTickIter aIter( rParentTicks, m_rIncrement, 0, nDepth-1 );
+    double* pfNextParentTick = aIter.firstValue();
+    if(!pfNextParentTick)
+        return;
+    double fLastParentTick = *pfNextParentTick;
+    pfNextParentTick = aIter.nextValue();
+    if(!pfNextParentTick)
+        return;
+
+    sal_Int32 nMaxSubTickCount = this->getMaxTickCount( nDepth );
+    if(!nMaxSubTickCount)
+        return;
+
+    uno::Sequence< double > aSubTicks(nMaxSubTickCount);
+    sal_Int32 nRealSubTickCount = 0;
+    sal_Int32 nIntervalCount = m_rIncrement.SubIncrements[nDepth-1].IntervalCount;
+
+    double* pValue = NULL;
+    for(; pfNextParentTick; fLastParentTick=*pfNextParentTick, pfNextParentTick = aIter.nextValue())
+    {
+        for( sal_Int32 nPartTick = 1; nPartTick<nIntervalCount; nPartTick++ )
+        {
+            pValue = this->getMinorTick( nPartTick, nDepth
+                        , fLastParentTick, *pfNextParentTick );
+            if(!pValue)
+                continue;
+
+            aSubTicks[nRealSubTickCount] = *pValue;
+            nRealSubTickCount++;
+        }
+    }
+
+    aSubTicks.realloc(nRealSubTickCount);
+    rParentTicks[nDepth] = aSubTicks;
+    if(m_rIncrement.SubIncrements.getLength()>nDepth)
+        addSubTicks( nDepth+1, rParentTicks );
+}
+
+//-----------------------------------------------------------------------------
+// ___TickmarkHelper_2D___
+//-----------------------------------------------------------------------------
+TickmarkHelper_2D::TickmarkHelper_2D(
+          const ExplicitScaleData& rScale, const ExplicitIncrementData& rIncrement
+          //, double fStrech_SceneToScreen, double fOffset_SceneToScreen )
+          , const B2DVector& rStartScreenPos, const B2DVector& rEndScreenPos
+          , const B2DVector& rAxisLineToLabelLineShift )
+          : TickmarkHelper( rScale, rIncrement )
+          , m_aAxisStartScreenPosition2D(rStartScreenPos)
+          , m_aAxisEndScreenPosition2D(rEndScreenPos)
+          , m_aAxisLineToLabelLineShift(rAxisLineToLabelLineShift)
+          , m_fStrech_LogicToScreen(1.0)
+          , m_fOffset_LogicToScreen(0.0)
+{
+    double fWidthY = m_fScaledVisibleMax - m_fScaledVisibleMin;
+    if( AxisOrientation_MATHEMATICAL==m_rScale.Orientation )
+    {
+        m_fStrech_LogicToScreen = 1.0/fWidthY;
+        m_fOffset_LogicToScreen = -m_fScaledVisibleMin;
+    }
+    else
+    {
+        B2DVector aSwap(m_aAxisStartScreenPosition2D);
+        m_aAxisStartScreenPosition2D = m_aAxisEndScreenPosition2D;
+        m_aAxisEndScreenPosition2D = aSwap;
+
+        m_fStrech_LogicToScreen = -1.0/fWidthY;
+        m_fOffset_LogicToScreen = -m_fScaledVisibleMax;
+    }
+}
+
+TickmarkHelper* TickmarkHelper_2D::createShiftedTickmarkHelper() const
+{
+    ExplicitIncrementData aShiftedIncrement( m_rIncrement );
+    aShiftedIncrement.BaseValue = m_rIncrement.BaseValue-m_rIncrement.Distance/2.0;
+
+    ::basegfx::B2DVector aStart( m_aAxisStartScreenPosition2D );
+    ::basegfx::B2DVector aEnd( m_aAxisEndScreenPosition2D );
+    if( AxisOrientation_MATHEMATICAL==m_rScale.Orientation )
+        std::swap( aStart, aEnd );
+
+    return new TickmarkHelper_2D( m_rScale, aShiftedIncrement, aStart, aEnd, m_aAxisLineToLabelLineShift );
+}
+
+TickmarkHelper_2D::~TickmarkHelper_2D()
+{
+}
+
+bool TickmarkHelper_2D::isHorizontalAxis() const
+{
+    return ( m_aAxisStartScreenPosition2D.getY() == m_aAxisEndScreenPosition2D.getY() );
+}
+bool TickmarkHelper_2D::isVerticalAxis() const
+{
+    return ( m_aAxisStartScreenPosition2D.getX() == m_aAxisEndScreenPosition2D.getX() );
+}
+
+sal_Int32 TickmarkHelper_2D::getTickScreenDistance( TickIter& rIter )
+{
+    //return the positive distance between the two first tickmarks in screen values
+    //if there are less than two tickmarks -1 is returned
+
+    const TickInfo* pFirstTickInfo = rIter.firstInfo();
+    const TickInfo* pSecondTickInfo = rIter.nextInfo();
+    if(!pSecondTickInfo  || !pFirstTickInfo)
+        return -1;
+
+    return pFirstTickInfo->getScreenDistanceBetweenTicks( *pSecondTickInfo );
+}
+
+B2DVector TickmarkHelper_2D::getTickScreenPosition2D( double fScaledLogicTickValue ) const
+{
+    B2DVector aRet(m_aAxisStartScreenPosition2D);
+    aRet += (m_aAxisEndScreenPosition2D-m_aAxisStartScreenPosition2D)
+                *((fScaledLogicTickValue+m_fOffset_LogicToScreen)*m_fStrech_LogicToScreen);
+    return aRet;
+}
+
+void TickmarkHelper_2D::addPointSequenceForTickLine( drawing::PointSequenceSequence& rPoints
+                                , sal_Int32 nSequenceIndex
+                                , double fScaledLogicTickValue, double fInnerDirectionSign
+                                , const TickmarkProperties& rTickmarkProperties
+                                , bool bPlaceAtLabels ) const
+{
+    if( fInnerDirectionSign==0.0 )
+        fInnerDirectionSign = 1.0;
+
+    B2DVector aTickScreenPosition = this->getTickScreenPosition2D(fScaledLogicTickValue);
+    if( bPlaceAtLabels )
+        aTickScreenPosition += m_aAxisLineToLabelLineShift;
+
+    B2DVector aMainDirection = m_aAxisEndScreenPosition2D-m_aAxisStartScreenPosition2D;
+    aMainDirection.normalize();
+    B2DVector aOrthoDirection(-aMainDirection.getY(),aMainDirection.getX());
+    aOrthoDirection *= fInnerDirectionSign;
+    aOrthoDirection.normalize();
+
+    B2DVector aStart = aTickScreenPosition + aOrthoDirection*rTickmarkProperties.RelativePos;
+    B2DVector aEnd = aStart - aOrthoDirection*rTickmarkProperties.Length;
+
+    rPoints[nSequenceIndex].realloc(2);
+    rPoints[nSequenceIndex][0].X = static_cast<sal_Int32>(aStart.getX());
+    rPoints[nSequenceIndex][0].Y = static_cast<sal_Int32>(aStart.getY());
+    rPoints[nSequenceIndex][1].X = static_cast<sal_Int32>(aEnd.getX());
+    rPoints[nSequenceIndex][1].Y = static_cast<sal_Int32>(aEnd.getY());
+}
+
+B2DVector TickmarkHelper_2D::getDistanceAxisTickToText( const AxisProperties& rAxisProperties, bool bIncludeFarAwayDistanceIfSo, bool bIncludeSpaceBetweenTickAndText ) const
+{
+    bool bFarAwayLabels = false;
+    if( ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_START == rAxisProperties.m_eLabelPos
+        || ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_END == rAxisProperties.m_eLabelPos )
+        bFarAwayLabels = true;
+
+    double fInnerDirectionSign = rAxisProperties.m_fInnerDirectionSign;
+    if( fInnerDirectionSign==0.0 )
+        fInnerDirectionSign = 1.0;
+
+    B2DVector aMainDirection = m_aAxisEndScreenPosition2D-m_aAxisStartScreenPosition2D;
+    aMainDirection.normalize();
+    B2DVector aOrthoDirection(-aMainDirection.getY(),aMainDirection.getX());
+    aOrthoDirection *= fInnerDirectionSign;
+    aOrthoDirection.normalize();
+
+    B2DVector aStart(0,0), aEnd(0,0);
+    if( bFarAwayLabels )
+    {
+        TickmarkProperties aProps( AxisProperties::getBiggestTickmarkProperties() );
+        aStart = aOrthoDirection*aProps.RelativePos;
+        aEnd = aStart - aOrthoDirection*aProps.Length;
+    }
+    else
+    {
+        for( sal_Int32 nN=rAxisProperties.m_aTickmarkPropertiesList.size();nN--;)
+        {
+            const TickmarkProperties& rProps = rAxisProperties.m_aTickmarkPropertiesList[nN];
+            B2DVector aNewStart = aOrthoDirection*rProps.RelativePos;
+            B2DVector aNewEnd = aNewStart - aOrthoDirection*rProps.Length;
+            if(aNewStart.getLength()>aStart.getLength())
+                aStart=aNewStart;
+            if(aNewEnd.getLength()>aEnd.getLength())
+                aEnd=aNewEnd;
+        }
+    }
+
+    B2DVector aLabelDirection(aStart);
+    if( rAxisProperties.m_fInnerDirectionSign != rAxisProperties.m_fLabelDirectionSign )
+        aLabelDirection = aEnd;
+
+    B2DVector aOrthoLabelDirection(aOrthoDirection);
+    if( rAxisProperties.m_fInnerDirectionSign != rAxisProperties.m_fLabelDirectionSign )
+        aOrthoLabelDirection*=-1.0;
+    aOrthoLabelDirection.normalize();
+    if( bIncludeSpaceBetweenTickAndText )
+        aLabelDirection += aOrthoLabelDirection*AXIS2D_TICKLABELSPACING;
+    if( bFarAwayLabels && bIncludeFarAwayDistanceIfSo )
+        aLabelDirection += m_aAxisLineToLabelLineShift;
+    return aLabelDirection;
+}
+
+void TickmarkHelper_2D::createPointSequenceForAxisMainLine( drawing::PointSequenceSequence& rPoints ) const
+{
+    rPoints[0].realloc(2);
+    rPoints[0][0].X = static_cast<sal_Int32>(m_aAxisStartScreenPosition2D.getX());
+    rPoints[0][0].Y = static_cast<sal_Int32>(m_aAxisStartScreenPosition2D.getY());
+    rPoints[0][1].X = static_cast<sal_Int32>(m_aAxisEndScreenPosition2D.getX());
+    rPoints[0][1].Y = static_cast<sal_Int32>(m_aAxisEndScreenPosition2D.getY());
+}
+
+void TickmarkHelper_2D::updateScreenValues( ::std::vector< ::std::vector< TickInfo > >& rAllTickInfos ) const
+{
+    //get the transformed screen values for all tickmarks in rAllTickInfos
+    ::std::vector< ::std::vector< TickInfo > >::iterator aDepthIter       = rAllTickInfos.begin();
+    const ::std::vector< ::std::vector< TickInfo > >::const_iterator aDepthEnd  = rAllTickInfos.end();
+    for( ; aDepthIter != aDepthEnd; aDepthIter++ )
+    {
+        ::std::vector< TickInfo >::iterator       aTickIter = (*aDepthIter).begin();
+        const ::std::vector< TickInfo >::const_iterator aTickEnd  = (*aDepthIter).end();
+        for( ; aTickIter != aTickEnd; aTickIter++ )
+        {
+            TickInfo& rTickInfo = (*aTickIter);
+            rTickInfo.aTickScreenPosition =
+                this->getTickScreenPosition2D( rTickInfo.fScaledTickValue );
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+// ___TickmarkHelper_3D___
+//-----------------------------------------------------------------------------
+TickmarkHelper_3D::TickmarkHelper_3D(
+          const ExplicitScaleData& rScale, const ExplicitIncrementData& rIncrement )
+          : TickmarkHelper( rScale, rIncrement )
+{
+}
+
+TickmarkHelper* TickmarkHelper_3D::createShiftedTickmarkHelper() const
+{
+    ExplicitIncrementData aShiftedIncrement( m_rIncrement );
+    aShiftedIncrement.BaseValue = m_rIncrement.BaseValue-m_rIncrement.Distance/2.0;
+    return new TickmarkHelper_3D( m_rScale, aShiftedIncrement );
+}
+
+TickmarkHelper_3D::~TickmarkHelper_3D()
+{
+}
+
+//.............................................................................
+} //namespace chart
+//.............................................................................
diff --git a/chart2/source/view/axes/VAxisProperties.cxx b/chart2/source/view/axes/VAxisProperties.cxx
index d700ee9d27be..9f710d926e0c 100644
--- a/chart2/source/view/axes/VAxisProperties.cxx
+++ b/chart2/source/view/axes/VAxisProperties.cxx
@@ -157,7 +157,6 @@ TickmarkProperties AxisProperties::makeTickmarkPropertiesForComplexCategories(
     return aTickmarkProperties;
 }
 
-//static
 TickmarkProperties AxisProperties::getBiggestTickmarkProperties()
 {
     TickmarkProperties aTickmarkProperties;
diff --git a/chart2/source/view/axes/VCartesianGrid.cxx b/chart2/source/view/axes/VCartesianGrid.cxx
index 0baa9b2b6e9a..ff93feefa228 100644
--- a/chart2/source/view/axes/VCartesianGrid.cxx
+++ b/chart2/source/view/axes/VCartesianGrid.cxx
@@ -192,7 +192,6 @@ VCartesianGrid::~VCartesianGrid()
     m_pPosHelper = NULL;
 }
 
-//static
 void VCartesianGrid::fillLinePropertiesFromGridModel( ::std::vector<VLineProperties>& rLinePropertiesList
                                      , const Sequence< Reference< beans::XPropertySet > > & rGridPropertiesList )
 {
diff --git a/chart2/source/view/axes/VCoordinateSystem.cxx b/chart2/source/view/axes/VCoordinateSystem.cxx
index a99ab4368d60..42e6042d7e70 100644
--- a/chart2/source/view/axes/VCoordinateSystem.cxx
+++ b/chart2/source/view/axes/VCoordinateSystem.cxx
@@ -61,7 +61,6 @@ using namespace ::com::sun::star::chart2;
 using ::com::sun::star::uno::Reference;
 using ::com::sun::star::uno::Sequence;
 
-//static
 VCoordinateSystem* VCoordinateSystem::createCoordinateSystem(
             const Reference< XCoordinateSystem >& xCooSysModel )
 {
diff --git a/chart2/source/view/axes/VPolarGrid.cxx b/chart2/source/view/axes/VPolarGrid.cxx
index c3554fd4876b..30becdf4725d 100644
--- a/chart2/source/view/axes/VPolarGrid.cxx
+++ b/chart2/source/view/axes/VPolarGrid.cxx
@@ -77,7 +77,6 @@ void VPolarGrid::getAllTickInfos( sal_Int32 nDimensionIndex, ::std::vector< ::st
     aTickFactory.getAllTicks( rAllTickInfos );
 }
 
-//static
 void VPolarGrid::createLinePointSequence_ForAngleAxis(
         drawing::PointSequenceSequence& rPoints
         , ::std::vector< ::std::vector< TickInfo > >& rAllTickInfos
diff --git a/chart2/source/view/charttypes/VSeriesPlotter.cxx b/chart2/source/view/charttypes/VSeriesPlotter.cxx
index 6b2f916b03ec..c37842e19888 100644
--- a/chart2/source/view/charttypes/VSeriesPlotter.cxx
+++ b/chart2/source/view/charttypes/VSeriesPlotter.cxx
@@ -2137,7 +2137,6 @@ std::vector< ViewLegendEntry > SAL_CALL VSeriesPlotter::createLegendEntriesForCh
     return std::vector< ViewLegendEntry >();
 }
 
-//static
 VSeriesPlotter* VSeriesPlotter::createSeriesPlotter(
     const uno::Reference<XChartType>& xChartTypeModel
     , sal_Int32 nDimensionCount
diff --git a/chart2/source/view/main/ChartItemPool.cxx b/chart2/source/view/main/ChartItemPool.cxx
index 525f0a8de951..fe83c0eea7e2 100644
--- a/chart2/source/view/main/ChartItemPool.cxx
+++ b/chart2/source/view/main/ChartItemPool.cxx
@@ -65,7 +65,7 @@ ChartItemPool::ChartItemPool():
     SvULongs aTmp;
     ppPoolDefaults[SCHATTR_DATADESCR_AVAILABLE_PLACEMENTS - SCHATTR_START] = new SfxIntegerListItem(SCHATTR_DATADESCR_AVAILABLE_PLACEMENTS,aTmp);
     ppPoolDefaults[SCHATTR_DATADESCR_NO_PERCENTVALUE    - SCHATTR_START] = new SfxBoolItem(SCHATTR_DATADESCR_NO_PERCENTVALUE);
-    ppPoolDefaults[SCHATTR_PERCENT_NUMBERFORMAT_VALUE  - SCHATTR_START] = new SfxInt32Item(SCHATTR_PERCENT_NUMBERFORMAT_VALUE, 0);
+    ppPoolDefaults[SCHATTR_PERCENT_NUMBERFORMAT_VALUE  - SCHATTR_START] = new SfxUInt32Item(SCHATTR_PERCENT_NUMBERFORMAT_VALUE, 0);
     ppPoolDefaults[SCHATTR_PERCENT_NUMBERFORMAT_SOURCE - SCHATTR_START] = new SfxBoolItem(SCHATTR_PERCENT_NUMBERFORMAT_SOURCE);
 
     //legend
@@ -217,7 +217,6 @@ SfxMapUnit ChartItemPool::GetMetric(USHORT /* nWhich */) const
     return SFX_MAPUNIT_100TH_MM;
 }
 
-// static
 SfxItemPool* ChartItemPool::CreateChartItemPool()
 {
     return new ChartItemPool();
diff --git a/chart2/source/view/main/ChartView.cxx b/chart2/source/view/main/ChartView.cxx
index 4f39cac39c9d..72b40adfed88 100644
--- a/chart2/source/view/main/ChartView.cxx
+++ b/chart2/source/view/main/ChartView.cxx
@@ -118,7 +118,6 @@ using ::com::sun::star::uno::Sequence;
 using ::com::sun::star::uno::Any;
 using rtl::OUString;
 
-//static
 const uno::Sequence<sal_Int8>& ExplicitValueProvider::getUnoTunnelId()
 {
     static uno::Sequence<sal_Int8> * pSeq = 0;
@@ -135,7 +134,6 @@ const uno::Sequence<sal_Int8>& ExplicitValueProvider::getUnoTunnelId()
     return *pSeq;
 }
 
-//static
 ExplicitValueProvider* ExplicitValueProvider::getExplicitValueProvider(
         const Reference< uno::XInterface >& xChartView )
 {
@@ -1839,7 +1837,6 @@ bool lcl_getPropertySwapXAndYAxis( const uno::Reference< XDiagram >& xDiagram )
 
 }
 
-//static
 sal_Int32 ExplicitValueProvider::getExplicitNumberFormatKeyForAxis(
                   const Reference< chart2::XAxis >& xAxis
                 , const Reference< chart2::XCoordinateSystem > & xCorrespondingCoordinateSystem
@@ -1908,7 +1905,6 @@ sal_Int32 ExplicitValueProvider::getExplicitPercentageNumberFormatKeyForDataLabe
     return nFormat;
 }
 
-//static
 awt::Rectangle ExplicitValueProvider::addAxisTitleSizes(
             const Reference< frame::XModel >& xChartModel
             , const Reference< uno::XInterface >& xChartView
@@ -1976,7 +1972,6 @@ awt::Rectangle ExplicitValueProvider::addAxisTitleSizes(
     return aRet;
 }
 
-//static
 awt::Rectangle ExplicitValueProvider::substractAxisTitleSizes(
             const Reference< frame::XModel >& xChartModel
             , const Reference< uno::XInterface >& xChartView
diff --git a/chart2/source/view/main/DrawModelWrapper.cxx b/chart2/source/view/main/DrawModelWrapper.cxx
index 577f450172b5..83544d6a8f2b 100644
--- a/chart2/source/view/main/DrawModelWrapper.cxx
+++ b/chart2/source/view/main/DrawModelWrapper.cxx
@@ -370,7 +370,6 @@ SdrObject* DrawModelWrapper::getNamedSdrObject( const rtl::OUString& rName )
     return getNamedSdrObject( rName, GetPage(0) );
 }
 
-//static
 SdrObject* DrawModelWrapper::getNamedSdrObject( const String& rObjectCID, SdrObjList* pSearchList )
 {
     if(!pSearchList || rObjectCID.Len()==0)
@@ -390,7 +389,6 @@ SdrObject* DrawModelWrapper::getNamedSdrObject( const String& rObjectCID, SdrObj
     return 0;
 }
 
-//static
 bool DrawModelWrapper::removeShape( const uno::Reference< drawing::XShape >& xShape )
 {
     uno::Reference< container::XChild > xChild( xShape, uno::UNO_QUERY );
diff --git a/chart2/source/view/main/LabelPositionHelper.cxx b/chart2/source/view/main/LabelPositionHelper.cxx
index 24ec5a285468..cd954f53b7ba 100644
--- a/chart2/source/view/main/LabelPositionHelper.cxx
+++ b/chart2/source/view/main/LabelPositionHelper.cxx
@@ -67,7 +67,6 @@ awt::Point LabelPositionHelper::transformSceneToScreenPosition( const drawing::P
                   rScenePosition3D, m_xLogicTarget, m_pShapeFactory, m_nDimensionCount );
 }
 
-//static
 void LabelPositionHelper::changeTextAdjustment( tAnySequence& rPropValues, const tNameSequence& rPropNames, LabelAlignment eAlignment)
 {
     //HorizontalAdjustment
@@ -107,7 +106,6 @@ void lcl_doDynamicFontResize( uno::Any* pAOldAndNewFontHeightAny
     }
 }
 
-//static
 void LabelPositionHelper::doDynamicFontResize( tAnySequence& rPropValues
                     , const tNameSequence& rPropNames
                     , const uno::Reference< beans::XPropertySet >& xAxisModelProps
@@ -431,7 +429,6 @@ void lcl_correctRotation_Right_Bottom( double& rfXCorrection, double& rfYCorrect
 
 }//end anonymous namespace
 
-//static
 void LabelPositionHelper::correctPositionForRotation( const uno::Reference< drawing::XShape >& xShape2DText
                      , LabelAlignment eLabelAlignment, const double fRotationAngle, bool bRotateAroundCenter )
 {
diff --git a/chart2/source/view/main/PlottingPositionHelper.cxx b/chart2/source/view/main/PlottingPositionHelper.cxx
index 3f77115d9cf4..e257581d664b 100644
--- a/chart2/source/view/main/PlottingPositionHelper.cxx
+++ b/chart2/source/view/main/PlottingPositionHelper.cxx
@@ -212,7 +212,6 @@ drawing::Position3D PlottingPositionHelper::transformScaledLogicToScene(
     return SequenceToPosition3D(aSeq);
 }
 
-//static
 awt::Point PlottingPositionHelper::transformSceneToScreenPosition( const drawing::Position3D& rScenePosition3D
                 , const uno::Reference< drawing::XShapes >& xSceneTarget
                 , ShapeFactory* pShapeFactory
diff --git a/chart2/source/view/main/PropertyMapper.cxx b/chart2/source/view/main/PropertyMapper.cxx
index 1979582763fa..99b7c0bd2ae0 100644
--- a/chart2/source/view/main/PropertyMapper.cxx
+++ b/chart2/source/view/main/PropertyMapper.cxx
@@ -58,7 +58,6 @@ void lcl_overwriteOrAppendValues(
 
 } // anonymous namespace
 
-//static
 void PropertyMapper::setMappedProperties(
           const uno::Reference< beans::XPropertySet >& xTarget
         , const uno::Reference< beans::XPropertySet >& xSource
@@ -193,7 +192,6 @@ uno::Any* PropertyMapper::getValuePointerForLimitedSpace( tAnySequence& rPropVal
 //Schatten                          UNO_NAME_CHAR_SHADOWED bool
 */
 
-//static
 const tMakePropertyNameMap& PropertyMapper::getPropertyNameMapForCharacterProperties()
 {
     //shape property -- chart model object property
@@ -260,7 +258,6 @@ const tMakePropertyNameMap& PropertyMapper::getPropertyNameMapForCharacterProper
     return m_aShapePropertyMapForCharacterProperties;
 }
 
-//static
 const tMakePropertyNameMap& PropertyMapper::getPropertyNameMapForParagraphProperties()
 {
     //shape property -- chart model object property
@@ -277,7 +274,6 @@ const tMakePropertyNameMap& PropertyMapper::getPropertyNameMapForParagraphProper
     return m_aShapePropertyMapForParagraphProperties;
 }
 
-//static
 const tMakePropertyNameMap& PropertyMapper::getPropertyNameMapForFillProperties()
 {
     //shape property -- chart model object property
@@ -306,7 +302,6 @@ const tMakePropertyNameMap& PropertyMapper::getPropertyNameMapForFillProperties(
     return m_aShapePropertyMapForFillProperties;
 }
 
-//static
 const tMakePropertyNameMap& PropertyMapper::getPropertyNameMapForLineProperties()
 {
     //shape property -- chart model object property
@@ -322,7 +317,6 @@ const tMakePropertyNameMap& PropertyMapper::getPropertyNameMapForLineProperties(
     return m_aShapePropertyMapForLineProperties;
 }
 
-//static
 const tMakePropertyNameMap& PropertyMapper::getPropertyNameMapForFillAndLineProperties()
 {
     static tMakePropertyNameMap m_aShapePropertyMapForFillAndLineProperties =
@@ -334,7 +328,6 @@ const tMakePropertyNameMap& PropertyMapper::getPropertyNameMapForFillAndLineProp
     return m_aShapePropertyMapForFillAndLineProperties;
 }
 
-//static
 const tMakePropertyNameMap& PropertyMapper::getPropertyNameMapForTextShapeProperties()
 {
     static tMakePropertyNameMap m_aShapePropertyMapForTextShapeProperties =
@@ -357,7 +350,6 @@ const tMakePropertyNameMap& PropertyMapper::getPropertyNameMapForTextShapeProper
     return m_aShapePropertyMapForTextShapeProperties;
 }
 
-//static
 const tMakePropertyNameMap& PropertyMapper::getPropertyNameMapForLineSeriesProperties()
 {
     //shape property -- chart model object property
@@ -374,7 +366,6 @@ const tMakePropertyNameMap& PropertyMapper::getPropertyNameMapForLineSeriesPrope
     return m_aShapePropertyMapForLineSeriesProperties;
 }
 
-//static
 const tMakePropertyNameMap& PropertyMapper::getPropertyNameMapForFilledSeriesProperties()
 {
     //shape property -- chart model object property
@@ -410,7 +401,6 @@ const tMakePropertyNameMap& PropertyMapper::getPropertyNameMapForFilledSeriesPro
     return m_aShapePropertyMapForFilledSeriesProperties;
 }
 
-// static
 void PropertyMapper::setMultiProperties(
                   const tNameSequence& rNames
                 , const tAnySequence&  rValues
diff --git a/chart2/source/view/main/ShapeFactory.cxx b/chart2/source/view/main/ShapeFactory.cxx
index 721cabd15d83..311b5e076e9a 100644
--- a/chart2/source/view/main/ShapeFactory.cxx
+++ b/chart2/source/view/main/ShapeFactory.cxx
@@ -80,7 +80,6 @@ namespace chart
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 
-//static
 void ShapeFactory::setShapeName( const uno::Reference< drawing::XShape >& xShape
                                , const rtl::OUString& rName )
 {
@@ -104,7 +103,6 @@ void ShapeFactory::setShapeName( const uno::Reference< drawing::XShape >& xShape
 
 //-----------------------------------------------------------------------------
 
-//static
 rtl::OUString ShapeFactory::getShapeName( const uno::Reference< drawing::XShape >& xShape )
 {
     rtl::OUString aRet;
@@ -1961,7 +1959,6 @@ uno::Reference< drawing::XShape >
     return xShape;
 }
 
-//static
 rtl::OUString ShapeFactory::getStackedString( const rtl::OUString& rString, bool bStacked )
 {
     sal_Int32 nLen = rString.getLength();
@@ -1982,7 +1979,6 @@ rtl::OUString ShapeFactory::getStackedString( const rtl::OUString& rString, bool
     return aStackStr.makeStringAndClear();
 }
 
-//static
 bool ShapeFactory::hasPolygonAnyLines( drawing::PolyPolygonShape3D& rPoly)
 {
     // #i67757# check all contained polygons, if at least one polygon contains 2 or more points, return true
@@ -1992,7 +1988,6 @@ bool ShapeFactory::hasPolygonAnyLines( drawing::PolyPolygonShape3D& rPoly)
     return false;
 }
 
-//static
 bool ShapeFactory::isPolygonEmptyOrSinglePoint( drawing::PolyPolygonShape3D& rPoly)
 {
     // true, if empty polypolygon or one polygon with one point
@@ -2000,7 +1995,6 @@ bool ShapeFactory::isPolygonEmptyOrSinglePoint( drawing::PolyPolygonShape3D& rPo
         ((rPoly.SequenceX.getLength() == 1) && (rPoly.SequenceX[0].getLength() <= 1));
 }
 
-//static
 void ShapeFactory::closePolygon( drawing::PolyPolygonShape3D& rPoly)
 {
     DBG_ASSERT( rPoly.SequenceX.getLength() <= 1, "ShapeFactory::closePolygon - single polygon expected" );
@@ -2011,7 +2005,6 @@ void ShapeFactory::closePolygon( drawing::PolyPolygonShape3D& rPoly)
     AddPointToPoly( rPoly, aFirst );
 }
 
-//static
 awt::Size ShapeFactory::calculateNewSizeRespectingAspectRatio(
          const awt::Size& rTargetSize
          , const awt::Size& rSourceSizeWithCorrectAspectRatio )
@@ -2027,7 +2020,6 @@ awt::Size ShapeFactory::calculateNewSizeRespectingAspectRatio(
     return aNewSize;
 }
 
-//static
 awt::Point ShapeFactory::calculateTopLeftPositionToCenterObject(
            const awt::Point& rTargetAreaPosition
          , const awt::Size& rTargetAreaSize
@@ -2039,7 +2031,6 @@ awt::Point ShapeFactory::calculateTopLeftPositionToCenterObject(
     return aNewPosition;
 }
 
-//static
 ::basegfx::B2IRectangle ShapeFactory::getRectangleOfShape(
         const uno::Reference< drawing::XShape >& xShape )
 {
@@ -2055,7 +2046,6 @@ awt::Point ShapeFactory::calculateTopLeftPositionToCenterObject(
 
 }
 
-//static
 awt::Size ShapeFactory::getSizeAfterRotation(
          const uno::Reference< drawing::XShape >& xShape, double fRotationAngleDegree )
 {
diff --git a/chart2/source/view/main/VLegend.cxx b/chart2/source/view/main/VLegend.cxx
index e247060fe8d4..fbc74bad05a5 100644
--- a/chart2/source/view/main/VLegend.cxx
+++ b/chart2/source/view/main/VLegend.cxx
@@ -651,7 +651,6 @@ void VLegend::setDefaultWritingMode( sal_Int16 nDefaultWritingMode )
 
 // ----------------------------------------
 
-// static
 bool VLegend::isVisible( const Reference< XLegend > & xLegend )
 {
     if( ! xLegend.is())
diff --git a/chart2/source/view/main/VLegendSymbolFactory.cxx b/chart2/source/view/main/VLegendSymbolFactory.cxx
index 958a8defe0b6..d29b28e8dbe9 100644
--- a/chart2/source/view/main/VLegendSymbolFactory.cxx
+++ b/chart2/source/view/main/VLegendSymbolFactory.cxx
@@ -104,7 +104,6 @@ void lcl_setPropetiesToShape(
 namespace chart
 {
 
-// static
 Reference< drawing::XShape > VLegendSymbolFactory::createSymbol(
     const Reference< drawing::XShapes > xSymbolContainer,
     chart2::LegendSymbolStyle eStyle,