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_chart2.hxx" 26 #include <basegfx/numeric/ftools.hxx> 27 28 #include "VCartesianAxis.hxx" 29 #include "PlottingPositionHelper.hxx" 30 #include "ShapeFactory.hxx" 31 #include "CommonConverters.hxx" 32 #include "macros.hxx" 33 #include "ViewDefines.hxx" 34 #include "PropertyMapper.hxx" 35 #include "NumberFormatterWrapper.hxx" 36 #include "LabelPositionHelper.hxx" 37 #include "TrueGuard.hxx" 38 #include "BaseGFXHelper.hxx" 39 #include "AxisHelper.hxx" 40 #include "Tickmarks_Equidistant.hxx" 41 42 #include <rtl/math.hxx> 43 #include <tools/color.hxx> 44 #include <tools/debug.hxx> 45 #include <com/sun/star/text/XText.hpp> 46 #include <com/sun/star/text/WritingMode2.hpp> 47 #include <editeng/unoprnms.hxx> 48 #include <svx/unoshape.hxx> 49 #include <svx/unoshtxt.hxx> 50 51 #include <algorithm> 52 #include <memory> 53 54 //............................................................................. 55 namespace chart 56 { 57 //............................................................................. 58 using namespace ::com::sun::star; 59 using namespace ::com::sun::star::chart2; 60 using namespace ::rtl::math; 61 using ::com::sun::star::uno::Reference; 62 63 //----------------------------------------------------------------------------- 64 //----------------------------------------------------------------------------- 65 //----------------------------------------------------------------------------- 66 67 VCartesianAxis::VCartesianAxis( const AxisProperties& rAxisProperties 68 , const Reference< util::XNumberFormatsSupplier >& xNumberFormatsSupplier 69 , sal_Int32 nDimensionIndex, sal_Int32 nDimensionCount 70 , PlottingPositionHelper* pPosHelper )//takes ownership 71 : VAxisBase( nDimensionIndex, nDimensionCount, rAxisProperties, xNumberFormatsSupplier ) 72 { 73 if( pPosHelper ) 74 m_pPosHelper = pPosHelper; 75 else 76 m_pPosHelper = new PlottingPositionHelper(); 77 } 78 79 VCartesianAxis::~VCartesianAxis() 80 { 81 delete m_pPosHelper; 82 m_pPosHelper = NULL; 83 } 84 85 //----------------------------------------------------------------------------- 86 //----------------------------------------------------------------------------- 87 88 Reference< drawing::XShape > createSingleLabel( 89 const Reference< lang::XMultiServiceFactory>& xShapeFactory 90 , const Reference< drawing::XShapes >& xTarget 91 , const awt::Point& rAnchorScreenPosition2D 92 , const rtl::OUString& rLabel 93 , const AxisLabelProperties& rAxisLabelProperties 94 , const AxisProperties& rAxisProperties 95 , const tNameSequence& rPropNames 96 , const tAnySequence& rPropValues 97 ) 98 { 99 if( rLabel.isEmpty() ) 100 return 0; 101 102 // #i78696# use mathematically correct rotation now 103 const double fRotationAnglePi(rAxisLabelProperties.fRotationAngleDegree * (F_PI / -180.0)); 104 uno::Any aATransformation = ShapeFactory::makeTransformation( rAnchorScreenPosition2D, fRotationAnglePi ); 105 rtl::OUString aLabel = ShapeFactory::getStackedString( rLabel, rAxisLabelProperties.bStackCharacters ); 106 107 Reference< drawing::XShape > xShape2DText = ShapeFactory(xShapeFactory) 108 .createText( xTarget, aLabel, rPropNames, rPropValues, aATransformation ); 109 110 //correctPositionForRotation 111 LabelPositionHelper::correctPositionForRotation( xShape2DText 112 , rAxisProperties.m_aLabelAlignment, rAxisLabelProperties.fRotationAngleDegree, rAxisProperties.m_bComplexCategories ); 113 114 return xShape2DText; 115 } 116 117 bool lcl_doesShapeOverlapWithTickmark( const Reference< drawing::XShape >& xShape 118 , double fRotationAngleDegree 119 , const basegfx::B2DVector& rTickScreenPosition 120 , bool bIsHorizontalAxis, bool bIsVerticalAxis ) 121 { 122 if(!xShape.is()) 123 return false; 124 125 ::basegfx::B2IRectangle aShapeRect = BaseGFXHelper::makeRectangle(xShape->getPosition(),ShapeFactory::getSizeAfterRotation( xShape, fRotationAngleDegree )); 126 127 if( bIsVerticalAxis ) 128 { 129 return ( (rTickScreenPosition.getY() >= aShapeRect.getMinY()) 130 && (rTickScreenPosition.getY() <= aShapeRect.getMaxY()) ); 131 } 132 if( bIsHorizontalAxis ) 133 { 134 return ( (rTickScreenPosition.getX() >= aShapeRect.getMinX()) 135 && (rTickScreenPosition.getX() <= aShapeRect.getMaxX()) ); 136 } 137 138 basegfx::B2IVector aPosition( 139 static_cast<sal_Int32>( rTickScreenPosition.getX() ) 140 , static_cast<sal_Int32>( rTickScreenPosition.getY() ) ); 141 return aShapeRect.isInside(aPosition); 142 } 143 144 bool doesOverlap( const Reference< drawing::XShape >& xShape1 145 , const Reference< drawing::XShape >& xShape2 146 , double fRotationAngleDegree ) 147 { 148 if( !xShape1.is() || !xShape2.is() ) 149 return false; 150 151 ::basegfx::B2IRectangle aRect1( BaseGFXHelper::makeRectangle(xShape1->getPosition(),ShapeFactory::getSizeAfterRotation( xShape1, fRotationAngleDegree ))); 152 ::basegfx::B2IRectangle aRect2( BaseGFXHelper::makeRectangle(xShape2->getPosition(),ShapeFactory::getSizeAfterRotation( xShape2, fRotationAngleDegree ))); 153 return aRect1.overlaps(aRect2); 154 } 155 156 void removeShapesAtWrongRhythm( TickIter& rIter 157 , sal_Int32 nCorrectRhythm 158 , sal_Int32 nMaxTickToCheck 159 , const Reference< drawing::XShapes >& xTarget ) 160 { 161 sal_Int32 nTick = 0; 162 for( TickInfo* pTickInfo = rIter.firstInfo() 163 ; pTickInfo && nTick <= nMaxTickToCheck 164 ; pTickInfo = rIter.nextInfo(), nTick++ ) 165 { 166 //remove labels which does not fit into the rhythm 167 if( nTick%nCorrectRhythm != 0) 168 { 169 if(pTickInfo->xTextShape.is()) 170 { 171 xTarget->remove(pTickInfo->xTextShape); 172 pTickInfo->xTextShape = NULL; 173 } 174 } 175 } 176 } 177 178 class LabelIterator : public TickIter 179 { 180 //this Iterator iterates over existing text labels 181 182 //if the labels are staggered and bInnerLine is true 183 //we iterate only through the labels which are lying more inside the diagram 184 185 //if the labels are staggered and bInnerLine is false 186 //we iterate only through the labels which are lying more outside the diagram 187 188 //if the labels are not staggered 189 //we iterate through all labels 190 191 public: 192 LabelIterator( ::std::vector< TickInfo >& rTickInfoVector 193 , const AxisLabelStaggering eAxisLabelStaggering 194 , bool bInnerLine ); 195 196 virtual TickInfo* firstInfo(); 197 virtual TickInfo* nextInfo(); 198 199 private: //methods 200 LabelIterator(); 201 202 private: //member 203 PureTickIter m_aPureTickIter; 204 const AxisLabelStaggering m_eAxisLabelStaggering; 205 bool m_bInnerLine; 206 }; 207 208 LabelIterator::LabelIterator( ::std::vector< TickInfo >& rTickInfoVector 209 , const AxisLabelStaggering eAxisLabelStaggering 210 , bool bInnerLine ) 211 : m_aPureTickIter( rTickInfoVector ) 212 , m_eAxisLabelStaggering(eAxisLabelStaggering) 213 , m_bInnerLine(bInnerLine) 214 { 215 } 216 217 TickInfo* LabelIterator::firstInfo() 218 { 219 TickInfo* pTickInfo = m_aPureTickIter.firstInfo(); 220 while( pTickInfo && !pTickInfo->xTextShape.is() ) 221 pTickInfo = m_aPureTickIter.nextInfo(); 222 if(!pTickInfo) 223 return NULL; 224 if( (STAGGER_EVEN==m_eAxisLabelStaggering && m_bInnerLine) 225 || 226 (STAGGER_ODD==m_eAxisLabelStaggering && !m_bInnerLine) 227 ) 228 { 229 //skip first label 230 do 231 pTickInfo = m_aPureTickIter.nextInfo(); 232 while( pTickInfo && !pTickInfo->xTextShape.is() ); 233 } 234 if(!pTickInfo) 235 return NULL; 236 return pTickInfo; 237 } 238 239 TickInfo* LabelIterator::nextInfo() 240 { 241 TickInfo* pTickInfo = NULL; 242 //get next label 243 do 244 pTickInfo = m_aPureTickIter.nextInfo(); 245 while( pTickInfo && !pTickInfo->xTextShape.is() ); 246 247 if( STAGGER_EVEN==m_eAxisLabelStaggering 248 || STAGGER_ODD==m_eAxisLabelStaggering ) 249 { 250 //skip one label 251 do 252 pTickInfo = m_aPureTickIter.nextInfo(); 253 while( pTickInfo && !pTickInfo->xTextShape.is() ); 254 } 255 return pTickInfo; 256 } 257 258 B2DVector lcl_getLabelsDistance( TickIter& rIter, const B2DVector& rDistanceTickToText, double fRotationAngleDegree ) 259 { 260 //calculates the height or width of a line of labels 261 //thus a following line of labels can be shifted for that distance 262 263 B2DVector aRet(0,0); 264 265 sal_Int32 nDistanceTickToText = static_cast<sal_Int32>( rDistanceTickToText.getLength() ); 266 if( nDistanceTickToText==0.0) 267 return aRet; 268 269 B2DVector aStaggerDirection(rDistanceTickToText); 270 aStaggerDirection.normalize(); 271 272 sal_Int32 nDistance=0; 273 Reference< drawing::XShape > xShape2DText(NULL); 274 for( TickInfo* pTickInfo = rIter.firstInfo() 275 ; pTickInfo 276 ; pTickInfo = rIter.nextInfo() ) 277 { 278 xShape2DText = pTickInfo->xTextShape; 279 if( xShape2DText.is() ) 280 { 281 awt::Size aSize = ShapeFactory::getSizeAfterRotation( xShape2DText, fRotationAngleDegree ); 282 if(fabs(aStaggerDirection.getX())>fabs(aStaggerDirection.getY())) 283 nDistance = ::std::max(nDistance,aSize.Width); 284 else 285 nDistance = ::std::max(nDistance,aSize.Height); 286 } 287 } 288 289 aRet = aStaggerDirection*nDistance; 290 291 //add extra distance for vertical distance 292 if(fabs(aStaggerDirection.getX())>fabs(aStaggerDirection.getY())) 293 aRet += rDistanceTickToText; 294 295 return aRet; 296 } 297 298 void lcl_shiftLables( TickIter& rIter, const B2DVector& rStaggerDistance ) 299 { 300 if(rStaggerDistance.getLength()==0.0) 301 return; 302 Reference< drawing::XShape > xShape2DText(NULL); 303 for( TickInfo* pTickInfo = rIter.firstInfo() 304 ; pTickInfo 305 ; pTickInfo = rIter.nextInfo() ) 306 { 307 xShape2DText = pTickInfo->xTextShape; 308 if( xShape2DText.is() ) 309 { 310 awt::Point aPos = xShape2DText->getPosition(); 311 aPos.X += static_cast<sal_Int32>(rStaggerDistance.getX()); 312 aPos.Y += static_cast<sal_Int32>(rStaggerDistance.getY()); 313 xShape2DText->setPosition( aPos ); 314 } 315 } 316 } 317 318 bool lcl_hasWordBreak( const Reference< drawing::XShape >& rxShape ) 319 { 320 if ( rxShape.is() ) 321 { 322 SvxShape* pShape = SvxShape::getImplementation( rxShape ); 323 SvxShapeText* pShapeText = dynamic_cast< SvxShapeText* >( pShape ); 324 if ( pShapeText ) 325 { 326 SvxTextEditSource* pTextEditSource = dynamic_cast< SvxTextEditSource* >( pShapeText->GetEditSource() ); 327 if ( pTextEditSource ) 328 { 329 pTextEditSource->UpdateOutliner(); 330 SvxTextForwarder* pTextForwarder = pTextEditSource->GetTextForwarder(); 331 if ( pTextForwarder ) 332 { 333 sal_uInt16 nParaCount = pTextForwarder->GetParagraphCount(); 334 for ( sal_uInt16 nPara = 0; nPara < nParaCount; ++nPara ) 335 { 336 sal_uInt16 nLineCount = pTextForwarder->GetLineCount( nPara ); 337 for ( sal_uInt16 nLine = 0; nLine < nLineCount; ++nLine ) 338 { 339 sal_uInt16 nLineStart = 0; 340 sal_uInt16 nLineEnd = 0; 341 pTextForwarder->GetLineBoundaries( nLineStart, nLineEnd, nPara, nLine ); 342 sal_uInt16 nWordStart = 0; 343 sal_uInt16 nWordEnd = 0; 344 if ( pTextForwarder->GetWordIndices( nPara, nLineStart, nWordStart, nWordEnd ) && 345 ( nWordStart != nLineStart ) ) 346 { 347 return true; 348 } 349 } 350 } 351 } 352 } 353 } 354 } 355 356 return false; 357 } 358 359 class MaxLabelTickIter : public TickIter 360 { 361 //iterate over first two and last two labels and the longest label 362 public: 363 MaxLabelTickIter( ::std::vector< TickInfo >& rTickInfoVector 364 , sal_Int32 nLongestLabelIndex ); 365 virtual ~MaxLabelTickIter(); 366 367 virtual TickInfo* firstInfo(); 368 virtual TickInfo* nextInfo(); 369 370 private: 371 ::std::vector< TickInfo >& m_rTickInfoVector; 372 ::std::vector< sal_Int32 > m_aValidIndices; 373 sal_Int32 m_nCurrentIndex; 374 }; 375 376 MaxLabelTickIter::MaxLabelTickIter( ::std::vector< TickInfo >& rTickInfoVector 377 , sal_Int32 nLongestLabelIndex ) 378 : m_rTickInfoVector(rTickInfoVector) 379 , m_nCurrentIndex(0) 380 { 381 sal_Int32 nMaxIndex = m_rTickInfoVector.size()-1; 382 if( nLongestLabelIndex<0 || nLongestLabelIndex>=nMaxIndex-1 ) 383 nLongestLabelIndex = 0; 384 385 if( nMaxIndex>=0 ) 386 m_aValidIndices.push_back(0); 387 if( nMaxIndex>=1 ) 388 m_aValidIndices.push_back(1); 389 if( nLongestLabelIndex>1 ) 390 m_aValidIndices.push_back(nLongestLabelIndex); 391 if( nMaxIndex > 2 ) 392 m_aValidIndices.push_back(nMaxIndex-1); 393 if( nMaxIndex > 1 ) 394 m_aValidIndices.push_back(nMaxIndex); 395 } 396 MaxLabelTickIter::~MaxLabelTickIter() 397 { 398 } 399 400 TickInfo* MaxLabelTickIter::firstInfo() 401 { 402 m_nCurrentIndex = 0; 403 if( m_nCurrentIndex < static_cast<sal_Int32>(m_aValidIndices.size()) ) 404 return &m_rTickInfoVector[m_aValidIndices[m_nCurrentIndex]]; 405 return 0; 406 } 407 408 TickInfo* MaxLabelTickIter::nextInfo() 409 { 410 m_nCurrentIndex++; 411 if( m_nCurrentIndex>=0 && m_nCurrentIndex<static_cast<sal_Int32>(m_aValidIndices.size()) ) 412 return &m_rTickInfoVector[m_aValidIndices[m_nCurrentIndex]]; 413 return 0; 414 } 415 416 bool VCartesianAxis::isBreakOfLabelsAllowed( const AxisLabelProperties& rAxisLabelProperties 417 , bool bIsHorizontalAxis ) 418 { 419 if( m_aTextLabels.getLength() > 100 ) 420 return false; 421 if( !rAxisLabelProperties.bLineBreakAllowed ) 422 return false; 423 if( rAxisLabelProperties.bStackCharacters ) 424 return false; 425 //no break for value axis 426 if( !m_bUseTextLabels ) 427 return false; 428 if( !::rtl::math::approxEqual( rAxisLabelProperties.fRotationAngleDegree, 0.0 ) ) 429 return false; 430 //break only for horizontal axis 431 return bIsHorizontalAxis; 432 } 433 434 bool VCartesianAxis::isAutoStaggeringOfLabelsAllowed( const AxisLabelProperties& rAxisLabelProperties 435 , bool bIsHorizontalAxis, bool bIsVerticalAxis ) 436 { 437 if( rAxisLabelProperties.eStaggering != STAGGER_AUTO ) 438 return false; 439 if( rAxisLabelProperties.bOverlapAllowed ) 440 return false; 441 if( rAxisLabelProperties.bLineBreakAllowed ) //auto line break or auto staggering, doing both automatisms they may conflict... 442 return false; 443 if( !::rtl::math::approxEqual( rAxisLabelProperties.fRotationAngleDegree, 0.0 ) ) 444 return false; 445 //automatic staggering only for horizontal axis with horizontal text 446 //or vertical axis with vertical text 447 if( bIsHorizontalAxis ) 448 return !rAxisLabelProperties.bStackCharacters; 449 if( bIsVerticalAxis ) 450 return rAxisLabelProperties.bStackCharacters; 451 return false; 452 } 453 454 struct ComplexCategoryPlacement 455 { 456 rtl::OUString Text; 457 sal_Int32 Count; 458 double TickValue; 459 460 ComplexCategoryPlacement( const rtl::OUString& rText, sal_Int32 nCount, double fTickValue ) 461 : Text(rText), Count(nCount), TickValue(fTickValue) 462 {} 463 }; 464 465 void VCartesianAxis::createAllTickInfosFromComplexCategories( ::std::vector< ::std::vector< TickInfo > >& rAllTickInfos, bool bShiftedPosition ) 466 { 467 //no minor tickmarks will be generated! 468 //order is: inner labels first , outer labels last (that is different to all other TickIter cases) 469 if(!bShiftedPosition) 470 { 471 rAllTickInfos.clear(); 472 sal_Int32 nLevel=0; 473 sal_Int32 nLevelCount = m_aAxisProperties.m_pExplicitCategoriesProvider->getCategoryLevelCount(); 474 for( ; nLevel<nLevelCount; nLevel++ ) 475 { 476 ::std::vector< TickInfo > aTickInfoVector; 477 std::vector< ComplexCategory > aComplexCategories( m_aAxisProperties.m_pExplicitCategoriesProvider->getCategoriesByLevel( nLevel ) ); 478 sal_Int32 nCatIndex = 0; 479 std::vector< ComplexCategory >::const_iterator aIt(aComplexCategories.begin()); 480 std::vector< ComplexCategory >::const_iterator aEnd(aComplexCategories.end()); 481 for(;aIt!=aEnd;++aIt) 482 { 483 TickInfo aTickInfo(0); 484 ComplexCategory aCat(*aIt); 485 sal_Int32 nCount = aCat.Count; 486 if( nCatIndex + 1.0 + nCount >= m_aScale.Maximum ) 487 { 488 nCount = static_cast<sal_Int32>(m_aScale.Maximum - 1.0 - nCatIndex); 489 if( nCount <= 0 ) 490 nCount = 1; 491 } 492 aTickInfo.fScaledTickValue = nCatIndex + 1.0 + nCount/2.0; 493 aTickInfo.nFactorForLimitedTextWidth = nCount; 494 aTickInfo.aText = aCat.Text; 495 aTickInfoVector.push_back(aTickInfo); 496 nCatIndex += nCount; 497 if( nCatIndex + 1.0 >= m_aScale.Maximum ) 498 break; 499 } 500 rAllTickInfos.push_back(aTickInfoVector); 501 } 502 } 503 else //bShiftedPosition==false 504 { 505 rAllTickInfos.clear(); 506 sal_Int32 nLevel=0; 507 sal_Int32 nLevelCount = m_aAxisProperties.m_pExplicitCategoriesProvider->getCategoryLevelCount(); 508 for( ; nLevel<nLevelCount; nLevel++ ) 509 { 510 ::std::vector< TickInfo > aTickInfoVector; 511 std::vector< ComplexCategory > aComplexCategories( m_aAxisProperties.m_pExplicitCategoriesProvider->getCategoriesByLevel( nLevel ) ); 512 sal_Int32 nCatIndex = 0; 513 std::vector< ComplexCategory >::const_iterator aIt(aComplexCategories.begin()); 514 std::vector< ComplexCategory >::const_iterator aEnd(aComplexCategories.end()); 515 for(;aIt!=aEnd;++aIt) 516 { 517 TickInfo aTickInfo(0); 518 ComplexCategory aCat(*aIt); 519 aTickInfo.fScaledTickValue = nCatIndex + 1.0; 520 aTickInfoVector.push_back(aTickInfo); 521 nCatIndex += aCat.Count; 522 if( nCatIndex + 1.0 > m_aScale.Maximum ) 523 break; 524 } 525 //fill up with single ticks until maximum scale 526 while( nCatIndex + 1.0 < m_aScale.Maximum ) 527 { 528 TickInfo aTickInfo(0); 529 aTickInfo.fScaledTickValue = nCatIndex + 1.0; 530 aTickInfoVector.push_back(aTickInfo); 531 nCatIndex ++; 532 if( nLevel>0 ) 533 break; 534 } 535 //add an additional tick at the end 536 { 537 TickInfo aTickInfo(0); 538 aTickInfo.fScaledTickValue = m_aScale.Maximum; 539 aTickInfoVector.push_back(aTickInfo); 540 } 541 rAllTickInfos.push_back(aTickInfoVector); 542 } 543 } 544 } 545 546 void VCartesianAxis::createAllTickInfos( ::std::vector< ::std::vector< TickInfo > >& rAllTickInfos ) 547 { 548 if( isComplexCategoryAxis() ) 549 createAllTickInfosFromComplexCategories( rAllTickInfos, false ); 550 else 551 VAxisBase::createAllTickInfos(rAllTickInfos); 552 } 553 554 ::std::auto_ptr< TickIter > VCartesianAxis::createLabelTickIterator( sal_Int32 nTextLevel ) 555 { 556 if( nTextLevel>=0 && nTextLevel < static_cast< sal_Int32 >(m_aAllTickInfos.size()) ) 557 return ::std::auto_ptr< TickIter >( new PureTickIter( m_aAllTickInfos[nTextLevel] ) ); 558 return ::std::auto_ptr< TickIter >(); 559 } 560 ::std::auto_ptr< TickIter > VCartesianAxis::createMaximumLabelTickIterator( sal_Int32 nTextLevel ) 561 { 562 if( isComplexCategoryAxis() || isDateAxis() ) 563 { 564 return createLabelTickIterator( nTextLevel ); //mmmm maybe todo: create less than all texts here 565 } 566 else 567 { 568 if(nTextLevel==0) 569 { 570 if( !m_aAllTickInfos.empty() ) 571 { 572 sal_Int32 nLongestLabelIndex = m_bUseTextLabels ? this->getIndexOfLongestLabel( m_aTextLabels ) : 0; 573 return ::std::auto_ptr< TickIter >( new MaxLabelTickIter( m_aAllTickInfos[0], nLongestLabelIndex ) ); 574 } 575 } 576 } 577 return ::std::auto_ptr< TickIter >(); 578 } 579 580 sal_Int32 VCartesianAxis::getTextLevelCount() const 581 { 582 sal_Int32 nTextLevelCount = 1; 583 if( isComplexCategoryAxis() ) 584 nTextLevelCount = m_aAxisProperties.m_pExplicitCategoriesProvider->getCategoryLevelCount(); 585 return nTextLevelCount; 586 } 587 588 bool VCartesianAxis::createTextShapes( 589 const Reference< drawing::XShapes >& xTarget 590 , TickIter& rTickIter 591 , AxisLabelProperties& rAxisLabelProperties 592 , TickFactory_2D* pTickFactory 593 , sal_Int32 nScreenDistanceBetweenTicks ) 594 { 595 //returns true if the text shapes have been created successfully 596 //otherwise false - in this case the AxisLabelProperties have changed 597 //and contain new instructions for the next try for text shape creation 598 599 Reference< XScaling > xInverseScaling( NULL ); 600 if( m_aScale.Scaling.is() ) 601 xInverseScaling = m_aScale.Scaling->getInverseScaling(); 602 603 FixedNumberFormatter aFixedNumberFormatter( 604 m_xNumberFormatsSupplier, rAxisLabelProperties.nNumberFormatKey ); 605 606 const bool bIsHorizontalAxis = pTickFactory->isHorizontalAxis(); 607 const bool bIsVerticalAxis = pTickFactory->isVerticalAxis(); 608 bool bIsStaggered = rAxisLabelProperties.getIsStaggered(); 609 B2DVector aTextToTickDistance( pTickFactory->getDistanceAxisTickToText( m_aAxisProperties, true ) ); 610 sal_Int32 nLimitedSpaceForText = -1; 611 if( isBreakOfLabelsAllowed( rAxisLabelProperties, bIsHorizontalAxis ) ) 612 { 613 nLimitedSpaceForText = nScreenDistanceBetweenTicks; 614 if( bIsStaggered ) 615 nLimitedSpaceForText *= 2; 616 617 if( nLimitedSpaceForText > 0 ) 618 { //reduce space for a small amount to have a visible distance between the labels: 619 sal_Int32 nReduce = (nLimitedSpaceForText*5)/100; 620 if(!nReduce) 621 nReduce = 1; 622 nLimitedSpaceForText -= nReduce; 623 } 624 } 625 626 std::vector< ComplexCategoryPlacement > aComplexCategoryPlacements; 627 uno::Sequence< rtl::OUString >* pCategories = 0; 628 if( m_bUseTextLabels && !m_aAxisProperties.m_bComplexCategories ) 629 pCategories = &m_aTextLabels; 630 631 TickInfo* pPreviousVisibleTickInfo = NULL; 632 TickInfo* pPREPreviousVisibleTickInfo = NULL; 633 TickInfo* pLastVisibleNeighbourTickInfo = NULL; 634 635 //------------------------------------------------ 636 //prepare properties for multipropertyset-interface of shape 637 tNameSequence aPropNames; 638 tAnySequence aPropValues; 639 640 bool bLimitedHeight = fabs(aTextToTickDistance.getX()) > fabs(aTextToTickDistance.getY()); 641 Reference< beans::XPropertySet > xProps( m_aAxisProperties.m_xAxisModel, uno::UNO_QUERY ); 642 PropertyMapper::getTextLabelMultiPropertyLists( xProps, aPropNames, aPropValues, false 643 , nLimitedSpaceForText, bLimitedHeight ); 644 LabelPositionHelper::doDynamicFontResize( aPropValues, aPropNames, xProps 645 , m_aAxisLabelProperties.m_aFontReferenceSize ); 646 LabelPositionHelper::changeTextAdjustment( aPropValues, aPropNames, m_aAxisProperties.m_aLabelAlignment ); 647 648 uno::Any* pColorAny = PropertyMapper::getValuePointer(aPropValues,aPropNames,C2U("CharColor")); 649 sal_Int32 nColor = Color( COL_AUTO ).GetColor(); 650 if(pColorAny) 651 *pColorAny >>= nColor; 652 653 uno::Any* pLimitedSpaceAny = PropertyMapper::getValuePointerForLimitedSpace(aPropValues,aPropNames,bLimitedHeight); 654 //------------------------------------------------ 655 656 sal_Int32 nTick = 0; 657 for( TickInfo* pTickInfo = rTickIter.firstInfo() 658 ; pTickInfo 659 ; pTickInfo = rTickIter.nextInfo(), nTick++ ) 660 { 661 pLastVisibleNeighbourTickInfo = bIsStaggered ? 662 pPREPreviousVisibleTickInfo : pPreviousVisibleTickInfo; 663 664 //don't create labels which does not fit into the rhythm 665 if( nTick%rAxisLabelProperties.nRhythm != 0) 666 continue; 667 668 //don't create labels for invisible ticks 669 if( !pTickInfo->bPaintIt ) 670 continue; 671 672 //if NO OVERLAP -> don't create labels where the tick overlaps 673 //with the text of the last neighbour tickmark 674 if( pLastVisibleNeighbourTickInfo && !rAxisLabelProperties.bOverlapAllowed ) 675 { 676 if( lcl_doesShapeOverlapWithTickmark( pLastVisibleNeighbourTickInfo->xTextShape 677 , rAxisLabelProperties.fRotationAngleDegree 678 , pTickInfo->aTickScreenPosition 679 , bIsHorizontalAxis, bIsVerticalAxis ) ) 680 { 681 bool bOverlapAlsoAfterSwitchingOnAutoStaggering = true; 682 if( !bIsStaggered && isAutoStaggeringOfLabelsAllowed( rAxisLabelProperties, bIsHorizontalAxis, bIsVerticalAxis ) ) 683 { 684 bIsStaggered = true; 685 rAxisLabelProperties.eStaggering = STAGGER_EVEN; 686 pLastVisibleNeighbourTickInfo = pPREPreviousVisibleTickInfo; 687 if( !pLastVisibleNeighbourTickInfo || 688 !lcl_doesShapeOverlapWithTickmark( pLastVisibleNeighbourTickInfo->xTextShape 689 , rAxisLabelProperties.fRotationAngleDegree 690 , pTickInfo->aTickScreenPosition 691 , bIsHorizontalAxis, bIsVerticalAxis ) ) 692 bOverlapAlsoAfterSwitchingOnAutoStaggering = false; 693 } 694 if( bOverlapAlsoAfterSwitchingOnAutoStaggering ) 695 { 696 if( rAxisLabelProperties.bRhythmIsFix ) 697 continue; 698 rAxisLabelProperties.nRhythm++; 699 removeShapesAtWrongRhythm( rTickIter, rAxisLabelProperties.nRhythm, nTick, xTarget ); 700 return false; 701 } 702 } 703 } 704 705 //xxxxx pTickInfo->updateUnscaledValue( xInverseScaling ); 706 707 bool bHasExtraColor=false; 708 sal_Int32 nExtraColor=0; 709 710 rtl::OUString aLabel; 711 if(pCategories) 712 { 713 sal_Int32 nIndex = static_cast< sal_Int32 >(pTickInfo->getUnscaledTickValue()) - 1; //first category (index 0) matches with real number 1.0 714 if( nIndex>=0 && nIndex<pCategories->getLength() ) 715 aLabel = (*pCategories)[nIndex]; 716 } 717 else if( m_aAxisProperties.m_bComplexCategories ) 718 { 719 aLabel = pTickInfo->aText; 720 } 721 else 722 aLabel = aFixedNumberFormatter.getFormattedString( pTickInfo->getUnscaledTickValue(), nExtraColor, bHasExtraColor ); 723 724 if(pColorAny) 725 *pColorAny = uno::makeAny(bHasExtraColor?nExtraColor:nColor); 726 if(pLimitedSpaceAny) 727 *pLimitedSpaceAny = uno::makeAny(sal_Int32(nLimitedSpaceForText*pTickInfo->nFactorForLimitedTextWidth)); 728 729 B2DVector aTickScreenPos2D( pTickInfo->aTickScreenPosition ); 730 aTickScreenPos2D += aTextToTickDistance; 731 awt::Point aAnchorScreenPosition2D( 732 static_cast<sal_Int32>(aTickScreenPos2D.getX()) 733 ,static_cast<sal_Int32>(aTickScreenPos2D.getY())); 734 735 //create single label 736 if(!pTickInfo->xTextShape.is()) 737 pTickInfo->xTextShape = createSingleLabel( m_xShapeFactory, xTarget 738 , aAnchorScreenPosition2D, aLabel 739 , rAxisLabelProperties, m_aAxisProperties 740 , aPropNames, aPropValues ); 741 if(!pTickInfo->xTextShape.is()) 742 continue; 743 744 recordMaximumTextSize( pTickInfo->xTextShape, rAxisLabelProperties.fRotationAngleDegree ); 745 746 //better rotate if single words are broken apart 747 if( nLimitedSpaceForText>0 && !rAxisLabelProperties.bOverlapAllowed 748 && ::rtl::math::approxEqual( rAxisLabelProperties.fRotationAngleDegree, 0.0 ) 749 && m_aAxisProperties.m_bComplexCategories 750 && lcl_hasWordBreak( pTickInfo->xTextShape ) ) 751 { 752 rAxisLabelProperties.fRotationAngleDegree = 90; 753 rAxisLabelProperties.bLineBreakAllowed = false; 754 m_aAxisLabelProperties.fRotationAngleDegree = rAxisLabelProperties.fRotationAngleDegree; 755 removeTextShapesFromTicks(); 756 return false; 757 } 758 759 //if NO OVERLAP -> remove overlapping shapes 760 if( pLastVisibleNeighbourTickInfo && !rAxisLabelProperties.bOverlapAllowed ) 761 { 762 if( doesOverlap( pLastVisibleNeighbourTickInfo->xTextShape, pTickInfo->xTextShape, rAxisLabelProperties.fRotationAngleDegree ) ) 763 { 764 bool bOverlapAlsoAfterSwitchingOnAutoStaggering = true; 765 if( !bIsStaggered && isAutoStaggeringOfLabelsAllowed( rAxisLabelProperties, bIsHorizontalAxis, bIsVerticalAxis ) ) 766 { 767 bIsStaggered = true; 768 rAxisLabelProperties.eStaggering = STAGGER_EVEN; 769 pLastVisibleNeighbourTickInfo = pPREPreviousVisibleTickInfo; 770 if( !pLastVisibleNeighbourTickInfo || 771 !lcl_doesShapeOverlapWithTickmark( pLastVisibleNeighbourTickInfo->xTextShape 772 , rAxisLabelProperties.fRotationAngleDegree 773 , pTickInfo->aTickScreenPosition 774 , bIsHorizontalAxis, bIsVerticalAxis ) ) 775 bOverlapAlsoAfterSwitchingOnAutoStaggering = false; 776 } 777 if( bOverlapAlsoAfterSwitchingOnAutoStaggering ) 778 { 779 if( rAxisLabelProperties.bRhythmIsFix ) 780 { 781 xTarget->remove(pTickInfo->xTextShape); 782 pTickInfo->xTextShape = NULL; 783 continue; 784 } 785 rAxisLabelProperties.nRhythm++; 786 removeShapesAtWrongRhythm( rTickIter, rAxisLabelProperties.nRhythm, nTick, xTarget ); 787 return false; 788 } 789 } 790 } 791 792 pPREPreviousVisibleTickInfo = pPreviousVisibleTickInfo; 793 pPreviousVisibleTickInfo = pTickInfo; 794 } 795 return true; 796 } 797 798 drawing::PointSequenceSequence lcl_makePointSequence( B2DVector& rStart, B2DVector& rEnd ) 799 { 800 drawing::PointSequenceSequence aPoints(1); 801 aPoints[0].realloc(2); 802 aPoints[0][0].X = static_cast<sal_Int32>(rStart.getX()); 803 aPoints[0][0].Y = static_cast<sal_Int32>(rStart.getY()); 804 aPoints[0][1].X = static_cast<sal_Int32>(rEnd.getX()); 805 aPoints[0][1].Y = static_cast<sal_Int32>(rEnd.getY()); 806 return aPoints; 807 } 808 809 double VCartesianAxis::getLogicValueWhereMainLineCrossesOtherAxis() const 810 { 811 double fMin = (m_nDimensionIndex==1) ? m_pPosHelper->getLogicMinX() : m_pPosHelper->getLogicMinY(); 812 double fMax = (m_nDimensionIndex==1) ? m_pPosHelper->getLogicMaxX() : m_pPosHelper->getLogicMaxY(); 813 814 double fCrossesOtherAxis; 815 if(m_aAxisProperties.m_pfMainLinePositionAtOtherAxis) 816 fCrossesOtherAxis = *m_aAxisProperties.m_pfMainLinePositionAtOtherAxis; 817 else 818 { 819 if( ::com::sun::star::chart::ChartAxisPosition_END == m_aAxisProperties.m_eCrossoverType ) 820 fCrossesOtherAxis = fMax; 821 else 822 fCrossesOtherAxis = fMin; 823 } 824 return fCrossesOtherAxis; 825 } 826 827 double VCartesianAxis::getLogicValueWhereLabelLineCrossesOtherAxis() const 828 { 829 double fMin = (m_nDimensionIndex==1) ? m_pPosHelper->getLogicMinX() : m_pPosHelper->getLogicMinY(); 830 double fMax = (m_nDimensionIndex==1) ? m_pPosHelper->getLogicMaxX() : m_pPosHelper->getLogicMaxY(); 831 832 double fCrossesOtherAxis; 833 if( ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_START == m_aAxisProperties.m_eLabelPos ) 834 fCrossesOtherAxis = fMin; 835 else if( ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_END == m_aAxisProperties.m_eLabelPos ) 836 fCrossesOtherAxis = fMax; 837 else 838 fCrossesOtherAxis = getLogicValueWhereMainLineCrossesOtherAxis(); 839 return fCrossesOtherAxis; 840 } 841 842 bool VCartesianAxis::getLogicValueWhereExtraLineCrossesOtherAxis( double& fCrossesOtherAxis ) const 843 { 844 if( !m_aAxisProperties.m_pfExrtaLinePositionAtOtherAxis ) 845 return false; 846 double fMin = (m_nDimensionIndex==1) ? m_pPosHelper->getLogicMinX() : m_pPosHelper->getLogicMinY(); 847 double fMax = (m_nDimensionIndex==1) ? m_pPosHelper->getLogicMaxX() : m_pPosHelper->getLogicMaxY(); 848 if( *m_aAxisProperties.m_pfExrtaLinePositionAtOtherAxis <= fMin 849 || *m_aAxisProperties.m_pfExrtaLinePositionAtOtherAxis >= fMax ) 850 return false; 851 fCrossesOtherAxis = *m_aAxisProperties.m_pfExrtaLinePositionAtOtherAxis; 852 return true; 853 } 854 855 B2DVector VCartesianAxis::getScreenPosition( double fLogicX, double fLogicY, double fLogicZ ) const 856 { 857 B2DVector aRet(0,0); 858 859 if( m_pPosHelper ) 860 { 861 drawing::Position3D aScenePos = m_pPosHelper->transformLogicToScene( fLogicX, fLogicY, fLogicZ, true ); 862 if(3==m_nDimension) 863 { 864 if( m_xLogicTarget.is() && m_pPosHelper && m_pShapeFactory ) 865 { 866 tPropertyNameMap aDummyPropertyNameMap; 867 Reference< drawing::XShape > xShape3DAnchor = m_pShapeFactory->createCube( m_xLogicTarget 868 , aScenePos,drawing::Direction3D(1,1,1), 0, 0, aDummyPropertyNameMap); 869 awt::Point a2DPos = xShape3DAnchor->getPosition(); //get 2D position from xShape3DAnchor 870 m_xLogicTarget->remove(xShape3DAnchor); 871 aRet.setX( a2DPos.X ); 872 aRet.setY( a2DPos.Y ); 873 } 874 else 875 { 876 DBG_ERROR("cannot calculate scrren position in VCartesianAxis::getScreenPosition"); 877 } 878 } 879 else 880 { 881 aRet.setX( aScenePos.PositionX ); 882 aRet.setY( aScenePos.PositionY ); 883 } 884 } 885 886 return aRet; 887 } 888 889 VCartesianAxis::ScreenPosAndLogicPos VCartesianAxis::getScreenPosAndLogicPos( double fLogicX_, double fLogicY_, double fLogicZ_ ) const 890 { 891 ScreenPosAndLogicPos aRet; 892 aRet.fLogicX = fLogicX_; 893 aRet.fLogicY = fLogicY_; 894 aRet.fLogicZ = fLogicZ_; 895 aRet.aScreenPos = getScreenPosition( fLogicX_, fLogicY_, fLogicZ_ ); 896 return aRet; 897 } 898 899 typedef ::std::vector< VCartesianAxis::ScreenPosAndLogicPos > tScreenPosAndLogicPosList; 900 struct lcl_LessXPos : ::std::binary_function< VCartesianAxis::ScreenPosAndLogicPos, VCartesianAxis::ScreenPosAndLogicPos, bool > 901 { 902 inline bool operator() ( const VCartesianAxis::ScreenPosAndLogicPos& rPos1, const VCartesianAxis::ScreenPosAndLogicPos& rPos2 ) 903 { 904 return ( rPos1.aScreenPos.getX() < rPos2.aScreenPos.getX() ); 905 } 906 }; 907 908 struct lcl_GreaterYPos : ::std::binary_function< VCartesianAxis::ScreenPosAndLogicPos, VCartesianAxis::ScreenPosAndLogicPos, bool > 909 { 910 inline bool operator() ( const VCartesianAxis::ScreenPosAndLogicPos& rPos1, const VCartesianAxis::ScreenPosAndLogicPos& rPos2 ) 911 { 912 return ( rPos1.aScreenPos.getY() > rPos2.aScreenPos.getY() ); 913 } 914 }; 915 916 void VCartesianAxis::get2DAxisMainLine( B2DVector& rStart, B2DVector& rEnd, double fCrossesOtherAxis ) 917 { 918 //m_aAxisProperties might get updated and changed here because 919 // the label alignmant and inner direction sign depends exactly of the choice of the axis line position which is made here in this method 920 921 double fMinX = m_pPosHelper->getLogicMinX(); 922 double fMinY = m_pPosHelper->getLogicMinY(); 923 double fMinZ = m_pPosHelper->getLogicMinZ(); 924 double fMaxX = m_pPosHelper->getLogicMaxX(); 925 double fMaxY = m_pPosHelper->getLogicMaxY(); 926 double fMaxZ = m_pPosHelper->getLogicMaxZ(); 927 928 double fXStart = fMinX; 929 double fYStart = fMinY; 930 double fZStart = fMinZ; 931 double fXEnd = fXStart; 932 double fYEnd = fYStart; 933 double fZEnd = fZStart; 934 935 double fXOnXPlane = fMinX; 936 double fXOther = fMaxX; 937 int nDifferentValue = !m_pPosHelper->isMathematicalOrientationX() ? -1 : 1; 938 if( !m_pPosHelper->isSwapXAndY() ) 939 nDifferentValue *= (CuboidPlanePosition_Left != m_eLeftWallPos) ? -1 : 1; 940 else 941 nDifferentValue *= (CuboidPlanePosition_Bottom != m_eBottomPos) ? -1 : 1; 942 if( nDifferentValue<0 ) 943 { 944 fXOnXPlane = fMaxX; 945 fXOther = fMinX; 946 } 947 948 double fYOnYPlane = fMinY; 949 double fYOther = fMaxY; 950 nDifferentValue = !m_pPosHelper->isMathematicalOrientationY() ? -1 : 1; 951 if( !m_pPosHelper->isSwapXAndY() ) 952 nDifferentValue *= (CuboidPlanePosition_Bottom != m_eBottomPos) ? -1 : 1; 953 else 954 nDifferentValue *= (CuboidPlanePosition_Left != m_eLeftWallPos) ? -1 : 1; 955 if( nDifferentValue<0 ) 956 { 957 fYOnYPlane = fMaxY; 958 fYOther = fMinY; 959 } 960 961 double fZOnZPlane = fMaxZ; 962 double fZOther = fMinZ; 963 nDifferentValue = !m_pPosHelper->isMathematicalOrientationZ() ? -1 : 1; 964 nDifferentValue *= (CuboidPlanePosition_Back != m_eBackWallPos) ? -1 : 1; 965 if( nDifferentValue<0 ) 966 { 967 fZOnZPlane = fMinZ; 968 fZOther = fMaxZ; 969 } 970 971 if( 0==m_nDimensionIndex ) //x-axis 972 { 973 if( fCrossesOtherAxis < fMinY ) 974 fCrossesOtherAxis = fMinY; 975 else if( fCrossesOtherAxis > fMaxY ) 976 fCrossesOtherAxis = fMaxY; 977 978 fYStart = fYEnd = fCrossesOtherAxis; 979 fXEnd=m_pPosHelper->getLogicMaxX(); 980 981 if(3==m_nDimension) 982 { 983 if( AxisHelper::isAxisPositioningEnabled() ) 984 { 985 if( ::rtl::math::approxEqual( fYOther, fYStart) ) 986 fZStart = fZEnd = fZOnZPlane; 987 else 988 fZStart = fZEnd = fZOther; 989 } 990 else 991 { 992 rStart = getScreenPosition( fXStart, fYStart, fZStart ); 993 rEnd = getScreenPosition( fXEnd, fYEnd, fZEnd ); 994 995 double fDeltaX = rEnd.getX() - rStart.getX(); 996 double fDeltaY = rEnd.getY() - rStart.getY(); 997 998 //only those points are candidates which are lying on exactly one wall as these are outer edges 999 tScreenPosAndLogicPosList aPosList; 1000 aPosList.push_back( getScreenPosAndLogicPos( fMinX, fYOnYPlane, fZOther ) ); 1001 aPosList.push_back( getScreenPosAndLogicPos( fMinX, fYOther, fZOnZPlane ) ); 1002 1003 if( fabs(fDeltaY) > fabs(fDeltaX) ) 1004 { 1005 m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_LEFT; 1006 //choose most left positions 1007 ::std::sort( aPosList.begin(), aPosList.end(), lcl_LessXPos() ); 1008 m_aAxisProperties.m_fLabelDirectionSign = fDeltaY<0 ? -1 : 1; 1009 } 1010 else 1011 { 1012 m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_BOTTOM; 1013 //choose most bottom positions 1014 ::std::sort( aPosList.begin(), aPosList.end(), lcl_GreaterYPos() ); 1015 m_aAxisProperties.m_fLabelDirectionSign = fDeltaX<0 ? -1 : 1; 1016 } 1017 ScreenPosAndLogicPos aBestPos( aPosList[0] ); 1018 fYStart = fYEnd = aBestPos.fLogicY; 1019 fZStart = fZEnd = aBestPos.fLogicZ; 1020 if( !m_pPosHelper->isMathematicalOrientationX() ) 1021 m_aAxisProperties.m_fLabelDirectionSign *= -1; 1022 } 1023 }//end 3D x axis 1024 } 1025 else if( 1==m_nDimensionIndex ) //y-axis 1026 { 1027 if( fCrossesOtherAxis < fMinX ) 1028 fCrossesOtherAxis = fMinX; 1029 else if( fCrossesOtherAxis > fMaxX ) 1030 fCrossesOtherAxis = fMaxX; 1031 1032 fXStart = fXEnd = fCrossesOtherAxis; 1033 fYEnd=m_pPosHelper->getLogicMaxY(); 1034 1035 if(3==m_nDimension) 1036 { 1037 if( AxisHelper::isAxisPositioningEnabled() ) 1038 { 1039 if( ::rtl::math::approxEqual( fXOther, fXStart) ) 1040 fZStart = fZEnd = fZOnZPlane; 1041 else 1042 fZStart = fZEnd = fZOther; 1043 } 1044 else 1045 { 1046 rStart = getScreenPosition( fXStart, fYStart, fZStart ); 1047 rEnd = getScreenPosition( fXEnd, fYEnd, fZEnd ); 1048 1049 double fDeltaX = rEnd.getX() - rStart.getX(); 1050 double fDeltaY = rEnd.getY() - rStart.getY(); 1051 1052 //only those points are candidates which are lying on exactly one wall as these are outer edges 1053 tScreenPosAndLogicPosList aPosList; 1054 aPosList.push_back( getScreenPosAndLogicPos( fXOnXPlane, fMinY, fZOther ) ); 1055 aPosList.push_back( getScreenPosAndLogicPos( fXOther, fMinY, fZOnZPlane ) ); 1056 1057 if( fabs(fDeltaY) > fabs(fDeltaX) ) 1058 { 1059 m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_LEFT; 1060 //choose most left positions 1061 ::std::sort( aPosList.begin(), aPosList.end(), lcl_LessXPos() ); 1062 m_aAxisProperties.m_fLabelDirectionSign = fDeltaY<0 ? -1 : 1; 1063 } 1064 else 1065 { 1066 m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_BOTTOM; 1067 //choose most bottom positions 1068 ::std::sort( aPosList.begin(), aPosList.end(), lcl_GreaterYPos() ); 1069 m_aAxisProperties.m_fLabelDirectionSign = fDeltaX<0 ? -1 : 1; 1070 } 1071 ScreenPosAndLogicPos aBestPos( aPosList[0] ); 1072 fXStart = fXEnd = aBestPos.fLogicX; 1073 fZStart = fZEnd = aBestPos.fLogicZ; 1074 if( !m_pPosHelper->isMathematicalOrientationY() ) 1075 m_aAxisProperties.m_fLabelDirectionSign *= -1; 1076 } 1077 }//end 3D y axis 1078 } 1079 else //z-axis 1080 { 1081 fZEnd = m_pPosHelper->getLogicMaxZ(); 1082 if( AxisHelper::isAxisPositioningEnabled() ) 1083 { 1084 if( !m_aAxisProperties.m_bSwapXAndY ) 1085 { 1086 if( fCrossesOtherAxis < fMinY ) 1087 fCrossesOtherAxis = fMinY; 1088 else if( fCrossesOtherAxis > fMaxY ) 1089 fCrossesOtherAxis = fMaxY; 1090 fYStart = fYEnd = fCrossesOtherAxis; 1091 1092 if( ::rtl::math::approxEqual( fYOther, fYStart) ) 1093 fXStart = fXEnd = fXOnXPlane; 1094 else 1095 fXStart = fXEnd = fXOther; 1096 } 1097 else 1098 { 1099 if( fCrossesOtherAxis < fMinX ) 1100 fCrossesOtherAxis = fMinX; 1101 else if( fCrossesOtherAxis > fMaxX ) 1102 fCrossesOtherAxis = fMaxX; 1103 fXStart = fXEnd = fCrossesOtherAxis; 1104 1105 if( ::rtl::math::approxEqual( fXOther, fXStart) ) 1106 fYStart = fYEnd = fYOnYPlane; 1107 else 1108 fYStart = fYEnd = fYOther; 1109 } 1110 } 1111 else 1112 { 1113 if( !m_pPosHelper->isSwapXAndY() ) 1114 { 1115 fXStart = fXEnd = m_pPosHelper->isMathematicalOrientationX() ? m_pPosHelper->getLogicMaxX() : m_pPosHelper->getLogicMinX(); 1116 fYStart = fYEnd = m_pPosHelper->isMathematicalOrientationY() ? m_pPosHelper->getLogicMinY() : m_pPosHelper->getLogicMaxY(); 1117 } 1118 else 1119 { 1120 fXStart = fXEnd = m_pPosHelper->isMathematicalOrientationX() ? m_pPosHelper->getLogicMinX() : m_pPosHelper->getLogicMaxX(); 1121 fYStart = fYEnd = m_pPosHelper->isMathematicalOrientationY() ? m_pPosHelper->getLogicMaxY() : m_pPosHelper->getLogicMinY(); 1122 } 1123 1124 if(3==m_nDimension) 1125 { 1126 rStart = getScreenPosition( fXStart, fYStart, fZStart ); 1127 rEnd = getScreenPosition( fXEnd, fYEnd, fZEnd ); 1128 1129 double fDeltaX = rEnd.getX() - rStart.getX(); 1130 1131 //only those points are candidates which are lying on exactly one wall as these are outer edges 1132 tScreenPosAndLogicPosList aPosList; 1133 aPosList.push_back( getScreenPosAndLogicPos( fXOther, fYOnYPlane, fMinZ ) ); 1134 aPosList.push_back( getScreenPosAndLogicPos( fXOnXPlane, fYOther, fMinZ ) ); 1135 1136 ::std::sort( aPosList.begin(), aPosList.end(), lcl_GreaterYPos() ); 1137 ScreenPosAndLogicPos aBestPos( aPosList[0] ); 1138 ScreenPosAndLogicPos aNotSoGoodPos( aPosList[1] ); 1139 1140 //choose most bottom positions 1141 if( !::rtl::math::approxEqual( fDeltaX, 0.0 ) ) // prefere left-right algnments 1142 { 1143 if( aBestPos.aScreenPos.getX() > aNotSoGoodPos.aScreenPos.getX() ) 1144 m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_RIGHT; 1145 else 1146 m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_LEFT; 1147 } 1148 else 1149 { 1150 if( aBestPos.aScreenPos.getY() > aNotSoGoodPos.aScreenPos.getY() ) 1151 m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_BOTTOM; 1152 else 1153 m_aAxisProperties.m_aLabelAlignment = LABEL_ALIGN_TOP; 1154 } 1155 1156 m_aAxisProperties.m_fLabelDirectionSign = fDeltaX<0 ? -1 : 1; 1157 if( !m_pPosHelper->isMathematicalOrientationZ() ) 1158 m_aAxisProperties.m_fLabelDirectionSign *= -1; 1159 1160 fXStart = fXEnd = aBestPos.fLogicX; 1161 fYStart = fYEnd = aBestPos.fLogicY; 1162 } 1163 }//end 3D z axis 1164 } 1165 1166 rStart = getScreenPosition( fXStart, fYStart, fZStart ); 1167 rEnd = getScreenPosition( fXEnd, fYEnd, fZEnd ); 1168 1169 if(3==m_nDimension && !AxisHelper::isAxisPositioningEnabled() ) 1170 m_aAxisProperties.m_fInnerDirectionSign = m_aAxisProperties.m_fLabelDirectionSign;//to behave like before 1171 1172 if(3==m_nDimension && AxisHelper::isAxisPositioningEnabled() ) 1173 { 1174 double fDeltaX = rEnd.getX() - rStart.getX(); 1175 double fDeltaY = rEnd.getY() - rStart.getY(); 1176 1177 if( 2==m_nDimensionIndex ) 1178 { 1179 if( m_eLeftWallPos != CuboidPlanePosition_Left ) 1180 { 1181 m_aAxisProperties.m_fLabelDirectionSign *= -1.0; 1182 m_aAxisProperties.m_fInnerDirectionSign *= -1.0; 1183 } 1184 1185 m_aAxisProperties.m_aLabelAlignment = 1186 ( m_aAxisProperties.m_fLabelDirectionSign<0 ) ? 1187 LABEL_ALIGN_LEFT : LABEL_ALIGN_RIGHT; 1188 1189 if( ( fDeltaY<0 && m_aScale.Orientation == AxisOrientation_REVERSE ) || 1190 ( fDeltaY>0 && m_aScale.Orientation == AxisOrientation_MATHEMATICAL ) ) 1191 m_aAxisProperties.m_aLabelAlignment = 1192 ( m_aAxisProperties.m_aLabelAlignment==LABEL_ALIGN_RIGHT ) ? 1193 LABEL_ALIGN_LEFT : LABEL_ALIGN_RIGHT; 1194 } 1195 else if( fabs(fDeltaY) > fabs(fDeltaX) ) 1196 { 1197 if( m_eBackWallPos != CuboidPlanePosition_Back ) 1198 { 1199 m_aAxisProperties.m_fLabelDirectionSign *= -1.0; 1200 m_aAxisProperties.m_fInnerDirectionSign *= -1.0; 1201 } 1202 1203 m_aAxisProperties.m_aLabelAlignment = 1204 ( m_aAxisProperties.m_fLabelDirectionSign<0 ) ? 1205 LABEL_ALIGN_LEFT : LABEL_ALIGN_RIGHT; 1206 1207 if( ( fDeltaY<0 && m_aScale.Orientation == AxisOrientation_REVERSE ) || 1208 ( fDeltaY>0 && m_aScale.Orientation == AxisOrientation_MATHEMATICAL ) ) 1209 m_aAxisProperties.m_aLabelAlignment = 1210 ( m_aAxisProperties.m_aLabelAlignment==LABEL_ALIGN_RIGHT ) ? 1211 LABEL_ALIGN_LEFT : LABEL_ALIGN_RIGHT; 1212 } 1213 else 1214 { 1215 if( m_eBackWallPos != CuboidPlanePosition_Back ) 1216 { 1217 m_aAxisProperties.m_fLabelDirectionSign *= -1.0; 1218 m_aAxisProperties.m_fInnerDirectionSign *= -1.0; 1219 } 1220 1221 m_aAxisProperties.m_aLabelAlignment = 1222 ( m_aAxisProperties.m_fLabelDirectionSign<0 ) ? 1223 LABEL_ALIGN_TOP : LABEL_ALIGN_BOTTOM; 1224 1225 if( ( fDeltaX>0 && m_aScale.Orientation == AxisOrientation_REVERSE ) || 1226 ( fDeltaX<0 && m_aScale.Orientation == AxisOrientation_MATHEMATICAL ) ) 1227 m_aAxisProperties.m_aLabelAlignment = 1228 ( m_aAxisProperties.m_aLabelAlignment==LABEL_ALIGN_TOP ) ? 1229 LABEL_ALIGN_BOTTOM : LABEL_ALIGN_TOP; 1230 } 1231 } 1232 } 1233 1234 TickFactory* VCartesianAxis::createTickFactory() 1235 { 1236 return createTickFactory2D(); 1237 } 1238 1239 TickFactory_2D* VCartesianAxis::createTickFactory2D() 1240 { 1241 B2DVector aStart, aEnd; 1242 this->get2DAxisMainLine( aStart, aEnd, this->getLogicValueWhereMainLineCrossesOtherAxis() ); 1243 1244 B2DVector aLabelLineStart, aLabelLineEnd; 1245 this->get2DAxisMainLine( aLabelLineStart, aLabelLineEnd, this->getLogicValueWhereLabelLineCrossesOtherAxis() ); 1246 1247 return new TickFactory_2D( m_aScale, m_aIncrement, aStart, aEnd, aLabelLineStart-aStart ); 1248 } 1249 1250 void lcl_hideIdenticalScreenValues( TickIter& rTickIter ) 1251 { 1252 TickInfo* pPreviousTickInfo = rTickIter.firstInfo(); 1253 if(!pPreviousTickInfo) 1254 return; 1255 pPreviousTickInfo->bPaintIt = true; 1256 for( TickInfo* pTickInfo = rTickIter.nextInfo(); pTickInfo; pTickInfo = rTickIter.nextInfo()) 1257 { 1258 pTickInfo->bPaintIt = 1259 ( static_cast<sal_Int32>(pTickInfo->aTickScreenPosition.getX()) 1260 != static_cast<sal_Int32>(pPreviousTickInfo->aTickScreenPosition.getX()) ) 1261 || 1262 ( static_cast<sal_Int32>(pTickInfo->aTickScreenPosition.getY()) 1263 != static_cast<sal_Int32>(pPreviousTickInfo->aTickScreenPosition.getY()) ); 1264 pPreviousTickInfo = pTickInfo; 1265 } 1266 } 1267 1268 //'hide' tickmarks with identical screen values in aAllTickInfos 1269 void VCartesianAxis::hideIdenticalScreenValues( ::std::vector< ::std::vector< TickInfo > >& rTickInfos ) const 1270 { 1271 if( isComplexCategoryAxis() || isDateAxis() ) 1272 { 1273 sal_Int32 nCount = rTickInfos.size(); 1274 for( sal_Int32 nN=0; nN<nCount; nN++ ) 1275 { 1276 PureTickIter aTickIter( rTickInfos[nN] ); 1277 lcl_hideIdenticalScreenValues( aTickIter ); 1278 } 1279 } 1280 else 1281 { 1282 EquidistantTickIter aTickIter( rTickInfos, m_aIncrement, 0, -1 ); 1283 lcl_hideIdenticalScreenValues( aTickIter ); 1284 } 1285 } 1286 1287 sal_Int32 VCartesianAxis::estimateMaximumAutoMainIncrementCount() 1288 { 1289 sal_Int32 nRet = 10; 1290 1291 if( m_nMaximumTextWidthSoFar==0 && m_nMaximumTextHeightSoFar==0 ) 1292 return nRet; 1293 1294 B2DVector aStart, aEnd; 1295 this->get2DAxisMainLine( aStart, aEnd, this->getLogicValueWhereMainLineCrossesOtherAxis() ); 1296 1297 sal_Int32 nMaxHeight = static_cast<sal_Int32>(fabs(aEnd.getY()-aStart.getY())); 1298 sal_Int32 nMaxWidth = static_cast<sal_Int32>(fabs(aEnd.getX()-aStart.getX())); 1299 1300 sal_Int32 nTotalAvailable = nMaxHeight; 1301 sal_Int32 nSingleNeeded = m_nMaximumTextHeightSoFar; 1302 1303 //for horizontal axis: 1304 if( (m_nDimensionIndex == 0 && !m_aAxisProperties.m_bSwapXAndY) 1305 || (m_nDimensionIndex == 1 && m_aAxisProperties.m_bSwapXAndY) ) 1306 { 1307 nTotalAvailable = nMaxWidth; 1308 nSingleNeeded = m_nMaximumTextWidthSoFar; 1309 } 1310 1311 if( nSingleNeeded>0 ) 1312 nRet = nTotalAvailable/nSingleNeeded; 1313 1314 return nRet; 1315 } 1316 1317 void VCartesianAxis::doStaggeringOfLabels( const AxisLabelProperties& rAxisLabelProperties, TickFactory_2D* pTickFactory2D ) 1318 { 1319 if( !pTickFactory2D ) 1320 return; 1321 1322 if( isComplexCategoryAxis() ) 1323 { 1324 sal_Int32 nTextLevelCount = getTextLevelCount(); 1325 B2DVector aCummulatedLabelsDistance(0,0); 1326 for( sal_Int32 nTextLevel=0; nTextLevel<nTextLevelCount; nTextLevel++ ) 1327 { 1328 ::std::auto_ptr< TickIter > apTickIter = createLabelTickIterator( nTextLevel ); 1329 if(apTickIter.get()) 1330 { 1331 double fRotationAngleDegree = m_aAxisLabelProperties.fRotationAngleDegree; 1332 if( nTextLevel>0 ) 1333 { 1334 lcl_shiftLables( *apTickIter.get(), aCummulatedLabelsDistance ); 1335 fRotationAngleDegree = 0.0; 1336 } 1337 aCummulatedLabelsDistance += lcl_getLabelsDistance( *apTickIter.get() 1338 , pTickFactory2D->getDistanceAxisTickToText( m_aAxisProperties ) 1339 , fRotationAngleDegree ); 1340 } 1341 } 1342 } 1343 else if( rAxisLabelProperties.getIsStaggered() ) 1344 { 1345 if( !m_aAllTickInfos.empty() ) 1346 { 1347 LabelIterator aInnerIter( m_aAllTickInfos[0], rAxisLabelProperties.eStaggering, true ); 1348 LabelIterator aOuterIter( m_aAllTickInfos[0], rAxisLabelProperties.eStaggering, false ); 1349 1350 lcl_shiftLables( aOuterIter 1351 , lcl_getLabelsDistance( aInnerIter 1352 , pTickFactory2D->getDistanceAxisTickToText( m_aAxisProperties ), 0.0 ) ); 1353 } 1354 } 1355 } 1356 1357 void VCartesianAxis::createLabels() 1358 { 1359 if( !prepareShapeCreation() ) 1360 return; 1361 1362 //----------------------------------------- 1363 //create labels 1364 if( m_aAxisProperties.m_bDisplayLabels ) 1365 { 1366 std::auto_ptr< TickFactory_2D > apTickFactory2D( this->createTickFactory2D() ); 1367 TickFactory_2D* pTickFactory2D = apTickFactory2D.get(); 1368 if( !pTickFactory2D ) 1369 return; 1370 1371 //----------------------------------------- 1372 //get the transformed screen values for all tickmarks in aAllTickInfos 1373 pTickFactory2D->updateScreenValues( m_aAllTickInfos ); 1374 //----------------------------------------- 1375 //'hide' tickmarks with identical screen values in aAllTickInfos 1376 hideIdenticalScreenValues( m_aAllTickInfos ); 1377 1378 removeTextShapesFromTicks(); 1379 1380 //create tick mark text shapes 1381 sal_Int32 nTextLevelCount = getTextLevelCount(); 1382 sal_Int32 nScreenDistanceBetweenTicks = -1; 1383 for( sal_Int32 nTextLevel=0; nTextLevel<nTextLevelCount; nTextLevel++ ) 1384 { 1385 ::std::auto_ptr< TickIter > apTickIter = createLabelTickIterator( nTextLevel ); 1386 if(apTickIter.get()) 1387 { 1388 if(nTextLevel==0) 1389 { 1390 nScreenDistanceBetweenTicks = TickFactory_2D::getTickScreenDistance( *apTickIter.get() ); 1391 if( nTextLevelCount>1 ) 1392 nScreenDistanceBetweenTicks*=2; //the above used tick iter does contain also the sub ticks -> thus the given distance is only the half 1393 } 1394 1395 AxisLabelProperties aComplexProps(m_aAxisLabelProperties); 1396 if( m_aAxisProperties.m_bComplexCategories ) 1397 { 1398 if( nTextLevel==0 ) 1399 { 1400 aComplexProps.bLineBreakAllowed = true; 1401 aComplexProps.bOverlapAllowed = !::rtl::math::approxEqual( aComplexProps.fRotationAngleDegree, 0.0 ); 1402 } 1403 else 1404 { 1405 aComplexProps.bOverlapAllowed = true; 1406 aComplexProps.bRhythmIsFix = true; 1407 aComplexProps.nRhythm = 1; 1408 aComplexProps.fRotationAngleDegree = 0.0; 1409 } 1410 } 1411 AxisLabelProperties& rAxisLabelProperties = m_aAxisProperties.m_bComplexCategories ? aComplexProps : m_aAxisLabelProperties; 1412 while( !createTextShapes( m_xTextTarget, *apTickIter.get(), rAxisLabelProperties, pTickFactory2D, nScreenDistanceBetweenTicks ) ) 1413 { 1414 }; 1415 } 1416 } 1417 doStaggeringOfLabels( m_aAxisLabelProperties, pTickFactory2D ); 1418 } 1419 } 1420 1421 void VCartesianAxis::createMaximumLabels() 1422 { 1423 TrueGuard aRecordMaximumTextSize(m_bRecordMaximumTextSize); 1424 1425 if( !prepareShapeCreation() ) 1426 return; 1427 1428 //----------------------------------------- 1429 //create labels 1430 if( m_aAxisProperties.m_bDisplayLabels ) 1431 { 1432 std::auto_ptr< TickFactory_2D > apTickFactory2D( this->createTickFactory2D() ); 1433 TickFactory_2D* pTickFactory2D = apTickFactory2D.get(); 1434 if( !pTickFactory2D ) 1435 return; 1436 1437 //----------------------------------------- 1438 //get the transformed screen values for all tickmarks in aAllTickInfos 1439 pTickFactory2D->updateScreenValues( m_aAllTickInfos ); 1440 1441 //create tick mark text shapes 1442 //@todo: iterate through all tick depth which should be labeled 1443 1444 AxisLabelProperties aAxisLabelProperties( m_aAxisLabelProperties ); 1445 if( isAutoStaggeringOfLabelsAllowed( aAxisLabelProperties, pTickFactory2D->isHorizontalAxis(), pTickFactory2D->isVerticalAxis() ) ) 1446 aAxisLabelProperties.eStaggering = STAGGER_EVEN; 1447 aAxisLabelProperties.bOverlapAllowed = true; 1448 aAxisLabelProperties.bLineBreakAllowed = false; 1449 sal_Int32 nTextLevelCount = getTextLevelCount(); 1450 for( sal_Int32 nTextLevel=0; nTextLevel<nTextLevelCount; nTextLevel++ ) 1451 { 1452 ::std::auto_ptr< TickIter > apTickIter = createMaximumLabelTickIterator( nTextLevel ); 1453 if(apTickIter.get()) 1454 { 1455 while( !createTextShapes( m_xTextTarget, *apTickIter.get(), aAxisLabelProperties, pTickFactory2D, -1 ) ) 1456 { 1457 }; 1458 } 1459 } 1460 doStaggeringOfLabels( aAxisLabelProperties, pTickFactory2D ); 1461 } 1462 } 1463 1464 void VCartesianAxis::updatePositions() 1465 { 1466 //----------------------------------------- 1467 //update positions of labels 1468 if( m_aAxisProperties.m_bDisplayLabels ) 1469 { 1470 std::auto_ptr< TickFactory_2D > apTickFactory2D( this->createTickFactory2D() ); 1471 TickFactory_2D* pTickFactory2D = apTickFactory2D.get(); 1472 if( !pTickFactory2D ) 1473 return; 1474 1475 //----------------------------------------- 1476 //update positions of all existing text shapes 1477 pTickFactory2D->updateScreenValues( m_aAllTickInfos ); 1478 1479 ::std::vector< ::std::vector< TickInfo > >::iterator aDepthIter = m_aAllTickInfos.begin(); 1480 const ::std::vector< ::std::vector< TickInfo > >::const_iterator aDepthEnd = m_aAllTickInfos.end(); 1481 for( sal_Int32 nDepth=0; aDepthIter != aDepthEnd; aDepthIter++, nDepth++ ) 1482 { 1483 ::std::vector< TickInfo >::iterator aTickIter = aDepthIter->begin(); 1484 const ::std::vector< TickInfo >::const_iterator aTickEnd = aDepthIter->end(); 1485 for( ; aTickIter != aTickEnd; aTickIter++ ) 1486 { 1487 TickInfo& rTickInfo = (*aTickIter); 1488 Reference< drawing::XShape > xShape2DText( rTickInfo.xTextShape ); 1489 if( xShape2DText.is() ) 1490 { 1491 B2DVector aTextToTickDistance( pTickFactory2D->getDistanceAxisTickToText( m_aAxisProperties, true ) ); 1492 B2DVector aTickScreenPos2D( rTickInfo.aTickScreenPosition ); 1493 aTickScreenPos2D += aTextToTickDistance; 1494 awt::Point aAnchorScreenPosition2D( 1495 static_cast<sal_Int32>(aTickScreenPos2D.getX()) 1496 ,static_cast<sal_Int32>(aTickScreenPos2D.getY())); 1497 1498 double fRotationAngleDegree = m_aAxisLabelProperties.fRotationAngleDegree; 1499 if( nDepth>0 ) 1500 fRotationAngleDegree = 0.0; 1501 1502 // #i78696# use mathematically correct rotation now 1503 const double fRotationAnglePi(fRotationAngleDegree * (F_PI / -180.0)); 1504 uno::Any aATransformation = ShapeFactory::makeTransformation(aAnchorScreenPosition2D, fRotationAnglePi); 1505 1506 //set new position 1507 uno::Reference< beans::XPropertySet > xProp( xShape2DText, uno::UNO_QUERY ); 1508 if( xProp.is() ) 1509 { 1510 try 1511 { 1512 xProp->setPropertyValue( C2U( "Transformation" ), aATransformation ); 1513 } 1514 catch( uno::Exception& e ) 1515 { 1516 ASSERT_EXCEPTION( e ); 1517 } 1518 } 1519 1520 //correctPositionForRotation 1521 LabelPositionHelper::correctPositionForRotation( xShape2DText 1522 , m_aAxisProperties.m_aLabelAlignment, fRotationAngleDegree, m_aAxisProperties.m_bComplexCategories ); 1523 } 1524 } 1525 } 1526 1527 doStaggeringOfLabels( m_aAxisLabelProperties, pTickFactory2D ); 1528 } 1529 } 1530 1531 void VCartesianAxis::createTickMarkLineShapes( ::std::vector< TickInfo >& rTickInfos, const TickmarkProperties& rTickmarkProperties, TickFactory_2D& rTickFactory2D, bool bOnlyAtLabels ) 1532 { 1533 sal_Int32 nPointCount = rTickInfos.size(); 1534 drawing::PointSequenceSequence aPoints(2*nPointCount); 1535 1536 ::std::vector< TickInfo >::const_iterator aTickIter = rTickInfos.begin(); 1537 const ::std::vector< TickInfo >::const_iterator aTickEnd = rTickInfos.end(); 1538 sal_Int32 nN = 0; 1539 for( ; aTickIter != aTickEnd; aTickIter++ ) 1540 { 1541 if( !(*aTickIter).bPaintIt ) 1542 continue; 1543 1544 bool bTicksAtLabels = ( m_aAxisProperties.m_eTickmarkPos != ::com::sun::star::chart::ChartAxisMarkPosition_AT_AXIS ); 1545 double fInnerDirectionSign = m_aAxisProperties.m_fInnerDirectionSign; 1546 if( bTicksAtLabels && m_aAxisProperties.m_eLabelPos == ::com::sun::star::chart::ChartAxisLabelPosition_OUTSIDE_END ) 1547 fInnerDirectionSign *= -1.0; 1548 bTicksAtLabels = bTicksAtLabels || bOnlyAtLabels; 1549 //add ticks at labels: 1550 rTickFactory2D.addPointSequenceForTickLine( aPoints, nN++, (*aTickIter).fScaledTickValue 1551 , fInnerDirectionSign , rTickmarkProperties, bTicksAtLabels ); 1552 //add ticks at axis (without lables): 1553 if( !bOnlyAtLabels && m_aAxisProperties.m_eTickmarkPos == ::com::sun::star::chart::ChartAxisMarkPosition_AT_LABELS_AND_AXIS ) 1554 rTickFactory2D.addPointSequenceForTickLine( aPoints, nN++, (*aTickIter).fScaledTickValue 1555 , m_aAxisProperties.m_fInnerDirectionSign, rTickmarkProperties, !bTicksAtLabels ); 1556 } 1557 aPoints.realloc(nN); 1558 m_pShapeFactory->createLine2D( m_xGroupShape_Shapes, aPoints 1559 , &rTickmarkProperties.aLineProperties ); 1560 } 1561 1562 void VCartesianAxis::createShapes() 1563 { 1564 if( !prepareShapeCreation() ) 1565 return; 1566 1567 std::auto_ptr< TickFactory_2D > apTickFactory2D( this->createTickFactory2D() ); 1568 TickFactory_2D* pTickFactory2D = apTickFactory2D.get(); 1569 if( !pTickFactory2D ) 1570 return; 1571 1572 //----------------------------------------- 1573 //create line shapes 1574 if(2==m_nDimension) 1575 { 1576 //----------------------------------------- 1577 //create extra long ticks to separate complex categories (create them only there where the labels are) 1578 if( isComplexCategoryAxis() ) 1579 { 1580 ::std::vector< ::std::vector< TickInfo > > aComplexTickInfos; 1581 createAllTickInfosFromComplexCategories( aComplexTickInfos, true ); 1582 pTickFactory2D->updateScreenValues( aComplexTickInfos ); 1583 hideIdenticalScreenValues( aComplexTickInfos ); 1584 1585 ::std::vector<TickmarkProperties> aTickmarkPropertiesList; 1586 static bool bIncludeSpaceBetweenTickAndText = false; 1587 sal_Int32 nOffset = static_cast<sal_Int32>(pTickFactory2D->getDistanceAxisTickToText( m_aAxisProperties, false, bIncludeSpaceBetweenTickAndText ).getLength()); 1588 sal_Int32 nTextLevelCount = getTextLevelCount(); 1589 for( sal_Int32 nTextLevel=0; nTextLevel<nTextLevelCount; nTextLevel++ ) 1590 { 1591 ::std::auto_ptr< TickIter > apTickIter = createLabelTickIterator( nTextLevel ); 1592 if( apTickIter.get() ) 1593 { 1594 double fRotationAngleDegree = m_aAxisLabelProperties.fRotationAngleDegree; 1595 if( nTextLevel>0 ) 1596 fRotationAngleDegree = 0.0; 1597 B2DVector aLabelsDistance( lcl_getLabelsDistance( *apTickIter.get(), pTickFactory2D->getDistanceAxisTickToText( m_aAxisProperties, false ), fRotationAngleDegree ) ); 1598 sal_Int32 nCurrentLength = static_cast<sal_Int32>(aLabelsDistance.getLength()); 1599 aTickmarkPropertiesList.push_back( m_aAxisProperties.makeTickmarkPropertiesForComplexCategories( nOffset + nCurrentLength, 0, nTextLevel ) ); 1600 nOffset += nCurrentLength; 1601 } 1602 } 1603 1604 sal_Int32 nTickmarkPropertiesCount = aTickmarkPropertiesList.size(); 1605 ::std::vector< ::std::vector< TickInfo > >::iterator aDepthIter = aComplexTickInfos.begin(); 1606 const ::std::vector< ::std::vector< TickInfo > >::const_iterator aDepthEnd = aComplexTickInfos.end(); 1607 for( sal_Int32 nDepth=0; aDepthIter != aDepthEnd && nDepth < nTickmarkPropertiesCount; aDepthIter++, nDepth++ ) 1608 { 1609 if(nDepth==0 && !m_aAxisProperties.m_nMajorTickmarks) 1610 continue; 1611 createTickMarkLineShapes( *aDepthIter, aTickmarkPropertiesList[nDepth], *pTickFactory2D, true /*bOnlyAtLabels*/ ); 1612 } 1613 } 1614 //----------------------------------------- 1615 //create normal ticks for major and minor intervals 1616 { 1617 ::std::vector< ::std::vector< TickInfo > > aUnshiftedTickInfos; 1618 if( m_aScale.ShiftedCategoryPosition )// if ShiftedCategoryPosition==true the tickmarks in m_aAllTickInfos are shifted 1619 { 1620 pTickFactory2D->getAllTicks( aUnshiftedTickInfos ); 1621 pTickFactory2D->updateScreenValues( aUnshiftedTickInfos ); 1622 hideIdenticalScreenValues( aUnshiftedTickInfos ); 1623 } 1624 ::std::vector< ::std::vector< TickInfo > >& rAllTickInfos = m_aScale.ShiftedCategoryPosition ? aUnshiftedTickInfos : m_aAllTickInfos; 1625 1626 ::std::vector< ::std::vector< TickInfo > >::iterator aDepthIter = rAllTickInfos.begin(); 1627 const ::std::vector< ::std::vector< TickInfo > >::const_iterator aDepthEnd = rAllTickInfos.end(); 1628 if(aDepthIter == aDepthEnd)//no tickmarks at all 1629 return; 1630 1631 sal_Int32 nTickmarkPropertiesCount = m_aAxisProperties.m_aTickmarkPropertiesList.size(); 1632 for( sal_Int32 nDepth=0; aDepthIter != aDepthEnd && nDepth < nTickmarkPropertiesCount; aDepthIter++, nDepth++ ) 1633 createTickMarkLineShapes( *aDepthIter, m_aAxisProperties.m_aTickmarkPropertiesList[nDepth], *pTickFactory2D, false /*bOnlyAtLabels*/ ); 1634 } 1635 //----------------------------------------- 1636 //create axis main lines 1637 //it serves also as the handle shape for the axis selection 1638 { 1639 drawing::PointSequenceSequence aPoints(1); 1640 apTickFactory2D->createPointSequenceForAxisMainLine( aPoints ); 1641 Reference< drawing::XShape > xShape = m_pShapeFactory->createLine2D( 1642 m_xGroupShape_Shapes, aPoints 1643 , &m_aAxisProperties.m_aLineProperties ); 1644 //because of this name this line will be used for marking the axis 1645 m_pShapeFactory->setShapeName( xShape, C2U("MarkHandles") ); 1646 } 1647 //----------------------------------------- 1648 //create an additional line at NULL 1649 if( !AxisHelper::isAxisPositioningEnabled() ) 1650 { 1651 double fExtraLineCrossesOtherAxis; 1652 if( getLogicValueWhereExtraLineCrossesOtherAxis(fExtraLineCrossesOtherAxis) ) 1653 { 1654 B2DVector aStart, aEnd; 1655 this->get2DAxisMainLine( aStart, aEnd, fExtraLineCrossesOtherAxis ); 1656 drawing::PointSequenceSequence aPoints( lcl_makePointSequence(aStart,aEnd) ); 1657 Reference< drawing::XShape > xShape = m_pShapeFactory->createLine2D( 1658 m_xGroupShape_Shapes, aPoints, &m_aAxisProperties.m_aLineProperties ); 1659 } 1660 } 1661 } 1662 1663 //createLabels(); 1664 } 1665 1666 //............................................................................. 1667 } //namespace chart 1668 //............................................................................. 1669