chart2/source/controller/itemsetwrapper/AxisItemConverter.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: AxisItemConverter.cxx,v $
  10  * $Revision: 1.14.44.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_chart2.hxx"
  33 #include "AxisItemConverter.hxx"
  34 #include "ItemPropertyMap.hxx"
  35 #include "CharacterPropertyItemConverter.hxx"
  36 #include "GraphicPropertyItemConverter.hxx"
  37 #include "chartview/ChartSfxItemIds.hxx"
  38 #include "chartview/ExplicitValueProvider.hxx"
  39 #include "SchWhichPairs.hxx"
  40 #include "macros.hxx"
  41 #include "ChartModelHelper.hxx"
  42 #include "AxisHelper.hxx"
  43 #include "CommonConverters.hxx"
  44
  45 #include <com/sun/star/chart/ChartAxisLabelPosition.hpp>
  46 #include <com/sun/star/chart/ChartAxisMarkPosition.hpp>
  47 #include <com/sun/star/chart/ChartAxisPosition.hpp>
  48 #include <com/sun/star/chart2/XAxis.hpp>
  49 #include <com/sun/star/chart2/AxisOrientation.hpp>
  50
  51 // for SfxBoolItem
  52 #include <svtools/eitem.hxx>
  53 // for SvxDoubleItem
  54 #include <svx/chrtitem.hxx>
  55 // for SfxInt32Item
  56 #include <svtools/intitem.hxx>
  57 #include <rtl/math.hxx>
  58
  59 #include <algorithm>
  60
  61 using namespace ::com::sun::star;
  62 using namespace ::com::sun::star::chart2;
  63 using ::com::sun::star::uno::Reference;
  64
  65 namespace
  66 {
  67 ::comphelper::ItemPropertyMapType & lcl_GetAxisPropertyMap()
  68 {
  69     static ::comphelper::ItemPropertyMapType aAxisPropertyMap(
  70         ::comphelper::MakeItemPropertyMap
  71         IPM_MAP_ENTRY( SCHATTR_AXIS_SHOWDESCR, "DisplayLabels",    0 )
  72         IPM_MAP_ENTRY( SCHATTR_AXIS_TICKS,     "MajorTickmarks",   0 )
  73         IPM_MAP_ENTRY( SCHATTR_AXIS_HELPTICKS, "MinorTickmarks",   0 )
  74         IPM_MAP_ENTRY( SCHATTR_TEXT_ORDER,     "ArrangeOrder",     0 )
  75         IPM_MAP_ENTRY( SCHATTR_TEXT_STACKED,   "StackCharacters",  0 )
  76         IPM_MAP_ENTRY( SCHATTR_TEXTBREAK,      "TextBreak",        0 )
  77         IPM_MAP_ENTRY( SCHATTR_TEXT_OVERLAP,   "TextOverlap",      0 )
  78         );
  79
  80     return aAxisPropertyMap;
  81 };
  82 } // anonymous namespace
  83
  84 namespace chart
  85 {
  86 namespace wrapper
  87 {
  88
  89 AxisItemConverter::AxisItemConverter(
  90     const Reference< beans::XPropertySet > & rPropertySet,
  91     SfxItemPool& rItemPool,
  92     SdrModel& rDrawModel,
  93     const Reference< chart2::XChartDocument > & xChartDoc,
  94     chart2::ExplicitScaleData * pScale /* = NULL */,
  95     chart2::ExplicitIncrementData * pIncrement /* = NULL */,
  96     ::std::auto_ptr< awt::Size > pRefSize /* = NULL */ ) :
  97         ItemConverter( rPropertySet, rItemPool ),
  98         m_xChartDoc( xChartDoc ),
  99         m_pExplicitScale( NULL ),
 100         m_pExplicitIncrement( NULL )
 101 {
 102     Reference< lang::XMultiServiceFactory > xNamedPropertyContainerFactory( xChartDoc, uno::UNO_QUERY );
 103
 104     if( pScale )
 105         m_pExplicitScale = new chart2::ExplicitScaleData( *pScale );
 106     if( pIncrement )
 107         m_pExplicitIncrement = new chart2::ExplicitIncrementData( *pIncrement );
 108
 109     m_aConverters.push_back( new GraphicPropertyItemConverter(
 110                                  rPropertySet, rItemPool, rDrawModel,
 111                                  xNamedPropertyContainerFactory,
 112                                  GraphicPropertyItemConverter::LINE_PROPERTIES ));
 113     m_aConverters.push_back( new CharacterPropertyItemConverter( rPropertySet, rItemPool, pRefSize,
 114                                                                  C2U( "ReferencePageSize" ) ));
 115
 116     m_xAxis.set( Reference< chart2::XAxis >( rPropertySet, uno::UNO_QUERY ) );
 117     OSL_ASSERT( m_xAxis.is());
 118 }
 119
 120 AxisItemConverter::~AxisItemConverter()
 121 {
 122     delete m_pExplicitScale;
 123     delete m_pExplicitIncrement;
 124
 125     ::std::for_each( m_aConverters.begin(), m_aConverters.end(),
 126                      ::comphelper::DeleteItemConverterPtr() );
 127 }
 128
 129 void AxisItemConverter::FillItemSet( SfxItemSet & rOutItemSet ) const
 130 {
 131     ::std::for_each( m_aConverters.begin(), m_aConverters.end(),
 132                      ::comphelper::FillItemSetFunc( rOutItemSet ));
 133
 134     // own items
 135     ItemConverter::FillItemSet( rOutItemSet );
 136 }
 137
 138 bool AxisItemConverter::ApplyItemSet( const SfxItemSet & rItemSet )
 139 {
 140     bool bResult = false;
 141
 142     ::std::for_each( m_aConverters.begin(), m_aConverters.end(),
 143                      ::comphelper::ApplyItemSetFunc( rItemSet, bResult ));
 144
 145     // own items
 146     return ItemConverter::ApplyItemSet( rItemSet ) || bResult;
 147 }
 148
 149 const USHORT * AxisItemConverter::GetWhichPairs() const
 150 {
 151     // must span all used items!
 152     return nAxisWhichPairs;
 153 }
 154
 155 bool AxisItemConverter::GetItemProperty( tWhichIdType nWhichId, tPropertyNameWithMemberId & rOutProperty ) const
 156 {
 157     ::comphelper::ItemPropertyMapType & rMap( lcl_GetAxisPropertyMap());
 158     ::comphelper::ItemPropertyMapType::const_iterator aIt( rMap.find( nWhichId ));
 159
 160     if( aIt == rMap.end())
 161         return false;
 162
 163     rOutProperty =(*aIt).second;
 164
 165     return true;
 166 }
 167
 168 void AxisItemConverter::FillSpecialItem( USHORT nWhichId, SfxItemSet & rOutItemSet ) const
 169     throw( uno::Exception )
 170 {
 171     if( ! m_xAxis.is() )
 172         return;
 173
 174     const chart2::ScaleData     aScale( m_xAxis->getScaleData() );
 175     const chart2::IncrementData aInc( aScale.IncrementData );
 176     const uno::Sequence< chart2::SubIncrement > aSubIncs( aScale.IncrementData.SubIncrements );
 177
 178     switch( nWhichId )
 179     {
 180         case SCHATTR_AXIS_AUTO_MAX:
 181             // if the any has no value => auto is on
 182             rOutItemSet.Put( SfxBoolItem( nWhichId, !hasDoubleValue(aScale.Maximum) ) );
 183             break;
 184
 185         case SCHATTR_AXIS_MAX:
 186             {
 187                 double fMax = 10.0;
 188                 if( aScale.Maximum >>= fMax )
 189                 {
 190                     rOutItemSet.Put( SvxDoubleItem( fMax, nWhichId ) );
 191                 }
 192                 else
 193                 {
 194                     if( m_pExplicitScale )
 195                         fMax = m_pExplicitScale->Maximum;
 196                     rOutItemSet.Put( SvxDoubleItem( fMax, nWhichId ) );
 197                 }
 198             }
 199             break;
 200
 201         case SCHATTR_AXIS_AUTO_MIN:
 202             // if the any has no value => auto is on
 203             rOutItemSet.Put( SfxBoolItem( nWhichId, !hasDoubleValue(aScale.Minimum) ) );
 204             break;
 205
 206         case SCHATTR_AXIS_MIN:
 207             {
 208                 double fMin = 0.0;
 209                 if( aScale.Minimum >>= fMin )
 210                 {
 211                     rOutItemSet.Put( SvxDoubleItem( fMin, nWhichId ) );
 212                 }
 213                 else
 214                 {
 215                     if( m_pExplicitScale )
 216                         rOutItemSet.Put( SvxDoubleItem( m_pExplicitScale->Minimum, nWhichId ));
 217                 }
 218             }
 219             break;
 220
 221         case SCHATTR_AXIS_LOGARITHM:
 222         {
 223             BOOL bValue = AxisHelper::isLogarithmic( aScale.Scaling );
 224             rOutItemSet.Put( SfxBoolItem( nWhichId, bValue ));
 225         }
 226         break;
 227
 228         case SCHATTR_AXIS_REVERSE:
 229             rOutItemSet.Put( SfxBoolItem( nWhichId, (AxisOrientation_REVERSE == aScale.Orientation) ));
 230             break;
 231
 232         // Increment
 233         case SCHATTR_AXIS_AUTO_STEP_MAIN:
 234             // if the any has no value => auto is on
 235             rOutItemSet.Put( SfxBoolItem( nWhichId, !hasDoubleValue(aInc.Distance) ) );
 236             break;
 237
 238         case SCHATTR_AXIS_STEP_MAIN:
 239             {
 240                 double fDistance = 1.0;
 241                 if( aInc.Distance >>= fDistance )
 242                 {
 243                     rOutItemSet.Put( SvxDoubleItem(fDistance, nWhichId ));
 244                 }
 245                 else
 246                 {
 247                     if( m_pExplicitIncrement )
 248                         rOutItemSet.Put( SvxDoubleItem( m_pExplicitIncrement->Distance, nWhichId ));
 249                 }
 250             }
 251             break;
 252
 253         // SubIncrement
 254         case SCHATTR_AXIS_AUTO_STEP_HELP:
 255         {
 256             // if the any has no value => auto is on
 257             rOutItemSet.Put(
 258                 SfxBoolItem(
 259                     nWhichId,
 260                     ! ( aSubIncs.getLength() > 0 &&
 261                         aSubIncs[0].IntervalCount.hasValue() )));
 262         }
 263         break;
 264
 265         case SCHATTR_AXIS_STEP_HELP:
 266         {
 267             if( aSubIncs.getLength() > 0 &&
 268                 aSubIncs[0].IntervalCount.hasValue())
 269             {
 270                 OSL_ASSERT( aSubIncs[0].IntervalCount.getValueTypeClass() == uno::TypeClass_LONG );
 271                 rOutItemSet.Put(
 272                     SfxInt32Item(
 273                         nWhichId,
 274                         *reinterpret_cast< const sal_Int32 * >(
 275                             aSubIncs[0].IntervalCount.getValue()) ));
 276             }
 277             else
 278             {
 279                 if( m_pExplicitIncrement &&
 280                     m_pExplicitIncrement->SubIncrements.getLength() > 0 )
 281                 {
 282                     rOutItemSet.Put(
 283                         SfxInt32Item(
 284                             nWhichId,
 285                             m_pExplicitIncrement->SubIncrements[0].IntervalCount ));
 286                 }
 287             }
 288         }
 289         break;
 290
 291         case SCHATTR_AXIS_AUTO_ORIGIN:
 292         {
 293             // if the any has no double value => auto is on
 294             rOutItemSet.Put( SfxBoolItem( nWhichId, ( !hasDoubleValue(aScale.Origin) )));
 295         }
 296         break;
 297
 298         case SCHATTR_AXIS_ORIGIN:
 299         {
 300             double fOrigin = 0.0;
 301             if( !(aScale.Origin >>= fOrigin) )
 302             {
 303                 if( m_pExplicitScale )
 304                     fOrigin = m_pExplicitScale->Origin;
 305             }
 306             rOutItemSet.Put( SvxDoubleItem( fOrigin, nWhichId ));
 307         }
 308         break;
 309
 310         case SCHATTR_AXIS_POSITION:
 311         {
 312             ::com::sun::star::chart::ChartAxisPosition eAxisPos( ::com::sun::star::chart::ChartAxisPosition_ZERO );
 313             GetPropertySet()->getPropertyValue(C2U( "CrossoverPosition" )) >>= eAxisPos;
 314             rOutItemSet.Put( SfxInt32Item( nWhichId, eAxisPos ) );
 315         }
 316         break;
 317
 318         case SCHATTR_AXIS_POSITION_VALUE:
 319         {
 320             double fValue = 0.0;
 321             if( GetPropertySet()->getPropertyValue(C2U( "CrossoverValue" )) >>= fValue )
 322                 rOutItemSet.Put( SvxDoubleItem( fValue, nWhichId ) );
 323         }
 324         break;
 325
 326         case SCHATTR_AXIS_CROSSING_MAIN_AXIS_NUMBERFORMAT:
 327         {
 328             //read only item
 329             //necessary tp display the crossing value with an appropriate format
 330
 331             Reference< chart2::XCoordinateSystem > xCooSys( AxisHelper::getCoordinateSystemOfAxis(
 332                 m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ) );
 333
 334             Reference< chart2::XAxis > xCrossingMainAxis( AxisHelper::getCrossingMainAxis( m_xAxis, xCooSys ) );
 335
 336             sal_Int32 nFormatKey = ExplicitValueProvider::getExplicitNumberFormatKeyForAxis(
 337                 xCrossingMainAxis, xCooSys, Reference< util::XNumberFormatsSupplier >( m_xChartDoc, uno::UNO_QUERY ) );
 338
 339             rOutItemSet.Put( SfxUInt32Item( nWhichId, nFormatKey ));
 340         }
 341         break;
 342
 343         case SCHATTR_AXIS_LABEL_POSITION:
 344         {
 345             ::com::sun::star::chart::ChartAxisLabelPosition ePos( ::com::sun::star::chart::ChartAxisLabelPosition_NEAR_AXIS );
 346             GetPropertySet()->getPropertyValue(C2U( "LabelPosition" )) >>= ePos;
 347             rOutItemSet.Put( SfxInt32Item( nWhichId, ePos ) );
 348         }
 349         break;
 350
 351         case SCHATTR_AXIS_MARK_POSITION:
 352         {
 353             ::com::sun::star::chart::ChartAxisMarkPosition ePos( ::com::sun::star::chart::ChartAxisMarkPosition_AT_LABELS_AND_AXIS );
 354             GetPropertySet()->getPropertyValue(C2U( "MarkPosition" )) >>= ePos;
 355             rOutItemSet.Put( SfxInt32Item( nWhichId, ePos ) );
 356         }
 357         break;
 358
 359         case SCHATTR_TEXT_DEGREES:
 360         {
 361             // convert double to int (times 100)
 362             double fVal = 0;
 363
 364             if( GetPropertySet()->getPropertyValue( C2U( "TextRotation" )) >>= fVal )
 365             {
 366                 rOutItemSet.Put( SfxInt32Item( nWhichId, static_cast< sal_Int32 >(
 367                                                    ::rtl::math::round( fVal * 100.0 ) ) ));
 368             }
 369         }
 370         break;
 371
 372         case SID_ATTR_NUMBERFORMAT_VALUE:
 373 //         case SCHATTR_AXIS_NUMFMT:
 374         {
 375             if( m_pExplicitScale )
 376             {
 377                 Reference< chart2::XCoordinateSystem > xCooSys(
 378                         AxisHelper::getCoordinateSystemOfAxis(
 379                               m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ) );
 380
 381                 sal_Int32 nFormatKey = ExplicitValueProvider::getExplicitNumberFormatKeyForAxis(
 382                     m_xAxis, xCooSys, Reference< util::XNumberFormatsSupplier >( m_xChartDoc, uno::UNO_QUERY ) );
 383
 384                 rOutItemSet.Put( SfxUInt32Item( nWhichId, nFormatKey ));
 385             }
 386         }
 387         break;
 388
 389         case SID_ATTR_NUMBERFORMAT_SOURCE:
 390         {
 391             bool bNumberFormatIsSet = ( GetPropertySet()->getPropertyValue( C2U( "NumberFormat" )).hasValue());
 392             rOutItemSet.Put( SfxBoolItem( nWhichId, ! bNumberFormatIsSet ));
 393         }
 394         break;
 395
 396         case SCHATTR_AXISTYPE:
 397         rOutItemSet.Put( SfxInt32Item( nWhichId, aScale.AxisType ));
 398         break;
 399     }
 400 }
 401
 402 bool AxisItemConverter::ApplySpecialItem( USHORT nWhichId, const SfxItemSet & rItemSet )
 403     throw( uno::Exception )
 404 {
 405     if( !m_xAxis.is() )
 406         return false;
 407
 408     chart2::ScaleData     aScale( m_xAxis->getScaleData() );
 409
 410     bool bSetScale    = false;
 411     bool bChangedOtherwise = false;
 412
 413     uno::Any aValue;
 414
 415     switch( nWhichId )
 416     {
 417         case SCHATTR_AXIS_AUTO_MAX:
 418             if( (static_cast< const SfxBoolItem & >(
 419                      rItemSet.Get( nWhichId )).GetValue() ))
 420             {
 421                 aScale.Maximum.clear();
 422                 bSetScale = true;
 423             }
 424             // else SCHATTR_AXIS_MAX must have some value
 425             break;
 426
 427         case SCHATTR_AXIS_MAX:
 428             // only if auto if false
 429             if( ! (static_cast< const SfxBoolItem & >(
 430                        rItemSet.Get( SCHATTR_AXIS_AUTO_MAX )).GetValue() ))
 431             {
 432                 rItemSet.Get( nWhichId ).QueryValue( aValue );
 433
 434                 if( aScale.Maximum != aValue )
 435                 {
 436                     aScale.Maximum = aValue;
 437                     bSetScale = true;
 438                 }
 439             }
 440             break;
 441
 442         case SCHATTR_AXIS_AUTO_MIN:
 443             if( (static_cast< const SfxBoolItem & >(
 444                      rItemSet.Get( nWhichId )).GetValue() ))
 445             {
 446                 aScale.Minimum.clear();
 447                 bSetScale = true;
 448             }
 449             // else SCHATTR_AXIS_MIN must have some value
 450             break;
 451
 452         case SCHATTR_AXIS_MIN:
 453             // only if auto if false
 454             if( ! (static_cast< const SfxBoolItem & >(
 455                        rItemSet.Get( SCHATTR_AXIS_AUTO_MIN )).GetValue() ))
 456             {
 457                 rItemSet.Get( nWhichId ).QueryValue( aValue );
 458
 459                 if( aScale.Minimum != aValue )
 460                 {
 461                     aScale.Minimum = aValue;
 462                     bSetScale = true;
 463                 }
 464             }
 465             break;
 466
 467         case SCHATTR_AXIS_LOGARITHM:
 468         {
 469             bool bWasLogarithm = AxisHelper::isLogarithmic( aScale.Scaling );
 470
 471             if( (static_cast< const SfxBoolItem & >(
 472                      rItemSet.Get( nWhichId )).GetValue() ))
 473             {
 474                 // logarithm is true
 475                 if( ! bWasLogarithm )
 476                 {
 477                     aScale.Scaling = AxisHelper::createLogarithmicScaling( 10.0 );
 478                     bSetScale = true;
 479                 }
 480             }
 481             else
 482             {
 483                 // logarithm is false => linear scaling
 484                 if( bWasLogarithm )
 485                 {
 486                     aScale.Scaling = AxisHelper::createLinearScaling();
 487                     bSetScale = true;
 488                 }
 489             }
 490         }
 491         break;
 492
 493         case SCHATTR_AXIS_REVERSE:
 494         {
 495             bool bWasReverse = ( AxisOrientation_REVERSE == aScale.Orientation );
 496             bool bNewReverse = (static_cast< const SfxBoolItem & >(
 497                      rItemSet.Get( nWhichId )).GetValue() );
 498             if( bWasReverse != bNewReverse )
 499             {
 500                 aScale.Orientation = bNewReverse ? AxisOrientation_REVERSE : AxisOrientation_MATHEMATICAL;
 501                 bSetScale = true;
 502             }
 503         }
 504         break;
 505
 506         // Increment
 507         case SCHATTR_AXIS_AUTO_STEP_MAIN:
 508             if( (static_cast< const SfxBoolItem & >(
 509                      rItemSet.Get( nWhichId )).GetValue() ))
 510             {
 511                 aScale.IncrementData.Distance.clear();
 512                 bSetScale = true;
 513             }
 514             // else SCHATTR_AXIS_STEP_MAIN must have some value
 515             break;
 516
 517         case SCHATTR_AXIS_STEP_MAIN:
 518             // only if auto if false
 519             if( ! (static_cast< const SfxBoolItem & >(
 520                        rItemSet.Get( SCHATTR_AXIS_AUTO_STEP_MAIN )).GetValue() ))
 521             {
 522                 rItemSet.Get( nWhichId ).QueryValue( aValue );
 523
 524                 if( aScale.IncrementData.Distance != aValue )
 525                 {
 526                     aScale.IncrementData.Distance = aValue;
 527                     bSetScale = true;
 528                 }
 529             }
 530             break;
 531
 532         // SubIncrement
 533         case SCHATTR_AXIS_AUTO_STEP_HELP:
 534             if( (static_cast< const SfxBoolItem & >(
 535                      rItemSet.Get( nWhichId )).GetValue() ) &&
 536                 aScale.IncrementData.SubIncrements.getLength() > 0 &&
 537                 aScale.IncrementData.SubIncrements[0].IntervalCount.hasValue() )
 538             {
 539                     aScale.IncrementData.SubIncrements[0].IntervalCount.clear();
 540                     bSetScale = true;
 541             }
 542             // else SCHATTR_AXIS_STEP_MAIN must have some value
 543             break;
 544
 545         case SCHATTR_AXIS_STEP_HELP:
 546             // only if auto if false
 547             if( ! (static_cast< const SfxBoolItem & >(
 548                        rItemSet.Get( SCHATTR_AXIS_AUTO_STEP_HELP )).GetValue() ) &&
 549                 aScale.IncrementData.SubIncrements.getLength() > 0 )
 550             {
 551                 rItemSet.Get( nWhichId ).QueryValue( aValue );
 552
 553                 if( ! aScale.IncrementData.SubIncrements[0].IntervalCount.hasValue() ||
 554                     aScale.IncrementData.SubIncrements[0].IntervalCount != aValue )
 555                 {
 556                     OSL_ASSERT( aValue.getValueTypeClass() == uno::TypeClass_LONG );
 557                     aScale.IncrementData.SubIncrements[0].IntervalCount = aValue;
 558                     bSetScale = true;
 559                 }
 560             }
 561             break;
 562
 563         case SCHATTR_AXIS_AUTO_ORIGIN:
 564         {
 565             if( (static_cast< const SfxBoolItem & >(
 566                      rItemSet.Get( nWhichId )).GetValue() ))
 567             {
 568                 aScale.Origin.clear();
 569                 bSetScale = true;
 570             }
 571         }
 572         break;
 573
 574         case SCHATTR_AXIS_ORIGIN:
 575         {
 576             // only if auto is false
 577             if( ! (static_cast< const SfxBoolItem & >(
 578                        rItemSet.Get( SCHATTR_AXIS_AUTO_ORIGIN )).GetValue() ))
 579             {
 580                 rItemSet.Get( nWhichId ).QueryValue( aValue );
 581
 582                 if( aScale.Origin != aValue )
 583                 {
 584                     aScale.Origin = aValue;
 585                     bSetScale = true;
 586
 587                     if( !AxisHelper::isAxisPositioningEnabled() )
 588                     {
 589                         //keep old and new settings for axis positioning in sync somehow
 590                         Reference< chart2::XCoordinateSystem > xCooSys( AxisHelper::getCoordinateSystemOfAxis(
 591                             m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ) );
 592
 593                         sal_Int32 nDimensionIndex=0;
 594                         sal_Int32 nAxisIndex=0;
 595                         if( AxisHelper::getIndicesForAxis( m_xAxis, xCooSys, nDimensionIndex, nAxisIndex ) && nAxisIndex==0 )
 596                         {
 597                             Reference< beans::XPropertySet > xCrossingMainAxis( AxisHelper::getCrossingMainAxis( m_xAxis, xCooSys ), uno::UNO_QUERY );
 598                             if( xCrossingMainAxis.is() )
 599                             {
 600                                 double fValue = 0.0;
 601                                 if( aValue >>= fValue )
 602                                 {
 603                                     xCrossingMainAxis->setPropertyValue( C2U( "CrossoverPosition" ), uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_VALUE ));
 604                                     xCrossingMainAxis->setPropertyValue( C2U( "CrossoverValue" ), uno::makeAny( fValue ));
 605                                 }
 606                                 else
 607                                     xCrossingMainAxis->setPropertyValue( C2U( "CrossoverPosition" ), uno::makeAny( ::com::sun::star::chart::ChartAxisPosition_START ));
 608                             }
 609                         }
 610                     }
 611                 }
 612             }
 613         }
 614         break;
 615
 616         case SCHATTR_AXIS_POSITION:
 617         {
 618             ::com::sun::star::chart::ChartAxisPosition eAxisPos =
 619                 (::com::sun::star::chart::ChartAxisPosition)
 620                 static_cast< const SfxInt32Item & >( rItemSet.Get( nWhichId )).GetValue();
 621
 622             ::com::sun::star::chart::ChartAxisPosition eOldAxisPos( ::com::sun::star::chart::ChartAxisPosition_ZERO );
 623             bool bPropExisted = ( GetPropertySet()->getPropertyValue(C2U( "CrossoverPosition" )) >>= eOldAxisPos );
 624
 625             if( !bPropExisted || ( eOldAxisPos != eAxisPos ))
 626             {
 627                 GetPropertySet()->setPropertyValue( C2U( "CrossoverPosition" ), uno::makeAny( eAxisPos ));
 628                 bChangedOtherwise = true;
 629
 630                 //move the parallel axes to the other side if necessary
 631                 if( eAxisPos==::com::sun::star::chart::ChartAxisPosition_START || eAxisPos==::com::sun::star::chart::ChartAxisPosition_END )
 632                 {
 633                     Reference< beans::XPropertySet > xParallelAxis( AxisHelper::getParallelAxis( m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ), uno::UNO_QUERY );
 634                     if( xParallelAxis.is() )
 635                     {
 636                         ::com::sun::star::chart::ChartAxisPosition eOtherPos;
 637                         if( xParallelAxis->getPropertyValue( C2U( "CrossoverPosition" ) ) >>= eOtherPos )
 638                         {
 639                             if( eOtherPos == eAxisPos )
 640                             {
 641                                 ::com::sun::star::chart::ChartAxisPosition eOppositePos =
 642                                     (eAxisPos==::com::sun::star::chart::ChartAxisPosition_START)
 643                                     ? ::com::sun::star::chart::ChartAxisPosition_END
 644                                     : ::com::sun::star::chart::ChartAxisPosition_START;
 645                                 xParallelAxis->setPropertyValue( C2U( "CrossoverPosition" ), uno::makeAny( eOppositePos ));
 646                             }
 647                         }
 648                     }
 649                 }
 650             }
 651         }
 652         break;
 653
 654         case SCHATTR_AXIS_POSITION_VALUE:
 655         {
 656             double fValue = static_cast< const SvxDoubleItem & >( rItemSet.Get( nWhichId )).GetValue();
 657
 658             double fOldValue = 0.0;
 659             bool bPropExisted = ( GetPropertySet()->getPropertyValue(C2U( "CrossoverValue" )) >>= fOldValue );
 660
 661             if( !bPropExisted || ( fOldValue != fValue ))
 662             {
 663                 GetPropertySet()->setPropertyValue( C2U( "CrossoverValue" ), uno::makeAny( fValue ));
 664                 bChangedOtherwise = true;
 665
 666                 //keep old and new settings for axis positioning in sync somehow
 667                 {
 668                     Reference< chart2::XCoordinateSystem > xCooSys( AxisHelper::getCoordinateSystemOfAxis(
 669                         m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ) );
 670
 671                     sal_Int32 nDimensionIndex=0;
 672                     sal_Int32 nAxisIndex=0;
 673                     if( AxisHelper::getIndicesForAxis( m_xAxis, xCooSys, nDimensionIndex, nAxisIndex ) && nAxisIndex==0 && nDimensionIndex==0 )
 674                     {
 675                         Reference< chart2::XAxis > xCrossingMainAxis( AxisHelper::getCrossingMainAxis( m_xAxis, xCooSys ) );
 676                         if( xCrossingMainAxis.is() )
 677                         {
 678                             ScaleData aCrossingScale( xCrossingMainAxis->getScaleData() );
 679                             aCrossingScale.Origin = uno::makeAny(fValue);
 680                             xCrossingMainAxis->setScaleData(aCrossingScale);
 681                         }
 682                     }
 683                 }
 684             }
 685         }
 686         break;
 687
 688         case SCHATTR_AXIS_LABEL_POSITION:
 689         {
 690             ::com::sun::star::chart::ChartAxisLabelPosition ePos =
 691                 (::com::sun::star::chart::ChartAxisLabelPosition)
 692                 static_cast< const SfxInt32Item & >( rItemSet.Get( nWhichId )).GetValue();
 693
 694             ::com::sun::star::chart::ChartAxisLabelPosition eOldPos( ::com::sun::star::chart::ChartAxisLabelPosition_NEAR_AXIS );
 695             bool bPropExisted = ( GetPropertySet()->getPropertyValue(C2U( "LabelPosition" )) >>= eOldPos );
 696
 697             if( !bPropExisted || ( eOldPos != ePos ))
 698             {
 699                 GetPropertySet()->setPropertyValue( C2U( "LabelPosition" ), uno::makeAny( ePos ));
 700                 bChangedOtherwise = true;
 701
 702                 //move the parallel axes to the other side if necessary
 703                 if( ePos==::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_START || ePos==::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_END )
 704                 {
 705                     Reference< beans::XPropertySet > xParallelAxis( AxisHelper::getParallelAxis( m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ), uno::UNO_QUERY );
 706                     if( xParallelAxis.is() )
 707                     {
 708                         ::com::sun::star::chart::ChartAxisLabelPosition eOtherPos;
 709                         if( xParallelAxis->getPropertyValue( C2U( "LabelPosition" ) ) >>= eOtherPos )
 710                         {
 711                             if( eOtherPos == ePos )
 712                             {
 713                                 ::com::sun::star::chart::ChartAxisLabelPosition eOppositePos =
 714                                     (ePos==::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_START)
 715                                     ? ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_END
 716                                     : ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_START;
 717                                 xParallelAxis->setPropertyValue( C2U( "LabelPosition" ), uno::makeAny( eOppositePos ));
 718                             }
 719                         }
 720                     }
 721                 }
 722             }
 723         }
 724         break;
 725
 726         case SCHATTR_AXIS_MARK_POSITION:
 727         {
 728             ::com::sun::star::chart::ChartAxisMarkPosition ePos =
 729                 (::com::sun::star::chart::ChartAxisMarkPosition)
 730                 static_cast< const SfxInt32Item & >( rItemSet.Get( nWhichId )).GetValue();
 731
 732             ::com::sun::star::chart::ChartAxisMarkPosition eOldPos( ::com::sun::star::chart::ChartAxisMarkPosition_AT_LABELS_AND_AXIS );
 733             bool bPropExisted = ( GetPropertySet()->getPropertyValue(C2U( "MarkPosition" )) >>= eOldPos );
 734
 735             if( !bPropExisted || ( eOldPos != ePos ))
 736             {
 737                 GetPropertySet()->setPropertyValue( C2U( "MarkPosition" ), uno::makeAny( ePos ));
 738                 bChangedOtherwise = true;
 739             }
 740         }
 741         break;
 742
 743         case SCHATTR_TEXT_DEGREES:
 744         {
 745             // convert int to double (divided by 100)
 746             double fVal = static_cast< double >(
 747                 static_cast< const SfxInt32Item & >(
 748                     rItemSet.Get( nWhichId )).GetValue()) / 100.0;
 749             double fOldVal = 0.0;
 750             bool bPropExisted =
 751                 ( GetPropertySet()->getPropertyValue( C2U( "TextRotation" )) >>= fOldVal );
 752
 753             if( ! bPropExisted ||
 754                 ( bPropExisted && fOldVal != fVal ))
 755             {
 756                 GetPropertySet()->setPropertyValue( C2U( "TextRotation" ), uno::makeAny( fVal ));
 757                 bChangedOtherwise = true;
 758             }
 759         }
 760         break;
 761
 762         case SID_ATTR_NUMBERFORMAT_VALUE:
 763 //         case SCHATTR_AXIS_NUMFMT:
 764         {
 765             if( m_pExplicitScale )
 766             {
 767                 bool bUseSourceFormat =
 768                     (static_cast< const SfxBoolItem & >(
 769                         rItemSet.Get( SID_ATTR_NUMBERFORMAT_SOURCE )).GetValue() );
 770
 771                 if( ! bUseSourceFormat )
 772                 {
 773                     sal_Int32 nFmt = static_cast< sal_Int32 >(
 774                         static_cast< const SfxUInt32Item & >(
 775                             rItemSet.Get( nWhichId )).GetValue());
 776
 777                     aValue = uno::makeAny(nFmt);
 778                     if( GetPropertySet()->getPropertyValue( C2U( "NumberFormat" )) != aValue )
 779                     {
 780                         GetPropertySet()->setPropertyValue( C2U( "NumberFormat" ), aValue );
 781                         bChangedOtherwise = true;
 782                     }
 783                 }
 784             }
 785         }
 786         break;
 787
 788         case SID_ATTR_NUMBERFORMAT_SOURCE:
 789         {
 790             bool bUseSourceFormat =
 791                 (static_cast< const SfxBoolItem & >(
 792                     rItemSet.Get( nWhichId )).GetValue() );
 793             bool bNumberFormatIsSet = ( GetPropertySet()->getPropertyValue( C2U( "NumberFormat" )).hasValue());
 794
 795             bChangedOtherwise = (bUseSourceFormat == bNumberFormatIsSet);
 796             if( bChangedOtherwise )
 797             {
 798                 if( ! bUseSourceFormat )
 799                 {
 800                     SfxItemState aState = rItemSet.GetItemState( SID_ATTR_NUMBERFORMAT_VALUE );
 801                     if( aState == SFX_ITEM_SET )
 802                     {
 803                         sal_Int32 nFormatKey = static_cast< sal_Int32 >(
 804                         static_cast< const SfxUInt32Item & >(
 805                             rItemSet.Get( SID_ATTR_NUMBERFORMAT_VALUE )).GetValue());
 806                         aValue <<= nFormatKey;
 807                     }
 808                     else
 809                     {
 810                         Reference< chart2::XCoordinateSystem > xCooSys(
 811                         AxisHelper::getCoordinateSystemOfAxis(
 812                               m_xAxis, ChartModelHelper::findDiagram( m_xChartDoc ) ) );
 813
 814                         sal_Int32 nFormatKey = ExplicitValueProvider::getExplicitNumberFormatKeyForAxis(
 815                             m_xAxis, xCooSys, Reference< util::XNumberFormatsSupplier >( m_xChartDoc, uno::UNO_QUERY ) );
 816
 817                         aValue <<= nFormatKey;
 818                     }
 819                 }
 820                 // else set a void Any
 821                 GetPropertySet()->setPropertyValue( C2U( "NumberFormat" ), aValue );
 822             }
 823         }
 824         break;
 825
 826         case SCHATTR_AXISTYPE:
 827         //don't allow to change the axis type so far
 828         break;
 829     }
 830
 831     if( bSetScale )
 832         m_xAxis->setScaleData( aScale );
 833
 834     return (bSetScale || bChangedOtherwise);
 835 }
 836
 837 } //  namespace wrapper
 838 } //  namespace chart