LCOV - code coverage report
Current view: top level - chart2/source/controller/itemsetwrapper - AxisItemConverter.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 0 439 0.0 %
Date: 2015-06-13 12:38:46 Functions: 0 14 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include "AxisItemConverter.hxx"
      21             : #include "ItemPropertyMap.hxx"
      22             : #include "CharacterPropertyItemConverter.hxx"
      23             : #include "GraphicPropertyItemConverter.hxx"
      24             : #include "chartview/ChartSfxItemIds.hxx"
      25             : #include "chartview/ExplicitValueProvider.hxx"
      26             : #include "SchWhichPairs.hxx"
      27             : #include "macros.hxx"
      28             : #include "ChartModelHelper.hxx"
      29             : #include "AxisHelper.hxx"
      30             : #include "CommonConverters.hxx"
      31             : #include "ChartTypeHelper.hxx"
      32             : #include <unonames.hxx>
      33             : 
      34             : #include <com/sun/star/chart/ChartAxisLabelPosition.hpp>
      35             : #include <com/sun/star/chart/ChartAxisMarkPosition.hpp>
      36             : #include <com/sun/star/chart/ChartAxisPosition.hpp>
      37             : #include <com/sun/star/chart2/XAxis.hpp>
      38             : #include <com/sun/star/chart2/AxisOrientation.hpp>
      39             : #include <com/sun/star/chart2/AxisType.hpp>
      40             : 
      41             : #include <svl/eitem.hxx>
      42             : #include <svx/chrtitem.hxx>
      43             : #include <svl/intitem.hxx>
      44             : #include <rtl/math.hxx>
      45             : 
      46             : #include <algorithm>
      47             : 
      48             : using namespace ::com::sun::star;
      49             : using namespace ::com::sun::star::chart2;
      50             : using ::com::sun::star::uno::Reference;
      51             : using ::com::sun::star::chart::TimeInterval;
      52             : using ::com::sun::star::chart::TimeIncrement;
      53             : 
      54             : namespace chart { namespace wrapper {
      55             : 
      56             : namespace {
      57             : 
      58           0 : ItemPropertyMapType & lcl_GetAxisPropertyMap()
      59             : {
      60             :     static ItemPropertyMapType aAxisPropertyMap(
      61             :         MakeItemPropertyMap
      62             :         IPM_MAP_ENTRY( SCHATTR_AXIS_SHOWDESCR,     "DisplayLabels",    0 )
      63           0 :         IPM_MAP_ENTRY( SCHATTR_AXIS_TICKS,         "MajorTickmarks",   0 )
      64           0 :         IPM_MAP_ENTRY( SCHATTR_AXIS_HELPTICKS,     "MinorTickmarks",   0 )
      65           0 :         IPM_MAP_ENTRY( SCHATTR_AXIS_LABEL_ORDER,   "ArrangeOrder",     0 )
      66           0 :         IPM_MAP_ENTRY( SCHATTR_TEXT_STACKED,       "StackCharacters",  0 )
      67           0 :         IPM_MAP_ENTRY( SCHATTR_AXIS_LABEL_BREAK,   "TextBreak",        0 )
      68           0 :         IPM_MAP_ENTRY( SCHATTR_AXIS_LABEL_OVERLAP, "TextOverlap",      0 )
      69           0 :         );
      70             : 
      71           0 :     return aAxisPropertyMap;
      72             : };
      73             : 
      74             : } // anonymous namespace
      75             : 
      76           0 : AxisItemConverter::AxisItemConverter(
      77             :     const Reference< beans::XPropertySet > & rPropertySet,
      78             :     SfxItemPool& rItemPool,
      79             :     SdrModel& rDrawModel,
      80             :     const Reference< chart2::XChartDocument > & xChartDoc,
      81             :     ::chart::ExplicitScaleData * pScale /* = NULL */,
      82             :     ::chart::ExplicitIncrementData * pIncrement /* = NULL */,
      83             :     const awt::Size* pRefSize ) :
      84             :         ItemConverter( rPropertySet, rItemPool ),
      85             :         m_xChartDoc( xChartDoc ),
      86             :         m_pExplicitScale( NULL ),
      87           0 :         m_pExplicitIncrement( NULL )
      88             : {
      89           0 :     Reference< lang::XMultiServiceFactory > xNamedPropertyContainerFactory( xChartDoc, uno::UNO_QUERY );
      90             : 
      91           0 :     if( pScale )
      92           0 :         m_pExplicitScale = new ::chart::ExplicitScaleData( *pScale );
      93           0 :     if( pIncrement )
      94           0 :         m_pExplicitIncrement = new ::chart::ExplicitIncrementData( *pIncrement );
      95             : 
      96             :     m_aConverters.push_back( new GraphicPropertyItemConverter(
      97             :                                  rPropertySet, rItemPool, rDrawModel,
      98             :                                  xNamedPropertyContainerFactory,
      99           0 :                                  GraphicPropertyItemConverter::LINE_PROPERTIES ));
     100             :     m_aConverters.push_back(
     101           0 :         new CharacterPropertyItemConverter(rPropertySet, rItemPool, pRefSize, "ReferencePageSize"));
     102             : 
     103           0 :     m_xAxis.set( Reference< chart2::XAxis >( rPropertySet, uno::UNO_QUERY ) );
     104           0 :     OSL_ASSERT( m_xAxis.is());
     105           0 : }
     106             : 
     107           0 : AxisItemConverter::~AxisItemConverter()
     108             : {
     109           0 :     delete m_pExplicitScale;
     110           0 :     delete m_pExplicitIncrement;
     111             : 
     112           0 :     ::std::for_each(m_aConverters.begin(), m_aConverters.end(), boost::checked_deleter<ItemConverter>());
     113           0 : }
     114             : 
     115           0 : void AxisItemConverter::FillItemSet( SfxItemSet & rOutItemSet ) const
     116             : {
     117           0 :     ::std::for_each( m_aConverters.begin(), m_aConverters.end(), FillItemSetFunc( rOutItemSet ));
     118             : 
     119             :     // own items
     120           0 :     ItemConverter::FillItemSet( rOutItemSet );
     121           0 : }
     122             : 
     123           0 : bool AxisItemConverter::ApplyItemSet( const SfxItemSet & rItemSet )
     124             : {
     125           0 :     bool bResult = false;
     126             : 
     127           0 :     ::std::for_each( m_aConverters.begin(), m_aConverters.end(), ApplyItemSetFunc( rItemSet, bResult ));
     128             : 
     129             :     // own items
     130           0 :     return ItemConverter::ApplyItemSet( rItemSet ) || bResult;
     131             : }
     132             : 
     133           0 : const sal_uInt16 * AxisItemConverter::GetWhichPairs() const
     134             : {
     135             :     // must span all used items!
     136           0 :     return nAxisWhichPairs;
     137             : }
     138             : 
     139           0 : bool AxisItemConverter::GetItemProperty( tWhichIdType nWhichId, tPropertyNameWithMemberId & rOutProperty ) const
     140             : {
     141           0 :     ItemPropertyMapType & rMap( lcl_GetAxisPropertyMap());
     142           0 :     ItemPropertyMapType::const_iterator aIt( rMap.find( nWhichId ));
     143             : 
     144           0 :     if( aIt == rMap.end())
     145           0 :         return false;
     146             : 
     147           0 :     rOutProperty =(*aIt).second;
     148             : 
     149           0 :     return true;
     150             : }
     151             : 
     152           0 : bool lcl_hasTimeIntervalValue( const uno::Any& rAny )
     153             : {
     154           0 :     bool bRet = false;
     155           0 :     TimeInterval aValue;
     156           0 :     if( rAny >>= aValue )
     157           0 :         bRet = true;
     158           0 :     return bRet;
     159             : }
     160             : 
     161           0 : void AxisItemConverter::FillSpecialItem( sal_uInt16 nWhichId, SfxItemSet & rOutItemSet ) const
     162             :     throw( uno::Exception )
     163             : {
     164           0 :     if( !m_xAxis.is() )
     165           0 :         return;
     166             : 
     167           0 :     const chart2::ScaleData&     rScale( m_xAxis->getScaleData() );
     168           0 :     const chart2::IncrementData& rIncrement( rScale.IncrementData );
     169           0 :     const uno::Sequence< chart2::SubIncrement >& rSubIncrements( rScale.IncrementData.SubIncrements );
     170           0 :     const TimeIncrement& rTimeIncrement( rScale.TimeIncrement );
     171           0 :     bool bDateAxis = (chart2::AxisType::DATE == rScale.AxisType);
     172           0 :     if( m_pExplicitScale )
     173           0 :         bDateAxis = (chart2::AxisType::DATE == m_pExplicitScale->AxisType);
     174             : 
     175           0 :     switch( nWhichId )
     176             :     {
     177             :         case SCHATTR_AXIS_AUTO_MAX:
     178           0 :                 rOutItemSet.Put( SfxBoolItem( nWhichId, !hasDoubleValue(rScale.Maximum) ) );
     179           0 :             break;
     180             : 
     181             :         case SCHATTR_AXIS_MAX:
     182             :             {
     183           0 :                 double fMax = 10.0;
     184           0 :                 if( rScale.Maximum >>= fMax )
     185           0 :                     rOutItemSet.Put( SvxDoubleItem( fMax, nWhichId ) );
     186             :                 else
     187             :                 {
     188           0 :                     if( m_pExplicitScale )
     189           0 :                         fMax = m_pExplicitScale->Maximum;
     190           0 :                     rOutItemSet.Put( SvxDoubleItem( fMax, nWhichId ) );
     191             :                 }
     192             :             }
     193           0 :             break;
     194             : 
     195             :         case SCHATTR_AXIS_AUTO_MIN:
     196           0 :                 rOutItemSet.Put( SfxBoolItem( nWhichId, !hasDoubleValue(rScale.Minimum) ) );
     197           0 :             break;
     198             : 
     199             :         case SCHATTR_AXIS_MIN:
     200             :             {
     201           0 :                 double fMin = 0.0;
     202           0 :                 if( rScale.Minimum >>= fMin )
     203           0 :                     rOutItemSet.Put( SvxDoubleItem( fMin, nWhichId ) );
     204           0 :                 else if( m_pExplicitScale )
     205           0 :                     rOutItemSet.Put( SvxDoubleItem( m_pExplicitScale->Minimum, nWhichId ));
     206             :             }
     207           0 :             break;
     208             : 
     209             :         case SCHATTR_AXIS_LOGARITHM:
     210             :             {
     211           0 :                 bool bValue = AxisHelper::isLogarithmic( rScale.Scaling );
     212           0 :                 rOutItemSet.Put( SfxBoolItem( nWhichId, bValue ));
     213             :             }
     214           0 :             break;
     215             : 
     216             :         case SCHATTR_AXIS_REVERSE:
     217           0 :                 rOutItemSet.Put( SfxBoolItem( nWhichId, (AxisOrientation_REVERSE == rScale.Orientation) ));
     218           0 :             break;
     219             : 
     220             :         // Increment
     221             :         case SCHATTR_AXIS_AUTO_STEP_MAIN:
     222           0 :             if( bDateAxis )
     223           0 :                 rOutItemSet.Put( SfxBoolItem( nWhichId, !lcl_hasTimeIntervalValue(rTimeIncrement.MajorTimeInterval) ) );
     224             :             else
     225           0 :                 rOutItemSet.Put( SfxBoolItem( nWhichId, !hasDoubleValue(rIncrement.Distance) ) );
     226           0 :             break;
     227             : 
     228             :         case SCHATTR_AXIS_MAIN_TIME_UNIT:
     229             :             {
     230           0 :                 TimeInterval aTimeInterval;
     231           0 :                 if( rTimeIncrement.MajorTimeInterval >>= aTimeInterval )
     232           0 :                     rOutItemSet.Put( SfxInt32Item( nWhichId, aTimeInterval.TimeUnit ) );
     233           0 :                 else if( m_pExplicitIncrement )
     234           0 :                     rOutItemSet.Put( SfxInt32Item( nWhichId, m_pExplicitIncrement->MajorTimeInterval.TimeUnit ) );
     235             :             }
     236           0 :             break;
     237             : 
     238             :         case SCHATTR_AXIS_STEP_MAIN:
     239           0 :             if( bDateAxis )
     240             :             {
     241           0 :                 TimeInterval aTimeInterval;
     242           0 :                 if( rTimeIncrement.MajorTimeInterval >>= aTimeInterval )
     243           0 :                     rOutItemSet.Put( SvxDoubleItem(aTimeInterval.Number, nWhichId ));
     244           0 :                 else if( m_pExplicitIncrement )
     245           0 :                     rOutItemSet.Put( SvxDoubleItem( m_pExplicitIncrement->MajorTimeInterval.Number, nWhichId ));
     246             :             }
     247             :             else
     248             :             {
     249           0 :                 double fDistance = 1.0;
     250           0 :                 if( rIncrement.Distance >>= fDistance )
     251           0 :                     rOutItemSet.Put( SvxDoubleItem(fDistance, nWhichId ));
     252           0 :                 else if( m_pExplicitIncrement )
     253           0 :                     rOutItemSet.Put( SvxDoubleItem( m_pExplicitIncrement->Distance, nWhichId ));
     254             :             }
     255           0 :             break;
     256             : 
     257             :         // SubIncrement
     258             :         case SCHATTR_AXIS_AUTO_STEP_HELP:
     259           0 :             if( bDateAxis )
     260           0 :                 rOutItemSet.Put( SfxBoolItem( nWhichId, !lcl_hasTimeIntervalValue(rTimeIncrement.MinorTimeInterval) ) );
     261             :             else
     262             :                 rOutItemSet.Put( SfxBoolItem( nWhichId,
     263           0 :                     ! ( rSubIncrements.getLength() > 0 && rSubIncrements[0].IntervalCount.hasValue() )));
     264           0 :             break;
     265             : 
     266             :         case SCHATTR_AXIS_HELP_TIME_UNIT:
     267             :             {
     268           0 :                 TimeInterval aTimeInterval;
     269           0 :                 if( rTimeIncrement.MinorTimeInterval >>= aTimeInterval )
     270           0 :                     rOutItemSet.Put( SfxInt32Item( nWhichId, aTimeInterval.TimeUnit ) );
     271           0 :                 else if( m_pExplicitIncrement )
     272           0 :                     rOutItemSet.Put( SfxInt32Item( nWhichId, m_pExplicitIncrement->MinorTimeInterval.TimeUnit ) );
     273             :             }
     274           0 :             break;
     275             : 
     276             :         case SCHATTR_AXIS_STEP_HELP:
     277           0 :             if( bDateAxis )
     278             :             {
     279           0 :                 TimeInterval aTimeInterval;
     280           0 :                 if( rTimeIncrement.MinorTimeInterval >>= aTimeInterval )
     281           0 :                     rOutItemSet.Put( SfxInt32Item( nWhichId, aTimeInterval.Number ));
     282           0 :                 else if( m_pExplicitIncrement )
     283           0 :                     rOutItemSet.Put( SfxInt32Item( nWhichId, m_pExplicitIncrement->MinorTimeInterval.Number ));
     284             :             }
     285             :             else
     286             :             {
     287           0 :                 if( rSubIncrements.getLength() > 0 && rSubIncrements[0].IntervalCount.hasValue())
     288             :                 {
     289             :                     OSL_ASSERT( rSubIncrements[0].IntervalCount.getValueTypeClass() == uno::TypeClass_LONG );
     290             :                     rOutItemSet.Put( SfxInt32Item( nWhichId,
     291             :                             *static_cast< const sal_Int32 * >(
     292           0 :                                 rSubIncrements[0].IntervalCount.getValue()) ));
     293             :                 }
     294             :                 else
     295             :                 {
     296           0 :                     if( m_pExplicitIncrement && !m_pExplicitIncrement->SubIncrements.empty() )
     297             :                     {
     298             :                         rOutItemSet.Put( SfxInt32Item( nWhichId,
     299           0 :                                 m_pExplicitIncrement->SubIncrements[0].IntervalCount ));
     300             :                     }
     301             :                 }
     302             :             }
     303           0 :             break;
     304             : 
     305             :         case SCHATTR_AXIS_AUTO_TIME_RESOLUTION:
     306             :             {
     307             :                 rOutItemSet.Put( SfxBoolItem( nWhichId,
     308           0 :                         !rTimeIncrement.TimeResolution.hasValue() ));
     309             :             }
     310           0 :             break;
     311             :         case SCHATTR_AXIS_TIME_RESOLUTION:
     312             :             {
     313           0 :                 long nTimeResolution=0;
     314           0 :                 if( rTimeIncrement.TimeResolution >>= nTimeResolution )
     315           0 :                     rOutItemSet.Put( SfxInt32Item( nWhichId, nTimeResolution ) );
     316           0 :                 else if( m_pExplicitScale )
     317           0 :                     rOutItemSet.Put( SfxInt32Item( nWhichId, m_pExplicitScale->TimeResolution ) );
     318             :             }
     319           0 :             break;
     320             : 
     321             :         case SCHATTR_AXIS_AUTO_ORIGIN:
     322             :         {
     323           0 :             rOutItemSet.Put( SfxBoolItem( nWhichId, ( !hasDoubleValue(rScale.Origin) )));
     324             :         }
     325           0 :         break;
     326             : 
     327             :         case SCHATTR_AXIS_ORIGIN:
     328             :         {
     329           0 :             double fOrigin = 0.0;
     330           0 :             if( !(rScale.Origin >>= fOrigin) )
     331             :             {
     332           0 :                 if( m_pExplicitScale )
     333           0 :                     fOrigin = m_pExplicitScale->Origin;
     334             :             }
     335           0 :             rOutItemSet.Put( SvxDoubleItem( fOrigin, nWhichId ));
     336             :         }
     337           0 :         break;
     338             : 
     339             :         case SCHATTR_AXIS_POSITION:
     340             :         {
     341           0 :             ::com::sun::star::chart::ChartAxisPosition eAxisPos( ::com::sun::star::chart::ChartAxisPosition_ZERO );
     342           0 :             GetPropertySet()->getPropertyValue( "CrossoverPosition" ) >>= eAxisPos;
     343           0 :             rOutItemSet.Put( SfxInt32Item( nWhichId, eAxisPos ) );
     344             :         }
     345           0 :         break;
     346             : 
     347             :         case SCHATTR_AXIS_POSITION_VALUE:
     348             :         {
     349           0 :             double fValue = 0.0;
     350           0 :             if( GetPropertySet()->getPropertyValue( "CrossoverValue" ) >>= fValue )
     351           0 :                 rOutItemSet.Put( SvxDoubleItem( fValue, nWhichId ) );
     352             :         }
     353           0 :         break;
     354             : 
     355             :         case SCHATTR_AXIS_CROSSING_MAIN_AXIS_NUMBERFORMAT:
     356             :         {
     357             :             //read only item
     358             :             //necessary tp display the crossing value with an appropriate format
     359             : 
     360             :             Reference< chart2::XCoordinateSystem > xCooSys( AxisHelper::getCoordinateSystemOfAxis(
     361           0 :                 m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ) );
     362             : 
     363           0 :             Reference< chart2::XAxis > xCrossingMainAxis( AxisHelper::getCrossingMainAxis( m_xAxis, xCooSys ) );
     364             : 
     365             :             sal_Int32 nFormatKey = ExplicitValueProvider::getExplicitNumberFormatKeyForAxis(
     366           0 :                 xCrossingMainAxis, xCooSys, m_xChartDoc);
     367             : 
     368           0 :             rOutItemSet.Put( SfxUInt32Item( nWhichId, nFormatKey ));
     369             :         }
     370           0 :         break;
     371             : 
     372             :         case SCHATTR_AXIS_LABEL_POSITION:
     373             :         {
     374           0 :             ::com::sun::star::chart::ChartAxisLabelPosition ePos( ::com::sun::star::chart::ChartAxisLabelPosition_NEAR_AXIS );
     375           0 :             GetPropertySet()->getPropertyValue( "LabelPosition" ) >>= ePos;
     376           0 :             rOutItemSet.Put( SfxInt32Item( nWhichId, ePos ) );
     377             :         }
     378           0 :         break;
     379             : 
     380             :         case SCHATTR_AXIS_MARK_POSITION:
     381             :         {
     382           0 :             ::com::sun::star::chart::ChartAxisMarkPosition ePos( ::com::sun::star::chart::ChartAxisMarkPosition_AT_LABELS_AND_AXIS );
     383           0 :             GetPropertySet()->getPropertyValue( "MarkPosition" ) >>= ePos;
     384           0 :             rOutItemSet.Put( SfxInt32Item( nWhichId, ePos ) );
     385             :         }
     386           0 :         break;
     387             : 
     388             :         case SCHATTR_TEXT_DEGREES:
     389             :         {
     390             :             // convert double to int (times 100)
     391           0 :             double fVal = 0;
     392             : 
     393           0 :             if( GetPropertySet()->getPropertyValue( "TextRotation" ) >>= fVal )
     394             :             {
     395             :                 rOutItemSet.Put( SfxInt32Item( nWhichId, static_cast< sal_Int32 >(
     396           0 :                                                    ::rtl::math::round( fVal * 100.0 ) ) ));
     397             :             }
     398             :         }
     399           0 :         break;
     400             : 
     401             :         case SID_ATTR_NUMBERFORMAT_VALUE:
     402             :         {
     403           0 :             if( m_pExplicitScale )
     404             :             {
     405             :                 Reference< chart2::XCoordinateSystem > xCooSys(
     406             :                         AxisHelper::getCoordinateSystemOfAxis(
     407           0 :                               m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ) );
     408             : 
     409             :                 sal_Int32 nFormatKey = ExplicitValueProvider::getExplicitNumberFormatKeyForAxis(
     410           0 :                     m_xAxis, xCooSys, m_xChartDoc);
     411             : 
     412           0 :                 rOutItemSet.Put( SfxUInt32Item( nWhichId, nFormatKey ));
     413             :             }
     414             :         }
     415           0 :         break;
     416             : 
     417             :         case SID_ATTR_NUMBERFORMAT_SOURCE:
     418             :         {
     419           0 :             bool bLinkToSource = true;
     420           0 :             GetPropertySet()->getPropertyValue(CHART_UNONAME_LINK_TO_SRC_NUMFMT) >>= bLinkToSource;
     421           0 :             rOutItemSet.Put(SfxBoolItem(nWhichId, bLinkToSource));
     422             :         }
     423           0 :         break;
     424             : 
     425             :         case SCHATTR_AXISTYPE:
     426           0 :             rOutItemSet.Put( SfxInt32Item( nWhichId, rScale.AxisType ));
     427           0 :         break;
     428             : 
     429             :         case SCHATTR_AXIS_AUTO_DATEAXIS:
     430           0 :             rOutItemSet.Put( SfxBoolItem( nWhichId, rScale.AutoDateAxis ));
     431           0 :         break;
     432             : 
     433             :         case SCHATTR_AXIS_ALLOW_DATEAXIS:
     434             :         {
     435             :             Reference< chart2::XCoordinateSystem > xCooSys(
     436           0 :                 AxisHelper::getCoordinateSystemOfAxis( m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ) );
     437           0 :             sal_Int32 nDimensionIndex=0; sal_Int32 nAxisIndex=0;
     438           0 :             AxisHelper::getIndicesForAxis(m_xAxis, xCooSys, nDimensionIndex, nAxisIndex );
     439           0 :             bool bChartTypeAllowsDateAxis = ChartTypeHelper::isSupportingDateAxis( AxisHelper::getChartTypeByIndex( xCooSys, 0 ), 2, nDimensionIndex );
     440           0 :             rOutItemSet.Put( SfxBoolItem( nWhichId, bChartTypeAllowsDateAxis ));
     441             :         }
     442           0 :         break;
     443           0 :     }
     444             : }
     445             : 
     446           0 : bool lcl_isDateAxis( const SfxItemSet & rItemSet )
     447             : {
     448           0 :     sal_Int32 nAxisType = static_cast< const SfxInt32Item & >( rItemSet.Get( SCHATTR_AXISTYPE )).GetValue();//::com::sun::star::chart2::AxisType
     449           0 :     return (chart2::AxisType::DATE == nAxisType);
     450             : }
     451             : 
     452           0 : bool lcl_isAutoMajor( const SfxItemSet & rItemSet )
     453             : {
     454           0 :     bool bRet = static_cast< const SfxBoolItem & >( rItemSet.Get( SCHATTR_AXIS_AUTO_STEP_MAIN )).GetValue();
     455           0 :     return bRet;
     456             : }
     457             : 
     458           0 : bool lcl_isAutoMinor( const SfxItemSet & rItemSet )
     459             : {
     460           0 :     bool bRet = static_cast< const SfxBoolItem & >( rItemSet.Get( SCHATTR_AXIS_AUTO_STEP_HELP )).GetValue();
     461           0 :     return bRet;
     462             : }
     463             : 
     464           0 : bool AxisItemConverter::ApplySpecialItem( sal_uInt16 nWhichId, const SfxItemSet & rItemSet )
     465             :     throw( uno::Exception )
     466             : {
     467           0 :     if( !m_xAxis.is() )
     468           0 :         return false;
     469             : 
     470           0 :     chart2::ScaleData     aScale( m_xAxis->getScaleData() );
     471             : 
     472           0 :     bool bSetScale    = false;
     473           0 :     bool bChangedOtherwise = false;
     474             : 
     475           0 :     uno::Any aValue;
     476             : 
     477           0 :     switch( nWhichId )
     478             :     {
     479             :         case SCHATTR_AXIS_AUTO_MAX:
     480           0 :             if( (static_cast< const SfxBoolItem & >(
     481           0 :                      rItemSet.Get( nWhichId )).GetValue() ))
     482             :             {
     483           0 :                 aScale.Maximum.clear();
     484           0 :                 bSetScale = true;
     485             :             }
     486             :             // else SCHATTR_AXIS_MAX must have some value
     487           0 :             break;
     488             : 
     489             :         case SCHATTR_AXIS_MAX:
     490             :             // only if auto if false
     491           0 :             if( ! (static_cast< const SfxBoolItem & >(
     492           0 :                        rItemSet.Get( SCHATTR_AXIS_AUTO_MAX )).GetValue() ))
     493             :             {
     494           0 :                 rItemSet.Get( nWhichId ).QueryValue( aValue );
     495             : 
     496           0 :                 if( aScale.Maximum != aValue )
     497             :                 {
     498           0 :                     aScale.Maximum = aValue;
     499           0 :                     bSetScale = true;
     500             :                 }
     501             :             }
     502           0 :             break;
     503             : 
     504             :         case SCHATTR_AXIS_AUTO_MIN:
     505           0 :             if( (static_cast< const SfxBoolItem & >(
     506           0 :                      rItemSet.Get( nWhichId )).GetValue() ))
     507             :             {
     508           0 :                 aScale.Minimum.clear();
     509           0 :                 bSetScale = true;
     510             :             }
     511             :             // else SCHATTR_AXIS_MIN must have some value
     512           0 :             break;
     513             : 
     514             :         case SCHATTR_AXIS_MIN:
     515             :             // only if auto if false
     516           0 :             if( ! (static_cast< const SfxBoolItem & >(
     517           0 :                        rItemSet.Get( SCHATTR_AXIS_AUTO_MIN )).GetValue() ))
     518             :             {
     519           0 :                 rItemSet.Get( nWhichId ).QueryValue( aValue );
     520             : 
     521           0 :                 if( aScale.Minimum != aValue )
     522             :                 {
     523           0 :                     aScale.Minimum = aValue;
     524           0 :                     bSetScale = true;
     525             :                 }
     526             :             }
     527           0 :             break;
     528             : 
     529             :         case SCHATTR_AXIS_LOGARITHM:
     530             :         {
     531           0 :             bool bWasLogarithm = AxisHelper::isLogarithmic( aScale.Scaling );
     532             : 
     533           0 :             if( (static_cast< const SfxBoolItem & >(
     534           0 :                      rItemSet.Get( nWhichId )).GetValue() ))
     535             :             {
     536             :                 // logarithm is true
     537           0 :                 if( ! bWasLogarithm )
     538             :                 {
     539           0 :                     aScale.Scaling = AxisHelper::createLogarithmicScaling( 10.0 );
     540           0 :                     bSetScale = true;
     541             :                 }
     542             :             }
     543             :             else
     544             :             {
     545             :                 // logarithm is false => linear scaling
     546           0 :                 if( bWasLogarithm )
     547             :                 {
     548           0 :                     aScale.Scaling = AxisHelper::createLinearScaling();
     549           0 :                     bSetScale = true;
     550             :                 }
     551             :             }
     552             :         }
     553           0 :         break;
     554             : 
     555             :         case SCHATTR_AXIS_REVERSE:
     556             :         {
     557           0 :             bool bWasReverse = ( AxisOrientation_REVERSE == aScale.Orientation );
     558             :             bool bNewReverse = (static_cast< const SfxBoolItem & >(
     559           0 :                      rItemSet.Get( nWhichId )).GetValue() );
     560           0 :             if( bWasReverse != bNewReverse )
     561             :             {
     562           0 :                 aScale.Orientation = bNewReverse ? AxisOrientation_REVERSE : AxisOrientation_MATHEMATICAL;
     563           0 :                 bSetScale = true;
     564             :             }
     565             :         }
     566           0 :         break;
     567             : 
     568             :         // Increment
     569             :         case SCHATTR_AXIS_AUTO_STEP_MAIN:
     570           0 :             if( lcl_isAutoMajor(rItemSet) )
     571             :             {
     572           0 :                 aScale.IncrementData.Distance.clear();
     573           0 :                 aScale.TimeIncrement.MajorTimeInterval.clear();
     574           0 :                 bSetScale = true;
     575             :             }
     576             :             // else SCHATTR_AXIS_STEP_MAIN must have some value
     577           0 :             break;
     578             : 
     579             :         case SCHATTR_AXIS_MAIN_TIME_UNIT:
     580           0 :             if( !lcl_isAutoMajor(rItemSet) )
     581             :             {
     582           0 :                 if( rItemSet.Get( nWhichId ).QueryValue( aValue ) )
     583             :                 {
     584           0 :                     TimeInterval aTimeInterval;
     585           0 :                     aScale.TimeIncrement.MajorTimeInterval >>= aTimeInterval;
     586           0 :                     aValue >>= aTimeInterval.TimeUnit;
     587           0 :                     aScale.TimeIncrement.MajorTimeInterval = uno::makeAny( aTimeInterval );
     588           0 :                     bSetScale = true;
     589             :                 }
     590             :             }
     591           0 :             break;
     592             : 
     593             :         case SCHATTR_AXIS_STEP_MAIN:
     594             :             // only if auto if false
     595           0 :             if( !lcl_isAutoMajor(rItemSet) )
     596             :             {
     597           0 :                 rItemSet.Get( nWhichId ).QueryValue( aValue );
     598           0 :                 if( lcl_isDateAxis(rItemSet) )
     599             :                 {
     600           0 :                     double fValue = 1.0;
     601           0 :                     if( aValue >>= fValue )
     602             :                     {
     603           0 :                         TimeInterval aTimeInterval;
     604           0 :                         aScale.TimeIncrement.MajorTimeInterval >>= aTimeInterval;
     605           0 :                         aTimeInterval.Number = static_cast<sal_Int32>(fValue);
     606           0 :                         aScale.TimeIncrement.MajorTimeInterval = uno::makeAny( aTimeInterval );
     607           0 :                         bSetScale = true;
     608             :                     }
     609             :                 }
     610           0 :                 else if( aScale.IncrementData.Distance != aValue )
     611             :                 {
     612           0 :                     aScale.IncrementData.Distance = aValue;
     613           0 :                     bSetScale = true;
     614             :                 }
     615             :             }
     616           0 :             break;
     617             : 
     618             :         // SubIncrement
     619             :         case SCHATTR_AXIS_AUTO_STEP_HELP:
     620           0 :             if( lcl_isAutoMinor(rItemSet) )
     621             :             {
     622           0 :                 if( aScale.IncrementData.SubIncrements.getLength() > 0 &&
     623           0 :                     aScale.IncrementData.SubIncrements[0].IntervalCount.hasValue() )
     624             :                 {
     625           0 :                         aScale.IncrementData.SubIncrements[0].IntervalCount.clear();
     626           0 :                         bSetScale = true;
     627             :                 }
     628           0 :                 if( aScale.TimeIncrement.MinorTimeInterval.hasValue() )
     629             :                 {
     630           0 :                     aScale.TimeIncrement.MinorTimeInterval.clear();
     631           0 :                     bSetScale = true;
     632             :                 }
     633             :             }
     634             :             // else SCHATTR_AXIS_STEP_MAIN must have some value
     635           0 :             break;
     636             : 
     637             :         case SCHATTR_AXIS_HELP_TIME_UNIT:
     638           0 :             if( !lcl_isAutoMinor(rItemSet) )
     639             :             {
     640           0 :                 if( rItemSet.Get( nWhichId ).QueryValue( aValue ) )
     641             :                 {
     642           0 :                     TimeInterval aTimeInterval;
     643           0 :                     aScale.TimeIncrement.MinorTimeInterval >>= aTimeInterval;
     644           0 :                     aValue >>= aTimeInterval.TimeUnit;
     645           0 :                     aScale.TimeIncrement.MinorTimeInterval = uno::makeAny( aTimeInterval );
     646           0 :                     bSetScale = true;
     647             :                 }
     648             :             }
     649           0 :             break;
     650             : 
     651             :         case SCHATTR_AXIS_STEP_HELP:
     652             :             // only if auto is false
     653           0 :             if( !lcl_isAutoMinor(rItemSet) )
     654             :             {
     655           0 :                 rItemSet.Get( nWhichId ).QueryValue( aValue );
     656           0 :                 if( lcl_isDateAxis(rItemSet) )
     657             :                 {
     658           0 :                     TimeInterval aTimeInterval;
     659           0 :                     aScale.TimeIncrement.MinorTimeInterval >>= aTimeInterval;
     660           0 :                     aValue >>= aTimeInterval.Number;
     661           0 :                     aScale.TimeIncrement.MinorTimeInterval = uno::makeAny(aTimeInterval);
     662           0 :                     bSetScale = true;
     663             :                 }
     664           0 :                 else if( aScale.IncrementData.SubIncrements.getLength() > 0 )
     665             :                 {
     666           0 :                     if( ! aScale.IncrementData.SubIncrements[0].IntervalCount.hasValue() ||
     667           0 :                         aScale.IncrementData.SubIncrements[0].IntervalCount != aValue )
     668             :                     {
     669             :                         OSL_ASSERT( aValue.getValueTypeClass() == uno::TypeClass_LONG );
     670           0 :                         aScale.IncrementData.SubIncrements[0].IntervalCount = aValue;
     671           0 :                         bSetScale = true;
     672             :                     }
     673             :                 }
     674             :             }
     675           0 :             break;
     676             : 
     677             :         case SCHATTR_AXIS_AUTO_TIME_RESOLUTION:
     678           0 :             if( (static_cast< const SfxBoolItem & >( rItemSet.Get( nWhichId )).GetValue() ))
     679             :             {
     680           0 :                 aScale.TimeIncrement.TimeResolution.clear();
     681           0 :                 bSetScale = true;
     682             :             }
     683           0 :             break;
     684             :         case SCHATTR_AXIS_TIME_RESOLUTION:
     685             :             // only if auto is false
     686           0 :             if( ! (static_cast< const SfxBoolItem & >( rItemSet.Get( SCHATTR_AXIS_AUTO_TIME_RESOLUTION )).GetValue() ))
     687             :             {
     688           0 :                 rItemSet.Get( nWhichId ).QueryValue( aValue );
     689             : 
     690           0 :                 if( aScale.TimeIncrement.TimeResolution != aValue )
     691             :                 {
     692           0 :                     aScale.TimeIncrement.TimeResolution = aValue;
     693           0 :                     bSetScale = true;
     694             :                 }
     695             :             }
     696           0 :             break;
     697             : 
     698             :         case SCHATTR_AXIS_AUTO_ORIGIN:
     699             :         {
     700           0 :             if( (static_cast< const SfxBoolItem & >(
     701           0 :                      rItemSet.Get( nWhichId )).GetValue() ))
     702             :             {
     703           0 :                 aScale.Origin.clear();
     704           0 :                 bSetScale = true;
     705             :             }
     706             :         }
     707           0 :         break;
     708             : 
     709             :         case SCHATTR_AXIS_ORIGIN:
     710             :         {
     711             :             // only if auto is false
     712           0 :             if( ! (static_cast< const SfxBoolItem & >(
     713           0 :                        rItemSet.Get( SCHATTR_AXIS_AUTO_ORIGIN )).GetValue() ))
     714             :             {
     715           0 :                 rItemSet.Get( nWhichId ).QueryValue( aValue );
     716             : 
     717           0 :                 if( aScale.Origin != aValue )
     718             :                 {
     719           0 :                     aScale.Origin = aValue;
     720           0 :                     bSetScale = true;
     721             : 
     722           0 :                     if( !AxisHelper::isAxisPositioningEnabled() )
     723             :                     {
     724             :                         //keep old and new settings for axis positioning in sync somehow
     725             :                         Reference< chart2::XCoordinateSystem > xCooSys( AxisHelper::getCoordinateSystemOfAxis(
     726           0 :                             m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ) );
     727             : 
     728           0 :                         sal_Int32 nDimensionIndex=0;
     729           0 :                         sal_Int32 nAxisIndex=0;
     730           0 :                         if( AxisHelper::getIndicesForAxis( m_xAxis, xCooSys, nDimensionIndex, nAxisIndex ) && nAxisIndex==0 )
     731             :                         {
     732           0 :                             Reference< beans::XPropertySet > xCrossingMainAxis( AxisHelper::getCrossingMainAxis( m_xAxis, xCooSys ), uno::UNO_QUERY );
     733           0 :                             if( xCrossingMainAxis.is() )
     734             :                             {
     735           0 :                                 double fValue = 0.0;
     736           0 :                                 if( aValue >>= fValue )
     737             :                                 {
     738           0 :                                     xCrossingMainAxis->setPropertyValue( "CrossoverPosition" , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_VALUE ));
     739           0 :                                     xCrossingMainAxis->setPropertyValue( "CrossoverValue" , uno::makeAny( fValue ));
     740             :                                 }
     741             :                                 else
     742           0 :                                     xCrossingMainAxis->setPropertyValue( "CrossoverPosition" , uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_START ));
     743           0 :                             }
     744           0 :                         }
     745             :                     }
     746             :                 }
     747             :             }
     748             :         }
     749           0 :         break;
     750             : 
     751             :         case SCHATTR_AXIS_POSITION:
     752             :         {
     753             :             ::com::sun::star::chart::ChartAxisPosition eAxisPos =
     754             :                 (::com::sun::star::chart::ChartAxisPosition)
     755           0 :                 static_cast< const SfxInt32Item & >( rItemSet.Get( nWhichId )).GetValue();
     756             : 
     757           0 :             ::com::sun::star::chart::ChartAxisPosition eOldAxisPos( ::com::sun::star::chart::ChartAxisPosition_ZERO );
     758           0 :             bool bPropExisted = ( GetPropertySet()->getPropertyValue( "CrossoverPosition" ) >>= eOldAxisPos );
     759             : 
     760           0 :             if( !bPropExisted || ( eOldAxisPos != eAxisPos ))
     761             :             {
     762           0 :                 GetPropertySet()->setPropertyValue( "CrossoverPosition" , uno::makeAny( eAxisPos ));
     763           0 :                 bChangedOtherwise = true;
     764             : 
     765             :                 //move the parallel axes to the other side if necessary
     766           0 :                 if( eAxisPos==::com::sun::star::chart::ChartAxisPosition_START || eAxisPos==::com::sun::star::chart::ChartAxisPosition_END )
     767             :                 {
     768           0 :                     Reference< beans::XPropertySet > xParallelAxis( AxisHelper::getParallelAxis( m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ), uno::UNO_QUERY );
     769           0 :                     if( xParallelAxis.is() )
     770             :                     {
     771             :                         ::com::sun::star::chart::ChartAxisPosition eOtherPos;
     772           0 :                         if( xParallelAxis->getPropertyValue( "CrossoverPosition" ) >>= eOtherPos )
     773             :                         {
     774           0 :                             if( eOtherPos == eAxisPos )
     775             :                             {
     776             :                                 ::com::sun::star::chart::ChartAxisPosition eOppositePos =
     777           0 :                                     (eAxisPos==::com::sun::star::chart::ChartAxisPosition_START)
     778             :                                     ? ::com::sun::star::chart::ChartAxisPosition_END
     779           0 :                                     : ::com::sun::star::chart::ChartAxisPosition_START;
     780           0 :                                 xParallelAxis->setPropertyValue( "CrossoverPosition" , uno::makeAny( eOppositePos ));
     781             :                             }
     782             :                         }
     783           0 :                     }
     784             :                 }
     785             :             }
     786             :         }
     787           0 :         break;
     788             : 
     789             :         case SCHATTR_AXIS_POSITION_VALUE:
     790             :         {
     791           0 :             double fValue = static_cast< const SvxDoubleItem & >( rItemSet.Get( nWhichId )).GetValue();
     792             : 
     793           0 :             double fOldValue = 0.0;
     794           0 :             bool bPropExisted = ( GetPropertySet()->getPropertyValue( "CrossoverValue" ) >>= fOldValue );
     795             : 
     796           0 :             if( !bPropExisted || ( fOldValue != fValue ))
     797             :             {
     798           0 :                 GetPropertySet()->setPropertyValue( "CrossoverValue" , uno::makeAny( fValue ));
     799           0 :                 bChangedOtherwise = true;
     800             : 
     801             :                 //keep old and new settings for axis positioning in sync somehow
     802             :                 {
     803             :                     Reference< chart2::XCoordinateSystem > xCooSys( AxisHelper::getCoordinateSystemOfAxis(
     804           0 :                         m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ) );
     805             : 
     806           0 :                     sal_Int32 nDimensionIndex=0;
     807           0 :                     sal_Int32 nAxisIndex=0;
     808           0 :                     if( AxisHelper::getIndicesForAxis( m_xAxis, xCooSys, nDimensionIndex, nAxisIndex ) && nAxisIndex==0 )
     809             :                     {
     810           0 :                         Reference< chart2::XAxis > xCrossingMainAxis( AxisHelper::getCrossingMainAxis( m_xAxis, xCooSys ) );
     811           0 :                         if( xCrossingMainAxis.is() )
     812             :                         {
     813           0 :                             ScaleData aCrossingScale( xCrossingMainAxis->getScaleData() );
     814           0 :                             aCrossingScale.Origin = uno::makeAny(fValue);
     815           0 :                             xCrossingMainAxis->setScaleData(aCrossingScale);
     816           0 :                         }
     817           0 :                     }
     818             :                 }
     819             :             }
     820             :         }
     821           0 :         break;
     822             : 
     823             :         case SCHATTR_AXIS_LABEL_POSITION:
     824             :         {
     825             :             ::com::sun::star::chart::ChartAxisLabelPosition ePos =
     826             :                 (::com::sun::star::chart::ChartAxisLabelPosition)
     827           0 :                 static_cast< const SfxInt32Item & >( rItemSet.Get( nWhichId )).GetValue();
     828             : 
     829           0 :             ::com::sun::star::chart::ChartAxisLabelPosition eOldPos( ::com::sun::star::chart::ChartAxisLabelPosition_NEAR_AXIS );
     830           0 :             bool bPropExisted = ( GetPropertySet()->getPropertyValue( "LabelPosition" ) >>= eOldPos );
     831             : 
     832           0 :             if( !bPropExisted || ( eOldPos != ePos ))
     833             :             {
     834           0 :                 GetPropertySet()->setPropertyValue( "LabelPosition" , uno::makeAny( ePos ));
     835           0 :                 bChangedOtherwise = true;
     836             : 
     837             :                 //move the parallel axes to the other side if necessary
     838           0 :                 if( ePos==::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_START || ePos==::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_END )
     839             :                 {
     840           0 :                     Reference< beans::XPropertySet > xParallelAxis( AxisHelper::getParallelAxis( m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ), uno::UNO_QUERY );
     841           0 :                     if( xParallelAxis.is() )
     842             :                     {
     843             :                         ::com::sun::star::chart::ChartAxisLabelPosition eOtherPos;
     844           0 :                         if( xParallelAxis->getPropertyValue( "LabelPosition" ) >>= eOtherPos )
     845             :                         {
     846           0 :                             if( eOtherPos == ePos )
     847             :                             {
     848             :                                 ::com::sun::star::chart::ChartAxisLabelPosition eOppositePos =
     849           0 :                                     (ePos==::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_START)
     850             :                                     ? ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_END
     851           0 :                                     : ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_START;
     852           0 :                                 xParallelAxis->setPropertyValue( "LabelPosition" , uno::makeAny( eOppositePos ));
     853             :                             }
     854             :                         }
     855           0 :                     }
     856             :                 }
     857             :             }
     858             :         }
     859           0 :         break;
     860             : 
     861             :         case SCHATTR_AXIS_MARK_POSITION:
     862             :         {
     863             :             ::com::sun::star::chart::ChartAxisMarkPosition ePos =
     864             :                 (::com::sun::star::chart::ChartAxisMarkPosition)
     865           0 :                 static_cast< const SfxInt32Item & >( rItemSet.Get( nWhichId )).GetValue();
     866             : 
     867           0 :             ::com::sun::star::chart::ChartAxisMarkPosition eOldPos( ::com::sun::star::chart::ChartAxisMarkPosition_AT_LABELS_AND_AXIS );
     868           0 :             bool bPropExisted = ( GetPropertySet()->getPropertyValue( "MarkPosition" ) >>= eOldPos );
     869             : 
     870           0 :             if( !bPropExisted || ( eOldPos != ePos ))
     871             :             {
     872           0 :                 GetPropertySet()->setPropertyValue( "MarkPosition" , uno::makeAny( ePos ));
     873           0 :                 bChangedOtherwise = true;
     874             :             }
     875             :         }
     876           0 :         break;
     877             : 
     878             :         case SCHATTR_TEXT_DEGREES:
     879             :         {
     880             :             // convert int to double (divided by 100)
     881             :             double fVal = static_cast< double >(
     882             :                 static_cast< const SfxInt32Item & >(
     883           0 :                     rItemSet.Get( nWhichId )).GetValue()) / 100.0;
     884           0 :             double fOldVal = 0.0;
     885             :             bool bPropExisted =
     886           0 :                 ( GetPropertySet()->getPropertyValue( "TextRotation" ) >>= fOldVal );
     887             : 
     888           0 :             if( ! bPropExisted ||
     889           0 :                 ( bPropExisted && fOldVal != fVal ))
     890             :             {
     891           0 :                 GetPropertySet()->setPropertyValue( "TextRotation" , uno::makeAny( fVal ));
     892           0 :                 bChangedOtherwise = true;
     893             :             }
     894             :         }
     895           0 :         break;
     896             : 
     897             :         case SID_ATTR_NUMBERFORMAT_VALUE:
     898             :         {
     899           0 :             if( m_pExplicitScale )
     900             :             {
     901             :                 bool bUseSourceFormat =
     902             :                     (static_cast< const SfxBoolItem & >(
     903           0 :                         rItemSet.Get( SID_ATTR_NUMBERFORMAT_SOURCE )).GetValue() );
     904             : 
     905           0 :                 if( ! bUseSourceFormat )
     906             :                 {
     907             :                     sal_Int32 nFmt = static_cast< sal_Int32 >(
     908             :                         static_cast< const SfxUInt32Item & >(
     909           0 :                             rItemSet.Get( nWhichId )).GetValue());
     910             : 
     911           0 :                     aValue = uno::makeAny(nFmt);
     912           0 :                     if (GetPropertySet()->getPropertyValue(CHART_UNONAME_NUMFMT) != aValue)
     913             :                     {
     914           0 :                         GetPropertySet()->setPropertyValue(CHART_UNONAME_NUMFMT , aValue);
     915           0 :                         bChangedOtherwise = true;
     916             :                     }
     917             :                 }
     918             :             }
     919             :         }
     920           0 :         break;
     921             : 
     922             :         case SID_ATTR_NUMBERFORMAT_SOURCE:
     923             :         {
     924             :             bool bUseSourceFormat =
     925             :                 (static_cast< const SfxBoolItem & >(
     926           0 :                     rItemSet.Get( nWhichId )).GetValue() );
     927           0 :             GetPropertySet()->setPropertyValue(CHART_UNONAME_LINK_TO_SRC_NUMFMT, uno::makeAny(bUseSourceFormat));
     928             : 
     929           0 :             bool bNumberFormatIsSet = GetPropertySet()->getPropertyValue(CHART_UNONAME_NUMFMT).hasValue();
     930             : 
     931           0 :             bChangedOtherwise = (bUseSourceFormat == bNumberFormatIsSet);
     932           0 :             if( bChangedOtherwise )
     933             :             {
     934           0 :                 if( ! bUseSourceFormat )
     935             :                 {
     936           0 :                     SfxItemState aState = rItemSet.GetItemState( SID_ATTR_NUMBERFORMAT_VALUE );
     937           0 :                     if( aState == SfxItemState::SET )
     938             :                     {
     939             :                         sal_Int32 nFormatKey = static_cast< sal_Int32 >(
     940             :                         static_cast< const SfxUInt32Item & >(
     941           0 :                             rItemSet.Get( SID_ATTR_NUMBERFORMAT_VALUE )).GetValue());
     942           0 :                         aValue <<= nFormatKey;
     943             :                     }
     944             :                     else
     945             :                     {
     946             :                         Reference< chart2::XCoordinateSystem > xCooSys(
     947             :                         AxisHelper::getCoordinateSystemOfAxis(
     948           0 :                               m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ) );
     949             : 
     950             :                         sal_Int32 nFormatKey = ExplicitValueProvider::getExplicitNumberFormatKeyForAxis(
     951           0 :                             m_xAxis, xCooSys, m_xChartDoc);
     952             : 
     953           0 :                         aValue <<= nFormatKey;
     954             :                     }
     955             :                 }
     956             :                 // else set a void Any
     957           0 :                 GetPropertySet()->setPropertyValue(CHART_UNONAME_NUMFMT , aValue);
     958             :             }
     959             :         }
     960           0 :         break;
     961             : 
     962             :         case SCHATTR_AXISTYPE:
     963             :         {
     964           0 :             sal_Int32 nNewAxisType = static_cast< const SfxInt32Item & >( rItemSet.Get( nWhichId )).GetValue();//::com::sun::star::chart2::AxisType
     965           0 :             aScale.AxisType = nNewAxisType;
     966           0 :             bSetScale = true;
     967             :         }
     968           0 :         break;
     969             : 
     970             :         case SCHATTR_AXIS_AUTO_DATEAXIS:
     971             :         {
     972           0 :             bool bNewValue = static_cast< const SfxBoolItem & >( rItemSet.Get( nWhichId )).GetValue();
     973           0 :             bool bOldValue = aScale.AutoDateAxis;
     974           0 :             if( bOldValue != bNewValue )
     975             :             {
     976           0 :                 aScale.AutoDateAxis = bNewValue;
     977           0 :                 bSetScale = true;
     978             :             }
     979             :         }
     980           0 :         break;
     981             :     }
     982             : 
     983           0 :     if( bSetScale )
     984           0 :         m_xAxis->setScaleData( aScale );
     985             : 
     986           0 :     return (bSetScale || bChangedOtherwise);
     987             : }
     988             : 
     989             : }}
     990             : 
     991             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11