/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* 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 .
*/
#include <AxisItemConverter.hxx>
#include <ItemPropertyMap.hxx>
#include <CharacterPropertyItemConverter.hxx>
#include <GraphicPropertyItemConverter.hxx>
#include <chartview/ChartSfxItemIds.hxx>
#include <chartview/ExplicitScaleValues.hxx>
#include <chartview/ExplicitValueProvider.hxx>
#include "SchWhichPairs.hxx"
#include <ChartModelHelper.hxx>
#include <AxisHelper.hxx>
#include <CommonConverters.hxx>
#include <ChartTypeHelper.hxx>
#include <unonames.hxx>
#include <memory>
#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/chart/TimeInterval.hpp>
#include <com/sun/star/chart2/XAxis.hpp>
#include <com/sun/star/chart2/AxisOrientation.hpp>
#include <com/sun/star/chart2/AxisType.hpp>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <osl/diagnose.h>
#include <o3tl/any.hxx>
#include <svl/eitem.hxx>
#include <svx/chrtitem.hxx>
#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;
using ::com::sun::star::chart::TimeInterval;
using ::com::sun::star::chart::TimeIncrement;
namespace chart { namespace wrapper {
namespace {
ItemPropertyMapType & lcl_GetAxisPropertyMap()
{
static ItemPropertyMapType aAxisPropertyMap{
{SCHATTR_AXIS_SHOWDESCR, {"DisplayLabels", 0}},
{SCHATTR_AXIS_TICKS, {"MajorTickmarks", 0}},
{SCHATTR_AXIS_HELPTICKS, {"MinorTickmarks", 0}},
{SCHATTR_AXIS_LABEL_ORDER, {"ArrangeOrder", 0}},
{SCHATTR_TEXT_STACKED, {"StackCharacters", 0}},
{SCHATTR_AXIS_LABEL_BREAK, {"TextBreak", 0}},
{SCHATTR_AXIS_LABEL_OVERLAP, {"TextOverlap", 0}}};
return aAxisPropertyMap;
};
} // anonymous namespace
AxisItemConverter::AxisItemConverter(
const Reference< beans::XPropertySet > & rPropertySet,
SfxItemPool& rItemPool,
SdrModel& rDrawModel,
const Reference< chart2::XChartDocument > & xChartDoc,
::chart::ExplicitScaleData const * pScale /* = NULL */,
::chart::ExplicitIncrementData const * pIncrement /* = NULL */,
const awt::Size* pRefSize ) :
ItemConverter( rPropertySet, rItemPool ),
m_xChartDoc( xChartDoc )
{
Reference< lang::XMultiServiceFactory > xNamedPropertyContainerFactory( xChartDoc, uno::UNO_QUERY );
if( pScale )
m_pExplicitScale.reset( new ::chart::ExplicitScaleData( *pScale ) );
if( pIncrement )
m_pExplicitIncrement.reset( new ::chart::ExplicitIncrementData( *pIncrement ) );
m_aConverters.emplace_back( new GraphicPropertyItemConverter(
rPropertySet, rItemPool, rDrawModel,
xNamedPropertyContainerFactory,
GraphicObjectType::LineProperties ));
m_aConverters.emplace_back(
new CharacterPropertyItemConverter(rPropertySet, rItemPool, pRefSize, "ReferencePageSize"));
m_xAxis.set( Reference< chart2::XAxis >( rPropertySet, uno::UNO_QUERY ) );
OSL_ASSERT( m_xAxis.is());
}
AxisItemConverter::~AxisItemConverter()
{
}
void AxisItemConverter::FillItemSet( SfxItemSet & rOutItemSet ) const
{
for( const auto& pConv : m_aConverters )
pConv->FillItemSet( rOutItemSet );
// own items
ItemConverter::FillItemSet( rOutItemSet );
}
bool AxisItemConverter::ApplyItemSet( const SfxItemSet & rItemSet )
{
bool bResult = false;
for( const auto& pConv : m_aConverters )
bResult = pConv->ApplyItemSet( rItemSet ) || bResult;
// own items
return ItemConverter::ApplyItemSet( rItemSet ) || bResult;
}
const sal_uInt16 * AxisItemConverter::GetWhichPairs() const
{
// must span all used items!
return nAxisWhichPairs;
}
bool AxisItemConverter::GetItemProperty( tWhichIdType nWhichId, tPropertyNameWithMemberId & rOutProperty ) const
{
ItemPropertyMapType & rMap( lcl_GetAxisPropertyMap());
ItemPropertyMapType::const_iterator aIt( rMap.find( nWhichId ));
if( aIt == rMap.end())
return false;
rOutProperty =(*aIt).second;
return true;
}
bool lcl_hasTimeIntervalValue( const uno::Any& rAny )
{
bool bRet = false;
TimeInterval aValue;
if( rAny >>= aValue )
bRet = true;
return bRet;
}
void AxisItemConverter::FillSpecialItem( sal_uInt16 nWhichId, SfxItemSet & rOutItemSet ) const
{
if( !m_xAxis.is() )
return;
const chart2::ScaleData& rScale( m_xAxis->getScaleData() );
const chart2::IncrementData& rIncrement( rScale.IncrementData );
const uno::Sequence< chart2::SubIncrement >& rSubIncrements( rScale.IncrementData.SubIncrements );
const TimeIncrement& rTimeIncrement( rScale.TimeIncrement );
bool bDateAxis = (rScale.AxisType == chart2::AxisType::DATE);
if( m_pExplicitScale )
bDateAxis = (m_pExplicitScale->AxisType == chart2::AxisType::DATE);
switch( nWhichId )
{
case SCHATTR_AXIS_AUTO_MAX:
rOutItemSet.Put( SfxBoolItem( nWhichId, !hasDoubleValue(rScale.Maximum) ) );
break;
case SCHATTR_AXIS_MAX:
{
double fMax = 10.0;
if( rScale.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:
rOutItemSet.Put( SfxBoolItem( nWhichId, !hasDoubleValue(rScale.Minimum) ) );
break;
case SCHATTR_AXIS_MIN:
{
double fMin = 0.0;
if( rScale.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( rScale.Scaling );
rOutItemSet.Put( SfxBoolItem( nWhichId, bValue ));
}
break;
case SCHATTR_AXIS_REVERSE:
rOutItemSet.Put( SfxBoolItem( nWhichId, (rScale.Orientation == AxisOrientation_REVERSE) ));
break;
// Increment
case SCHATTR_AXIS_AUTO_STEP_MAIN:
if( bDateAxis )
rOutItemSet.Put( SfxBoolItem( nWhichId, !lcl_hasTimeIntervalValue(rTimeIncrement.MajorTimeInterval) ) );
else
rOutItemSet.Put( SfxBoolItem( nWhichId, !hasDoubleValue(rIncrement.Distance) ) );
break;
case SCHATTR_AXIS_MAIN_TIME_UNIT:
{
TimeInterval aTimeInterval;
if( rTimeIncrement.MajorTimeInterval >>= aTimeInterval )
rOutItemSet.Put( SfxInt32Item( nWhichId, aTimeInterval.TimeUnit ) );
else if( m_pExplicitIncrement )
rOutItemSet.Put( SfxInt32Item( nWhichId, m_pExplicitIncrement->MajorTimeInterval.TimeUnit ) );
}
break;
case SCHATTR_AXIS_STEP_MAIN:
if( bDateAxis )
{
TimeInterval aTimeInterval;
if( rTimeIncrement.MajorTimeInterval >>= aTimeInterval )
rOutItemSet.Put( SvxDoubleItem(aTimeInterval.Number, nWhichId ));
else if( m_pExplicitIncrement )
rOutItemSet.Put( SvxDoubleItem( m_pExplicitIncrement->MajorTimeInterval.Number, nWhichId ));
}
else
{
double fDistance = 1.0;
if( rIncrement.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( bDateAxis )
rOutItemSet.Put( SfxBoolItem( nWhichId, !lcl_hasTimeIntervalValue(rTimeIncrement.MinorTimeInterval) ) );
else
rOutItemSet.Put( SfxBoolItem( nWhichId,
! ( rSubIncrements.getLength() > 0 && rSubIncrements[0].IntervalCount.hasValue() )));
break;
case SCHATTR_AXIS_HELP_TIME_UNIT:
{
TimeInterval aTimeInterval;
if( rTimeIncrement.MinorTimeInterval >>= aTimeInterval )
rOutItemSet.Put( SfxInt32Item( nWhichId, aTimeInterval.TimeUnit ) );
else if( m_pExplicitIncrement )
rOutItemSet.Put( SfxInt32Item( nWhichId, m_pExplicitIncrement->MinorTimeInterval.TimeUnit ) );
}
break;
case SCHATTR_AXIS_STEP_HELP:
if( bDateAxis )
{
TimeInterval aTimeInterval;
if( rTimeIncrement.MinorTimeInterval >>= aTimeInterval )
rOutItemSet.Put( SfxInt32Item( nWhichId, aTimeInterval.Number ));
else if( m_pExplicitIncrement )
rOutItemSet.Put( SfxInt32Item( nWhichId, m_pExplicitIncrement->MinorTimeInterval.Number ));
}
else
{
if( rSubIncrements.getLength() > 0 && rSubIncrements[0].IntervalCount.hasValue())
{
rOutItemSet.Put( SfxInt32Item( nWhichId,
*o3tl::doAccess<sal_Int32>(
rSubIncrements[0].IntervalCount) ));
}
else
{
if( m_pExplicitIncrement && !m_pExplicitIncrement->SubIncrements.empty() )
{
rOutItemSet.Put( SfxInt32Item( nWhichId,
m_pExplicitIncrement->SubIncrements[0].IntervalCount ));
}
}
}
break;
case SCHATTR_AXIS_AUTO_TIME_RESOLUTION:
{
rOutItemSet.Put( SfxBoolItem( nWhichId,
!rTimeIncrement.TimeResolution.hasValue() ));
}
break;
case SCHATTR_AXIS_TIME_RESOLUTION:
{
long nTimeResolution=0;
if( rTimeIncrement.TimeResolution >>= nTimeResolution )
rOutItemSet.Put( SfxInt32Item( nWhichId, nTimeResolution ) );
else if( m_pExplicitScale )
rOutItemSet.Put( SfxInt32Item( nWhichId, m_pExplicitScale->TimeResolution ) );
}
break;
case SCHATTR_AXIS_AUTO_ORIGIN:
{
rOutItemSet.Put( SfxBoolItem( nWhichId, ( !hasDoubleValue(rScale.Origin) )));
}
break;
case SCHATTR_AXIS_ORIGIN:
{
double fOrigin = 0.0;
if( !(rScale.Origin >>= fOrigin) )
{
if( m_pExplicitScale )
fOrigin = m_pExplicitScale->Origin;
}
rOutItemSet.Put( SvxDoubleItem( fOrigin, nWhichId ));
}
break;
case SCHATTR_AXIS_POSITION:
{
css::chart::ChartAxisPosition eAxisPos( css::chart::ChartAxisPosition_ZERO );
GetPropertySet()->getPropertyValue( "CrossoverPosition" ) >>= eAxisPos;
rOutItemSet.Put( SfxInt32Item( nWhichId, static_cast<sal_Int32>(eAxisPos) ) );
}
break;
case SCHATTR_AXIS_POSITION_VALUE:
{
double fValue = 0.0;
if( GetPropertySet()->getPropertyValue( "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, m_xChartDoc);
rOutItemSet.Put( SfxUInt32Item( nWhichId, nFormatKey ));
}
break;
case SCHATTR_AXIS_LABEL_POSITION:
{
css::chart::ChartAxisLabelPosition ePos( css::chart::ChartAxisLabelPosition_NEAR_AXIS );
GetPropertySet()->getPropertyValue( "LabelPosition" ) >>= ePos;
rOutItemSet.Put( SfxInt32Item( nWhichId, static_cast<sal_Int32>(ePos) ) );
}
break;
case SCHATTR_AXIS_MARK_POSITION:
{
css::chart::ChartAxisMarkPosition ePos( css::chart::ChartAxisMarkPosition_AT_LABELS_AND_AXIS );
GetPropertySet()->getPropertyValue( "MarkPosition" ) >>= ePos;
rOutItemSet.Put( SfxInt32Item( nWhichId, static_cast<sal_Int32>(ePos) ) );
}
break;
case SCHATTR_TEXT_DEGREES:
{
// convert double to int (times 100)
double fVal = 0;
if( GetPropertySet()->getPropertyValue( "TextRotation" ) >>= fVal )
{
rOutItemSet.Put( SfxInt32Item( nWhichId, static_cast< sal_Int32 >(
::rtl::math::round( fVal * 100.0 ) ) ));
}
}
break;
case SID_ATTR_NUMBERFORMAT_VALUE:
{
if( m_pExplicitScale )
{
Reference< chart2::XCoordinateSystem > xCooSys(
AxisHelper::getCoordinateSystemOfAxis(
m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ) );
sal_Int32 nFormatKey = ExplicitValueProvider::getExplicitNumberFormatKeyForAxis(
m_xAxis, xCooSys, m_xChartDoc);
rOutItemSet.Put( SfxUInt32Item( nWhichId, nFormatKey ));
}
}
break;
case SID_ATTR_NUMBERFORMAT_SOURCE:
{
bool bLinkToSource = true;
GetPropertySet()->getPropertyValue(CHART_UNONAME_LINK_TO_SRC_NUMFMT) >>= bLinkToSource;
rOutItemSet.Put(SfxBoolItem(nWhichId, bLinkToSource));
}
break;
case SCHATTR_AXISTYPE:
rOutItemSet.Put( SfxInt32Item( nWhichId, rScale.AxisType ));
break;
case SCHATTR_AXIS_AUTO_DATEAXIS:
rOutItemSet.Put( SfxBoolItem( nWhichId, rScale.AutoDateAxis ));
break;
case SCHATTR_AXIS_ALLOW_DATEAXIS:
{
Reference< chart2::XCoordinateSystem > xCooSys(
AxisHelper::getCoordinateSystemOfAxis( m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ) );
sal_Int32 nDimensionIndex=0; sal_Int32 nAxisIndex=0;
AxisHelper::getIndicesForAxis(m_xAxis, xCooSys, nDimensionIndex, nAxisIndex );
bool bChartTypeAllowsDateAxis = ChartTypeHelper::isSupportingDateAxis( AxisHelper::getChartTypeByIndex( xCooSys, 0 ), nDimensionIndex );
rOutItemSet.Put( SfxBoolItem( nWhichId, bChartTypeAllowsDateAxis ));
}
break;
}
}
bool lcl_isDateAxis( const SfxItemSet & rItemSet )
{
sal_Int32 nAxisType = rItemSet.Get( SCHATTR_AXISTYPE ).GetValue();//css::chart2::AxisType
return (nAxisType == chart2::AxisType::DATE);
}
bool lcl_isAutoMajor( const SfxItemSet & rItemSet )
{
bool bRet = rItemSet.Get( SCHATTR_AXIS_AUTO_STEP_MAIN ).GetValue();
return bRet;
}
bool lcl_isAutoMinor( const SfxItemSet & rItemSet )
{
bool bRet = rItemSet.Get( SCHATTR_AXIS_AUTO_STEP_HELP ).GetValue();
return bRet;
}
bool AxisItemConverter::ApplySpecialItem( sal_uInt16 nWhichId, const SfxItemSet & rItemSet )
{
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( ! (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( ! (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 = ( aScale.Orientation == AxisOrientation_REVERSE );
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( lcl_isAutoMajor(rItemSet) )
{
aScale.IncrementData.Distance.clear();
aScale.TimeIncrement.MajorTimeInterval.clear();
bSetScale = true;
}
// else SCHATTR_AXIS_STEP_MAIN must have some value
break;
case SCHATTR_AXIS_MAIN_TIME_UNIT:
if( !lcl_isAutoMajor(rItemSet) )
{
if( rItemSet.Get( nWhichId ).QueryValue( aValue ) )
{
TimeInterval aTimeInterval;
aScale.TimeIncrement.MajorTimeInterval >>= aTimeInterval;
aValue >>= aTimeInterval.TimeUnit;
aScale.TimeIncrement.MajorTimeInterval <<= aTimeInterval;
bSetScale = true;
}
}
break;
case SCHATTR_AXIS_STEP_MAIN:
// only if auto if false
if( !lcl_isAutoMajor(rItemSet) )
{
rItemSet.Get( nWhichId ).QueryValue( aValue );
if( lcl_isDateAxis(rItemSet) )
{
double fValue = 1.0;
if( aValue >>= fValue )
{
TimeInterval aTimeInterval;
aScale.TimeIncrement.MajorTimeInterval >>= aTimeInterval;
aTimeInterval.Number = static_cast<sal_Int32>(fValue);
aScale.TimeIncrement.MajorTimeInterval <<= aTimeInterval;
bSetScale = true;
}
}
else if( aScale.IncrementData.Distance != aValue )
{
aScale.IncrementData.Distance = aValue;
bSetScale = true;
}
}
break;
// SubIncrement
case SCHATTR_AXIS_AUTO_STEP_HELP:
if( lcl_isAutoMinor(rItemSet) )
{
if( aScale.IncrementData.SubIncrements.getLength() > 0 &&
aScale.IncrementData.SubIncrements[0].IntervalCount.hasValue() )
{
aScale.IncrementData.SubIncrements[0].IntervalCount.clear();
bSetScale = true;
}
if( aScale.TimeIncrement.MinorTimeInterval.hasValue() )
{
aScale.TimeIncrement.MinorTimeInterval.clear();
bSetScale = true;
}
}
// else SCHATTR_AXIS_STEP_MAIN must have some value
break;
case SCHATTR_AXIS_HELP_TIME_UNIT:
if( !lcl_isAutoMinor(rItemSet) )
{
if( rItemSet.Get( nWhichId ).QueryValue( aValue ) )
{
TimeInterval aTimeInterval;
aScale.TimeIncrement.MinorTimeInterval >>= aTimeInterval;
aValue >>= aTimeInterval.TimeUnit;
aScale.TimeIncrement.MinorTimeInterval <<= aTimeInterval;
bSetScale = true;
}
}
break;
case SCHATTR_AXIS_STEP_HELP:
// only if auto is false
if( !lcl_isAutoMinor(rItemSet) )
{
rItemSet.Get( nWhichId ).QueryValue( aValue );
if( lcl_isDateAxis(rItemSet) )
{
TimeInterval aTimeInterval;
aScale.TimeIncrement.MinorTimeInterval >>= aTimeInterval;
aValue >>= aTimeInterval.Number;
aScale.TimeIncrement.MinorTimeInterval <<= aTimeInterval;
bSetScale = true;
}
else if( aScale.IncrementData.SubIncrements.getLength() > 0 )
{
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_TIME_RESOLUTION:
if( static_cast< const SfxBoolItem & >( rItemSet.Get( nWhichId )).GetValue() )
{
aScale.TimeIncrement.TimeResolution.clear();
bSetScale = true;
}
break;
case SCHATTR_AXIS_TIME_RESOLUTION:
// only if auto is false
if( ! ( rItemSet.Get( SCHATTR_AXIS_AUTO_TIME_RESOLUTION ).GetValue() ))
{
rItemSet.Get( nWhichId ).QueryValue( aValue );
if( aScale.TimeIncrement.TimeResolution != aValue )
{
aScale.TimeIncrement.TimeResolution = 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( ! (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( "CrossoverPosition" , uno::Any( css::chart::ChartAxisPosition_VALUE ));
xCrossingMainAxis->setPropertyValue( "CrossoverValue" , uno::Any( fValue ));
}
else
xCrossingMainAxis->setPropertyValue( "CrossoverPosition" , uno::Any( css::chart::ChartAxisPosition_START ));
}
}
}
}
}
}
break;
case SCHATTR_AXIS_POSITION:
{
css::chart::ChartAxisPosition eAxisPos =
static_cast<css::chart::ChartAxisPosition>(static_cast< const SfxInt32Item & >( rItemSet.Get( nWhichId )).GetValue());
css::chart::ChartAxisPosition eOldAxisPos( css::chart::ChartAxisPosition_ZERO );
bool bPropExisted = ( GetPropertySet()->getPropertyValue( "CrossoverPosition" ) >>= eOldAxisPos );
if( !bPropExisted || ( eOldAxisPos != eAxisPos ))
{
GetPropertySet()->setPropertyValue( "CrossoverPosition" , uno::Any( eAxisPos ));
bChangedOtherwise = true;
//move the parallel axes to the other side if necessary
if( eAxisPos==css::chart::ChartAxisPosition_START || eAxisPos==css::chart::ChartAxisPosition_END )
{
Reference< beans::XPropertySet > xParallelAxis( AxisHelper::getParallelAxis( m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ), uno::UNO_QUERY );
if( xParallelAxis.is() )
{
css::chart::ChartAxisPosition eOtherPos;
if( xParallelAxis->getPropertyValue( "CrossoverPosition" ) >>= eOtherPos )
{
if( eOtherPos == eAxisPos )
{
css::chart::ChartAxisPosition eOppositePos =
(eAxisPos==css::chart::ChartAxisPosition_START)
? css::chart::ChartAxisPosition_END
: css::chart::ChartAxisPosition_START;
xParallelAxis->setPropertyValue( "CrossoverPosition" , uno::Any( 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( "CrossoverValue" ) >>= fOldValue );
if( !bPropExisted || ( fOldValue != fValue ))
{
GetPropertySet()->setPropertyValue( "CrossoverValue" , uno::Any( 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 )
{
Reference< chart2::XAxis > xCrossingMainAxis( AxisHelper::getCrossingMainAxis( m_xAxis, xCooSys ) );
if( xCrossingMainAxis.is() )
{
ScaleData aCrossingScale( xCrossingMainAxis->getScaleData() );
aCrossingScale.Origin <<= fValue;
xCrossingMainAxis->setScaleData(aCrossingScale);
}
}
}
}
}
break;
case SCHATTR_AXIS_LABEL_POSITION:
{
css::chart::ChartAxisLabelPosition ePos =
static_cast<css::chart::ChartAxisLabelPosition>(static_cast< const SfxInt32Item & >( rItemSet.Get( nWhichId )).GetValue());
css::chart::ChartAxisLabelPosition eOldPos( css::chart::ChartAxisLabelPosition_NEAR_AXIS );
bool bPropExisted = ( GetPropertySet()->getPropertyValue( "LabelPosition" ) >>= eOldPos );
if( !bPropExisted || ( eOldPos != ePos ))
{
GetPropertySet()->setPropertyValue( "LabelPosition" , uno::Any( ePos ));
bChangedOtherwise = true;
//move the parallel axes to the other side if necessary
if( ePos==css::chart::ChartAxisLabelPosition_OUTSIDE_START || ePos==css::chart::ChartAxisLabelPosition_OUTSIDE_END )
{
Reference< beans::XPropertySet > xParallelAxis( AxisHelper::getParallelAxis( m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ), uno::UNO_QUERY );
if( xParallelAxis.is() )
{
css::chart::ChartAxisLabelPosition eOtherPos;
if( xParallelAxis->getPropertyValue( "LabelPosition" ) >>= eOtherPos )
{
if( eOtherPos == ePos )
{
css::chart::ChartAxisLabelPosition eOppositePos =
(ePos==css::chart::ChartAxisLabelPosition_OUTSIDE_START)
? css::chart::ChartAxisLabelPosition_OUTSIDE_END
: css::chart::ChartAxisLabelPosition_OUTSIDE_START;
xParallelAxis->setPropertyValue( "LabelPosition" , uno::Any( eOppositePos ));
}
}
}
}
}
}
break;
case SCHATTR_AXIS_MARK_POSITION:
{
css::chart::ChartAxisMarkPosition ePos =
static_cast<css::chart::ChartAxisMarkPosition>(static_cast< const SfxInt32Item & >( rItemSet.Get( nWhichId )).GetValue());
css::chart::ChartAxisMarkPosition eOldPos( css::chart::ChartAxisMarkPosition_AT_LABELS_AND_AXIS );
bool bPropExisted = ( GetPropertySet()->getPropertyValue( "MarkPosition" ) >>= eOldPos );
if( !bPropExisted || ( eOldPos != ePos ))
{
GetPropertySet()->setPropertyValue( "MarkPosition" , uno::Any( 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( "TextRotation" ) >>= fOldVal );
if( ! bPropExisted || fOldVal != fVal )
{
GetPropertySet()->setPropertyValue( "TextRotation" , uno::Any( fVal ));
bChangedOtherwise = true;
}
}
break;
case SID_ATTR_NUMBERFORMAT_VALUE:
{
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 <<= nFmt;
if (GetPropertySet()->getPropertyValue(CHART_UNONAME_NUMFMT) != aValue)
{
GetPropertySet()->setPropertyValue(CHART_UNONAME_NUMFMT , aValue);
bChangedOtherwise = true;
}
}
}
}
break;
case SID_ATTR_NUMBERFORMAT_SOURCE:
{
bool bUseSourceFormat =
static_cast< const SfxBoolItem & >(
rItemSet.Get( nWhichId )).GetValue();
GetPropertySet()->setPropertyValue(CHART_UNONAME_LINK_TO_SRC_NUMFMT, uno::Any(bUseSourceFormat));
bool bNumberFormatIsSet = GetPropertySet()->getPropertyValue(CHART_UNONAME_NUMFMT).hasValue();
bChangedOtherwise = (bUseSourceFormat == bNumberFormatIsSet);
if( bChangedOtherwise )
{
if( ! bUseSourceFormat )
{
SfxItemState aState = rItemSet.GetItemState( SID_ATTR_NUMBERFORMAT_VALUE );
if( aState == SfxItemState::SET )
{
sal_Int32 nFormatKey = static_cast< sal_Int32 >(
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, m_xChartDoc);
aValue <<= nFormatKey;
}
}
// else set a void Any
GetPropertySet()->setPropertyValue(CHART_UNONAME_NUMFMT , aValue);
}
}
break;
case SCHATTR_AXISTYPE:
{
sal_Int32 nNewAxisType = static_cast< const SfxInt32Item & >( rItemSet.Get( nWhichId )).GetValue();//css::chart2::AxisType
aScale.AxisType = nNewAxisType;
bSetScale = true;
}
break;
case SCHATTR_AXIS_AUTO_DATEAXIS:
{
bool bNewValue = static_cast< const SfxBoolItem & >( rItemSet.Get( nWhichId )).GetValue();
bool bOldValue = aScale.AutoDateAxis;
if( bOldValue != bNewValue )
{
aScale.AutoDateAxis = bNewValue;
bSetScale = true;
}
}
break;
}
if( bSetScale )
m_xAxis->setScaleData( aScale );
return (bSetScale || bChangedOtherwise);
}
}}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V1023 A pointer without owner is added to the 'm_aConverters' container by the 'emplace_back' method. A memory leak will occur in case of an exception.
↑ V1023 A pointer without owner is added to the 'm_aConverters' container by the 'emplace_back' method. A memory leak will occur in case of an exception.