diff options
Diffstat (limited to 'chart2/source/controller/itemsetwrapper/AxisItemConverter.cxx')
| -rw-r--r-- | chart2/source/controller/itemsetwrapper/AxisItemConverter.cxx | 835 |
1 files changed, 835 insertions, 0 deletions
diff --git a/chart2/source/controller/itemsetwrapper/AxisItemConverter.cxx b/chart2/source/controller/itemsetwrapper/AxisItemConverter.cxx new file mode 100644 index 000000000000..8cf07aabad08 --- /dev/null +++ b/chart2/source/controller/itemsetwrapper/AxisItemConverter.cxx @@ -0,0 +1,835 @@ +/************************************************************************* + * + * 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 "AxisItemConverter.hxx" +#include "ItemPropertyMap.hxx" +#include "CharacterPropertyItemConverter.hxx" +#include "GraphicPropertyItemConverter.hxx" +#include "chartview/ChartSfxItemIds.hxx" +#include "chartview/ExplicitValueProvider.hxx" +#include "SchWhichPairs.hxx" +#include "macros.hxx" +#include "ChartModelHelper.hxx" +#include "AxisHelper.hxx" +#include "CommonConverters.hxx" + +#include <com/sun/star/chart/ChartAxisLabelPosition.hpp> +#include <com/sun/star/chart/ChartAxisMarkPosition.hpp> +#include <com/sun/star/chart/ChartAxisPosition.hpp> +#include <com/sun/star/chart2/XAxis.hpp> +#include <com/sun/star/chart2/AxisOrientation.hpp> + +// for SfxBoolItem +#include <svl/eitem.hxx> +// for SvxDoubleItem +#include <svx/chrtitem.hxx> +// for SfxInt32Item +#include <svl/intitem.hxx> +#include <rtl/math.hxx> + +#include <algorithm> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::chart2; +using ::com::sun::star::uno::Reference; + +namespace +{ +::comphelper::ItemPropertyMapType & lcl_GetAxisPropertyMap() +{ + static ::comphelper::ItemPropertyMapType aAxisPropertyMap( + ::comphelper::MakeItemPropertyMap + IPM_MAP_ENTRY( SCHATTR_AXIS_SHOWDESCR, "DisplayLabels", 0 ) + IPM_MAP_ENTRY( SCHATTR_AXIS_TICKS, "MajorTickmarks", 0 ) + IPM_MAP_ENTRY( SCHATTR_AXIS_HELPTICKS, "MinorTickmarks", 0 ) + IPM_MAP_ENTRY( SCHATTR_TEXT_ORDER, "ArrangeOrder", 0 ) + IPM_MAP_ENTRY( SCHATTR_TEXT_STACKED, "StackCharacters", 0 ) + IPM_MAP_ENTRY( SCHATTR_TEXTBREAK, "TextBreak", 0 ) + IPM_MAP_ENTRY( SCHATTR_TEXT_OVERLAP, "TextOverlap", 0 ) + ); + + return aAxisPropertyMap; +}; +} // anonymous namespace + +namespace chart +{ +namespace wrapper +{ + +AxisItemConverter::AxisItemConverter( + const Reference< beans::XPropertySet > & rPropertySet, + SfxItemPool& rItemPool, + SdrModel& rDrawModel, + const Reference< chart2::XChartDocument > & xChartDoc, + chart2::ExplicitScaleData * pScale /* = NULL */, + chart2::ExplicitIncrementData * pIncrement /* = NULL */, + ::std::auto_ptr< awt::Size > pRefSize /* = NULL */ ) : + ItemConverter( rPropertySet, rItemPool ), + m_xChartDoc( xChartDoc ), + m_pExplicitScale( NULL ), + m_pExplicitIncrement( NULL ) +{ + Reference< lang::XMultiServiceFactory > xNamedPropertyContainerFactory( xChartDoc, uno::UNO_QUERY ); + + if( pScale ) + m_pExplicitScale = new chart2::ExplicitScaleData( *pScale ); + if( pIncrement ) + m_pExplicitIncrement = new chart2::ExplicitIncrementData( *pIncrement ); + + m_aConverters.push_back( new GraphicPropertyItemConverter( + rPropertySet, rItemPool, rDrawModel, + xNamedPropertyContainerFactory, + GraphicPropertyItemConverter::LINE_PROPERTIES )); + m_aConverters.push_back( new CharacterPropertyItemConverter( rPropertySet, rItemPool, pRefSize, + C2U( "ReferencePageSize" ) )); + + m_xAxis.set( Reference< chart2::XAxis >( rPropertySet, uno::UNO_QUERY ) ); + OSL_ASSERT( m_xAxis.is()); +} + +AxisItemConverter::~AxisItemConverter() +{ + delete m_pExplicitScale; + delete m_pExplicitIncrement; + + ::std::for_each( m_aConverters.begin(), m_aConverters.end(), + ::comphelper::DeleteItemConverterPtr() ); +} + +void AxisItemConverter::FillItemSet( SfxItemSet & rOutItemSet ) const +{ + ::std::for_each( m_aConverters.begin(), m_aConverters.end(), + ::comphelper::FillItemSetFunc( rOutItemSet )); + + // own items + ItemConverter::FillItemSet( rOutItemSet ); +} + +bool AxisItemConverter::ApplyItemSet( const SfxItemSet & rItemSet ) +{ + bool bResult = false; + + ::std::for_each( m_aConverters.begin(), m_aConverters.end(), + ::comphelper::ApplyItemSetFunc( rItemSet, bResult )); + + // own items + return ItemConverter::ApplyItemSet( rItemSet ) || bResult; +} + +const USHORT * AxisItemConverter::GetWhichPairs() const +{ + // must span all used items! + return nAxisWhichPairs; +} + +bool AxisItemConverter::GetItemProperty( tWhichIdType nWhichId, tPropertyNameWithMemberId & rOutProperty ) const +{ + ::comphelper::ItemPropertyMapType & rMap( lcl_GetAxisPropertyMap()); + ::comphelper::ItemPropertyMapType::const_iterator aIt( rMap.find( nWhichId )); + + if( aIt == rMap.end()) + return false; + + rOutProperty =(*aIt).second; + + return true; +} + +void AxisItemConverter::FillSpecialItem( USHORT nWhichId, SfxItemSet & rOutItemSet ) const + throw( uno::Exception ) +{ + if( ! m_xAxis.is() ) + return; + + const chart2::ScaleData aScale( m_xAxis->getScaleData() ); + const chart2::IncrementData aInc( aScale.IncrementData ); + const uno::Sequence< chart2::SubIncrement > aSubIncs( aScale.IncrementData.SubIncrements ); + + switch( nWhichId ) + { + case SCHATTR_AXIS_AUTO_MAX: + // if the any has no value => auto is on + rOutItemSet.Put( SfxBoolItem( nWhichId, !hasDoubleValue(aScale.Maximum) ) ); + break; + + case SCHATTR_AXIS_MAX: + { + double fMax = 10.0; + if( aScale.Maximum >>= fMax ) + { + rOutItemSet.Put( SvxDoubleItem( fMax, nWhichId ) ); + } + else + { + if( m_pExplicitScale ) + fMax = m_pExplicitScale->Maximum; + rOutItemSet.Put( SvxDoubleItem( fMax, nWhichId ) ); + } + } + break; + + case SCHATTR_AXIS_AUTO_MIN: + // if the any has no value => auto is on + rOutItemSet.Put( SfxBoolItem( nWhichId, !hasDoubleValue(aScale.Minimum) ) ); + break; + + case SCHATTR_AXIS_MIN: + { + double fMin = 0.0; + if( aScale.Minimum >>= fMin ) + { + rOutItemSet.Put( SvxDoubleItem( fMin, nWhichId ) ); + } + else + { + if( m_pExplicitScale ) + rOutItemSet.Put( SvxDoubleItem( m_pExplicitScale->Minimum, nWhichId )); + } + } + break; + + case SCHATTR_AXIS_LOGARITHM: + { + BOOL bValue = AxisHelper::isLogarithmic( aScale.Scaling ); + rOutItemSet.Put( SfxBoolItem( nWhichId, bValue )); + } + break; + + case SCHATTR_AXIS_REVERSE: + rOutItemSet.Put( SfxBoolItem( nWhichId, (AxisOrientation_REVERSE == aScale.Orientation) )); + break; + + // Increment + case SCHATTR_AXIS_AUTO_STEP_MAIN: + // if the any has no value => auto is on + rOutItemSet.Put( SfxBoolItem( nWhichId, !hasDoubleValue(aInc.Distance) ) ); + break; + + case SCHATTR_AXIS_STEP_MAIN: + { + double fDistance = 1.0; + if( aInc.Distance >>= fDistance ) + { + rOutItemSet.Put( SvxDoubleItem(fDistance, nWhichId )); + } + else + { + if( m_pExplicitIncrement ) + rOutItemSet.Put( SvxDoubleItem( m_pExplicitIncrement->Distance, nWhichId )); + } + } + break; + + // SubIncrement + case SCHATTR_AXIS_AUTO_STEP_HELP: + { + // if the any has no value => auto is on + rOutItemSet.Put( + SfxBoolItem( + nWhichId, + ! ( aSubIncs.getLength() > 0 && + aSubIncs[0].IntervalCount.hasValue() ))); + } + break; + + case SCHATTR_AXIS_STEP_HELP: + { + if( aSubIncs.getLength() > 0 && + aSubIncs[0].IntervalCount.hasValue()) + { + OSL_ASSERT( aSubIncs[0].IntervalCount.getValueTypeClass() == uno::TypeClass_LONG ); + rOutItemSet.Put( + SfxInt32Item( + nWhichId, + *reinterpret_cast< const sal_Int32 * >( + aSubIncs[0].IntervalCount.getValue()) )); + } + else + { + if( m_pExplicitIncrement && + m_pExplicitIncrement->SubIncrements.getLength() > 0 ) + { + rOutItemSet.Put( + SfxInt32Item( + nWhichId, + m_pExplicitIncrement->SubIncrements[0].IntervalCount )); + } + } + } + break; + + case SCHATTR_AXIS_AUTO_ORIGIN: + { + // if the any has no double value => auto is on + rOutItemSet.Put( SfxBoolItem( nWhichId, ( !hasDoubleValue(aScale.Origin) ))); + } + break; + + case SCHATTR_AXIS_ORIGIN: + { + double fOrigin = 0.0; + if( !(aScale.Origin >>= fOrigin) ) + { + if( m_pExplicitScale ) + fOrigin = m_pExplicitScale->Origin; + } + rOutItemSet.Put( SvxDoubleItem( fOrigin, nWhichId )); + } + break; + + case SCHATTR_AXIS_POSITION: + { + ::com::sun::star::chart::ChartAxisPosition eAxisPos( ::com::sun::star::chart::ChartAxisPosition_ZERO ); + GetPropertySet()->getPropertyValue(C2U( "CrossoverPosition" )) >>= eAxisPos; + rOutItemSet.Put( SfxInt32Item( nWhichId, eAxisPos ) ); + } + break; + + case SCHATTR_AXIS_POSITION_VALUE: + { + double fValue = 0.0; + if( GetPropertySet()->getPropertyValue(C2U( "CrossoverValue" )) >>= fValue ) + rOutItemSet.Put( SvxDoubleItem( fValue, nWhichId ) ); + } + break; + + case SCHATTR_AXIS_CROSSING_MAIN_AXIS_NUMBERFORMAT: + { + //read only item + //necessary tp display the crossing value with an appropriate format + + Reference< chart2::XCoordinateSystem > xCooSys( AxisHelper::getCoordinateSystemOfAxis( + m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ) ); + + Reference< chart2::XAxis > xCrossingMainAxis( AxisHelper::getCrossingMainAxis( m_xAxis, xCooSys ) ); + + sal_Int32 nFormatKey = ExplicitValueProvider::getExplicitNumberFormatKeyForAxis( + xCrossingMainAxis, xCooSys, Reference< util::XNumberFormatsSupplier >( m_xChartDoc, uno::UNO_QUERY ) ); + + rOutItemSet.Put( SfxUInt32Item( nWhichId, nFormatKey )); + } + break; + + case SCHATTR_AXIS_LABEL_POSITION: + { + ::com::sun::star::chart::ChartAxisLabelPosition ePos( ::com::sun::star::chart::ChartAxisLabelPosition_NEAR_AXIS ); + GetPropertySet()->getPropertyValue(C2U( "LabelPosition" )) >>= ePos; + rOutItemSet.Put( SfxInt32Item( nWhichId, ePos ) ); + } + break; + + case SCHATTR_AXIS_MARK_POSITION: + { + ::com::sun::star::chart::ChartAxisMarkPosition ePos( ::com::sun::star::chart::ChartAxisMarkPosition_AT_LABELS_AND_AXIS ); + GetPropertySet()->getPropertyValue(C2U( "MarkPosition" )) >>= ePos; + rOutItemSet.Put( SfxInt32Item( nWhichId, ePos ) ); + } + break; + + case SCHATTR_TEXT_DEGREES: + { + // convert double to int (times 100) + double fVal = 0; + + if( GetPropertySet()->getPropertyValue( C2U( "TextRotation" )) >>= fVal ) + { + rOutItemSet.Put( SfxInt32Item( nWhichId, static_cast< sal_Int32 >( + ::rtl::math::round( fVal * 100.0 ) ) )); + } + } + break; + + case SID_ATTR_NUMBERFORMAT_VALUE: +// case SCHATTR_AXIS_NUMFMT: + { + if( m_pExplicitScale ) + { + Reference< chart2::XCoordinateSystem > xCooSys( + AxisHelper::getCoordinateSystemOfAxis( + m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ) ); + + sal_Int32 nFormatKey = ExplicitValueProvider::getExplicitNumberFormatKeyForAxis( + m_xAxis, xCooSys, Reference< util::XNumberFormatsSupplier >( m_xChartDoc, uno::UNO_QUERY ) ); + + rOutItemSet.Put( SfxUInt32Item( nWhichId, nFormatKey )); + } + } + break; + + case SID_ATTR_NUMBERFORMAT_SOURCE: + { + bool bNumberFormatIsSet = ( GetPropertySet()->getPropertyValue( C2U( "NumberFormat" )).hasValue()); + rOutItemSet.Put( SfxBoolItem( nWhichId, ! bNumberFormatIsSet )); + } + break; + + case SCHATTR_AXISTYPE: + rOutItemSet.Put( SfxInt32Item( nWhichId, aScale.AxisType )); + break; + } +} + +bool AxisItemConverter::ApplySpecialItem( USHORT nWhichId, const SfxItemSet & rItemSet ) + throw( uno::Exception ) +{ + if( !m_xAxis.is() ) + return false; + + chart2::ScaleData aScale( m_xAxis->getScaleData() ); + + bool bSetScale = false; + bool bChangedOtherwise = false; + + uno::Any aValue; + + switch( nWhichId ) + { + case SCHATTR_AXIS_AUTO_MAX: + if( (static_cast< const SfxBoolItem & >( + rItemSet.Get( nWhichId )).GetValue() )) + { + aScale.Maximum.clear(); + bSetScale = true; + } + // else SCHATTR_AXIS_MAX must have some value + break; + + case SCHATTR_AXIS_MAX: + // only if auto if false + if( ! (static_cast< const SfxBoolItem & >( + rItemSet.Get( SCHATTR_AXIS_AUTO_MAX )).GetValue() )) + { + rItemSet.Get( nWhichId ).QueryValue( aValue ); + + if( aScale.Maximum != aValue ) + { + aScale.Maximum = aValue; + bSetScale = true; + } + } + break; + + case SCHATTR_AXIS_AUTO_MIN: + if( (static_cast< const SfxBoolItem & >( + rItemSet.Get( nWhichId )).GetValue() )) + { + aScale.Minimum.clear(); + bSetScale = true; + } + // else SCHATTR_AXIS_MIN must have some value + break; + + case SCHATTR_AXIS_MIN: + // only if auto if false + if( ! (static_cast< const SfxBoolItem & >( + rItemSet.Get( SCHATTR_AXIS_AUTO_MIN )).GetValue() )) + { + rItemSet.Get( nWhichId ).QueryValue( aValue ); + + if( aScale.Minimum != aValue ) + { + aScale.Minimum = aValue; + bSetScale = true; + } + } + break; + + case SCHATTR_AXIS_LOGARITHM: + { + bool bWasLogarithm = AxisHelper::isLogarithmic( aScale.Scaling ); + + if( (static_cast< const SfxBoolItem & >( + rItemSet.Get( nWhichId )).GetValue() )) + { + // logarithm is true + if( ! bWasLogarithm ) + { + aScale.Scaling = AxisHelper::createLogarithmicScaling( 10.0 ); + bSetScale = true; + } + } + else + { + // logarithm is false => linear scaling + if( bWasLogarithm ) + { + aScale.Scaling = AxisHelper::createLinearScaling(); + bSetScale = true; + } + } + } + break; + + case SCHATTR_AXIS_REVERSE: + { + bool bWasReverse = ( AxisOrientation_REVERSE == aScale.Orientation ); + bool bNewReverse = (static_cast< const SfxBoolItem & >( + rItemSet.Get( nWhichId )).GetValue() ); + if( bWasReverse != bNewReverse ) + { + aScale.Orientation = bNewReverse ? AxisOrientation_REVERSE : AxisOrientation_MATHEMATICAL; + bSetScale = true; + } + } + break; + + // Increment + case SCHATTR_AXIS_AUTO_STEP_MAIN: + if( (static_cast< const SfxBoolItem & >( + rItemSet.Get( nWhichId )).GetValue() )) + { + aScale.IncrementData.Distance.clear(); + bSetScale = true; + } + // else SCHATTR_AXIS_STEP_MAIN must have some value + break; + + case SCHATTR_AXIS_STEP_MAIN: + // only if auto if false + if( ! (static_cast< const SfxBoolItem & >( + rItemSet.Get( SCHATTR_AXIS_AUTO_STEP_MAIN )).GetValue() )) + { + rItemSet.Get( nWhichId ).QueryValue( aValue ); + + if( aScale.IncrementData.Distance != aValue ) + { + aScale.IncrementData.Distance = aValue; + bSetScale = true; + } + } + break; + + // SubIncrement + case SCHATTR_AXIS_AUTO_STEP_HELP: + if( (static_cast< const SfxBoolItem & >( + rItemSet.Get( nWhichId )).GetValue() ) && + aScale.IncrementData.SubIncrements.getLength() > 0 && + aScale.IncrementData.SubIncrements[0].IntervalCount.hasValue() ) + { + aScale.IncrementData.SubIncrements[0].IntervalCount.clear(); + bSetScale = true; + } + // else SCHATTR_AXIS_STEP_MAIN must have some value + break; + + case SCHATTR_AXIS_STEP_HELP: + // only if auto if false + if( ! (static_cast< const SfxBoolItem & >( + rItemSet.Get( SCHATTR_AXIS_AUTO_STEP_HELP )).GetValue() ) && + aScale.IncrementData.SubIncrements.getLength() > 0 ) + { + rItemSet.Get( nWhichId ).QueryValue( aValue ); + + if( ! aScale.IncrementData.SubIncrements[0].IntervalCount.hasValue() || + aScale.IncrementData.SubIncrements[0].IntervalCount != aValue ) + { + OSL_ASSERT( aValue.getValueTypeClass() == uno::TypeClass_LONG ); + aScale.IncrementData.SubIncrements[0].IntervalCount = aValue; + bSetScale = true; + } + } + break; + + case SCHATTR_AXIS_AUTO_ORIGIN: + { + if( (static_cast< const SfxBoolItem & >( + rItemSet.Get( nWhichId )).GetValue() )) + { + aScale.Origin.clear(); + bSetScale = true; + } + } + break; + + case SCHATTR_AXIS_ORIGIN: + { + // only if auto is false + if( ! (static_cast< const SfxBoolItem & >( + rItemSet.Get( SCHATTR_AXIS_AUTO_ORIGIN )).GetValue() )) + { + rItemSet.Get( nWhichId ).QueryValue( aValue ); + + if( aScale.Origin != aValue ) + { + aScale.Origin = aValue; + bSetScale = true; + + if( !AxisHelper::isAxisPositioningEnabled() ) + { + //keep old and new settings for axis positioning in sync somehow + Reference< chart2::XCoordinateSystem > xCooSys( AxisHelper::getCoordinateSystemOfAxis( + m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ) ); + + sal_Int32 nDimensionIndex=0; + sal_Int32 nAxisIndex=0; + if( AxisHelper::getIndicesForAxis( m_xAxis, xCooSys, nDimensionIndex, nAxisIndex ) && nAxisIndex==0 ) + { + Reference< beans::XPropertySet > xCrossingMainAxis( AxisHelper::getCrossingMainAxis( m_xAxis, xCooSys ), uno::UNO_QUERY ); + if( xCrossingMainAxis.is() ) + { + double fValue = 0.0; + if( aValue >>= fValue ) + { + xCrossingMainAxis->setPropertyValue( C2U( "CrossoverPosition" ), uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_VALUE )); + xCrossingMainAxis->setPropertyValue( C2U( "CrossoverValue" ), uno::makeAny( fValue )); + } + else + xCrossingMainAxis->setPropertyValue( C2U( "CrossoverPosition" ), uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_START )); + } + } + } + } + } + } + break; + + case SCHATTR_AXIS_POSITION: + { + ::com::sun::star::chart::ChartAxisPosition eAxisPos = + (::com::sun::star::chart::ChartAxisPosition) + static_cast< const SfxInt32Item & >( rItemSet.Get( nWhichId )).GetValue(); + + ::com::sun::star::chart::ChartAxisPosition eOldAxisPos( ::com::sun::star::chart::ChartAxisPosition_ZERO ); + bool bPropExisted = ( GetPropertySet()->getPropertyValue(C2U( "CrossoverPosition" )) >>= eOldAxisPos ); + + if( !bPropExisted || ( eOldAxisPos != eAxisPos )) + { + GetPropertySet()->setPropertyValue( C2U( "CrossoverPosition" ), uno::makeAny( eAxisPos )); + bChangedOtherwise = true; + + //move the parallel axes to the other side if necessary + if( eAxisPos==::com::sun::star::chart::ChartAxisPosition_START || eAxisPos==::com::sun::star::chart::ChartAxisPosition_END ) + { + Reference< beans::XPropertySet > xParallelAxis( AxisHelper::getParallelAxis( m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ), uno::UNO_QUERY ); + if( xParallelAxis.is() ) + { + ::com::sun::star::chart::ChartAxisPosition eOtherPos; + if( xParallelAxis->getPropertyValue( C2U( "CrossoverPosition" ) ) >>= eOtherPos ) + { + if( eOtherPos == eAxisPos ) + { + ::com::sun::star::chart::ChartAxisPosition eOppositePos = + (eAxisPos==::com::sun::star::chart::ChartAxisPosition_START) + ? ::com::sun::star::chart::ChartAxisPosition_END + : ::com::sun::star::chart::ChartAxisPosition_START; + xParallelAxis->setPropertyValue( C2U( "CrossoverPosition" ), uno::makeAny( eOppositePos )); + } + } + } + } + } + } + break; + + case SCHATTR_AXIS_POSITION_VALUE: + { + double fValue = static_cast< const SvxDoubleItem & >( rItemSet.Get( nWhichId )).GetValue(); + + double fOldValue = 0.0; + bool bPropExisted = ( GetPropertySet()->getPropertyValue(C2U( "CrossoverValue" )) >>= fOldValue ); + + if( !bPropExisted || ( fOldValue != fValue )) + { + GetPropertySet()->setPropertyValue( C2U( "CrossoverValue" ), uno::makeAny( fValue )); + bChangedOtherwise = true; + + //keep old and new settings for axis positioning in sync somehow + { + Reference< chart2::XCoordinateSystem > xCooSys( AxisHelper::getCoordinateSystemOfAxis( + m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ) ); + + sal_Int32 nDimensionIndex=0; + sal_Int32 nAxisIndex=0; + if( AxisHelper::getIndicesForAxis( m_xAxis, xCooSys, nDimensionIndex, nAxisIndex ) && nAxisIndex==0 && nDimensionIndex==0 ) + { + Reference< chart2::XAxis > xCrossingMainAxis( AxisHelper::getCrossingMainAxis( m_xAxis, xCooSys ) ); + if( xCrossingMainAxis.is() ) + { + ScaleData aCrossingScale( xCrossingMainAxis->getScaleData() ); + aCrossingScale.Origin = uno::makeAny(fValue); + xCrossingMainAxis->setScaleData(aCrossingScale); + } + } + } + } + } + break; + + case SCHATTR_AXIS_LABEL_POSITION: + { + ::com::sun::star::chart::ChartAxisLabelPosition ePos = + (::com::sun::star::chart::ChartAxisLabelPosition) + static_cast< const SfxInt32Item & >( rItemSet.Get( nWhichId )).GetValue(); + + ::com::sun::star::chart::ChartAxisLabelPosition eOldPos( ::com::sun::star::chart::ChartAxisLabelPosition_NEAR_AXIS ); + bool bPropExisted = ( GetPropertySet()->getPropertyValue(C2U( "LabelPosition" )) >>= eOldPos ); + + if( !bPropExisted || ( eOldPos != ePos )) + { + GetPropertySet()->setPropertyValue( C2U( "LabelPosition" ), uno::makeAny( ePos )); + bChangedOtherwise = true; + + //move the parallel axes to the other side if necessary + if( ePos==::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_START || ePos==::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_END ) + { + Reference< beans::XPropertySet > xParallelAxis( AxisHelper::getParallelAxis( m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ), uno::UNO_QUERY ); + if( xParallelAxis.is() ) + { + ::com::sun::star::chart::ChartAxisLabelPosition eOtherPos; + if( xParallelAxis->getPropertyValue( C2U( "LabelPosition" ) ) >>= eOtherPos ) + { + if( eOtherPos == ePos ) + { + ::com::sun::star::chart::ChartAxisLabelPosition eOppositePos = + (ePos==::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_START) + ? ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_END + : ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_START; + xParallelAxis->setPropertyValue( C2U( "LabelPosition" ), uno::makeAny( eOppositePos )); + } + } + } + } + } + } + break; + + case SCHATTR_AXIS_MARK_POSITION: + { + ::com::sun::star::chart::ChartAxisMarkPosition ePos = + (::com::sun::star::chart::ChartAxisMarkPosition) + static_cast< const SfxInt32Item & >( rItemSet.Get( nWhichId )).GetValue(); + + ::com::sun::star::chart::ChartAxisMarkPosition eOldPos( ::com::sun::star::chart::ChartAxisMarkPosition_AT_LABELS_AND_AXIS ); + bool bPropExisted = ( GetPropertySet()->getPropertyValue(C2U( "MarkPosition" )) >>= eOldPos ); + + if( !bPropExisted || ( eOldPos != ePos )) + { + GetPropertySet()->setPropertyValue( C2U( "MarkPosition" ), uno::makeAny( ePos )); + bChangedOtherwise = true; + } + } + break; + + case SCHATTR_TEXT_DEGREES: + { + // convert int to double (divided by 100) + double fVal = static_cast< double >( + static_cast< const SfxInt32Item & >( + rItemSet.Get( nWhichId )).GetValue()) / 100.0; + double fOldVal = 0.0; + bool bPropExisted = + ( GetPropertySet()->getPropertyValue( C2U( "TextRotation" )) >>= fOldVal ); + + if( ! bPropExisted || + ( bPropExisted && fOldVal != fVal )) + { + GetPropertySet()->setPropertyValue( C2U( "TextRotation" ), uno::makeAny( fVal )); + bChangedOtherwise = true; + } + } + break; + + case SID_ATTR_NUMBERFORMAT_VALUE: +// case SCHATTR_AXIS_NUMFMT: + { + if( m_pExplicitScale ) + { + bool bUseSourceFormat = + (static_cast< const SfxBoolItem & >( + rItemSet.Get( SID_ATTR_NUMBERFORMAT_SOURCE )).GetValue() ); + + if( ! bUseSourceFormat ) + { + sal_Int32 nFmt = static_cast< sal_Int32 >( + static_cast< const SfxUInt32Item & >( + rItemSet.Get( nWhichId )).GetValue()); + + aValue = uno::makeAny(nFmt); + if( GetPropertySet()->getPropertyValue( C2U( "NumberFormat" )) != aValue ) + { + GetPropertySet()->setPropertyValue( C2U( "NumberFormat" ), aValue ); + bChangedOtherwise = true; + } + } + } + } + break; + + case SID_ATTR_NUMBERFORMAT_SOURCE: + { + bool bUseSourceFormat = + (static_cast< const SfxBoolItem & >( + rItemSet.Get( nWhichId )).GetValue() ); + bool bNumberFormatIsSet = ( GetPropertySet()->getPropertyValue( C2U( "NumberFormat" )).hasValue()); + + bChangedOtherwise = (bUseSourceFormat == bNumberFormatIsSet); + if( bChangedOtherwise ) + { + if( ! bUseSourceFormat ) + { + SfxItemState aState = rItemSet.GetItemState( SID_ATTR_NUMBERFORMAT_VALUE ); + if( aState == SFX_ITEM_SET ) + { + sal_Int32 nFormatKey = static_cast< sal_Int32 >( + static_cast< const SfxUInt32Item & >( + rItemSet.Get( SID_ATTR_NUMBERFORMAT_VALUE )).GetValue()); + aValue <<= nFormatKey; + } + else + { + Reference< chart2::XCoordinateSystem > xCooSys( + AxisHelper::getCoordinateSystemOfAxis( + m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ) ); + + sal_Int32 nFormatKey = ExplicitValueProvider::getExplicitNumberFormatKeyForAxis( + m_xAxis, xCooSys, Reference< util::XNumberFormatsSupplier >( m_xChartDoc, uno::UNO_QUERY ) ); + + aValue <<= nFormatKey; + } + } + // else set a void Any + GetPropertySet()->setPropertyValue( C2U( "NumberFormat" ), aValue ); + } + } + break; + + case SCHATTR_AXISTYPE: + //don't allow to change the axis type so far + break; + } + + if( bSetScale ) + m_xAxis->setScaleData( aScale ); + + return (bSetScale || bChangedOtherwise); +} + +} // namespace wrapper +} // namespace chart |