/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_chart2.hxx"
#include <basegfx/numeric/ftools.hxx>
#include "VCartesianAxis.hxx"
#include "PlottingPositionHelper.hxx"
#include "ShapeFactory.hxx"
#include "CommonConverters.hxx"
#include "macros.hxx"
#include "ViewDefines.hxx"
#include "PropertyMapper.hxx"
#include "NumberFormatterWrapper.hxx"
#include "LabelPositionHelper.hxx"
#include "TrueGuard.hxx"
#include "BaseGFXHelper.hxx"
#include "AxisHelper.hxx"
#include "Tickmarks_Equidistant.hxx"
#include <rtl/math.hxx>
#include <tools/color.hxx>
#include <tools/debug.hxx>
#include <com/sun/star/text/XText.hpp>
#include <com/sun/star/text/WritingMode2.hpp>
#include <editeng/unoprnms.hxx>
#include <svx/unoshape.hxx>
#include <svx/unoshtxt.hxx>
#include <algorithm>
#include <memory>
//.............................................................................
namespace chart
{
//.............................................................................
using namespace ::com::sun::star;
using namespace ::com::sun::star::chart2;
using namespace ::rtl::math;
using ::com::sun::star::uno::Reference;
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
VCartesianAxis::VCartesianAxis( const AxisProperties& rAxisProperties
, const Reference< util::XNumberFormatsSupplier >& xNumberFormatsSupplier
, sal_Int32 nDimensionIndex, sal_Int32 nDimensionCount
, PlottingPositionHelper* pPosHelper )//takes ownership
: VAxisBase( nDimensionIndex, nDimensionCount, rAxisProperties, xNumberFormatsSupplier )
{
if( pPosHelper )
m_pPosHelper = pPosHelper;
else
m_pPosHelper = new PlottingPositionHelper();
}
VCartesianAxis::~VCartesianAxis()
{
delete m_pPosHelper;
m_pPosHelper = NULL;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
Reference< drawing::XShape > createSingleLabel(
const Reference< lang::XMultiServiceFactory>& xShapeFactory
, const Reference< drawing::XShapes >& xTarget
, const awt::Point& rAnchorScreenPosition2D
, const rtl::OUString& rLabel
, const AxisLabelProperties& rAxisLabelProperties
, const AxisProperties& rAxisProperties
, const tNameSequence& rPropNames
, const tAnySequence& rPropValues
)
{
if( rLabel.isEmpty() )
return 0;
// #i78696# use mathematically correct rotation now
const double fRotationAnglePi(rAxisLabelProperties.fRotationAngleDegree * (F_PI / -180.0));
uno::Any aATransformation = ShapeFactory::makeTransformation( rAnchorScreenPosition2D, fRotationAnglePi );
rtl::OUString aLabel = ShapeFactory::getStackedString( rLabel, rAxisLabelProperties.bStackCharacters );
Reference< drawing::XShape > xShape2DText = ShapeFactory(xShapeFactory)
.createText( xTarget, aLabel, rPropNames, rPropValues, aATransformation );
//correctPositionForRotation
LabelPositionHelper::correctPositionForRotation( xShape2DText
, rAxisProperties.m_aLabelAlignment, rAxisLabelProperties.fRotationAngleDegree, rAxisProperties.m_bComplexCategories );
return xShape2DText;
}
bool lcl_doesShapeOverlapWithTickmark( const Reference< drawing::XShape >& xShape
, double fRotationAngleDegree
, const basegfx::B2DVector& rTickScreenPosition
, bool bIsHorizontalAxis, bool bIsVerticalAxis )
{
if(!xShape.is())
return false;
::basegfx::B2IRectangle aShapeRect = BaseGFXHelper::makeRectangle(xShape->getPosition(),ShapeFactory::getSizeAfterRotation( xShape, fRotationAngleDegree ));
if( bIsVerticalAxis )
{
return ( (rTickScreenPosition.getY() >= aShapeRect.getMinY())
&& (rTickScreenPosition.getY() <= aShapeRect.getMaxY()) );
}
if( bIsHorizontalAxis )
{
return ( (rTickScreenPosition.getX() >= aShapeRect.getMinX())
&& (rTickScreenPosition.getX() <= aShapeRect.getMaxX()) );
}
basegfx::B2IVector aPosition(
static_cast<sal_Int32>( rTickScreenPosition.getX() )
, static_cast<sal_Int32>( rTickScreenPosition.getY() ) );
return aShapeRect.isInside(aPosition);
}
bool doesOverlap( const Reference< drawing::XShape >& xShape1
, const Reference< drawing::XShape >& xShape2
, double fRotationAngleDegree )
{
if( !xShape1.is() || !xShape2.is() )
return false;
::basegfx::B2IRectangle aRect1( BaseGFXHelper::makeRectangle(xShape1->getPosition(),ShapeFactory::getSizeAfterRotation( xShape1, fRotationAngleDegree )));
::basegfx::B2IRectangle aRect2( BaseGFXHelper::makeRectangle(xShape2->getPosition(),ShapeFactory::getSizeAfterRotation( xShape2, fRotationAngleDegree )));
return aRect1.overlaps(aRect2);
}
void removeShapesAtWrongRhythm( TickIter& rIter
, sal_Int32 nCorrectRhythm
, sal_Int32 nMaxTickToCheck
, const Reference< drawing::XShapes >& xTarget )
{
sal_Int32 nTick = 0;
for( TickInfo* pTickInfo = rIter.firstInfo()
; pTickInfo && nTick <= nMaxTickToCheck
; pTickInfo = rIter.nextInfo(), nTick++ )
{
//remove labels which does not fit into the rhythm
if( nTick%nCorrectRhythm != 0)
{
if(pTickInfo->xTextShape.is())
{
xTarget->remove(pTickInfo->xTextShape);
pTickInfo->xTextShape = NULL;
}
}
}
}
class LabelIterator : public TickIter
{
//this Iterator iterates over existing text labels
//if the labels are staggered and bInnerLine is true
//we iterate only through the labels which are lying more inside the diagram
//if the labels are staggered and bInnerLine is false
//we iterate only through the labels which are lying more outside the diagram
//if the labels are not staggered
//we iterate through all labels
public:
LabelIterator( ::std::vector< TickInfo >& rTickInfoVector
, const AxisLabelStaggering eAxisLabelStaggering
, bool bInnerLine );
virtual TickInfo* firstInfo();
virtual TickInfo* nextInfo();
private: //methods
LabelIterator();
private: //member
PureTickIter m_aPureTickIter;
const AxisLabelStaggering m_eAxisLabelStaggering;
bool m_bInnerLine;
};
LabelIterator::LabelIterator( ::std::vector< TickInfo >& rTickInfoVector
, const AxisLabelStaggering eAxisLabelStaggering
, bool bInnerLine )
: m_aPureTickIter( rTickInfoVector )
, m_eAxisLabelStaggering(eAxisLabelStaggering)
, m_bInnerLine(bInnerLine)
{
}
TickInfo* LabelIterator::firstInfo()
{
TickInfo* pTickInfo = m_aPureTickIter.firstInfo();
while( pTickInfo && !pTickInfo->xTextShape.is() )
pTickInfo = m_aPureTickIter.nextInfo();
if(!pTickInfo)
return NULL;
if( (STAGGER_EVEN==m_eAxisLabelStaggering && m_bInnerLine)
||
(STAGGER_ODD==m_eAxisLabelStaggering && !m_bInnerLine)
)
{
//skip first label
do
pTickInfo = m_aPureTickIter.nextInfo();
while( pTickInfo && !pTickInfo->xTextShape.is() );
}
if(!pTickInfo)
return NULL;
return pTickInfo;
}
TickInfo* LabelIterator::nextInfo()
{
TickInfo* pTickInfo = NULL;
//get next label
do
pTickInfo = m_aPureTickIter.nextInfo();
while( pTickInfo && !pTickInfo->xTextShape.is() );
if( STAGGER_EVEN==m_eAxisLabelStaggering
|| STAGGER_ODD==m_eAxisLabelStaggering )
{
//skip one label
do
pTickInfo = m_aPureTickIter.nextInfo();
while( pTickInfo && !pTickInfo->xTextShape.is() );
}
return pTickInfo;
}
B2DVector lcl_getLabelsDistance( TickIter& rIter, const B2DVector& rDistanceTickToText, double fRotationAngleDegree )
{
//calculates the height or width of a line of labels
//thus a following line of labels can be shifted for that distance
B2DVector aRet(0,0);
sal_Int32 nDistanceTickToText = static_cast<sal_Int32>( rDistanceTickToText.getLength() );
if( nDistanceTickToText==0.0)
return aRet;
B2DVector aStaggerDirection(rDistanceTickToText);
aStaggerDirection.normalize();
sal_Int32 nDistance=0;
Reference< drawing::XShape > xShape2DText(NULL);
for( TickInfo* pTickInfo = rIter.firstInfo()
; pTickInfo
; pTickInfo = rIter.nextInfo() )
{
xShape2DText = pTickInfo->xTextShape;
if( xShape2DText.is() )
{
awt::Size aSize = ShapeFactory::getSizeAfterRotation( xShape2DText, fRotationAngleDegree );
if(fabs(aStaggerDirection.getX())>fabs(aStaggerDirection.getY()))
nDistance = ::std::max(nDistance,aSize.Width);
else
nDistance = ::std::max(nDistance,aSize.Height);
}
}
aRet = aStaggerDirection*nDistance;
//add extra distance for vertical distance
if(fabs(aStaggerDirection.getX())>fabs(aStaggerDirection.getY()))
aRet += rDistanceTickToText;
return aRet;
}
void lcl_shiftLables( TickIter& rIter, const B2DVector& rStaggerDistance )
{
if(rStaggerDistance.getLength()==0.0)
return;
Reference< drawing::XShape > xShape2DText(NULL);
for( TickInfo* pTickInfo = rIter.firstInfo()
; pTickInfo
; pTickInfo = rIter.nextInfo() )
{
xShape2DText = pTickInfo->xTextShape;
if( xShape2DText.is() )
{
awt::Point aPos = xShape2DText->getPosition();
aPos.X += static_cast<sal_Int32>(rStaggerDistance.getX());
aPos.Y += static_cast<sal_Int32>(rStaggerDistance.getY());
xShape2DText->setPosition( aPos );
}
}
}
bool lcl_hasWordBreak( const Reference< drawing::XShape >& rxShape )
{
if ( rxShape.is() )
{
SvxShape* pShape = SvxShape::getImplementation( rxShape );
SvxShapeText* pShapeText = dynamic_cast< SvxShapeText* >( pShape );
if ( pShapeText )
{
SvxTextEditSource* pTextEditSource = dynamic_cast< SvxTextEditSource* >( pShapeText->GetEditSource() );
if ( pTextEditSource )
{
pTextEditSource->UpdateOutliner();
SvxTextForwarder* pTextForwarder = pTextEditSource->GetTextForwarder();
if ( pTextForwarder )
{
sal_uInt16 nParaCount = pTextForwarder->GetParagraphCount();
for ( sal_uInt16 nPara = 0; nPara < nParaCount; ++nPara )
{
sal_uInt16 nLineCount = pTextForwarder->GetLineCount( nPara );
for ( sal_uInt16 nLine = 0; nLine < nLineCount; ++nLine )
{
sal_uInt16 nLineStart = 0;
sal_uInt16 nLineEnd = 0;
pTextForwarder->GetLineBoundaries( nLineStart, nLineEnd, nPara, nLine );
sal_uInt16 nWordStart = 0;
sal_uInt16 nWordEnd = 0;
if ( pTextForwarder->GetWordIndices( nPara, nLineStart, nWordStart, nWordEnd ) &&
( nWordStart != nLineStart ) )
{
return true;
}
}
}
}
}
}
}
return false;
}
class MaxLabelTickIter : public TickIter
{
//iterate over first two and last two labels and the longest label
public:
MaxLabelTickIter( ::std::vector< TickInfo >& rTickInfoVector
, sal_Int32 nLongestLabelIndex );
virtual ~MaxLabelTickIter();
virtual TickInfo* firstInfo();
virtual TickInfo* nextInfo();
private:
::std::vector< TickInfo >& m_rTickInfoVector;
::std::vector< sal_Int32 > m_aValidIndices;
sal_Int32 m_nCurrentIndex;
};
MaxLabelTickIter::MaxLabelTickIter( ::std::vector< TickInfo >& rTickInfoVector
, sal_Int32 nLongestLabelIndex )
: m_rTickInfoVector(rTickInfoVector)
, m_nCurrentIndex(0)
{
sal_Int32 nMaxIndex = m_rTickInfoVector.size()-1;
if( nLongestLabelIndex<0 || nLongestLabelIndex>=nMaxIndex-1 )
nLongestLabelIndex = 0;
if( nMaxIndex>=0 )
m_aValidIndices.push_back(0);
if( nMaxIndex>=1 )
m_aValidIndices.push_back(1);
if( nLongestLabelIndex>1 )
m_aValidIndices.push_back(nLongestLabelIndex);
if( nMaxIndex > 2 )
m_aValidIndices.push_back(nMaxIndex-1);
if( nMaxIndex > 1 )
m_aValidIndices.push_back(nMaxIndex);
}
MaxLabelTickIter::~MaxLabelTickIter()
{
}
TickInfo* MaxLabelTickIter::firstInfo()
{
m_nCurrentIndex = 0;
if( m_nCurrentIndex < static_cast<sal_Int32>(m_aValidIndices.size()) )
return &m_rTickInfoVector[m_aValidIndices[m_nCurrentIndex]];
return 0;
}
TickInfo* MaxLabelTickIter::nextInfo()
{
m_nCurrentIndex++;
if( m_nCurrentIndex>=0 && m_nCurrentIndex<static_cast<sal_Int32>(m_aValidIndices.size()) )
return &m_rTickInfoVector[m_aValidIndices[m_nCurrentIndex]];
return 0;
}
bool VCartesianAxis::isBreakOfLabelsAllowed( const AxisLabelProperties& rAxisLabelProperties
, bool bIsHorizontalAxis )
{
if( m_aTextLabels.getLength() > 100 )
return false;
if( !rAxisLabelProperties.bLineBreakAllowed )
return false;
if( rAxisLabelProperties.bStackCharacters )
return false;
//no break for value axis
if( !m_bUseTextLabels )
return false;
if( !::rtl::math::approxEqual( rAxisLabelProperties.fRotationAngleDegree, 0.0 ) )
return false;
//break only for horizontal axis
return bIsHorizontalAxis;
}
bool VCartesianAxis::isAutoStaggeringOfLabelsAllowed( const AxisLabelProperties& rAxisLabelProperties
, bool bIsHorizontalAxis, bool bIsVerticalAxis )
{
if( rAxisLabelProperties.eStaggering != STAGGER_AUTO )
return false;
if( rAxisLabelProperties.bOverlapAllowed )
return false;
if( rAxisLabelProperties.bLineBreakAllowed ) //auto line break or auto staggering, doing both automatisms they may conflict...
return false;
if( !::rtl::math::approxEqual( rAxisLabelProperties.fRotationAngleDegree, 0.0 ) )
return false;
//automatic staggering only for horizontal axis with horizontal text
//or vertical axis with vertical text
if( bIsHorizontalAxis )
return !rAxisLabelProperties.bStackCharacters;
if( bIsVerticalAxis )
return rAxisLabelProperties.bStackCharacters;
return false;
}
struct ComplexCategoryPlacement
{
rtl::OUString Text;
sal_Int32 Count;
double TickValue;
ComplexCategoryPlacement( const rtl::OUString& rText, sal_Int32 nCount, double fTickValue )
: Text(rText), Count(nCount), TickValue(fTickValue)
{}
};
void VCartesianAxis::createAllTickInfosFromComplexCategories( ::std::vector< ::std::vector< TickInfo > >& rAllTickInfos, bool bShiftedPosition )
{
//no minor tickmarks will be generated!
//order is: inner labels first , outer labels last (that is different to all other TickIter cases)
if(!bShiftedPosition)
{
rAllTickInfos.clear();
sal_Int32 nLevel=0;
sal_Int32 nLevelCount = m_aAxisProperties.m_pExplicitCategoriesProvider->getCategoryLevelCount();
for( ; nLevel<nLevelCount; nLevel++ )
{
::std::vector< TickInfo > aTickInfoVector;
std::vector< ComplexCategory > aComplexCategories( m_aAxisProperties.m_pExplicitCategoriesProvider->getCategoriesByLevel( nLevel ) );
sal_Int32 nCatIndex = 0;
std::vector< ComplexCategory >::const_iterator aIt(aComplexCategories.begin());
std::vector< ComplexCategory >::const_iterator aEnd(aComplexCategories.end());
for(;aIt!=aEnd;++aIt)
{
TickInfo aTickInfo(0);
ComplexCategory aCat(*aIt);
sal_Int32 nCount = aCat.Count;
if( nCatIndex + 1.0 + nCount >= m_aScale.Maximum )
{
nCount = static_cast<sal_Int32>(m_aScale.Maximum - 1.0 - nCatIndex);
if( nCount <= 0 )
nCount = 1;
}
aTickInfo.fScaledTickValue = nCatIndex + 1.0 + nCount/2.0;
aTickInfo.nFactorForLimitedTextWidth = nCount;
aTickInfo.aText = aCat.Text;
aTickInfoVector.push_back(aTickInfo);
nCatIndex += nCount;
if( nCatIndex + 1.0 >= m_aScale.Maximum )
break;
}
rAllTickInfos.push_back(aTickInfoVector);
}
}
else //bShiftedPosition==false
{
rAllTickInfos.clear();
sal_Int32 nLevel=0;
sal_Int32 nLevelCount = m_aAxisProperties.m_pExplicitCategoriesProvider->getCategoryLevelCount();
for( ; nLevel<nLevelCount; nLevel++ )
{
::std::vector< TickInfo > aTickInfoVector;
std::vector< ComplexCategory > aComplexCategories( m_aAxisProperties.m_pExplicitCategoriesProvider->getCategoriesByLevel( nLevel ) );
sal_Int32 nCatIndex = 0;
std::vector< ComplexCategory >::const_iterator aIt(aComplexCategories.begin());
std::vector< ComplexCategory >::const_iterator aEnd(aComplexCategories.end());
for(;aIt!=aEnd;++aIt)
{
TickInfo aTickInfo(0);
ComplexCategory aCat(*aIt);
aTickInfo.fScaledTickValue = nCatIndex + 1.0;
aTickInfoVector.push_back(aTickInfo);
nCatIndex += aCat.Count;
if( nCatIndex + 1.0 > m_aScale.Maximum )
break;
}
//fill up with single ticks until maximum scale
while( nCatIndex + 1.0 < m_aScale.Maximum )
{
TickInfo aTickInfo(0);
aTickInfo.fScaledTickValue = nCatIndex + 1.0;
aTickInfoVector.push_back(aTickInfo);
nCatIndex ++;
if( nLevel>0 )
break;
}
//add an additional tick at the end
{
TickInfo aTickInfo(0);
aTickInfo.fScaledTickValue = m_aScale.Maximum;
aTickInfoVector.push_back(aTickInfo);
}
rAllTickInfos.push_back(aTickInfoVector);
}
}
}
void VCartesianAxis::createAllTickInfos( ::std::vector< ::std::vector< TickInfo > >& rAllTickInfos )
{
if( isComplexCategoryAxis() )
createAllTickInfosFromComplexCategories( rAllTickInfos, false );
else
VAxisBase::createAllTickInfos(rAllTickInfos);
}
::std::auto_ptr< TickIter > VCartesianAxis::createLabelTickIterator( sal_Int32 nTextLevel )
{
if( nTextLevel>=0 && nTextLevel < static_cast< sal_Int32 >(m_aAllTickInfos.size()) )
return ::std::auto_ptr< TickIter >( new PureTickIter( m_aAllTickInfos[nTextLevel] ) );
return ::std::auto_ptr< TickIter >();
}
::std::auto_ptr< TickIter > VCartesianAxis::createMaximumLabelTickIterator( sal_Int32 nTextLevel )
{
if( isComplexCategoryAxis() || isDateAxis() )
{
return createLabelTickIterator( nTextLevel ); //mmmm maybe todo: create less than all texts here
}
else
{
if(nTextLevel==0)
{
if( !m_aAllTickInfos.empty() )
{
sal_Int32 nLongestLabelIndex = m_bUseTextLabels ? this->getIndexOfLongestLabel( m_aTextLabels ) : 0;
return ::std::auto_ptr< TickIter >( new MaxLabelTickIter( m_aAllTickInfos[0], nLongestLabelIndex ) );
}
}
}
return ::std::auto_ptr< TickIter >();
}
sal_Int32 VCartesianAxis::getTextLevelCount() const
{
sal_Int32 nTextLevelCount = 1;
if( isComplexCategoryAxis() )
nTextLevelCount = m_aAxisProperties.m_pExplicitCategoriesProvider->getCategoryLevelCount();
return nTextLevelCount;
}
bool VCartesianAxis::createTextShapes(
const Reference< drawing::XShapes >& xTarget
, TickIter& rTickIter
, AxisLabelProperties& rAxisLabelProperties
, TickFactory_2D* pTickFactory
, sal_Int32 nScreenDistanceBetweenTicks )
{
//returns true if the text shapes have been created succesfully
//otherwise false - in this case the AxisLabelProperties have changed
//and contain new instructions for the next try for text shape creation
Reference< XScaling > xInverseScaling( NULL );
if( m_aScale.Scaling.is() )
xInverseScaling = m_aScale.Scaling->getInverseScaling();
FixedNumberFormatter aFixedNumberFormatter(
m_xNumberFormatsSupplier, rAxisLabelProperties.nNumberFormatKey );
const bool bIsHorizontalAxis = pTickFactory->isHorizontalAxis();
const bool bIsVerticalAxis = pTickFactory->isVerticalAxis();
bool bIsStaggered = rAxisLabelProperties.getIsStaggered();
B2DVector aTextToTickDistance( pTickFactory->getDistanceAxisTickToText( m_aAxisProperties, true ) );
sal_Int32 nLimitedSpaceForText = -1;
if( isBreakOfLabelsAllowed( rAxisLabelProperties, bIsHorizontalAxis ) )
{
nLimitedSpaceForText = nScreenDistanceBetweenTicks;
if( bIsStaggered )
nLimitedSpaceForText *= 2;
if( nLimitedSpaceForText > 0 )
{ //reduce space for a small amount to have a visible distance between the labels:
sal_Int32 nReduce = (nLimitedSpaceForText*5)/100;
if(!nReduce)
nReduce = 1;
nLimitedSpaceForText -= nReduce;
}
}
std::vector< ComplexCategoryPlacement > aComplexCategoryPlacements;
uno::Sequence< rtl::OUString >* pCategories = 0;
if( m_bUseTextLabels && !m_aAxisProperties.m_bComplexCategories )
pCategories = &m_aTextLabels;
TickInfo* pPreviousVisibleTickInfo = NULL;
TickInfo* pPREPreviousVisibleTickInfo = NULL;
TickInfo* pLastVisibleNeighbourTickInfo = NULL;
//------------------------------------------------
//prepare properties for multipropertyset-interface of shape
tNameSequence aPropNames;
tAnySequence aPropValues;
bool bLimitedHeight = fabs(aTextToTickDistance.getX()) > fabs(aTextToTickDistance.getY());
Reference< beans::XPropertySet > xProps( m_aAxisProperties.m_xAxisModel, uno::UNO_QUERY );
PropertyMapper::getTextLabelMultiPropertyLists( xProps, aPropNames, aPropValues, false
, nLimitedSpaceForText, bLimitedHeight );
LabelPositionHelper::doDynamicFontResize( aPropValues, aPropNames, xProps
, m_aAxisLabelProperties.m_aFontReferenceSize );
LabelPositionHelper::changeTextAdjustment( aPropValues, aPropNames, m_aAxisProperties.m_aLabelAlignment );
uno::Any* pColorAny = PropertyMapper::getValuePointer(aPropValues,aPropNames,C2U("CharColor"));
sal_Int32 nColor = Color( COL_AUTO ).GetColor();
if(pColorAny)
*pColorAny >>= nColor;
uno::Any* pLimitedSpaceAny = PropertyMapper::getValuePointerForLimitedSpace(aPropValues,aPropNames,bLimitedHeight);
//------------------------------------------------
sal_Int32 nTick = 0;
for( TickInfo* pTickInfo = rTickIter.firstInfo()
; pTickInfo
; pTickInfo = rTickIter.nextInfo(), nTick++ )
{
pLastVisibleNeighbourTickInfo = bIsStaggered ?
pPREPreviousVisibleTickInfo : pPreviousVisibleTickInfo;
//don't create labels which does not fit into the rhythm
if( nTick%rAxisLabelProperties.nRhythm != 0)
continue;
//don't create labels for invisible ticks
if( !pTickInfo->bPaintIt )
continue;
//if NO OVERLAP -> don't create labels where the tick overlaps
//with the text of the last neighbour tickmark
if( pLastVisibleNeighbourTickInfo && !rAxisLabelProperties.bOverlapAllowed )
{
if( lcl_doesShapeOverlapWithTickmark( pLastVisibleNeighbourTickInfo->xTextShape
, rAxisLabelProperties.fRotationAngleDegree
, pTickInfo->aTickScreenPosition
, bIsHorizontalAxis, bIsVerticalAxis ) )
{
bool bOverlapAlsoAfterSwitchingOnAutoStaggering = true;
if( !bIsStaggered && isAutoStaggeringOfLabelsAllowed( rAxisLabelProperties, bIsHorizontalAxis, bIsVerticalAxis ) )
{
bIsStaggered = true;
rAxisLabelProperties.eStaggering = STAGGER_EVEN;
pLastVisibleNeighbourTickInfo = pPREPreviousVisibleTickInfo;
if( !pLastVisibleNeighbourTickInfo ||
!lcl_doesShapeOverlapWithTickmark( pLastVisibleNeighbourTickInfo->xTextShape
, rAxisLabelProperties.fRotationAngleDegree
, pTickInfo->aTickScreenPosition
, bIsHorizontalAxis, bIsVerticalAxis ) )
bOverlapAlsoAfterSwitchingOnAutoStaggering = false;
}
if( bOverlapAlsoAfterSwitchingOnAutoStaggering )
{
if( rAxisLabelProperties.bRhythmIsFix )
continue;
rAxisLabelProperties.nRhythm++;
removeShapesAtWrongRhythm( rTickIter, rAxisLabelProperties.nRhythm, nTick, xTarget );
return false;
}
}
}
//xxxxx pTickInfo->updateUnscaledValue( xInverseScaling );
bool bHasExtraColor=false;
sal_Int32 nExtraColor=0;
rtl::OUString aLabel;
if(pCategories)
{
sal_Int32 nIndex = static_cast< sal_Int32 >(pTickInfo->getUnscaledTickValue()) - 1; //first category (index 0) matches with real number 1.0
if( nIndex>=0 && nIndex<pCategories->getLength() )
aLabel = (*pCategories)[nIndex];
}
else if( m_aAxisProperties.m_bComplexCategories )
{
aLabel = pTickInfo->aText;
}
else
aLabel = aFixedNumberFormatter.getFormattedString( pTickInfo->getUnscaledTickValue(), nExtraColor, bHasExtraColor );
if(pColorAny)
*pColorAny = uno::makeAny(bHasExtraColor?nExtraColor:nColor);
if(pLimitedSpaceAny)
*pLimitedSpaceAny = uno::makeAny(sal_Int32(nLimitedSpaceForText*pTickInfo->nFactorForLimitedTextWidth));
B2DVector aTickScreenPos2D( pTickInfo->aTickScreenPosition );
aTickScreenPos2D += aTextToTickDistance;
awt::Point aAnchorScreenPosition2D(
static_cast<sal_Int32>(aTickScreenPos2D.getX())
,static_cast<sal_Int32>(aTickScreenPos2D.getY()));
//create single label
if(!pTickInfo->xTextShape.is())
pTickInfo->xTextShape = createSingleLabel( m_xShapeFactory, xTarget
, aAnchorScreenPosition2D, aLabel
, rAxisLabelProperties, m_aAxisProperties
, aPropNames, aPropValues );
if(!pTickInfo->xTextShape.is())
continue;
recordMaximumTextSize( pTickInfo->xTextShape, rAxisLabelProperties.fRotationAngleDegree );
//better rotate if single words are broken apart
if( nLimitedSpaceForText>0 && !rAxisLabelProperties.bOverlapAllowed
&& ::rtl::math::approxEqual( rAxisLabelProperties.fRotationAngleDegree, 0.0 )
&& m_aAxisProperties.m_bComplexCategories
&& lcl_hasWordBreak( pTickInfo->xTextShape ) )
{
rAxisLabelProperties.fRotationAngleDegree = 90;
rAxisLabelProperties.bLineBreakAllowed = false;
m_aAxisLabelProperties.fRotationAngleDegree = rAxisLabelProperties.fRotationAngleDegree;
removeTextShapesFromTicks();
return false;
}
//if NO OVERLAP -> remove overlapping shapes
if( pLastVisibleNeighbourTickInfo && !rAxisLabelProperties.bOverlapAllowed )
{
if( doesOverlap( pLastVisibleNeighbourTickInfo->xTextShape, pTickInfo->xTextShape, rAxisLabelProperties.fRotationAngleDegree ) )
{
bool bOverlapAlsoAfterSwitchingOnAutoStaggering = true;
if( !bIsStaggered && isAutoStaggeringOfLabelsAllowed( rAxisLabelProperties, bIsHorizontalAxis, bIsVerticalAxis ) )
{
bIsStaggered = true;
rAxisLabelProperties.eStaggering = STAGGER_EVEN;
pLastVisibleNeighbourTickInfo = pPREPreviousVisibleTickInfo;
if( !pLastVisibleNeighbourTickInfo ||
!lcl_doesShapeOverlapWithTickmark( pLastVisibleNeighbourTickInfo->xTextShape
, rAxisLabelProperties.fRotationAngleDegree
, pTickInfo->aTickScreenPosition
, bIsHorizontalAxis, bIsVerticalAxis ) )
bOverlapAlsoAfterSwitchingOnAutoStaggering = false;
}
if( bOverlapAlsoAfterSwitchingOnAutoStaggering )
{
if( rAxisLabelProperties.bRhythmIsFix )
{
xTarget->remove(pTickInfo->xTextShape);
pTickInfo->xTextShape = NULL;
continue;
}
rAxisLabelProperties.nRhythm++;
removeShapesAtWrongRhythm( rTickIter, rAxisLabelProperties.nRhythm, nTick, xTarget );
return false;
}
}
}
pPREPreviousVisibleTickInfo = pPreviousVisibleTickInfo;
pPreviousVisibleTickInfo = pTickInfo;
}
return true;
}
drawing::PointSequenceSequence lcl_makePointSequence( B2DVector& rStart, B2DVector& rEnd )
{
drawing::PointSequenceSequence aPoints(1);
aPoints[0].realloc(2);
aPoints[0][0].X = static_cast<sal_Int32>(rStart.getX());
aPoints[0][0].Y = static_cast<sal_Int32>(rStart.getY());
aPoints[0][1].X = static_cast<sal_Int32>(rEnd.getX());
aPoints[0][1].Y = static_cast<sal_Int32>(rEnd.getY());
return aPoints;
}
double VCartesianAxis::getLogicValueWhereMainLineCrossesOtherAxis() const
{
double fMin = (m_nDimensionIndex==1) ? m_pPosHelper->getLogicMinX() : m_pPosHelper->getLogicMinY();
double fMax = (m_nDimensionIndex==1) ? m_pPosHelper->getLogicMaxX() : m_pPosHelper->getLogicMaxY();
double fCrossesOtherAxis;
if(m_aAxisProperties.m_pfMainLinePositionAtOtherAxis)
fCrossesOtherAxis = *m_aAxisProperties.m_pfMainLinePositionAtOtherAxis;
else
{
if( ::com::sun::star::chart::ChartAxisPosition_END == m_aAxisProperties.m_eCrossoverType )
fCrossesOtherAxis = fMax;
else
fCrossesOtherAxis = fMin;
}
return fCrossesOtherAxis;
}
double VCartesianAxis::getLogicValueWhereLabelLineCrossesOtherAxis() const
{
double fMin = (m_nDimensionIndex==1) ? m_pPosHelper->getLogicMinX() : m_pPosHelper->getLogicMinY();
double fMax = (m_nDimensionIndex==1) ? m_pPosHelper->getLogicMaxX() : m_pPosHelper->getLogicMaxY();
double fCrossesOtherAxis;
if( ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_START == m_aAxisProperties.m_eLabelPos )
fCrossesOtherAxis = fMin;
else if( ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_END == m_aAxisProperties.m_eLabelPos )
fCrossesOtherAxis = fMax;
else
fCrossesOtherAxis = getLogicValueWhereMainLineCrossesOtherAxis();
return fCrossesOtherAxis;
}
bool VCartesianAxis::getLogicValueWhereExtraLineCrossesOtherAxis( double& fCrossesOtherAxis ) const
{
if( !m_aAxisProperties.m_pfExrtaLinePositionAtOtherAxis )
return false;
double fMin = (m_nDimensionIndex==1) ? m_pPosHelper->getLogicMinX() : m_pPosHelper->getLogicMinY();
double fMax = (m_nDimensionIndex==1) ? m_pPosHelper->getLogicMaxX() : m_pPosHelper->getLogicMaxY();
if( *m_aAxisProperties.m_pfExrtaLinePositionAtOtherAxis <= fMin
|| *m_aAxisProperties.m_pfExrtaLinePositionAtOtherAxis >= fMax )
return false;
fCrossesOtherAxis = *m_aAxisProperties.m_pfExrtaLinePositionAtOtherAxis;
return true;
}
B2DVector VCartesianAxis::getScreenPosition( double fLogicX, double fLogicY, double fLogicZ ) const
{
B2DVector aRet(0,0);
if( m_pPosHelper )
{
drawing::Position3D aScenePos = m_pPosHelper->transformLogicToScene( fLogicX, fLogicY, fLogicZ, true );
if(3==m_nDimension)
{
if( m_xLogicTarget.is() && m_pPosHelper && m_pShapeFactory )
{
tPropertyNameMap aDummyPropertyNameMap;
Reference< drawing::XShape > xShape3DAnchor = m_pShapeFactory->createCube( m_xLogicTarget
, aScenePos,drawing::Direction3D(1,1,1), 0, 0, aDummyPropertyNameMap);
awt::Point a2DPos = xShape3DAnchor->getPosition(); //get 2D position from xShape3DAnchor
m_xLogicTarget->remove(xShape3DAnchor);
aRet.setX( a2DPos.X );
aRet.setY( a2DPos.Y );
}
else
{
DBG_ERROR("cannot calculate scrren position in VCartesianAxis::getScreenPosition");
}
}
else
{
aRet.setX( aScenePos.PositionX );
aRet.setY( aScenePos.PositionY );
}
}
return aRet;
}
VCartesianAxis::ScreenPosAndLogicPos VCartesianAxis::getScreenPosAndLogicPos( double fLogicX_, double fLogicY_, double fLogicZ_ ) const
{
ScreenPosAndLogicPos aRet;
aRet.fLogicX = fLogicX_;
aRet.fLogicY = fLogicY_;
aRet.fLogicZ = fLogicZ_;
aRet.aScreenPos = getScreenPosition( fLogicX_, fLogicY_, fLogicZ_ );
return aRet;
}
typedef ::std::vector< VCartesianAxis::ScreenPosAndLogicPos > tScreenPosAndLogicPosList;
struct lcl_LessXPos : ::std::binary_function< VCartesianAxis::ScreenPosAndLogicPos, VCartesianAxis::ScreenPosAndLogicPos, bool >
{
inline bool operator() ( const VCartesianAxis::ScreenPosAndLogicPos& rPos1, const VCartesianAxis::ScreenPosAndLogicPos& rPos2 )
{
return ( rPos1.aScreenPos.getX() < rPos2.aScreenPos.getX() );
}
};
struct lcl_GreaterYPos : ::std::binary_function< VCartesianAxis::ScreenPosAndLogicPos, VCartesianAxis::ScreenPosAndLogicPos, bool >
{
inline bool operator() ( const VCartesianAxis::ScreenPosAndLogicPos& rPos1, const VCartesianAxis::ScreenPosAndLogicPos& rPos2 )
{
return ( rPos1.aScreenPos.getY() > rPos2.aScreenPos.getY() );
}
};
void VCartesianAxis::get2DAxisMainLine( B2DVector& rStart, B2DVector& rEnd, double fCrossesOtherAxis )
{
//m_aAxisProperties might get updated and changed here because
// the label alignmant and inner direction sign depends exactly of the choice of the axis line position which is made here in this method
double fMinX = m_pPosHelper->getLogicMinX();
double fMinY = m_pPosHelper->getLogicMinY();
double fMinZ = m_pPosHelper->getLogicMinZ();
double fMaxX = m_pPosHelper->getLogicMaxX();
double fMaxY = m_pPosHelper->getLogicMaxY();
double fMaxZ = m_pPosHelper->getLogicMaxZ();
double fXStart = fMinX;
double fYStart = fMinY;
double fZStart = fMinZ;
double fXEnd = fXStart;
double fYEnd = fYStart;
double fZEnd = fZStart;
double fXOnXPlane = fMinX;
double fXOther = fMaxX;
int nDifferentValue = !m_pPosHelper->isMathematicalOrientationX() ? -1 : 1;
if( !m_pPosHelper->isSwapXAndY() )
nDifferentValue *= (CuboidPlanePosition_Left != m_eLeftWallPos) ? -1 : 1;
else
nDifferentValue *= (CuboidPlanePosition_Bottom != m_eBottomPos) ? -1 : 1;
if( nDifferentValue<0 )
{
fXOnXPlane = fMaxX;
fXOther = fMinX;
}
double fYOnYPlane = fMinY;
double fYOther = fMaxY;
nDifferentValue = !m_pPosHelper->isMathematicalOrientationY() ? -1 : 1;
if( !m_pPosHelper->isSwapXAndY() )
nDifferentValue *= (CuboidPlanePosition_Bottom != m_eBottomPos) ? -1 : 1;
else
nDifferentValue *= (CuboidPlanePosition_Left != m_eLeftWallPos) ? -1 : 1;
if( nDifferentValue<0 )
{
fYOnYPlane = fMaxY;
fYOther = fMinY;
}
double fZOnZPlane = fMaxZ;
double fZOther = fMinZ;
nDifferentValue = !m_pPosHelper->isMathematicalOrientationZ() ? -1 : 1;
nDifferentValue *= (CuboidPlanePosition_Back != m_eBackWallPos) ? -1 : 1;
if( nDifferentValue<0 )
{
fZOnZPlane = fMinZ;
fZOther = fMaxZ;
}
if( 0==m_nDimensionIndex ) //x-axis
{
if( fCrossesOtherAxis < fMinY )
fCrossesOtherAxis = fMinY;
else if( fCrossesOtherAxis > fMaxY )
fCrossesOtherAxis = fMaxY;
fYStart = fYEnd = fCrossesOtherAxis;
fXEnd=m_pPosHelper->getLogicMaxX();
if(3==m_nDimension)
{
if( AxisHelper::isAxisPositioningEnabled() )
{
if( ::rtl::math::approxEqual( fYOther, fYStart) )
fZStart = fZEnd = fZOnZPlane;
else
fZStart = fZEnd = fZOther;
}
else
{
rStart = getScreenPosition( fXStart, fYStart, fZStart );
rEnd = getScreenPosition( fXEnd, fYEnd, fZEnd );
double fDeltaX = rEnd.getX() - rStart.getX();
double fDeltaY = rEnd.getY() - rStart.getY();
//only those points are candidates which are lying on exactly one wall as these are outer edges
tScreenPosAndLogicPosList aPosList;
aPosList.push_back( getScreenPosAndLogicPos( fMinX, fYOnYPlane, fZOther ) );
aPosList.push_back( getScreenPosAndLogicPos( fMinX, fYOther, fZOnZPlane ) );
if( fabs(fDeltaY) > fabs(fDeltaX) )
{
m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_LEFT;
//choose most left positions
::std::sort( aPosList.begin(), aPosList.end(), lcl_LessXPos() );
m_aAxisProperties.m_fLabelDirectionSign = fDeltaY<0 ? -1 : 1;
}
else
{
m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_BOTTOM;
//choose most bottom positions
::std::sort( aPosList.begin(), aPosList.end(), lcl_GreaterYPos() );
m_aAxisProperties.m_fLabelDirectionSign = fDeltaX<0 ? -1 : 1;
}
ScreenPosAndLogicPos aBestPos( aPosList[0] );
fYStart = fYEnd = aBestPos.fLogicY;
fZStart = fZEnd = aBestPos.fLogicZ;
if( !m_pPosHelper->isMathematicalOrientationX() )
m_aAxisProperties.m_fLabelDirectionSign *= -1;
}
}//end 3D x axis
}
else if( 1==m_nDimensionIndex ) //y-axis
{
if( fCrossesOtherAxis < fMinX )
fCrossesOtherAxis = fMinX;
else if( fCrossesOtherAxis > fMaxX )
fCrossesOtherAxis = fMaxX;
fXStart = fXEnd = fCrossesOtherAxis;
fYEnd=m_pPosHelper->getLogicMaxY();
if(3==m_nDimension)
{
if( AxisHelper::isAxisPositioningEnabled() )
{
if( ::rtl::math::approxEqual( fXOther, fXStart) )
fZStart = fZEnd = fZOnZPlane;
else
fZStart = fZEnd = fZOther;
}
else
{
rStart = getScreenPosition( fXStart, fYStart, fZStart );
rEnd = getScreenPosition( fXEnd, fYEnd, fZEnd );
double fDeltaX = rEnd.getX() - rStart.getX();
double fDeltaY = rEnd.getY() - rStart.getY();
//only those points are candidates which are lying on exactly one wall as these are outer edges
tScreenPosAndLogicPosList aPosList;
aPosList.push_back( getScreenPosAndLogicPos( fXOnXPlane, fMinY, fZOther ) );
aPosList.push_back( getScreenPosAndLogicPos( fXOther, fMinY, fZOnZPlane ) );
if( fabs(fDeltaY) > fabs(fDeltaX) )
{
m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_LEFT;
//choose most left positions
::std::sort( aPosList.begin(), aPosList.end(), lcl_LessXPos() );
m_aAxisProperties.m_fLabelDirectionSign = fDeltaY<0 ? -1 : 1;
}
else
{
m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_BOTTOM;
//choose most bottom positions
::std::sort( aPosList.begin(), aPosList.end(), lcl_GreaterYPos() );
m_aAxisProperties.m_fLabelDirectionSign = fDeltaX<0 ? -1 : 1;
}
ScreenPosAndLogicPos aBestPos( aPosList[0] );
fXStart = fXEnd = aBestPos.fLogicX;
fZStart = fZEnd = aBestPos.fLogicZ;
if( !m_pPosHelper->isMathematicalOrientationY() )
m_aAxisProperties.m_fLabelDirectionSign *= -1;
}
}//end 3D y axis
}
else //z-axis
{
fZEnd = m_pPosHelper->getLogicMaxZ();
if( AxisHelper::isAxisPositioningEnabled() )
{
if( !m_aAxisProperties.m_bSwapXAndY )
{
if( fCrossesOtherAxis < fMinY )
fCrossesOtherAxis = fMinY;
else if( fCrossesOtherAxis > fMaxY )
fCrossesOtherAxis = fMaxY;
fYStart = fYEnd = fCrossesOtherAxis;
if( ::rtl::math::approxEqual( fYOther, fYStart) )
fXStart = fXEnd = fXOnXPlane;
else
fXStart = fXEnd = fXOther;
}
else
{
if( fCrossesOtherAxis < fMinX )
fCrossesOtherAxis = fMinX;
else if( fCrossesOtherAxis > fMaxX )
fCrossesOtherAxis = fMaxX;
fXStart = fXEnd = fCrossesOtherAxis;
if( ::rtl::math::approxEqual( fXOther, fXStart) )
fYStart = fYEnd = fYOnYPlane;
else
fYStart = fYEnd = fYOther;
}
}
else
{
if( !m_pPosHelper->isSwapXAndY() )
{
fXStart = fXEnd = m_pPosHelper->isMathematicalOrientationX() ? m_pPosHelper->getLogicMaxX() : m_pPosHelper->getLogicMinX();
fYStart = fYEnd = m_pPosHelper->isMathematicalOrientationY() ? m_pPosHelper->getLogicMinY() : m_pPosHelper->getLogicMaxY();
}
else
{
fXStart = fXEnd = m_pPosHelper->isMathematicalOrientationX() ? m_pPosHelper->getLogicMinX() : m_pPosHelper->getLogicMaxX();
fYStart = fYEnd = m_pPosHelper->isMathematicalOrientationY() ? m_pPosHelper->getLogicMaxY() : m_pPosHelper->getLogicMinY();
}
if(3==m_nDimension)
{
rStart = getScreenPosition( fXStart, fYStart, fZStart );
rEnd = getScreenPosition( fXEnd, fYEnd, fZEnd );
double fDeltaX = rEnd.getX() - rStart.getX();
//only those points are candidates which are lying on exactly one wall as these are outer edges
tScreenPosAndLogicPosList aPosList;
aPosList.push_back( getScreenPosAndLogicPos( fXOther, fYOnYPlane, fMinZ ) );
aPosList.push_back( getScreenPosAndLogicPos( fXOnXPlane, fYOther, fMinZ ) );
::std::sort( aPosList.begin(), aPosList.end(), lcl_GreaterYPos() );
ScreenPosAndLogicPos aBestPos( aPosList[0] );
ScreenPosAndLogicPos aNotSoGoodPos( aPosList[1] );
//choose most bottom positions
if( !::rtl::math::approxEqual( fDeltaX, 0.0 ) ) // prefere left-right algnments
{
if( aBestPos.aScreenPos.getX() > aNotSoGoodPos.aScreenPos.getX() )
m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_RIGHT;
else
m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_LEFT;
}
else
{
if( aBestPos.aScreenPos.getY() > aNotSoGoodPos.aScreenPos.getY() )
m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_BOTTOM;
else
m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_TOP;
}
m_aAxisProperties.m_fLabelDirectionSign = fDeltaX<0 ? -1 : 1;
if( !m_pPosHelper->isMathematicalOrientationZ() )
m_aAxisProperties.m_fLabelDirectionSign *= -1;
fXStart = fXEnd = aBestPos.fLogicX;
fYStart = fYEnd = aBestPos.fLogicY;
}
}//end 3D z axis
}
rStart = getScreenPosition( fXStart, fYStart, fZStart );
rEnd = getScreenPosition( fXEnd, fYEnd, fZEnd );
if(3==m_nDimension && !AxisHelper::isAxisPositioningEnabled() )
m_aAxisProperties.m_fInnerDirectionSign = m_aAxisProperties.m_fLabelDirectionSign;//to behave like before
if(3==m_nDimension && AxisHelper::isAxisPositioningEnabled() )
{
double fDeltaX = rEnd.getX() - rStart.getX();
double fDeltaY = rEnd.getY() - rStart.getY();
if( 2==m_nDimensionIndex )
{
if( m_eLeftWallPos != CuboidPlanePosition_Left )
{
m_aAxisProperties.m_fLabelDirectionSign *= -1.0;
m_aAxisProperties.m_fInnerDirectionSign *= -1.0;
}
m_aAxisProperties.m_aLabelAlignment =
( m_aAxisProperties.m_fLabelDirectionSign<0 ) ?
LABEL_ALIGN_LEFT : LABEL_ALIGN_RIGHT;
if( ( fDeltaY<0 && m_aScale.Orientation == AxisOrientation_REVERSE ) ||
( fDeltaY>0 && m_aScale.Orientation == AxisOrientation_MATHEMATICAL ) )
m_aAxisProperties.m_aLabelAlignment =
( m_aAxisProperties.m_aLabelAlignment==LABEL_ALIGN_RIGHT ) ?
LABEL_ALIGN_LEFT : LABEL_ALIGN_RIGHT;
}
else if( fabs(fDeltaY) > fabs(fDeltaX) )
{
if( m_eBackWallPos != CuboidPlanePosition_Back )
{
m_aAxisProperties.m_fLabelDirectionSign *= -1.0;
m_aAxisProperties.m_fInnerDirectionSign *= -1.0;
}
m_aAxisProperties.m_aLabelAlignment =
( m_aAxisProperties.m_fLabelDirectionSign<0 ) ?
LABEL_ALIGN_LEFT : LABEL_ALIGN_RIGHT;
if( ( fDeltaY<0 && m_aScale.Orientation == AxisOrientation_REVERSE ) ||
( fDeltaY>0 && m_aScale.Orientation == AxisOrientation_MATHEMATICAL ) )
m_aAxisProperties.m_aLabelAlignment =
( m_aAxisProperties.m_aLabelAlignment==LABEL_ALIGN_RIGHT ) ?
LABEL_ALIGN_LEFT : LABEL_ALIGN_RIGHT;
}
else
{
if( m_eBackWallPos != CuboidPlanePosition_Back )
{
m_aAxisProperties.m_fLabelDirectionSign *= -1.0;
m_aAxisProperties.m_fInnerDirectionSign *= -1.0;
}
m_aAxisProperties.m_aLabelAlignment =
( m_aAxisProperties.m_fLabelDirectionSign<0 ) ?
LABEL_ALIGN_TOP : LABEL_ALIGN_BOTTOM;
if( ( fDeltaX>0 && m_aScale.Orientation == AxisOrientation_REVERSE ) ||
( fDeltaX<0 && m_aScale.Orientation == AxisOrientation_MATHEMATICAL ) )
m_aAxisProperties.m_aLabelAlignment =
( m_aAxisProperties.m_aLabelAlignment==LABEL_ALIGN_TOP ) ?
LABEL_ALIGN_BOTTOM : LABEL_ALIGN_TOP;
}
}
}
TickFactory* VCartesianAxis::createTickFactory()
{
return createTickFactory2D();
}
TickFactory_2D* VCartesianAxis::createTickFactory2D()
{
B2DVector aStart, aEnd;
this->get2DAxisMainLine( aStart, aEnd, this->getLogicValueWhereMainLineCrossesOtherAxis() );
B2DVector aLabelLineStart, aLabelLineEnd;
this->get2DAxisMainLine( aLabelLineStart, aLabelLineEnd, this->getLogicValueWhereLabelLineCrossesOtherAxis() );
return new TickFactory_2D( m_aScale, m_aIncrement, aStart, aEnd, aLabelLineStart-aStart );
}
void lcl_hideIdenticalScreenValues( TickIter& rTickIter )
{
TickInfo* pPreviousTickInfo = rTickIter.firstInfo();
if(!pPreviousTickInfo)
return;
pPreviousTickInfo->bPaintIt = true;
for( TickInfo* pTickInfo = rTickIter.nextInfo(); pTickInfo; pTickInfo = rTickIter.nextInfo())
{
pTickInfo->bPaintIt =
( static_cast<sal_Int32>(pTickInfo->aTickScreenPosition.getX())
!= static_cast<sal_Int32>(pPreviousTickInfo->aTickScreenPosition.getX()) )
||
( static_cast<sal_Int32>(pTickInfo->aTickScreenPosition.getY())
!= static_cast<sal_Int32>(pPreviousTickInfo->aTickScreenPosition.getY()) );
pPreviousTickInfo = pTickInfo;
}
}
//'hide' tickmarks with identical screen values in aAllTickInfos
void VCartesianAxis::hideIdenticalScreenValues( ::std::vector< ::std::vector< TickInfo > >& rTickInfos ) const
{
if( isComplexCategoryAxis() || isDateAxis() )
{
sal_Int32 nCount = rTickInfos.size();
for( sal_Int32 nN=0; nN<nCount; nN++ )
{
PureTickIter aTickIter( rTickInfos[nN] );
lcl_hideIdenticalScreenValues( aTickIter );
}
}
else
{
EquidistantTickIter aTickIter( rTickInfos, m_aIncrement, 0, -1 );
lcl_hideIdenticalScreenValues( aTickIter );
}
}
sal_Int32 VCartesianAxis::estimateMaximumAutoMainIncrementCount()
{
sal_Int32 nRet = 10;
if( m_nMaximumTextWidthSoFar==0 && m_nMaximumTextHeightSoFar==0 )
return nRet;
B2DVector aStart, aEnd;
this->get2DAxisMainLine( aStart, aEnd, this->getLogicValueWhereMainLineCrossesOtherAxis() );
sal_Int32 nMaxHeight = static_cast<sal_Int32>(fabs(aEnd.getY()-aStart.getY()));
sal_Int32 nMaxWidth = static_cast<sal_Int32>(fabs(aEnd.getX()-aStart.getX()));
sal_Int32 nTotalAvailable = nMaxHeight;
sal_Int32 nSingleNeeded = m_nMaximumTextHeightSoFar;
//for horizontal axis:
if( (m_nDimensionIndex == 0 && !m_aAxisProperties.m_bSwapXAndY)
|| (m_nDimensionIndex == 1 && m_aAxisProperties.m_bSwapXAndY) )
{
nTotalAvailable = nMaxWidth;
nSingleNeeded = m_nMaximumTextWidthSoFar;
}
if( nSingleNeeded>0 )
nRet = nTotalAvailable/nSingleNeeded;
return nRet;
}
void VCartesianAxis::doStaggeringOfLabels( const AxisLabelProperties& rAxisLabelProperties, TickFactory_2D* pTickFactory2D )
{
if( !pTickFactory2D )
return;
if( isComplexCategoryAxis() )
{
sal_Int32 nTextLevelCount = getTextLevelCount();
B2DVector aCummulatedLabelsDistance(0,0);
for( sal_Int32 nTextLevel=0; nTextLevel<nTextLevelCount; nTextLevel++ )
{
::std::auto_ptr< TickIter > apTickIter = createLabelTickIterator( nTextLevel );
if(apTickIter.get())
{
double fRotationAngleDegree = m_aAxisLabelProperties.fRotationAngleDegree;
if( nTextLevel>0 )
{
lcl_shiftLables( *apTickIter.get(), aCummulatedLabelsDistance );
fRotationAngleDegree = 0.0;
}
aCummulatedLabelsDistance += lcl_getLabelsDistance( *apTickIter.get()
, pTickFactory2D->getDistanceAxisTickToText( m_aAxisProperties )
, fRotationAngleDegree );
}
}
}
else if( rAxisLabelProperties.getIsStaggered() )
{
if( !m_aAllTickInfos.empty() )
{
LabelIterator aInnerIter( m_aAllTickInfos[0], rAxisLabelProperties.eStaggering, true );
LabelIterator aOuterIter( m_aAllTickInfos[0], rAxisLabelProperties.eStaggering, false );
lcl_shiftLables( aOuterIter
, lcl_getLabelsDistance( aInnerIter
, pTickFactory2D->getDistanceAxisTickToText( m_aAxisProperties ), 0.0 ) );
}
}
}
void VCartesianAxis::createLabels()
{
if( !prepareShapeCreation() )
return;
//-----------------------------------------
//create labels
if( m_aAxisProperties.m_bDisplayLabels )
{
std::auto_ptr< TickFactory_2D > apTickFactory2D( this->createTickFactory2D() );
TickFactory_2D* pTickFactory2D = apTickFactory2D.get();
if( !pTickFactory2D )
return;
//-----------------------------------------
//get the transformed screen values for all tickmarks in aAllTickInfos
pTickFactory2D->updateScreenValues( m_aAllTickInfos );
//-----------------------------------------
//'hide' tickmarks with identical screen values in aAllTickInfos
hideIdenticalScreenValues( m_aAllTickInfos );
removeTextShapesFromTicks();
//create tick mark text shapes
sal_Int32 nTextLevelCount = getTextLevelCount();
sal_Int32 nScreenDistanceBetweenTicks = -1;
for( sal_Int32 nTextLevel=0; nTextLevel<nTextLevelCount; nTextLevel++ )
{
::std::auto_ptr< TickIter > apTickIter = createLabelTickIterator( nTextLevel );
if(apTickIter.get())
{
if(nTextLevel==0)
{
nScreenDistanceBetweenTicks = TickFactory_2D::getTickScreenDistance( *apTickIter.get() );
if( nTextLevelCount>1 )
nScreenDistanceBetweenTicks*=2; //the above used tick iter does contain also the sub ticks -> thus the given distance is only the half
}
AxisLabelProperties aComplexProps(m_aAxisLabelProperties);
if( m_aAxisProperties.m_bComplexCategories )
{
if( nTextLevel==0 )
{
aComplexProps.bLineBreakAllowed = true;
aComplexProps.bOverlapAllowed = !::rtl::math::approxEqual( aComplexProps.fRotationAngleDegree, 0.0 );
}
else
{
aComplexProps.bOverlapAllowed = true;
aComplexProps.bRhythmIsFix = true;
aComplexProps.nRhythm = 1;
aComplexProps.fRotationAngleDegree = 0.0;
}
}
AxisLabelProperties& rAxisLabelProperties = m_aAxisProperties.m_bComplexCategories ? aComplexProps : m_aAxisLabelProperties;
while( !createTextShapes( m_xTextTarget, *apTickIter.get(), rAxisLabelProperties, pTickFactory2D, nScreenDistanceBetweenTicks ) )
{
};
}
}
doStaggeringOfLabels( m_aAxisLabelProperties, pTickFactory2D );
}
}
void VCartesianAxis::createMaximumLabels()
{
TrueGuard aRecordMaximumTextSize(m_bRecordMaximumTextSize);
if( !prepareShapeCreation() )
return;
//-----------------------------------------
//create labels
if( m_aAxisProperties.m_bDisplayLabels )
{
std::auto_ptr< TickFactory_2D > apTickFactory2D( this->createTickFactory2D() );
TickFactory_2D* pTickFactory2D = apTickFactory2D.get();
if( !pTickFactory2D )
return;
//-----------------------------------------
//get the transformed screen values for all tickmarks in aAllTickInfos
pTickFactory2D->updateScreenValues( m_aAllTickInfos );
//create tick mark text shapes
//@todo: iterate through all tick depth wich should be labeled
AxisLabelProperties aAxisLabelProperties( m_aAxisLabelProperties );
if( isAutoStaggeringOfLabelsAllowed( aAxisLabelProperties, pTickFactory2D->isHorizontalAxis(), pTickFactory2D->isVerticalAxis() ) )
aAxisLabelProperties.eStaggering = STAGGER_EVEN;
aAxisLabelProperties.bOverlapAllowed = true;
aAxisLabelProperties.bLineBreakAllowed = false;
sal_Int32 nTextLevelCount = getTextLevelCount();
for( sal_Int32 nTextLevel=0; nTextLevel<nTextLevelCount; nTextLevel++ )
{
::std::auto_ptr< TickIter > apTickIter = createMaximumLabelTickIterator( nTextLevel );
if(apTickIter.get())
{
while( !createTextShapes( m_xTextTarget, *apTickIter.get(), aAxisLabelProperties, pTickFactory2D, -1 ) )
{
};
}
}
doStaggeringOfLabels( aAxisLabelProperties, pTickFactory2D );
}
}
void VCartesianAxis::updatePositions()
{
//-----------------------------------------
//update positions of labels
if( m_aAxisProperties.m_bDisplayLabels )
{
std::auto_ptr< TickFactory_2D > apTickFactory2D( this->createTickFactory2D() );
TickFactory_2D* pTickFactory2D = apTickFactory2D.get();
if( !pTickFactory2D )
return;
//-----------------------------------------
//update positions of all existing text shapes
pTickFactory2D->updateScreenValues( m_aAllTickInfos );
::std::vector< ::std::vector< TickInfo > >::iterator aDepthIter = m_aAllTickInfos.begin();
const ::std::vector< ::std::vector< TickInfo > >::const_iterator aDepthEnd = m_aAllTickInfos.end();
for( sal_Int32 nDepth=0; aDepthIter != aDepthEnd; aDepthIter++, nDepth++ )
{
::std::vector< TickInfo >::iterator aTickIter = aDepthIter->begin();
const ::std::vector< TickInfo >::const_iterator aTickEnd = aDepthIter->end();
for( ; aTickIter != aTickEnd; aTickIter++ )
{
TickInfo& rTickInfo = (*aTickIter);
Reference< drawing::XShape > xShape2DText( rTickInfo.xTextShape );
if( xShape2DText.is() )
{
B2DVector aTextToTickDistance( pTickFactory2D->getDistanceAxisTickToText( m_aAxisProperties, true ) );
B2DVector aTickScreenPos2D( rTickInfo.aTickScreenPosition );
aTickScreenPos2D += aTextToTickDistance;
awt::Point aAnchorScreenPosition2D(
static_cast<sal_Int32>(aTickScreenPos2D.getX())
,static_cast<sal_Int32>(aTickScreenPos2D.getY()));
double fRotationAngleDegree = m_aAxisLabelProperties.fRotationAngleDegree;
if( nDepth>0 )
fRotationAngleDegree = 0.0;
// #i78696# use mathematically correct rotation now
const double fRotationAnglePi(fRotationAngleDegree * (F_PI / -180.0));
uno::Any aATransformation = ShapeFactory::makeTransformation(aAnchorScreenPosition2D, fRotationAnglePi);
//set new position
uno::Reference< beans::XPropertySet > xProp( xShape2DText, uno::UNO_QUERY );
if( xProp.is() )
{
try
{
xProp->setPropertyValue( C2U( "Transformation" ), aATransformation );
}
catch( uno::Exception& e )
{
ASSERT_EXCEPTION( e );
}
}
//correctPositionForRotation
LabelPositionHelper::correctPositionForRotation( xShape2DText
, m_aAxisProperties.m_aLabelAlignment, fRotationAngleDegree, m_aAxisProperties.m_bComplexCategories );
}
}
}
doStaggeringOfLabels( m_aAxisLabelProperties, pTickFactory2D );
}
}
void VCartesianAxis::createTickMarkLineShapes( ::std::vector< TickInfo >& rTickInfos, const TickmarkProperties& rTickmarkProperties, TickFactory_2D& rTickFactory2D, bool bOnlyAtLabels )
{
sal_Int32 nPointCount = rTickInfos.size();
drawing::PointSequenceSequence aPoints(2*nPointCount);
::std::vector< TickInfo >::const_iterator aTickIter = rTickInfos.begin();
const ::std::vector< TickInfo >::const_iterator aTickEnd = rTickInfos.end();
sal_Int32 nN = 0;
for( ; aTickIter != aTickEnd; aTickIter++ )
{
if( !(*aTickIter).bPaintIt )
continue;
bool bTicksAtLabels = ( m_aAxisProperties.m_eTickmarkPos != ::com::sun::star::chart::ChartAxisMarkPosition_AT_AXIS );
double fInnerDirectionSign = m_aAxisProperties.m_fInnerDirectionSign;
if( bTicksAtLabels && m_aAxisProperties.m_eLabelPos == ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_END )
fInnerDirectionSign *= -1.0;
bTicksAtLabels = bTicksAtLabels || bOnlyAtLabels;
//add ticks at labels:
rTickFactory2D.addPointSequenceForTickLine( aPoints, nN++, (*aTickIter).fScaledTickValue
, fInnerDirectionSign , rTickmarkProperties, bTicksAtLabels );
//add ticks at axis (without lables):
if( !bOnlyAtLabels && m_aAxisProperties.m_eTickmarkPos == ::com::sun::star::chart::ChartAxisMarkPosition_AT_LABELS_AND_AXIS )
rTickFactory2D.addPointSequenceForTickLine( aPoints, nN++, (*aTickIter).fScaledTickValue
, m_aAxisProperties.m_fInnerDirectionSign, rTickmarkProperties, !bTicksAtLabels );
}
aPoints.realloc(nN);
m_pShapeFactory->createLine2D( m_xGroupShape_Shapes, aPoints
, &rTickmarkProperties.aLineProperties );
}
void VCartesianAxis::createShapes()
{
if( !prepareShapeCreation() )
return;
std::auto_ptr< TickFactory_2D > apTickFactory2D( this->createTickFactory2D() );
TickFactory_2D* pTickFactory2D = apTickFactory2D.get();
if( !pTickFactory2D )
return;
//-----------------------------------------
//create line shapes
if(2==m_nDimension)
{
//-----------------------------------------
//create extra long ticks to separate complex categories (create them only there where the labels are)
if( isComplexCategoryAxis() )
{
::std::vector< ::std::vector< TickInfo > > aComplexTickInfos;
createAllTickInfosFromComplexCategories( aComplexTickInfos, true );
pTickFactory2D->updateScreenValues( aComplexTickInfos );
hideIdenticalScreenValues( aComplexTickInfos );
::std::vector<TickmarkProperties> aTickmarkPropertiesList;
static bool bIncludeSpaceBetweenTickAndText = false;
sal_Int32 nOffset = static_cast<sal_Int32>(pTickFactory2D->getDistanceAxisTickToText( m_aAxisProperties, false, bIncludeSpaceBetweenTickAndText ).getLength());
sal_Int32 nTextLevelCount = getTextLevelCount();
for( sal_Int32 nTextLevel=0; nTextLevel<nTextLevelCount; nTextLevel++ )
{
::std::auto_ptr< TickIter > apTickIter = createLabelTickIterator( nTextLevel );
if( apTickIter.get() )
{
double fRotationAngleDegree = m_aAxisLabelProperties.fRotationAngleDegree;
if( nTextLevel>0 )
fRotationAngleDegree = 0.0;
B2DVector aLabelsDistance( lcl_getLabelsDistance( *apTickIter.get(), pTickFactory2D->getDistanceAxisTickToText( m_aAxisProperties, false ), fRotationAngleDegree ) );
sal_Int32 nCurrentLength = static_cast<sal_Int32>(aLabelsDistance.getLength());
aTickmarkPropertiesList.push_back( m_aAxisProperties.makeTickmarkPropertiesForComplexCategories( nOffset + nCurrentLength, 0, nTextLevel ) );
nOffset += nCurrentLength;
}
}
sal_Int32 nTickmarkPropertiesCount = aTickmarkPropertiesList.size();
::std::vector< ::std::vector< TickInfo > >::iterator aDepthIter = aComplexTickInfos.begin();
const ::std::vector< ::std::vector< TickInfo > >::const_iterator aDepthEnd = aComplexTickInfos.end();
for( sal_Int32 nDepth=0; aDepthIter != aDepthEnd && nDepth < nTickmarkPropertiesCount; aDepthIter++, nDepth++ )
{
if(nDepth==0 && !m_aAxisProperties.m_nMajorTickmarks)
continue;
createTickMarkLineShapes( *aDepthIter, aTickmarkPropertiesList[nDepth], *pTickFactory2D, true /*bOnlyAtLabels*/ );
}
}
//-----------------------------------------
//create normal ticks for major and minor intervals
{
::std::vector< ::std::vector< TickInfo > > aUnshiftedTickInfos;
if( m_aScale.ShiftedCategoryPosition )// if ShiftedCategoryPosition==true the tickmarks in m_aAllTickInfos are shifted
{
pTickFactory2D->getAllTicks( aUnshiftedTickInfos );
pTickFactory2D->updateScreenValues( aUnshiftedTickInfos );
hideIdenticalScreenValues( aUnshiftedTickInfos );
}
::std::vector< ::std::vector< TickInfo > >& rAllTickInfos = m_aScale.ShiftedCategoryPosition ? aUnshiftedTickInfos : m_aAllTickInfos;
::std::vector< ::std::vector< TickInfo > >::iterator aDepthIter = rAllTickInfos.begin();
const ::std::vector< ::std::vector< TickInfo > >::const_iterator aDepthEnd = rAllTickInfos.end();
if(aDepthIter == aDepthEnd)//no tickmarks at all
return;
sal_Int32 nTickmarkPropertiesCount = m_aAxisProperties.m_aTickmarkPropertiesList.size();
for( sal_Int32 nDepth=0; aDepthIter != aDepthEnd && nDepth < nTickmarkPropertiesCount; aDepthIter++, nDepth++ )
createTickMarkLineShapes( *aDepthIter, m_aAxisProperties.m_aTickmarkPropertiesList[nDepth], *pTickFactory2D, false /*bOnlyAtLabels*/ );
}
//-----------------------------------------
//create axis main lines
//it serves also as the handle shape for the axis selection
{
drawing::PointSequenceSequence aPoints(1);
apTickFactory2D->createPointSequenceForAxisMainLine( aPoints );
Reference< drawing::XShape > xShape = m_pShapeFactory->createLine2D(
m_xGroupShape_Shapes, aPoints
, &m_aAxisProperties.m_aLineProperties );
//because of this name this line will be used for marking the axis
m_pShapeFactory->setShapeName( xShape, C2U("MarkHandles") );
}
//-----------------------------------------
//create an additional line at NULL
if( !AxisHelper::isAxisPositioningEnabled() )
{
double fExtraLineCrossesOtherAxis;
if( getLogicValueWhereExtraLineCrossesOtherAxis(fExtraLineCrossesOtherAxis) )
{
B2DVector aStart, aEnd;
this->get2DAxisMainLine( aStart, aEnd, fExtraLineCrossesOtherAxis );
drawing::PointSequenceSequence aPoints( lcl_makePointSequence(aStart,aEnd) );
Reference< drawing::XShape > xShape = m_pShapeFactory->createLine2D(
m_xGroupShape_Shapes, aPoints, &m_aAxisProperties.m_aLineProperties );
}
}
}
//createLabels();
}
//.............................................................................
} //namespace chart
//.............................................................................