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_vcl.hxx" 26 #include <tools/vcompat.hxx> 27 28 #include <vcl/graphictools.hxx> 29 30 static ::rtl::OString polyToString( const Polygon& rPoly ) 31 { 32 ::rtl::OString aStr; 33 sal_uInt16 nVertex; 34 for(nVertex=0; nVertex<rPoly.GetSize(); ++nVertex) 35 { 36 aStr += "("; 37 switch( rPoly.GetFlags(nVertex) ) 38 { 39 case POLY_NORMAL: 40 case POLY_SMOOTH: 41 case POLY_SYMMTR: 42 aStr += "n: "; 43 break; 44 45 case POLY_CONTROL: 46 aStr += "c: "; 47 break; 48 49 default: 50 DBG_ERROR( "SvtGraphicStroke::polyToString invalid flag"); 51 break; 52 } 53 aStr += ::rtl::OString::valueOf( static_cast< double >( rPoly[nVertex].getX() ) ); 54 aStr += ","; 55 aStr += ::rtl::OString::valueOf( static_cast< double >( rPoly[nVertex].getY() ) ); 56 aStr += ") "; 57 } 58 59 return aStr; 60 } 61 62 static ::rtl::OString polyPolyToString( const PolyPolygon& rPolyPoly ) 63 { 64 ::rtl::OString aStr; 65 sal_uInt16 nPoly; 66 for(nPoly=0; nPoly<rPolyPoly.Count(); ++nPoly) 67 { 68 const Polygon& rPoly = rPolyPoly[nPoly]; 69 70 aStr += "{ "; 71 aStr += polyToString( rPoly ); 72 aStr += "} "; 73 } 74 75 return aStr; 76 } 77 78 static ::rtl::OString dashToString( const SvtGraphicStroke::DashArray& rDashArray ) 79 { 80 ::rtl::OString aStr; 81 82 aStr += "dash: [ "; 83 84 int i, nDashes( rDashArray.size() ); 85 for(i=0; i<nDashes; ++i) 86 { 87 aStr += ::rtl::OString::valueOf( rDashArray[i] ); 88 aStr += " "; 89 } 90 91 aStr += "] "; 92 93 return aStr; 94 } 95 96 static ::rtl::OString colorToString( Color aColor ) 97 { 98 ::rtl::OString aStr; 99 100 aStr += "color: [ "; 101 aStr += ::rtl::OString::valueOf( aColor.GetRed() ); 102 aStr += " "; 103 aStr += ::rtl::OString::valueOf( aColor.GetGreen() ); 104 aStr += " "; 105 aStr += ::rtl::OString::valueOf( aColor.GetBlue() ); 106 aStr += " ] "; 107 108 return aStr; 109 } 110 111 //////////////////////////////////////////////////////////////////////////// 112 113 SvtGraphicFill::Transform::Transform() 114 { 115 matrix[0] = 1.0; matrix[1] = 0.0; matrix[2] = 0.0; 116 matrix[3] = 0.0; matrix[4] = 1.0; matrix[5] = 0.0; 117 } 118 119 //////////////////////////////////////////////////////////////////////////// 120 121 SvtGraphicStroke::SvtGraphicStroke() : 122 maPath(), 123 maStartArrow(), 124 maEndArrow(), 125 mfTransparency(), 126 mfStrokeWidth(), 127 maCapType(), 128 maJoinType(), 129 mfMiterLimit( 3.0 ), 130 maDashArray() 131 { 132 } 133 134 SvtGraphicStroke::SvtGraphicStroke( const Polygon& rPath, 135 const PolyPolygon& rStartArrow, 136 const PolyPolygon& rEndArrow, 137 double fTransparency, 138 double fStrokeWidth, 139 CapType aCap, 140 JoinType aJoin, 141 double fMiterLimit, 142 const DashArray& rDashArray ) : 143 maPath( rPath ), 144 maStartArrow( rStartArrow ), 145 maEndArrow( rEndArrow ), 146 mfTransparency( fTransparency ), 147 mfStrokeWidth( fStrokeWidth ), 148 maCapType( aCap ), 149 maJoinType( aJoin ), 150 mfMiterLimit( fMiterLimit ), 151 maDashArray( rDashArray ) 152 { 153 } 154 155 void SvtGraphicStroke::getPath( Polygon& rPath ) const 156 { 157 rPath = maPath; 158 } 159 160 void SvtGraphicStroke::getStartArrow( PolyPolygon& rPath ) const 161 { 162 rPath = maStartArrow; 163 } 164 165 void SvtGraphicStroke::getEndArrow( PolyPolygon& rPath ) const 166 { 167 rPath = maEndArrow; 168 } 169 170 double SvtGraphicStroke::getTransparency() const 171 { 172 return mfTransparency; 173 } 174 175 double SvtGraphicStroke::getStrokeWidth() const 176 { 177 return mfStrokeWidth; 178 } 179 180 SvtGraphicStroke::CapType SvtGraphicStroke::getCapType() const 181 { 182 return maCapType; 183 } 184 185 SvtGraphicStroke::JoinType SvtGraphicStroke::getJoinType() const 186 { 187 return maJoinType; 188 } 189 190 double SvtGraphicStroke::getMiterLimit() const 191 { 192 return mfMiterLimit; 193 } 194 195 void SvtGraphicStroke::getDashArray( DashArray& rDashArray ) const 196 { 197 rDashArray = maDashArray; 198 } 199 200 ::rtl::OString SvtGraphicStroke::toString() const 201 { 202 ::rtl::OString aStr; 203 204 aStr += polyToString( maPath ); 205 aStr += "trans: "; 206 aStr += ::rtl::OString::valueOf( static_cast< double >(getTransparency()) ); 207 aStr += " width: "; 208 aStr += ::rtl::OString::valueOf( static_cast< double >(getStrokeWidth()) ); 209 aStr += " cap: "; 210 switch( getCapType() ) 211 { 212 case capButt: 213 aStr += "butt"; 214 break; 215 216 case capRound: 217 aStr += "round"; 218 break; 219 220 case capSquare: 221 aStr += "square"; 222 break; 223 224 default: 225 DBG_ERROR( "SvtGraphicStroke::toString missing cap type"); 226 break; 227 } 228 aStr += " join: "; 229 switch( getJoinType() ) 230 { 231 case joinMiter: 232 aStr += "miter"; 233 break; 234 235 case joinRound: 236 aStr += "round"; 237 break; 238 239 case joinBevel: 240 aStr += "bevel"; 241 break; 242 243 case joinNone: 244 aStr += "none"; 245 break; 246 247 default: 248 DBG_ERROR( "SvtGraphicStroke::toString missing join type"); 249 break; 250 } 251 aStr += " "; 252 253 if( maStartArrow.Count() ) 254 { 255 aStr += "start: "; 256 aStr += polyPolyToString( maStartArrow ); 257 aStr += " "; 258 } 259 260 if( maEndArrow.Count() ) 261 { 262 aStr += "end: "; 263 aStr += polyPolyToString( maEndArrow ); 264 aStr += " "; 265 } 266 267 aStr += dashToString( maDashArray ); 268 269 return aStr; 270 } 271 272 void SvtGraphicStroke::setPath( const Polygon& rPoly ) 273 { 274 maPath = rPoly; 275 } 276 277 void SvtGraphicStroke::setStartArrow( const PolyPolygon& rPoly ) 278 { 279 maStartArrow = rPoly; 280 } 281 282 void SvtGraphicStroke::setEndArrow( const PolyPolygon& rPoly ) 283 { 284 maEndArrow = rPoly; 285 } 286 287 void SvtGraphicStroke::setTransparency( double fTrans ) 288 { 289 mfTransparency = fTrans; 290 } 291 292 void SvtGraphicStroke::setStrokeWidth( double fWidth ) 293 { 294 mfStrokeWidth = fWidth; 295 } 296 297 void SvtGraphicStroke::setCapType( CapType eType ) 298 { 299 maCapType = eType; 300 } 301 302 void SvtGraphicStroke::setJoinType( JoinType eType ) 303 { 304 maJoinType = eType; 305 } 306 307 void SvtGraphicStroke::setMiterLimit( double fMiterLimit ) 308 { 309 mfMiterLimit = fMiterLimit; 310 } 311 312 void SvtGraphicStroke::setDashArray( const DashArray& rDashArray ) 313 { 314 maDashArray = rDashArray; 315 } 316 317 SvStream& operator<<( SvStream& rOStm, const SvtGraphicStroke& rClass ) 318 { 319 VersionCompat aCompat( rOStm, STREAM_WRITE, 1 ); 320 321 rClass.maPath.Write( rOStm ); 322 rClass.maStartArrow.Write( rOStm ); 323 rClass.maEndArrow.Write( rOStm ); 324 rOStm << rClass.mfTransparency; 325 rOStm << rClass.mfStrokeWidth; 326 sal_uInt16 nTmp = sal::static_int_cast<sal_uInt16>( rClass.maCapType ); 327 rOStm << nTmp; 328 nTmp = sal::static_int_cast<sal_uInt16>( rClass.maJoinType ); 329 rOStm << nTmp; 330 rOStm << rClass.mfMiterLimit; 331 332 rOStm << static_cast<sal_uInt32>(rClass.maDashArray.size()); 333 size_t i; 334 for(i=0; i<rClass.maDashArray.size(); ++i) 335 rOStm << rClass.maDashArray[i]; 336 337 return rOStm; 338 } 339 340 SvStream& operator>>( SvStream& rIStm, SvtGraphicStroke& rClass ) 341 { 342 VersionCompat aCompat( rIStm, STREAM_READ ); 343 344 rClass.maPath.Read( rIStm ); 345 rClass.maStartArrow.Read( rIStm ); 346 rClass.maEndArrow.Read( rIStm ); 347 rIStm >> rClass.mfTransparency; 348 rIStm >> rClass.mfStrokeWidth; 349 sal_uInt16 nTmp; 350 rIStm >> nTmp; 351 rClass.maCapType = SvtGraphicStroke::CapType(nTmp); 352 rIStm >> nTmp; 353 rClass.maJoinType = SvtGraphicStroke::JoinType(nTmp); 354 rIStm >> rClass.mfMiterLimit; 355 356 sal_uInt32 nSize; 357 rIStm >> nSize; 358 rClass.maDashArray.resize(nSize); 359 size_t i; 360 for(i=0; i<rClass.maDashArray.size(); ++i) 361 rIStm >> rClass.maDashArray[i]; 362 363 return rIStm; 364 } 365 366 367 ///////////////////////////////////////////////////////////////////////////// 368 369 SvtGraphicFill::SvtGraphicFill() : 370 maPath(), 371 maFillColor( COL_BLACK ), 372 mfTransparency(), 373 maFillRule(), 374 maFillType(), 375 maFillTransform(), 376 maHatchType(), 377 maHatchColor( COL_BLACK ), 378 maGradientType(), 379 maGradient1stColor( COL_BLACK ), 380 maGradient2ndColor( COL_BLACK ), 381 maGradientStepCount( gradientStepsInfinite ), 382 maFillGraphic() 383 { 384 } 385 386 SvtGraphicFill::SvtGraphicFill( const PolyPolygon& rPath, 387 Color aFillColor, 388 double fTransparency, 389 FillRule aFillRule, 390 FillType aFillType, 391 const Transform& aFillTransform, 392 bool bTiling, 393 HatchType aHatchType, 394 Color aHatchColor, 395 GradientType aGradientType, 396 Color aGradient1stColor, 397 Color aGradient2ndColor, 398 int aGradientStepCount, 399 const Graphic& aFillGraphic ) : 400 maPath( rPath ), 401 maFillColor( aFillColor ), 402 mfTransparency( fTransparency ), 403 maFillRule( aFillRule ), 404 maFillType( aFillType ), 405 maFillTransform( aFillTransform ), 406 mbTiling( bTiling ), 407 maHatchType( aHatchType ), 408 maHatchColor( aHatchColor ), 409 maGradientType( aGradientType ), 410 maGradient1stColor( aGradient1stColor ), 411 maGradient2ndColor( aGradient2ndColor ), 412 maGradientStepCount( aGradientStepCount ), 413 maFillGraphic( aFillGraphic ) 414 { 415 } 416 417 void SvtGraphicFill::getPath( PolyPolygon& rPath ) const 418 { 419 rPath = maPath; 420 } 421 422 Color SvtGraphicFill::getFillColor() const 423 { 424 return maFillColor; 425 } 426 427 double SvtGraphicFill::getTransparency() const 428 { 429 return mfTransparency; 430 } 431 432 SvtGraphicFill::FillRule SvtGraphicFill::getFillRule() const 433 { 434 return maFillRule; 435 } 436 437 SvtGraphicFill::FillType SvtGraphicFill::getFillType() const 438 { 439 return maFillType; 440 } 441 442 void SvtGraphicFill::getTransform( Transform& rTrans ) const 443 { 444 rTrans = maFillTransform; 445 } 446 447 bool SvtGraphicFill::IsTiling() const 448 { 449 return mbTiling; 450 } 451 452 bool SvtGraphicFill::isTiling() const 453 { 454 return mbTiling; 455 } 456 457 SvtGraphicFill::HatchType SvtGraphicFill::getHatchType() const 458 { 459 return maHatchType; 460 } 461 462 Color SvtGraphicFill::getHatchColor() const 463 { 464 return maHatchColor; 465 } 466 467 SvtGraphicFill::GradientType SvtGraphicFill::getGradientType() const 468 { 469 return maGradientType; 470 } 471 472 Color SvtGraphicFill::getGradient1stColor() const 473 { 474 return maGradient1stColor; 475 } 476 477 Color SvtGraphicFill::getGradient2ndColor() const 478 { 479 return maGradient2ndColor; 480 } 481 482 int SvtGraphicFill::getGradientStepCount() const 483 { 484 return maGradientStepCount; 485 } 486 487 void SvtGraphicFill::getGraphic( Graphic& rGraphic ) const 488 { 489 rGraphic = maFillGraphic; 490 } 491 492 ::rtl::OString SvtGraphicFill::toString() const 493 { 494 ::rtl::OString aStr; 495 496 aStr += polyPolyToString( maPath ); 497 aStr += "fill"; 498 aStr += colorToString( getFillColor() ); 499 aStr += " trans: "; 500 aStr += ::rtl::OString::valueOf( static_cast< double >(getTransparency()) ); 501 aStr += " rule: "; 502 switch( getFillRule() ) 503 { 504 case fillNonZero: 505 aStr += "nonzero"; 506 break; 507 508 case fillEvenOdd: 509 aStr += "evenodd"; 510 break; 511 512 default: 513 DBG_ERROR( "SvtGraphicFill::toString missing fill rule"); 514 break; 515 } 516 aStr += " type: "; 517 switch( getFillType() ) 518 { 519 case fillSolid: 520 aStr += "solid"; 521 break; 522 523 case fillGradient: 524 aStr += "gradient"; 525 break; 526 527 case fillHatch: 528 aStr += "hatch"; 529 break; 530 531 case fillTexture: 532 aStr += "bitmap"; 533 break; 534 535 default: 536 DBG_ERROR( "SvtGraphicStroke::toString missing fill type"); 537 break; 538 } 539 540 aStr += " transform: [ "; 541 int i; 542 for(i=0; i<Transform::MatrixSize; ++i) 543 aStr += ::rtl::OString::valueOf( maFillTransform.matrix[i] ); 544 aStr += " ] "; 545 546 aStr += " hatch: "; 547 switch( getHatchType() ) 548 { 549 case hatchSingle: 550 aStr += "single"; 551 break; 552 553 case hatchDouble: 554 aStr += "double"; 555 break; 556 557 case hatchTriple: 558 aStr += "triple"; 559 break; 560 561 default: 562 DBG_ERROR( "SvtGraphicStroke::toString missing hatch type"); 563 break; 564 } 565 566 aStr += " hatch"; 567 aStr += colorToString( getHatchColor() ); 568 569 aStr += " gradient: "; 570 switch( getGradientType() ) 571 { 572 case gradientLinear: 573 aStr += "linear"; 574 break; 575 576 case gradientRadial: 577 aStr += "radial"; 578 break; 579 580 case gradientRectangular: 581 aStr += "rectangular"; 582 break; 583 584 default: 585 DBG_ERROR( "SvtGraphicStroke::toString missing gradient type"); 586 break; 587 } 588 589 aStr += " grad1st"; 590 aStr += colorToString( getGradient1stColor() ); 591 592 aStr += " grad2nd"; 593 aStr += colorToString( getGradient2ndColor() ); 594 595 aStr += " gradstep"; 596 aStr += ::rtl::OString::valueOf( (sal_Int32)getGradientStepCount() ); 597 598 if( maFillGraphic.GetType() != GRAPHIC_NONE ) 599 { 600 aStr += " fillgraphic: "; 601 switch( maFillGraphic.GetType() ) 602 { 603 case GRAPHIC_BITMAP: 604 aStr += "bitmap"; 605 break; 606 607 case GRAPHIC_GDIMETAFILE: 608 aStr += "metafile"; 609 break; 610 611 case GRAPHIC_DEFAULT: 612 aStr += "default"; 613 break; 614 615 default: 616 DBG_ERROR( "SvtGraphicStroke::toString missing graphic type"); 617 break; 618 } 619 620 aStr += " of "; 621 aStr += ::rtl::OString::valueOf( static_cast< sal_Int32 >(maFillGraphic.GetSizeBytes()) ); 622 aStr += " bytes"; 623 } 624 625 return aStr; 626 } 627 628 void SvtGraphicFill::setPath( const PolyPolygon& rPath ) 629 { 630 maPath = rPath; 631 } 632 633 void SvtGraphicFill::setFillColor( Color aFillColor ) 634 { 635 maFillColor = aFillColor; 636 } 637 638 void SvtGraphicFill::setTransparency( double fTransparency ) 639 { 640 mfTransparency = fTransparency; 641 } 642 643 void SvtGraphicFill::setFillRule( FillRule aFillRule ) 644 { 645 maFillRule = aFillRule; 646 } 647 648 void SvtGraphicFill::setFillType( FillType aFillType ) 649 { 650 maFillType = aFillType; 651 } 652 653 void SvtGraphicFill::setTransform( const Transform& rTransform ) 654 { 655 maFillTransform = rTransform; 656 } 657 658 void SvtGraphicFill::setTiling( bool bTiling ) 659 { 660 mbTiling = bTiling; 661 } 662 663 void SvtGraphicFill::setHatchType( HatchType aHatchType ) 664 { 665 maHatchType = aHatchType; 666 } 667 668 void SvtGraphicFill::setHatchColor( Color aHatchColor ) 669 { 670 maHatchColor = aHatchColor; 671 } 672 673 void SvtGraphicFill::setGradientType( GradientType aGradType ) 674 { 675 maGradientType = aGradType; 676 } 677 678 void SvtGraphicFill::setGradient1stColor( Color aColor ) 679 { 680 maGradient1stColor = aColor; 681 } 682 683 void SvtGraphicFill::setGradient2ndColor( Color aColor ) 684 { 685 maGradient2ndColor = aColor; 686 } 687 688 void SvtGraphicFill::setGradientStepCount( int aCount ) 689 { 690 maGradientStepCount = aCount; 691 } 692 693 void SvtGraphicFill::setGraphic( const Graphic& rGraphic ) 694 { 695 maFillGraphic = rGraphic; 696 } 697 698 SvStream& operator<<( SvStream& rOStm, const SvtGraphicFill& rClass ) 699 { 700 VersionCompat aCompat( rOStm, STREAM_WRITE, 1 ); 701 702 rClass.maPath.Write( rOStm ); 703 rOStm << rClass.maFillColor; 704 rOStm << rClass.mfTransparency; 705 sal_uInt16 nTmp = sal::static_int_cast<sal_uInt16>( rClass.maFillRule ); 706 rOStm << nTmp; 707 nTmp = sal::static_int_cast<sal_uInt16>( rClass.maFillType ); 708 rOStm << nTmp; 709 int i; 710 for(i=0; i<SvtGraphicFill::Transform::MatrixSize; ++i) 711 rOStm << rClass.maFillTransform.matrix[i]; 712 nTmp = rClass.mbTiling; 713 rOStm << nTmp; 714 nTmp = sal::static_int_cast<sal_uInt16>( rClass.maHatchType ); 715 rOStm << nTmp; 716 rOStm << rClass.maHatchColor; 717 nTmp = sal::static_int_cast<sal_uInt16>( rClass.maGradientType ); 718 rOStm << nTmp; 719 rOStm << rClass.maGradient1stColor; 720 rOStm << rClass.maGradient2ndColor; 721 rOStm << rClass.maGradientStepCount; 722 rOStm << rClass.maFillGraphic; 723 724 return rOStm; 725 } 726 727 SvStream& operator>>( SvStream& rIStm, SvtGraphicFill& rClass ) 728 { 729 VersionCompat aCompat( rIStm, STREAM_READ ); 730 731 rClass.maPath.Read( rIStm ); 732 rIStm >> rClass.maFillColor; 733 rIStm >> rClass.mfTransparency; 734 sal_uInt16 nTmp; 735 rIStm >> nTmp; 736 rClass.maFillRule = SvtGraphicFill::FillRule( nTmp ); 737 rIStm >> nTmp; 738 rClass.maFillType = SvtGraphicFill::FillType( nTmp ); 739 int i; 740 for(i=0; i<SvtGraphicFill::Transform::MatrixSize; ++i) 741 rIStm >> rClass.maFillTransform.matrix[i]; 742 rIStm >> nTmp; 743 rClass.mbTiling = nTmp; 744 rIStm >> nTmp; 745 rClass.maHatchType = SvtGraphicFill::HatchType( nTmp ); 746 rIStm >> rClass.maHatchColor; 747 rIStm >> nTmp; 748 rClass.maGradientType = SvtGraphicFill::GradientType( nTmp ); 749 rIStm >> rClass.maGradient1stColor; 750 rIStm >> rClass.maGradient2ndColor; 751 rIStm >> rClass.maGradientStepCount; 752 rIStm >> rClass.maFillGraphic; 753 754 return rIStm; 755 } 756