vcl/source/gdi/graphictools.cxx

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