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