xref: /aoo41x/main/vcl/source/gdi/graphictools.cxx (revision 9f62ea84)
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 
polyToString(const Polygon & rPoly)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 
polyPolyToString(const PolyPolygon & rPolyPoly)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 
dashToString(const SvtGraphicStroke::DashArray & rDashArray)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 
colorToString(Color aColor)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 
Transform()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 
SvtGraphicStroke()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 
SvtGraphicStroke(const Polygon & rPath,const PolyPolygon & rStartArrow,const PolyPolygon & rEndArrow,double fTransparency,double fStrokeWidth,CapType aCap,JoinType aJoin,double fMiterLimit,const DashArray & rDashArray)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 
getPath(Polygon & rPath) const155 void SvtGraphicStroke::getPath( Polygon& rPath ) const
156 {
157     rPath = maPath;
158 }
159 
getStartArrow(PolyPolygon & rPath) const160 void SvtGraphicStroke::getStartArrow( PolyPolygon& rPath ) const
161 {
162     rPath = maStartArrow;
163 }
164 
getEndArrow(PolyPolygon & rPath) const165 void SvtGraphicStroke::getEndArrow( PolyPolygon& rPath ) const
166 {
167     rPath = maEndArrow;
168 }
169 
getTransparency() const170 double SvtGraphicStroke::getTransparency() const
171 {
172     return mfTransparency;
173 }
174 
getStrokeWidth() const175 double SvtGraphicStroke::getStrokeWidth() const
176 {
177     return mfStrokeWidth;
178 }
179 
getCapType() const180 SvtGraphicStroke::CapType SvtGraphicStroke::getCapType() const
181 {
182     return maCapType;
183 }
184 
getJoinType() const185 SvtGraphicStroke::JoinType SvtGraphicStroke::getJoinType() const
186 {
187     return maJoinType;
188 }
189 
getMiterLimit() const190 double SvtGraphicStroke::getMiterLimit() const
191 {
192     return mfMiterLimit;
193 }
194 
getDashArray(DashArray & rDashArray) const195 void SvtGraphicStroke::getDashArray( DashArray& rDashArray ) const
196 {
197     rDashArray = maDashArray;
198 }
199 
toString() const200 ::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 
setPath(const Polygon & rPoly)272 void SvtGraphicStroke::setPath( const Polygon& rPoly )
273 {
274     maPath = rPoly;
275 }
276 
setStartArrow(const PolyPolygon & rPoly)277 void SvtGraphicStroke::setStartArrow( const PolyPolygon& rPoly )
278 {
279     maStartArrow = rPoly;
280 }
281 
setEndArrow(const PolyPolygon & rPoly)282 void SvtGraphicStroke::setEndArrow( const PolyPolygon& rPoly )
283 {
284     maEndArrow = rPoly;
285 }
286 
setTransparency(double fTrans)287 void SvtGraphicStroke::setTransparency( double fTrans )
288 {
289     mfTransparency = fTrans;
290 }
291 
setStrokeWidth(double fWidth)292 void SvtGraphicStroke::setStrokeWidth( double fWidth )
293 {
294     mfStrokeWidth = fWidth;
295 }
296 
setCapType(CapType eType)297 void SvtGraphicStroke::setCapType( CapType eType )
298 {
299     maCapType = eType;
300 }
301 
setJoinType(JoinType eType)302 void SvtGraphicStroke::setJoinType( JoinType eType )
303 {
304     maJoinType = eType;
305 }
306 
setMiterLimit(double fMiterLimit)307 void SvtGraphicStroke::setMiterLimit( double fMiterLimit )
308 {
309     mfMiterLimit = fMiterLimit;
310 }
311 
setDashArray(const DashArray & rDashArray)312 void SvtGraphicStroke::setDashArray( const DashArray& rDashArray )
313 {
314     maDashArray = rDashArray;
315 }
316 
operator <<(SvStream & rOStm,const SvtGraphicStroke & rClass)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 
operator >>(SvStream & rIStm,SvtGraphicStroke & rClass)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 
SvtGraphicFill()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 
SvtGraphicFill(const PolyPolygon & rPath,Color aFillColor,double fTransparency,FillRule aFillRule,FillType aFillType,const Transform & aFillTransform,bool bTiling,HatchType aHatchType,Color aHatchColor,GradientType aGradientType,Color aGradient1stColor,Color aGradient2ndColor,int aGradientStepCount,const Graphic & aFillGraphic)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 
getPath(PolyPolygon & rPath) const417 void SvtGraphicFill::getPath( PolyPolygon& rPath ) const
418 {
419     rPath = maPath;
420 }
421 
getFillColor() const422 Color SvtGraphicFill::getFillColor() const
423 {
424     return maFillColor;
425 }
426 
getTransparency() const427 double SvtGraphicFill::getTransparency() const
428 {
429     return mfTransparency;
430 }
431 
getFillRule() const432 SvtGraphicFill::FillRule SvtGraphicFill::getFillRule() const
433 {
434     return maFillRule;
435 }
436 
getFillType() const437 SvtGraphicFill::FillType SvtGraphicFill::getFillType() const
438 {
439     return maFillType;
440 }
441 
getTransform(Transform & rTrans) const442 void SvtGraphicFill::getTransform( Transform& rTrans ) const
443 {
444     rTrans = maFillTransform;
445 }
446 
IsTiling() const447 bool SvtGraphicFill::IsTiling() const
448 {
449     return mbTiling;
450 }
451 
isTiling() const452 bool SvtGraphicFill::isTiling() const
453 {
454     return mbTiling;
455 }
456 
getHatchType() const457 SvtGraphicFill::HatchType SvtGraphicFill::getHatchType() const
458 {
459     return maHatchType;
460 }
461 
getHatchColor() const462 Color SvtGraphicFill::getHatchColor() const
463 {
464     return maHatchColor;
465 }
466 
getGradientType() const467 SvtGraphicFill::GradientType SvtGraphicFill::getGradientType() const
468 {
469     return maGradientType;
470 }
471 
getGradient1stColor() const472 Color SvtGraphicFill::getGradient1stColor() const
473 {
474     return maGradient1stColor;
475 }
476 
getGradient2ndColor() const477 Color SvtGraphicFill::getGradient2ndColor() const
478 {
479     return maGradient2ndColor;
480 }
481 
getGradientStepCount() const482 int SvtGraphicFill::getGradientStepCount() const
483 {
484     return maGradientStepCount;
485 }
486 
getGraphic(Graphic & rGraphic) const487 void SvtGraphicFill::getGraphic( Graphic& rGraphic ) const
488 {
489     rGraphic = maFillGraphic;
490 }
491 
toString() const492 ::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 
setPath(const PolyPolygon & rPath)628 void SvtGraphicFill::setPath( const PolyPolygon& rPath )
629 {
630     maPath = rPath;
631 }
632 
setFillColor(Color aFillColor)633 void SvtGraphicFill::setFillColor( Color aFillColor )
634 {
635     maFillColor = aFillColor;
636 }
637 
setTransparency(double fTransparency)638 void SvtGraphicFill::setTransparency( double fTransparency )
639 {
640     mfTransparency = fTransparency;
641 }
642 
setFillRule(FillRule aFillRule)643 void SvtGraphicFill::setFillRule( FillRule aFillRule )
644 {
645     maFillRule = aFillRule;
646 }
647 
setFillType(FillType aFillType)648 void SvtGraphicFill::setFillType( FillType aFillType )
649 {
650     maFillType = aFillType;
651 }
652 
setTransform(const Transform & rTransform)653 void SvtGraphicFill::setTransform( const Transform& rTransform )
654 {
655     maFillTransform = rTransform;
656 }
657 
setTiling(bool bTiling)658 void SvtGraphicFill::setTiling( bool bTiling )
659 {
660     mbTiling = bTiling;
661 }
662 
setHatchType(HatchType aHatchType)663 void SvtGraphicFill::setHatchType( HatchType aHatchType )
664 {
665     maHatchType = aHatchType;
666 }
667 
setHatchColor(Color aHatchColor)668 void SvtGraphicFill::setHatchColor( Color aHatchColor )
669 {
670     maHatchColor = aHatchColor;
671 }
672 
setGradientType(GradientType aGradType)673 void SvtGraphicFill::setGradientType( GradientType aGradType )
674 {
675     maGradientType = aGradType;
676 }
677 
setGradient1stColor(Color aColor)678 void SvtGraphicFill::setGradient1stColor( Color aColor )
679 {
680     maGradient1stColor = aColor;
681 }
682 
setGradient2ndColor(Color aColor)683 void SvtGraphicFill::setGradient2ndColor( Color aColor )
684 {
685     maGradient2ndColor = aColor;
686 }
687 
setGradientStepCount(int aCount)688 void SvtGraphicFill::setGradientStepCount( int aCount )
689 {
690     maGradientStepCount = aCount;
691 }
692 
setGraphic(const Graphic & rGraphic)693 void SvtGraphicFill::setGraphic( const Graphic& rGraphic )
694 {
695     maFillGraphic = rGraphic;
696 }
697 
operator <<(SvStream & rOStm,const SvtGraphicFill & rClass)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 
operator >>(SvStream & rIStm,SvtGraphicFill & rClass)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