xref: /aoo4110/main/vcl/source/gdi/cvtsvm.cxx (revision b1cdbd2c)
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 
27 #define ENABLE_BYTESTRING_STREAM_OPERATORS
28 
29 #include <algorithm>
30 #include <string.h>
31 #include <tools/stack.hxx>
32 #include <tools/debug.hxx>
33 #include <tools/stream.hxx>
34 #include <vcl/virdev.hxx>
35 #include <vcl/graph.hxx>
36 #include <vcl/lineinfo.hxx>
37 #include <vcl/salbtype.hxx>
38 #include <vcl/cvtsvm.hxx>
39 #include <vcl/dibtools.hxx>
40 
41 // -----------
42 // - Defines -
43 // -----------
44 
45 #define CVTSVM_WRITE_SUBACTIONCOUNT 1
46 
47 // -----------
48 // - Inlines -
49 // -----------
50 
ImplReadRect(SvStream & rIStm,Rectangle & rRect)51 void ImplReadRect( SvStream& rIStm, Rectangle& rRect )
52 {
53 	Point aTL;
54 	Point aBR;
55 
56 	rIStm >> aTL;
57 	rIStm >> aBR;
58 
59 	rRect = Rectangle( aTL, aBR );
60 }
61 
62 // ------------------------------------------------------------------------
63 
ImplWriteRect(SvStream & rOStm,const Rectangle & rRect)64 void ImplWriteRect( SvStream& rOStm, const Rectangle& rRect )
65 {
66 	rOStm << rRect.TopLeft();
67 	rOStm << rRect.BottomRight();
68 }
69 
70 // ------------------------------------------------------------------------
71 
ImplReadPoly(SvStream & rIStm,Polygon & rPoly)72 void ImplReadPoly( SvStream& rIStm, Polygon& rPoly )
73 {
74 	sal_Int32	nSize;
75 
76 	rIStm >> nSize;
77 	rPoly = Polygon( (sal_uInt16) nSize );
78 
79 	for( sal_uInt16 i = 0; i < (sal_uInt16) nSize; i++ )
80 		rIStm >> rPoly[ i ];
81 }
82 
83 // ------------------------------------------------------------------------
84 
ImplReadPolyPoly(SvStream & rIStm,PolyPolygon & rPolyPoly)85 void ImplReadPolyPoly( SvStream& rIStm, PolyPolygon& rPolyPoly )
86 {
87 	Polygon aPoly;
88 	sal_Int32	nPolyCount;
89 
90 	rIStm >> nPolyCount;
91 
92 	for( sal_uInt16 i = 0; i < (sal_uInt16) nPolyCount; i++ )
93 	{
94 		ImplReadPoly( rIStm, aPoly );
95 		rPolyPoly.Insert( aPoly );
96 	}
97 }
98 
99 // ------------------------------------------------------------------------
100 
ImplWritePolyPolyAction(SvStream & rOStm,const PolyPolygon & rPolyPoly)101 void ImplWritePolyPolyAction( SvStream& rOStm, const PolyPolygon& rPolyPoly )
102 {
103 	const sal_uInt16	nPoly = rPolyPoly.Count();
104 	sal_uInt16			nPoints = 0;
105 	sal_uInt16			n;
106 
107 	for( n = 0; n < nPoly; n++ )
108 		nPoints = sal::static_int_cast<sal_uInt16>(nPoints + rPolyPoly[ n ].GetSize());
109 
110 	rOStm << (sal_Int16) GDI_POLYPOLYGON_ACTION;
111 	rOStm << (sal_Int32) ( 8 + ( nPoly << 2 ) + ( nPoints << 3 ) );
112 	rOStm << (sal_Int32) nPoly;
113 
114 	for( n = 0; n < nPoly; n++ )
115 	{
116         // #i102224# Here the evtl. curved nature of Polygon was
117         // ignored (for all those Years). Adapted to at least write
118         // a polygon representing the curve as good as possible
119  	    Polygon aSimplePoly;
120  	    rPolyPoly[n].AdaptiveSubdivide(aSimplePoly);
121  		const sal_uInt16 nSize(aSimplePoly.GetSize());
122 
123 		rOStm << (sal_Int32) nSize;
124 
125 		for( sal_uInt16 j = 0; j < nSize; j++ )
126 			rOStm << aSimplePoly[ j ];
127 	}
128 }
129 
130 // ------------------------------------------------------------------------
131 
ImplReadColor(SvStream & rIStm,Color & rColor)132 void ImplReadColor( SvStream& rIStm, Color& rColor )
133 {
134 	sal_Int16 nVal;
135 
136 	rIStm >> nVal; rColor.SetRed( sal::static_int_cast<sal_uInt8>((sal_uInt16)nVal >> 8) );
137 	rIStm >> nVal; rColor.SetGreen( sal::static_int_cast<sal_uInt8>((sal_uInt16)nVal >> 8) );
138 	rIStm >> nVal; rColor.SetBlue( sal::static_int_cast<sal_uInt8>((sal_uInt16)nVal >> 8) );
139 }
140 
141 // ------------------------------------------------------------------------
142 
ImplWriteColor(SvStream & rOStm,const Color & rColor)143 void ImplWriteColor( SvStream& rOStm, const Color& rColor )
144 {
145 	sal_Int16 nVal;
146 
147 	nVal = ( (sal_Int16) rColor.GetRed() << 8 ) | rColor.GetRed();
148 	rOStm << nVal;
149 
150 	nVal = ( (sal_Int16) rColor.GetGreen() << 8 ) | rColor.GetGreen();
151 	rOStm << nVal;
152 
153 	nVal = ( (sal_Int16) rColor.GetBlue() << 8 ) | rColor.GetBlue();
154 	rOStm << nVal;
155 }
156 
157 // ------------------------------------------------------------------------
158 
ImplReadMapMode(SvStream & rIStm,MapMode & rMapMode)159 void ImplReadMapMode( SvStream& rIStm, MapMode& rMapMode )
160 {
161 	Point	aOrg;
162 	sal_Int32	nXNum;
163 	sal_Int32	nXDenom;
164 	sal_Int32	nYNum;
165 	sal_Int32	nYDenom;
166 	sal_Int16	nUnit;
167 
168 	rIStm >> nUnit >> aOrg >> nXNum >> nXDenom >> nYNum >> nYDenom;
169 	rMapMode = MapMode( (MapUnit) nUnit, aOrg, Fraction( nXNum, nXDenom ), Fraction( nYNum, nYDenom ) );
170 }
171 
172 // ------------------------------------------------------------------------
173 
ImplWriteMapMode(SvStream & rOStm,const MapMode & rMapMode)174 void ImplWriteMapMode( SvStream& rOStm, const MapMode& rMapMode )
175 {
176 	rOStm << (sal_Int16) rMapMode.GetMapUnit();
177 	rOStm << rMapMode.GetOrigin();
178 	rOStm << (sal_Int32) rMapMode.GetScaleX().GetNumerator();
179 	rOStm << (sal_Int32) rMapMode.GetScaleX().GetDenominator();
180 	rOStm << (sal_Int32) rMapMode.GetScaleY().GetNumerator();
181 	rOStm << (sal_Int32) rMapMode.GetScaleY().GetDenominator();
182 }
183 
184 // ------------------------------------------------------------------------
185 
ImplWritePushAction(SvStream & rOStm)186 void ImplWritePushAction( SvStream& rOStm )
187 {
188 	rOStm << (sal_Int16) GDI_PUSH_ACTION;
189 	rOStm << (sal_Int32) 4;
190 }
191 
192 // ------------------------------------------------------------------------
193 
ImplWritePopAction(SvStream & rOStm)194 void ImplWritePopAction( SvStream& rOStm )
195 {
196 	rOStm << (sal_Int16) GDI_POP_ACTION;
197 	rOStm << (sal_Int32) 4;
198 }
199 
200 // ------------------------------------------------------------------------
201 
ImplWriteLineColor(SvStream & rOStm,const Color & rColor,sal_Int16 nStyle,sal_Int32 nWidth=0L)202 void ImplWriteLineColor( SvStream& rOStm, const Color& rColor, sal_Int16 nStyle, sal_Int32 nWidth = 0L )
203 {
204 	if( rColor.GetTransparency() > 127 )
205 		nStyle = 0;
206 
207 	rOStm << (sal_Int16) GDI_PEN_ACTION;
208 	rOStm << (sal_Int32) 16;
209 	ImplWriteColor( rOStm, rColor );
210 	rOStm << nWidth;
211 	rOStm << nStyle;
212 }
213 
214 // ------------------------------------------------------------------------
215 
ImplWriteFillColor(SvStream & rOStm,const Color & rColor,sal_Int16 nStyle)216 void ImplWriteFillColor( SvStream& rOStm, const Color& rColor, sal_Int16 nStyle )
217 {
218 	rOStm << (sal_Int16) GDI_FILLBRUSH_ACTION;
219 	rOStm << (sal_Int32) 20;
220 	ImplWriteColor( rOStm, rColor );
221 
222 	if( rColor.GetTransparency() > 127 )
223 		nStyle = 0;
224 
225 	if( nStyle > 1 )
226 	{
227 		ImplWriteColor( rOStm, COL_WHITE );
228 		rOStm << nStyle;
229 		rOStm << (sal_Int16) 1;
230 	}
231 	else
232 	{
233 		ImplWriteColor( rOStm, COL_BLACK );
234 		rOStm << nStyle;
235 		rOStm << (sal_Int16) 0;
236 	}
237 }
238 
239 // ------------------------------------------------------------------------
240 
ImplWriteFont(SvStream & rOStm,const Font & rFont,rtl_TextEncoding & rActualCharSet)241 void ImplWriteFont( SvStream& rOStm, const Font& rFont,
242 					rtl_TextEncoding& rActualCharSet )
243 {
244 	char	aName[32];
245 	short	nWeight;
246 
247 	ByteString aByteName( rFont.GetName(), rOStm.GetStreamCharSet() );
248 	strncpy( aName, aByteName.GetBuffer(), 32 );
249 
250 	switch ( rFont.GetWeight() )
251 	{
252 		case WEIGHT_THIN:
253 		case WEIGHT_ULTRALIGHT:
254 		case WEIGHT_LIGHT:
255 			nWeight = 1;
256 		break;
257 
258 		case WEIGHT_NORMAL:
259 		case WEIGHT_MEDIUM:
260 			nWeight = 2;
261 		break;
262 
263 		case WEIGHT_BOLD:
264 		case WEIGHT_ULTRABOLD:
265 		case WEIGHT_BLACK:
266 			nWeight = 3;
267 		break;
268 
269 		default:
270 			nWeight = 0;
271 		break;
272 	}
273 
274 	rOStm << (sal_Int16) GDI_FONT_ACTION;
275 	rOStm << (sal_Int32) 78;
276 
277 	rActualCharSet = GetStoreCharSet( rFont.GetCharSet() );
278 	ImplWriteColor( rOStm, rFont.GetColor() );
279 	ImplWriteColor( rOStm, rFont.GetFillColor() );
280 	rOStm.Write( aName, 32 );
281 	rOStm << rFont.GetSize();
282 	rOStm << (sal_Int16) 0; // no character orientation anymore
283 	rOStm << (sal_Int16) rFont.GetOrientation();
284 	rOStm << (sal_Int16) rActualCharSet;
285 	rOStm << (sal_Int16) rFont.GetFamily();
286 	rOStm << (sal_Int16) rFont.GetPitch();
287 	rOStm << (sal_Int16) rFont.GetAlign();
288 	rOStm << (sal_Int16) nWeight;
289 	rOStm << (sal_Int16) rFont.GetUnderline();
290 	rOStm << (sal_Int16) rFont.GetStrikeout();
291 	rOStm << (sal_Bool) ( rFont.GetItalic() != ITALIC_NONE );
292 	rOStm << rFont.IsOutline();
293 	rOStm << rFont.IsShadow();
294 	rOStm << rFont.IsTransparent();
295 	if ( rActualCharSet == RTL_TEXTENCODING_DONTKNOW )
296 		rActualCharSet = gsl_getSystemTextEncoding();
297 }
298 
299 // ------------------------------------------------------------------------
300 
ImplWriteRasterOpAction(SvStream & rOStm,sal_Int16 nRasterOp)301 void ImplWriteRasterOpAction( SvStream& rOStm, sal_Int16 nRasterOp )
302 {
303 	rOStm << (sal_Int16) GDI_RASTEROP_ACTION << (sal_Int32) 6 << nRasterOp;
304 }
305 
306 // ------------------------------------------------------------------------
307 
ImplWriteUnicodeComment(SvStream & rOStm,const String & rString)308 sal_Bool ImplWriteUnicodeComment( SvStream& rOStm, const String& rString )
309 {
310 	xub_StrLen i, nStringLen = rString.Len();
311 	if ( nStringLen )
312 	{
313 		sal_uInt32	nSize = ( nStringLen << 1 ) + 4;
314 		sal_uInt16	nType = GDI_UNICODE_COMMENT;
315 
316 		rOStm << nType << nSize;
317 		for ( i = 0; i < nStringLen; i++ )
318 		{
319 			sal_Unicode nUni = rString.GetChar( i );
320 			rOStm << nUni;
321 		}
322 	}
323 	return nStringLen != 0;
324 }
325 
326 // ------------------------------------------------------------------------
327 
ImplReadUnicodeComment(sal_uInt32 nStrmPos,SvStream & rIStm,String & rString)328 void ImplReadUnicodeComment( sal_uInt32 nStrmPos, SvStream& rIStm, String& rString )
329 {
330 	sal_uInt32 nOld = rIStm.Tell();
331 	if ( nStrmPos )
332 	{
333 		sal_uInt16	nType;
334 		sal_uInt32	nActionSize;
335         xub_StrLen  nStringLen;
336 
337 		rIStm.Seek( nStrmPos );
338 		rIStm	>> nType
339 				>> nActionSize;
340 
341 		nStringLen = sal::static_int_cast<xub_StrLen>(( nActionSize - 4 ) >> 1);
342 
343 		if ( nStringLen && ( nType == GDI_UNICODE_COMMENT ) )
344 		{
345 			sal_Unicode* pBuffer = rString.AllocBuffer( nStringLen );
346 			while ( nStringLen-- )
347 				rIStm >> *pBuffer++;
348 		}
349 	}
350 	rIStm.Seek( nOld );
351 }
352 
353 // ------------------------------------------------------------------------
354 
ImplSkipActions(SvStream & rIStm,sal_uLong nSkipCount)355 void ImplSkipActions( SvStream& rIStm, sal_uLong nSkipCount )
356 {
357 	sal_Int32 nActionSize;
358 	sal_Int16 nType;
359 
360 	for( sal_uLong i = 0UL; i < nSkipCount; i++ )
361 	{
362 		rIStm >> nType >> nActionSize;
363 		rIStm.SeekRel( nActionSize - 4L );
364 	}
365 }
366 
367 // ------------------------------------------------------------------------
368 
ImplWriteExtendedPolyPolygonAction(SvStream & rOStm,const PolyPolygon & rPolyPolygon,bool bOnlyWhenCurve)369 bool ImplWriteExtendedPolyPolygonAction(SvStream& rOStm, const PolyPolygon& rPolyPolygon, bool bOnlyWhenCurve)
370 {
371 	const sal_uInt16 nPolygonCount(rPolyPolygon.Count());
372 
373 	if(nPolygonCount)
374 	{
375 		sal_uInt32 nAllPolygonCount(0);
376 		sal_uInt32 nAllPointCount(0);
377 		sal_uInt32 nAllFlagCount(0);
378 		sal_uInt16 a(0);
379 
380 		for(a = 0; a < nPolygonCount; a++)
381 		{
382 		    const Polygon& rCandidate = rPolyPolygon.GetObject(a);
383 		    const sal_uInt16 nPointCount(rCandidate.GetSize());
384 
385 			if(nPointCount)
386 			{
387 				nAllPolygonCount++;
388 				nAllPointCount += nPointCount;
389 
390 				if(rCandidate.HasFlags())
391 				{
392 					nAllFlagCount += nPointCount;
393 				}
394 			}
395 		}
396 
397 		if((bOnlyWhenCurve && nAllFlagCount) || (!bOnlyWhenCurve && nAllPointCount))
398 		{
399 			rOStm << (sal_Int16) GDI_EXTENDEDPOLYGON_ACTION;
400 
401 			const sal_Int32 nActionSize(
402 				4 +							// Action size
403 				2 +							// PolygonCount
404 				(nAllPolygonCount * 2) +	// Points per polygon
405 				(nAllPointCount << 3) +		// Points themselves
406 				nAllPolygonCount +			// Bool if (when poly has points) it has flags, too
407 				nAllFlagCount);				// Flags themselves
408 
409 			rOStm << nActionSize;
410 			rOStm << (sal_uInt16)nAllPolygonCount;
411 
412 			for(a = 0; a < nPolygonCount; a++)
413 			{
414 				const Polygon& rCandidate = rPolyPolygon.GetObject(a);
415 				const sal_uInt16 nPointCount(rCandidate.GetSize());
416 
417 				if(nPointCount)
418 				{
419 					rOStm << nPointCount;
420 
421 					for(sal_uInt16 b(0); b < nPointCount; b++)
422 					{
423 						rOStm << rCandidate[b];
424 					}
425 
426 					if(rCandidate.HasFlags())
427 					{
428 						rOStm << (sal_uInt8)true;
429 
430 						for(sal_uInt16 c(0); c < nPointCount; c++)
431 						{
432 							rOStm << (sal_uInt8)rCandidate.GetFlags(c);
433 						}
434 					}
435 					else
436 					{
437 						rOStm << (sal_uInt8)false;
438 					}
439 				}
440 			}
441 
442 			return true;
443 		}
444 	}
445 
446 	return false;
447 }
448 
449 // ------------------------------------------------------------------------
450 
ImplReadExtendedPolyPolygonAction(SvStream & rIStm,PolyPolygon & rPolyPoly)451 void ImplReadExtendedPolyPolygonAction(SvStream& rIStm, PolyPolygon& rPolyPoly)
452 {
453 	rPolyPoly.Clear();
454 	sal_uInt16 nPolygonCount(0);
455 	rIStm >> nPolygonCount;
456 
457 	for(sal_uInt16 a(0); a < nPolygonCount; a++)
458 	{
459 		sal_uInt16 nPointCount(0);
460 		rIStm >> nPointCount;
461 		Polygon aCandidate(nPointCount);
462 
463 		if(nPointCount)
464 		{
465 			for(sal_uInt16 b(0); b < nPointCount; b++)
466 			{
467 				rIStm >> aCandidate[b];
468 			}
469 
470 			sal_uInt8 bHasFlags(false);
471 			rIStm >> bHasFlags;
472 
473 			if(bHasFlags)
474 			{
475 				sal_uInt8 aPolyFlags(0);
476 
477 				for(sal_uInt16 c(0); c < nPointCount; c++)
478 				{
479 					rIStm >> aPolyFlags;
480 					aCandidate.SetFlags(c, (PolyFlags)aPolyFlags);
481 				}
482 			}
483 		}
484 
485 		rPolyPoly.Insert(aCandidate);
486 	}
487 }
488 
489 // ----------------
490 // - SVMConverter -
491 // ----------------
492 
SVMConverter(SvStream & rStm,GDIMetaFile & rMtf,sal_uLong nConvertMode)493 SVMConverter::SVMConverter( SvStream& rStm, GDIMetaFile& rMtf, sal_uLong nConvertMode )
494 {
495 	if( !rStm.GetError() )
496 	{
497 		if( CONVERT_FROM_SVM1 == nConvertMode )
498 			ImplConvertFromSVM1( rStm, rMtf );
499 		else if( CONVERT_TO_SVM1 == nConvertMode )
500 			ImplConvertToSVM1( rStm, rMtf );
501 	}
502 }
503 
504 // ------------------------------------------------------------------------
505 
ImplConvertFromSVM1(SvStream & rIStm,GDIMetaFile & rMtf)506 void SVMConverter::ImplConvertFromSVM1( SvStream& rIStm, GDIMetaFile& rMtf )
507 {
508 	const sal_uLong			nPos = rIStm.Tell();
509 	const sal_uInt16		nOldFormat = rIStm.GetNumberFormatInt();
510 
511 	rIStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
512 
513 	char	aCode[ 5 ];
514 	Size	aPrefSz;
515 	sal_Int16	nSize;
516 	sal_Int16	nVersion;
517 
518 	// read header
519 	rIStm.Read( (char*) &aCode, sizeof( aCode ) );	// Kennung
520 	rIStm >> nSize; 								// Size
521 	rIStm >> nVersion;								// Version
522 	rIStm >> aPrefSz.Width();						// PrefSize.Width()
523 	rIStm >> aPrefSz.Height();						// PrefSize.Height()
524 
525 	// check header-magic and version
526 	if( rIStm.GetError()
527         || ( memcmp( aCode, "SVGDI", sizeof( aCode ) ) != 0 )
528         || ( nVersion != 200 ) )
529 	{
530 		rIStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
531 		rIStm.SetNumberFormatInt( nOldFormat );
532 		rIStm.Seek( nPos );
533 		return;
534 	}
535 
536 	LineInfo			aLineInfo( LINE_NONE, 0 );
537 	Stack				aLIStack;
538     VirtualDevice		aFontVDev;
539 	rtl_TextEncoding	eActualCharSet = gsl_getSystemTextEncoding();
540 	sal_Bool				bFatLine = sal_False;
541 
542 	// TODO: fix reindentation below if you can accept being blamed by the SCM
543         MapMode     aMapMode;
544 		Polygon 	aActionPoly;
545 		Rectangle	aRect;
546 		Point		aPt, aPt1;
547 		Size		aSz;
548 		Color		aActionColor;
549 		sal_Int32		nTmp, nTmp1, nActionSize;
550         sal_Int32	    nActions;
551 		sal_Int16		nType;
552 
553 		sal_uInt32	nUnicodeCommentStreamPos = 0;
554 		sal_Int32	    nUnicodeCommentActionNumber = 0;
555 
556         ImplReadMapMode( rIStm, aMapMode ); 			// MapMode
557         rIStm >> nActions;								// Action count
558 
559 		rMtf.SetPrefSize( aPrefSz );
560 		rMtf.SetPrefMapMode( aMapMode );
561 		sal_uInt32 nLastPolygonAction(0);
562 
563 		for( sal_Int32 i = 0L; i < nActions; i++ )
564 		{
565 			rIStm >> nType;
566 			sal_Int32 nActBegin = rIStm.Tell();
567 			rIStm >> nActionSize;
568 
569 			DBG_ASSERT( ( nType <= 33 ) || ( nType >= 1024 ), "Unknown GDIMetaAction while converting!" );
570 
571 			switch( nType )
572 			{
573 				case( GDI_PIXEL_ACTION ):
574 				{
575 					rIStm >> aPt;
576 					ImplReadColor( rIStm, aActionColor );
577 					rMtf.AddAction( new MetaPixelAction( aPt, aActionColor ) );
578 				}
579 				break;
580 
581 				case( GDI_POINT_ACTION ):
582 				{
583 					rIStm >> aPt;
584 					rMtf.AddAction( new MetaPointAction( aPt ) );
585 				}
586 				break;
587 
588 				case( GDI_LINE_ACTION ):
589 				{
590 					rIStm >> aPt >> aPt1;
591 					rMtf.AddAction( new MetaLineAction( aPt, aPt1, aLineInfo ) );
592 				}
593 				break;
594 
595 				case (GDI_LINEJOIN_ACTION) :
596 				{
597 					sal_Int16 nLineJoin(0);
598 					rIStm >> nLineJoin;
599 					aLineInfo.SetLineJoin((basegfx::B2DLineJoin)nLineJoin);
600 				}
601 				break;
602 
603                 case (GDI_LINECAP_ACTION) :
604                 {
605                     sal_Int16 nLineCap(0);
606                     rIStm >> nLineCap;
607                     aLineInfo.SetLineCap((com::sun::star::drawing::LineCap)nLineCap);
608                 }
609                 break;
610 
611 				case (GDI_LINEDASHDOT_ACTION) :
612 				{
613 					sal_Int16 a(0);
614 					sal_Int32 b(0);
615 
616 					rIStm >> a; aLineInfo.SetDashCount(a);
617 					rIStm >> b; aLineInfo.SetDashLen(b);
618 					rIStm >> a; aLineInfo.SetDotCount(a);
619 					rIStm >> b; aLineInfo.SetDotLen(b);
620 					rIStm >> b; aLineInfo.SetDistance(b);
621 
622 					if(((aLineInfo.GetDashCount() && aLineInfo.GetDashLen())
623 						|| (aLineInfo.GetDotCount() && aLineInfo.GetDotLen()))
624 						&& aLineInfo.GetDistance())
625 					{
626 						aLineInfo.SetStyle(LINE_DASH);
627 					}
628 				}
629 				break;
630 
631 				case (GDI_EXTENDEDPOLYGON_ACTION) :
632 				{
633 					// read the PolyPolygon in every case
634 					PolyPolygon aInputPolyPolygon;
635 					ImplReadExtendedPolyPolygonAction(rIStm, aInputPolyPolygon);
636 
637 					// now check if it can be set somewhere
638 					if(nLastPolygonAction < rMtf.GetActionCount())
639 					{
640 						MetaPolyLineAction* pPolyLineAction = dynamic_cast< MetaPolyLineAction* >(rMtf.GetAction(nLastPolygonAction));
641 
642 						if(pPolyLineAction)
643 						{
644 							// replace MetaPolyLineAction when we have a single polygon. Do not rely on the
645 							// same point count; the originally written GDI_POLYLINE_ACTION may have been
646 							// Subdivided for better quality for older usages
647 							if(1 == aInputPolyPolygon.Count())
648 							{
649 								rMtf.ReplaceAction(
650 									new MetaPolyLineAction(
651 										aInputPolyPolygon.GetObject(0),
652 										pPolyLineAction->GetLineInfo()),
653 									nLastPolygonAction);
654 								pPolyLineAction->Delete();
655 							}
656 						}
657 						else
658 						{
659 							MetaPolyPolygonAction* pPolyPolygonAction = dynamic_cast< MetaPolyPolygonAction* >(rMtf.GetAction(nLastPolygonAction));
660 
661 							if(pPolyPolygonAction)
662 							{
663 								// replace MetaPolyPolygonAction when we have a curved polygon. Do rely on the
664 								// same sub-polygon count
665 								if(pPolyPolygonAction->GetPolyPolygon().Count() == aInputPolyPolygon.Count())
666 								{
667 									rMtf.ReplaceAction(
668 										new MetaPolyPolygonAction(
669 											aInputPolyPolygon),
670 										nLastPolygonAction);
671 									pPolyPolygonAction->Delete();
672 								}
673 							}
674 							else
675 							{
676 								MetaPolygonAction* pPolygonAction = dynamic_cast< MetaPolygonAction* >(rMtf.GetAction(nLastPolygonAction));
677 
678 								if(pPolygonAction)
679 								{
680 									// replace MetaPolygonAction
681 									if(1 == aInputPolyPolygon.Count())
682 									{
683 										rMtf.ReplaceAction(
684 											new MetaPolygonAction(
685 												aInputPolyPolygon.GetObject(0)),
686 											nLastPolygonAction);
687 										pPolygonAction->Delete();
688 									}
689 								}
690 							}
691 						}
692 					}
693 				}
694 				break;
695 
696 				case( GDI_RECT_ACTION ):
697 				{
698 					ImplReadRect( rIStm, aRect );
699 					rIStm >> nTmp >> nTmp1;
700 
701 					if( nTmp || nTmp1 )
702 						rMtf.AddAction( new MetaRoundRectAction( aRect, nTmp, nTmp1 ) );
703 					else
704 					{
705 						rMtf.AddAction( new MetaRectAction( aRect ) );
706 
707 						if( bFatLine )
708 							rMtf.AddAction( new MetaPolyLineAction( aRect, aLineInfo ) );
709 					}
710 				}
711 				break;
712 
713 				case( GDI_ELLIPSE_ACTION ):
714 				{
715 					ImplReadRect( rIStm, aRect );
716 
717 					if( bFatLine )
718 					{
719 						const Polygon aPoly( aRect.Center(), aRect.GetWidth() >> 1, aRect.GetHeight() >> 1 );
720 
721 						rMtf.AddAction( new MetaPushAction( PUSH_LINECOLOR ) );
722 						rMtf.AddAction( new MetaLineColorAction( COL_TRANSPARENT, sal_False ) );
723 						rMtf.AddAction( new MetaPolygonAction( aPoly ) );
724 						rMtf.AddAction( new MetaPopAction() );
725 						rMtf.AddAction( new MetaPolyLineAction( aPoly, aLineInfo ) );
726 					}
727 					else
728 						rMtf.AddAction( new MetaEllipseAction( aRect ) );
729 				}
730 				break;
731 
732 				case( GDI_ARC_ACTION ):
733 				{
734 					ImplReadRect( rIStm, aRect );
735 					rIStm >> aPt >> aPt1;
736 
737 					if( bFatLine )
738 					{
739 						const Polygon aPoly( aRect, aPt, aPt1, POLY_ARC );
740 
741 						rMtf.AddAction( new MetaPushAction( PUSH_LINECOLOR ) );
742 						rMtf.AddAction( new MetaLineColorAction( COL_TRANSPARENT, sal_False ) );
743 						rMtf.AddAction( new MetaPolygonAction( aPoly ) );
744 						rMtf.AddAction( new MetaPopAction() );
745 						rMtf.AddAction( new MetaPolyLineAction( aPoly, aLineInfo ) );
746 					}
747 					else
748 						rMtf.AddAction( new MetaArcAction( aRect, aPt, aPt1 ) );
749 				}
750 				break;
751 
752 				case( GDI_PIE_ACTION ):
753 				{
754 					ImplReadRect( rIStm, aRect );
755 					rIStm >> aPt >> aPt1;
756 
757 					if( bFatLine )
758 					{
759 						const Polygon aPoly( aRect, aPt, aPt1, POLY_PIE );
760 
761 						rMtf.AddAction( new MetaPushAction( PUSH_LINECOLOR ) );
762 						rMtf.AddAction( new MetaLineColorAction( COL_TRANSPARENT, sal_False ) );
763 						rMtf.AddAction( new MetaPolygonAction( aPoly ) );
764 						rMtf.AddAction( new MetaPopAction() );
765 						rMtf.AddAction( new MetaPolyLineAction( aPoly, aLineInfo ) );
766 					}
767 					else
768 						rMtf.AddAction( new MetaPieAction( aRect, aPt, aPt1 ) );
769 				}
770 				break;
771 
772 				case( GDI_INVERTRECT_ACTION ):
773 				case( GDI_HIGHLIGHTRECT_ACTION ):
774 				{
775 					ImplReadRect( rIStm, aRect );
776 					rMtf.AddAction( new MetaPushAction( PUSH_RASTEROP ) );
777 					rMtf.AddAction( new MetaRasterOpAction( ROP_INVERT ) );
778 					rMtf.AddAction( new MetaRectAction( aRect ) );
779 					rMtf.AddAction( new MetaPopAction() );
780 				}
781 				break;
782 
783 				case( GDI_POLYLINE_ACTION ):
784 				{
785 					ImplReadPoly( rIStm, aActionPoly );
786 					nLastPolygonAction = rMtf.GetActionCount();
787 
788 					if( bFatLine )
789 						rMtf.AddAction( new MetaPolyLineAction( aActionPoly, aLineInfo ) );
790 					else
791 						rMtf.AddAction( new MetaPolyLineAction( aActionPoly ) );
792 				}
793 				break;
794 
795 				case( GDI_POLYGON_ACTION ):
796 				{
797 					ImplReadPoly( rIStm, aActionPoly );
798 
799 					if( bFatLine )
800 					{
801 						rMtf.AddAction( new MetaPushAction( PUSH_LINECOLOR ) );
802 						rMtf.AddAction( new MetaLineColorAction( COL_TRANSPARENT, sal_False ) );
803 						rMtf.AddAction( new MetaPolygonAction( aActionPoly ) );
804 						rMtf.AddAction( new MetaPopAction() );
805 						rMtf.AddAction( new MetaPolyLineAction( aActionPoly, aLineInfo ) );
806 					}
807 					else
808 					{
809 						nLastPolygonAction = rMtf.GetActionCount();
810 						rMtf.AddAction( new MetaPolygonAction( aActionPoly ) );
811 					}
812 				}
813 				break;
814 
815 				case( GDI_POLYPOLYGON_ACTION ):
816 				{
817 					PolyPolygon aPolyPoly;
818 
819 					ImplReadPolyPoly( rIStm, aPolyPoly );
820 
821 					if( bFatLine )
822 					{
823 						rMtf.AddAction( new MetaPushAction( PUSH_LINECOLOR ) );
824 						rMtf.AddAction( new MetaLineColorAction( COL_TRANSPARENT, sal_False ) );
825 						rMtf.AddAction( new MetaPolyPolygonAction( aPolyPoly ) );
826 						rMtf.AddAction( new MetaPopAction() );
827 
828 						for( sal_uInt16 nPoly = 0, nCount = aPolyPoly.Count(); nPoly < nCount; nPoly++ )
829 							rMtf.AddAction( new MetaPolyLineAction( aPolyPoly[ nPoly ], aLineInfo ) );
830 					}
831 					else
832 					{
833 						nLastPolygonAction = rMtf.GetActionCount();
834 						rMtf.AddAction( new MetaPolyPolygonAction( aPolyPoly ) );
835 					}
836 				}
837 				break;
838 
839 				case( GDI_FONT_ACTION ):
840 				{
841 					Font	aFont;
842 					char	aName[ 32 ];
843 					sal_Int32	nWidth, nHeight;
844 					sal_Int16	nCharSet, nFamily, nPitch, nAlign, nWeight, nUnderline, nStrikeout;
845 					sal_Int16	nCharOrient, nLineOrient;
846 					sal_Bool	bItalic, bOutline, bShadow, bTransparent;
847 
848 					ImplReadColor( rIStm, aActionColor ); aFont.SetColor( aActionColor );
849 					ImplReadColor( rIStm, aActionColor ); aFont.SetFillColor( aActionColor );
850 					rIStm.Read( aName, 32 );
851 					aFont.SetName( UniString( aName, rIStm.GetStreamCharSet() ) );
852 					rIStm >> nWidth >> nHeight;
853 					rIStm >> nCharOrient >> nLineOrient;
854 					rIStm >> nCharSet >> nFamily >> nPitch >> nAlign >> nWeight >> nUnderline >> nStrikeout;
855 					rIStm >> bItalic >> bOutline >> bShadow >> bTransparent;
856 
857 					aFont.SetSize( Size( nWidth, nHeight ) );
858 					aFont.SetCharSet( (CharSet) nCharSet );
859 					aFont.SetFamily( (FontFamily) nFamily );
860 					aFont.SetPitch( (FontPitch) nPitch );
861 					aFont.SetAlign( (FontAlign) nAlign );
862 					aFont.SetWeight( ( nWeight == 1 ) ? WEIGHT_LIGHT : ( nWeight == 2 ) ? WEIGHT_NORMAL :
863 									 ( nWeight == 3 ) ? WEIGHT_BOLD : WEIGHT_DONTKNOW );
864 					aFont.SetUnderline( (FontUnderline) nUnderline );
865 					aFont.SetStrikeout( (FontStrikeout) nStrikeout );
866 					aFont.SetItalic( bItalic ? ITALIC_NORMAL : ITALIC_NONE );
867 					aFont.SetOutline( bOutline );
868 					aFont.SetShadow( bShadow );
869 					aFont.SetOrientation( nLineOrient );
870 					aFont.SetTransparent( bTransparent );
871 
872 					eActualCharSet = aFont.GetCharSet();
873 					if ( eActualCharSet == RTL_TEXTENCODING_DONTKNOW )
874 						eActualCharSet = gsl_getSystemTextEncoding();
875 
876                     rMtf.AddAction( new MetaFontAction( aFont ) );
877                     rMtf.AddAction( new MetaTextAlignAction( aFont.GetAlign() ) );
878                     rMtf.AddAction( new MetaTextColorAction( aFont.GetColor() ) );
879                     rMtf.AddAction( new MetaTextFillColorAction( aFont.GetFillColor(), !aFont.IsTransparent() ) );
880 
881                     // #106172# Track font relevant data in shadow VDev
882                     aFontVDev.SetFont( aFont );
883 				}
884 				break;
885 
886 				case( GDI_TEXT_ACTION ):
887 				{
888 					ByteString	aByteStr;
889 					sal_Int32		nIndex, nLen;
890 
891 					rIStm >> aPt >> nIndex >> nLen >> nTmp;
892 					if ( nTmp && ( static_cast< sal_uInt32 >( nTmp ) < ( SAL_MAX_UINT16 - 1 ) ) )
893                                         {
894 						rIStm.Read( aByteStr.AllocBuffer( (sal_uInt16)nTmp ), nTmp + 1 );
895 						UniString aStr( aByteStr, eActualCharSet );
896 						if ( nUnicodeCommentActionNumber == i )
897 							ImplReadUnicodeComment( nUnicodeCommentStreamPos, rIStm, aStr );
898 						rMtf.AddAction( new MetaTextAction( aPt, aStr, (sal_uInt16) nIndex, (sal_uInt16) nLen ) );
899 					}
900                 			rIStm.Seek( nActBegin + nActionSize );
901 				}
902 				break;
903 
904 				case( GDI_TEXTARRAY_ACTION ):
905 				{
906 					ByteString	aByteStr;
907 					sal_Int32*	pDXAry = NULL;
908 					sal_Int32		nIndex, nLen, nAryLen;
909 
910 					rIStm >> aPt >> nIndex >> nLen >> nTmp >> nAryLen;
911 					if ( nTmp && ( static_cast< sal_uInt32 >( nTmp ) < ( SAL_MAX_UINT16 - 1 ) ) )
912 					{
913 						rIStm.Read( aByteStr.AllocBuffer( (sal_uInt16)nTmp ), nTmp + 1 );
914 						UniString aStr( aByteStr, eActualCharSet );
915 
916 						if( nAryLen > 0L )
917 						{
918 							sal_Int32 nStrLen( aStr.Len() );
919 
920 							pDXAry = new sal_Int32[ Max( nAryLen, nStrLen ) ];
921 
922 							for( long j = 0L; j < nAryLen; j++ )
923 								rIStm >> nTmp, pDXAry[ j ] = nTmp;
924 
925 							// #106172# Add last DX array elem, if missing
926 							if( nAryLen != nStrLen )
927 							{
928 								if( nAryLen+1 == nStrLen )
929 								{
930 									sal_Int32* pTmpAry = new sal_Int32[nStrLen];
931 
932 									aFontVDev.GetTextArray( aStr, pTmpAry, (sal_uInt16) nIndex, (sal_uInt16) nLen );
933 
934 									// now, the difference between the
935 									// last and the second last DX array
936 									// is the advancement for the last
937 									// glyph. Thus, to complete our meta
938 									// action's DX array, just add that
939 									// difference to last elem and store
940 									// in very last.
941 									if( nStrLen > 1 )
942 										pDXAry[ nStrLen-1 ] = pDXAry[ nStrLen-2 ] + pTmpAry[ nStrLen-1 ] - pTmpAry[ nStrLen-2 ];
943 									else
944 										pDXAry[ nStrLen-1 ] = pTmpAry[ nStrLen-1 ]; // len=1: 0th position taken to be 0
945 
946 									delete[] pTmpAry;
947 								}
948 	#ifdef DBG_UTIL
949 								else
950 									DBG_ERROR("More than one DX array element missing on SVM import");
951 	#endif
952 							}
953 						}
954 						if ( nUnicodeCommentActionNumber == i )
955 							ImplReadUnicodeComment( nUnicodeCommentStreamPos, rIStm, aStr );
956 						rMtf.AddAction( new MetaTextArrayAction( aPt, aStr, pDXAry, (sal_uInt16) nIndex, (sal_uInt16) nLen ) );
957 
958 						if( pDXAry )
959 							delete[] pDXAry;
960 					}
961                 			rIStm.Seek( nActBegin + nActionSize );
962 				}
963 				break;
964 
965 				case( GDI_STRETCHTEXT_ACTION ):
966 				{
967 					ByteString	aByteStr;
968 					sal_Int32		nIndex, nLen, nWidth;
969 
970 					rIStm >> aPt >> nIndex >> nLen >> nTmp >> nWidth;
971 					if ( nTmp && ( static_cast< sal_uInt32 >( nTmp ) < ( SAL_MAX_INT16 - 1 ) ) )
972 					{
973 						rIStm.Read( aByteStr.AllocBuffer( (sal_uInt16)nTmp ), nTmp + 1 );
974 						UniString aStr( aByteStr, eActualCharSet );
975 						if ( nUnicodeCommentActionNumber == i )
976 							ImplReadUnicodeComment( nUnicodeCommentStreamPos, rIStm, aStr );
977 						rMtf.AddAction( new MetaStretchTextAction( aPt, nWidth, aStr, (sal_uInt16) nIndex, (sal_uInt16) nLen ) );
978 					}
979                                         rIStm.Seek( nActBegin + nActionSize );
980 				}
981 				break;
982 
983 				case( GDI_BITMAP_ACTION ):
984 				{
985 					Bitmap aBmp;
986 
987 					rIStm >> aPt;
988                     ReadDIB(aBmp, rIStm, true);
989 					rMtf.AddAction( new MetaBmpAction( aPt, aBmp ) );
990 				}
991 				break;
992 
993 				case( GDI_BITMAPSCALE_ACTION ):
994 				{
995 					Bitmap aBmp;
996 
997 					rIStm >> aPt >> aSz;
998                     ReadDIB(aBmp, rIStm, true);
999 					rMtf.AddAction( new MetaBmpScaleAction( aPt, aSz, aBmp ) );
1000 				}
1001 				break;
1002 
1003 				case( GDI_BITMAPSCALEPART_ACTION ):
1004 				{
1005 					Bitmap	aBmp;
1006 					Size	aSz2;
1007 
1008 					rIStm >> aPt >> aSz >> aPt1 >> aSz2;
1009                     ReadDIB(aBmp, rIStm, true);
1010 					rMtf.AddAction( new MetaBmpScalePartAction( aPt, aSz, aPt1, aSz2, aBmp ) );
1011 				}
1012 				break;
1013 
1014 				case( GDI_PEN_ACTION ):
1015 				{
1016 					sal_Int32 nPenWidth;
1017 					sal_Int16 nPenStyle;
1018 
1019 					ImplReadColor( rIStm, aActionColor );
1020 					rIStm >> nPenWidth >> nPenStyle;
1021 
1022 					aLineInfo.SetStyle( nPenStyle ? LINE_SOLID : LINE_NONE );
1023 					aLineInfo.SetWidth( nPenWidth );
1024 					bFatLine = nPenStyle && !aLineInfo.IsDefault();
1025 
1026 					rMtf.AddAction( new MetaLineColorAction( aActionColor, nPenStyle != 0 ) );
1027 				}
1028 				break;
1029 
1030 				case( GDI_FILLBRUSH_ACTION ):
1031 				{
1032 					sal_Int16 nBrushStyle;
1033 
1034 					ImplReadColor( rIStm, aActionColor );
1035 					rIStm.SeekRel( 6L );
1036 					rIStm >> nBrushStyle;
1037 					rMtf.AddAction( new MetaFillColorAction( aActionColor, nBrushStyle != 0 ) );
1038 					rIStm.SeekRel( 2L );
1039 				}
1040 				break;
1041 
1042 				case( GDI_MAPMODE_ACTION ):
1043 				{
1044 					ImplReadMapMode( rIStm, aMapMode );
1045 					rMtf.AddAction( new MetaMapModeAction( aMapMode ) );
1046 
1047                     // #106172# Track font relevant data in shadow VDev
1048                     aFontVDev.SetMapMode( aMapMode );
1049 				}
1050 				break;
1051 
1052 				case( GDI_CLIPREGION_ACTION ):
1053 				{
1054 					Region	aRegion;
1055 					sal_Int16	nRegType;
1056 					sal_Int16	bIntersect;
1057 					sal_Bool	bClip = sal_False;
1058 
1059 					rIStm >> nRegType >> bIntersect;
1060 					ImplReadRect( rIStm, aRect );
1061 
1062 					switch( nRegType )
1063 					{
1064 						case( 0 ):
1065 						break;
1066 
1067 						case( 1 ):
1068 						{
1069 							Rectangle aRegRect;
1070 
1071 							ImplReadRect( rIStm, aRegRect );
1072 							aRegion = Region( aRegRect );
1073 							bClip = sal_True;
1074 						}
1075 						break;
1076 
1077 						case( 2 ):
1078 						{
1079 							ImplReadPoly( rIStm, aActionPoly );
1080 							aRegion = Region( aActionPoly );
1081 							bClip = sal_True;
1082 						}
1083 						break;
1084 
1085 						case( 3 ):
1086 						{
1087 							PolyPolygon aPolyPoly;
1088 							sal_Int32		nPolyCount;
1089 
1090 							rIStm >> nPolyCount;
1091 
1092 							for( sal_uInt16 j = 0; j < (sal_uInt16) nPolyCount; j++ )
1093 							{
1094 								ImplReadPoly( rIStm, aActionPoly );
1095 								aPolyPoly.Insert( aActionPoly );
1096 							}
1097 
1098 							aRegion = Region( aPolyPoly );
1099 							bClip = sal_True;
1100 						}
1101 						break;
1102 					}
1103 
1104 					if( bIntersect )
1105 						aRegion.Intersect( aRect );
1106 
1107 					rMtf.AddAction( new MetaClipRegionAction( aRegion, bClip ) );
1108 				}
1109 				break;
1110 
1111 				case( GDI_MOVECLIPREGION_ACTION ):
1112 				{
1113 					rIStm >> nTmp >> nTmp1;
1114 					rMtf.AddAction( new MetaMoveClipRegionAction( nTmp, nTmp1 ) );
1115 				}
1116 				break;
1117 
1118 				case( GDI_ISECTCLIPREGION_ACTION ):
1119 				{
1120 					ImplReadRect( rIStm, aRect );
1121 					rMtf.AddAction( new MetaISectRectClipRegionAction( aRect ) );
1122 				}
1123 				break;
1124 
1125 				case( GDI_RASTEROP_ACTION ):
1126 				{
1127 					RasterOp	eRasterOp;
1128 					sal_Int16		nRasterOp;
1129 
1130 					rIStm >> nRasterOp;
1131 
1132 					switch( nRasterOp )
1133 					{
1134 						case( 1 ):
1135 							eRasterOp = ROP_INVERT;
1136 						break;
1137 
1138 						case( 4 ):
1139 						case( 5 ):
1140 							eRasterOp = ROP_XOR;
1141 						break;
1142 
1143 						default:
1144 							eRasterOp = ROP_OVERPAINT;
1145 						break;
1146 					}
1147 
1148 					rMtf.AddAction( new MetaRasterOpAction( eRasterOp ) );
1149 				}
1150 				break;
1151 
1152 				case( GDI_PUSH_ACTION ):
1153 				{
1154 					aLIStack.Push( new LineInfo( aLineInfo ) );
1155 					rMtf.AddAction( new MetaPushAction( PUSH_ALL ) );
1156 
1157                     // #106172# Track font relevant data in shadow VDev
1158                     aFontVDev.Push();
1159 				}
1160 				break;
1161 
1162 				case( GDI_POP_ACTION ):
1163 				{
1164 
1165 					LineInfo* pLineInfo = (LineInfo*) aLIStack.Pop();
1166 
1167 					// restore line info
1168 					if( pLineInfo )
1169 					{
1170 						aLineInfo = *pLineInfo;
1171 						delete pLineInfo;
1172 						bFatLine = ( LINE_NONE != aLineInfo.GetStyle() ) && !aLineInfo.IsDefault();
1173 					}
1174 
1175 					rMtf.AddAction( new MetaPopAction() );
1176 
1177                     // #106172# Track font relevant data in shadow VDev
1178                     aFontVDev.Pop();
1179 				}
1180 				break;
1181 
1182 				case( GDI_GRADIENT_ACTION ):
1183 				{
1184 					Color	aStartCol;
1185 					Color	aEndCol;
1186 					sal_Int16	nStyle;
1187 					sal_Int16	nAngle;
1188 					sal_Int16	nBorder;
1189 					sal_Int16	nOfsX;
1190 					sal_Int16	nOfsY;
1191 					sal_Int16	nIntensityStart;
1192 					sal_Int16	nIntensityEnd;
1193 
1194 					ImplReadRect( rIStm, aRect );
1195 					rIStm >> nStyle;
1196 					ImplReadColor( rIStm, aStartCol );
1197 					ImplReadColor( rIStm, aEndCol );
1198 					rIStm >> nAngle >> nBorder >> nOfsX >> nOfsY >> nIntensityStart >> nIntensityEnd;
1199 
1200 					Gradient aGrad( (GradientStyle) nStyle, aStartCol, aEndCol );
1201 
1202 					aGrad.SetAngle( nAngle );
1203 					aGrad.SetBorder( nBorder );
1204 					aGrad.SetOfsX( nOfsX );
1205 					aGrad.SetOfsY( nOfsY );
1206 					aGrad.SetStartIntensity( nIntensityStart );
1207 					aGrad.SetEndIntensity( nIntensityEnd );
1208 					rMtf.AddAction( new MetaGradientAction( aRect, aGrad ) );
1209 				}
1210 				break;
1211 
1212 				case( GDI_TRANSPARENT_COMMENT ):
1213 				{
1214 					PolyPolygon aPolyPoly;
1215 					sal_Int32		nFollowingActionCount;
1216 					sal_Int16		nTrans;
1217 
1218 					rIStm >> aPolyPoly >> nTrans >> nFollowingActionCount;
1219 					ImplSkipActions( rIStm, nFollowingActionCount );
1220 					rMtf.AddAction( new MetaTransparentAction( aPolyPoly, nTrans ) );
1221 
1222 #ifdef CVTSVM_WRITE_SUBACTIONCOUNT
1223 					i += nFollowingActionCount;
1224 #endif
1225 				}
1226 				break;
1227 
1228 				case( GDI_FLOATTRANSPARENT_COMMENT ):
1229 				{
1230 					GDIMetaFile aMtf;
1231 					Point		aPos;
1232 					Size		aSize;
1233 					Gradient	aGradient;
1234 					sal_Int32		nFollowingActionCount;
1235 
1236 					rIStm >> aMtf >> aPos >> aSize >> aGradient >> nFollowingActionCount;
1237 					ImplSkipActions( rIStm, nFollowingActionCount );
1238 					rMtf.AddAction( new MetaFloatTransparentAction( aMtf, aPos, aSize, aGradient ) );
1239 
1240 #ifdef CVTSVM_WRITE_SUBACTIONCOUNT
1241 					i += nFollowingActionCount;
1242 #endif
1243 				}
1244 				break;
1245 
1246 				case( GDI_HATCH_COMMENT ):
1247 				{
1248 					PolyPolygon aPolyPoly;
1249 					Hatch		aHatch;
1250 					sal_Int32		nFollowingActionCount;
1251 
1252 					rIStm >> aPolyPoly >> aHatch >> nFollowingActionCount;
1253 					ImplSkipActions( rIStm, nFollowingActionCount );
1254 					rMtf.AddAction( new MetaHatchAction( aPolyPoly, aHatch ) );
1255 
1256 #ifdef CVTSVM_WRITE_SUBACTIONCOUNT
1257 					i += nFollowingActionCount;
1258 #endif
1259 				}
1260 				break;
1261 
1262 				case( GDI_REFPOINT_COMMENT ):
1263 				{
1264 					Point	aRefPoint;
1265 					sal_Bool	bSet;
1266 					sal_Int32	nFollowingActionCount;
1267 
1268 					rIStm >> aRefPoint >> bSet >> nFollowingActionCount;
1269 					ImplSkipActions( rIStm, nFollowingActionCount );
1270 					rMtf.AddAction( new MetaRefPointAction( aRefPoint, bSet ) );
1271 
1272 #ifdef CVTSVM_WRITE_SUBACTIONCOUNT
1273 					i += nFollowingActionCount;
1274 #endif
1275 
1276                     // #106172# Track font relevant data in shadow VDev
1277                     if( bSet )
1278                         aFontVDev.SetRefPoint( aRefPoint );
1279                     else
1280                         aFontVDev.SetRefPoint();
1281 				}
1282 				break;
1283 
1284 				case( GDI_TEXTLINECOLOR_COMMENT ):
1285 				{
1286 					Color	aColor;
1287 					sal_Bool	bSet;
1288 					sal_Int32	nFollowingActionCount;
1289 
1290 					rIStm >> aColor >> bSet >> nFollowingActionCount;
1291 					ImplSkipActions( rIStm, nFollowingActionCount );
1292 					rMtf.AddAction( new MetaTextLineColorAction( aColor, bSet ) );
1293 
1294 #ifdef CVTSVM_WRITE_SUBACTIONCOUNT
1295 					i += nFollowingActionCount;
1296 #endif
1297 				}
1298 				break;
1299 
1300 				case( GDI_TEXTLINE_COMMENT ):
1301 				{
1302 					Point	aStartPt;
1303 					long	nWidth;
1304 					sal_uInt32 nStrikeout;
1305 					sal_uInt32 nUnderline;
1306 					sal_Int32	nFollowingActionCount;
1307 
1308 					rIStm >> aStartPt >> nWidth >> nStrikeout >> nUnderline >> nFollowingActionCount;
1309 					ImplSkipActions( rIStm, nFollowingActionCount );
1310 					rMtf.AddAction( new MetaTextLineAction( aStartPt, nWidth,
1311 															(FontStrikeout) nStrikeout,
1312 															(FontUnderline) nUnderline,
1313                                                             UNDERLINE_NONE ) );
1314 
1315 #ifdef CVTSVM_WRITE_SUBACTIONCOUNT
1316 					i += nFollowingActionCount;
1317 #endif
1318 				}
1319 				break;
1320 
1321 				case( GDI_GRADIENTEX_COMMENT ):
1322 				{
1323 					PolyPolygon aPolyPoly;
1324 					Gradient	aGradient;
1325 					sal_Int32		nFollowingActionCount;
1326 
1327 					rIStm >> aPolyPoly >> aGradient >> nFollowingActionCount;
1328 					ImplSkipActions( rIStm, nFollowingActionCount );
1329 					rMtf.AddAction( new MetaGradientExAction( aPolyPoly, aGradient ) );
1330 
1331 #ifdef CVTSVM_WRITE_SUBACTIONCOUNT
1332 					i += nFollowingActionCount;
1333 #endif
1334 				}
1335 				break;
1336 
1337 				case( GDI_COMMENT_COMMENT ):
1338 				{
1339 					ByteString	aComment;
1340 					sal_Int32	nValue;
1341 					sal_uInt32	nDataSize;
1342 					sal_uInt8*		pData;
1343 					sal_Int32		nFollowingActionCount;
1344 
1345 					rIStm >> aComment >> nValue >> nDataSize;
1346 
1347 					if( nDataSize )
1348 					{
1349 						pData = new sal_uInt8[ nDataSize ];
1350 						rIStm.Read( pData, nDataSize );
1351 					}
1352 					else
1353 						pData = NULL;
1354 
1355 					rIStm >> nFollowingActionCount;
1356 					ImplSkipActions( rIStm, nFollowingActionCount );
1357 					rMtf.AddAction( new MetaCommentAction( aComment, nValue, pData, nDataSize ) );
1358 
1359 #ifdef CVTSVM_WRITE_SUBACTIONCOUNT
1360 					i += nFollowingActionCount;
1361 #endif
1362 				}
1363 				break;
1364 
1365 				case ( GDI_UNICODE_COMMENT ):
1366 				{
1367 					nUnicodeCommentActionNumber = i + 1;
1368 					nUnicodeCommentStreamPos = rIStm.Tell() - 6;
1369 					rIStm.SeekRel( nActionSize - 4 );
1370 				}
1371 				break;
1372 
1373 				default:
1374 					rIStm.SeekRel( nActionSize - 4L );
1375 				break;
1376 			}
1377                 }
1378 
1379 		// cleanup push-pop stack if neccessary
1380 		for( void* pLineInfo = aLIStack.Pop(); pLineInfo; pLineInfo = aLIStack.Pop() )
1381 			delete (LineInfo*) pLineInfo;
1382 
1383 	rIStm.SetNumberFormatInt( nOldFormat );
1384 }
1385 
1386 // ------------------------------------------------------------------------
1387 
ImplConvertToSVM1(SvStream & rOStm,GDIMetaFile & rMtf)1388 void SVMConverter::ImplConvertToSVM1( SvStream& rOStm, GDIMetaFile& rMtf )
1389 {
1390 	sal_uLong				nPos;
1391 	sal_uLong				nCountPos;
1392 	Font				aSaveFont;
1393 	const sal_uInt16		nOldFormat = rOStm.GetNumberFormatInt();
1394 	rtl_TextEncoding	eActualCharSet = gsl_getSystemTextEncoding();
1395 	const Size			aPrefSize( rMtf.GetPrefSize() );
1396 	sal_Bool				bRop_0_1 = sal_False;
1397 	VirtualDevice		aSaveVDev;
1398 	Color				aLineCol( COL_BLACK );
1399 	Stack				aLineColStack;
1400 
1401 	rOStm.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
1402 
1403 	//MagicCode schreiben
1404 	rOStm << "SVGDI";                                   // Kennung
1405 	nPos = rOStm.Tell();
1406 	rOStm << (sal_Int16) 42;								// HeaderSize
1407 	rOStm << (sal_Int16) 200;								// VERSION
1408 	rOStm << (sal_Int32) aPrefSize.Width();
1409 	rOStm << (sal_Int32) aPrefSize.Height();
1410 	ImplWriteMapMode( rOStm, rMtf.GetPrefMapMode() );
1411 
1412 	// ActionCount wird spaeter geschrieben
1413 	nCountPos = rOStm.Tell();
1414 	rOStm.SeekRel( 4L );
1415 
1416 	const sal_Int32 nActCount = ImplWriteActions( rOStm, rMtf, aSaveVDev, bRop_0_1, aLineCol, aLineColStack, eActualCharSet );
1417 	const sal_uLong nActPos = rOStm.Tell();
1418 
1419 	rOStm.Seek( nCountPos );
1420 	rOStm << nActCount;
1421 	rOStm.Seek( nActPos );
1422 	rOStm.SetNumberFormatInt( nOldFormat );
1423 
1424 	// cleanup push-pop stack if neccessary
1425 	for( void* pCol = aLineColStack.Pop(); pCol; pCol = aLineColStack.Pop() )
1426 		delete (Color*) pCol;
1427 }
1428 
1429 // ------------------------------------------------------------------------
1430 
ImplWriteActions(SvStream & rOStm,GDIMetaFile & rMtf,VirtualDevice & rSaveVDev,sal_Bool & rRop_0_1,Color & rLineCol,Stack & rLineColStack,rtl_TextEncoding & rActualCharSet)1431 sal_uLong SVMConverter::ImplWriteActions( SvStream& rOStm, GDIMetaFile& rMtf,
1432 									  VirtualDevice& rSaveVDev, sal_Bool& rRop_0_1,
1433 									  Color& rLineCol, Stack& rLineColStack,
1434 									  rtl_TextEncoding& rActualCharSet )
1435 {
1436 	sal_uLong nCount = 0;
1437 	for( sal_uLong i = 0, nActionCount = rMtf.GetActionCount(); i < nActionCount; i++ )
1438 	{
1439 		const MetaAction* pAction = rMtf.GetAction( i );
1440 
1441 		switch( pAction->GetType() )
1442 		{
1443 			case( META_PIXEL_ACTION ):
1444 			{
1445 				MetaPixelAction* pAct = (MetaPixelAction*) pAction;
1446 
1447 				rOStm << (sal_Int16) GDI_PIXEL_ACTION;
1448 				rOStm << (sal_Int32) 18;
1449 				rOStm << pAct->GetPoint();
1450 				ImplWriteColor( rOStm, pAct->GetColor() );
1451 				nCount++;
1452 			}
1453 			break;
1454 
1455 			case( META_POINT_ACTION ):
1456 			{
1457 				MetaPointAction* pAct = (MetaPointAction*) pAction;
1458 
1459 				rOStm << (sal_Int16) GDI_POINT_ACTION;
1460 				rOStm << (sal_Int32) 12;
1461 				rOStm << pAct->GetPoint();
1462 				nCount++;
1463 			}
1464 			break;
1465 
1466 			case( META_LINE_ACTION ):
1467 			{
1468 				MetaLineAction* pAct = (MetaLineAction*) pAction;
1469 				const LineInfo& rInfo = pAct->GetLineInfo();
1470 				const bool bFatLine(!rInfo.IsDefault() && (LINE_NONE != rInfo.GetStyle()));
1471 				const bool bLineJoin(bFatLine && basegfx::B2DLINEJOIN_ROUND != rInfo.GetLineJoin());
1472                 const bool bLineCap(bFatLine && com::sun::star::drawing::LineCap_BUTT != rInfo.GetLineCap());
1473 				const bool bLineDashDot(LINE_DASH == rInfo.GetStyle());
1474 
1475 				if( bFatLine )
1476 				{
1477 					ImplWritePushAction( rOStm );
1478 					ImplWriteLineColor( rOStm, rLineCol, 1, rInfo.GetWidth() );
1479 
1480 					if(bLineJoin)
1481 					{
1482 						rOStm << (sal_Int16) GDI_LINEJOIN_ACTION;
1483 						rOStm << (sal_Int32) 6;
1484 						rOStm << (sal_Int16) rInfo.GetLineJoin();
1485 					}
1486 
1487                     if(bLineCap)
1488                     {
1489                         rOStm << (sal_Int16) GDI_LINECAP_ACTION;
1490                         rOStm << (sal_Int32) 6;
1491                         rOStm << (sal_Int16) rInfo.GetLineCap();
1492                     }
1493 				}
1494 
1495 				if(bLineDashDot)
1496 				{
1497 					rOStm << (sal_Int16) GDI_LINEDASHDOT_ACTION;
1498 					rOStm << (sal_Int32) 4 + 16;
1499 					rOStm << (sal_Int16)rInfo.GetDashCount();
1500 					rOStm << (sal_Int32)rInfo.GetDashLen();
1501 					rOStm << (sal_Int16)rInfo.GetDotCount();
1502 					rOStm << (sal_Int32)rInfo.GetDotLen();
1503 					rOStm << (sal_Int32)rInfo.GetDistance();
1504 				}
1505 
1506 				rOStm << (sal_Int16) GDI_LINE_ACTION;
1507 				rOStm << (sal_Int32) 20;
1508 				rOStm << pAct->GetStartPoint();
1509 				rOStm << pAct->GetEndPoint();
1510 				nCount++;
1511 
1512 				if( bFatLine )
1513 				{
1514 					ImplWritePopAction( rOStm );
1515 					nCount += 3;
1516 
1517 					if(bLineJoin)
1518 					{
1519 						nCount += 1;
1520 					}
1521 
1522                     if(bLineCap)
1523                     {
1524                         nCount += 1;
1525                     }
1526 				}
1527 
1528                 if(bLineDashDot)
1529 				{
1530 					nCount += 1;
1531 				}
1532 			}
1533 			break;
1534 
1535 			case( META_RECT_ACTION ):
1536 			{
1537 				MetaRectAction* pAct = (MetaRectAction*) pAction;
1538 
1539 				rOStm << (sal_Int16) GDI_RECT_ACTION;
1540 				rOStm << (sal_Int32) 28;
1541 				ImplWriteRect( rOStm, pAct->GetRect() );
1542 				rOStm << (sal_Int32) 0;
1543 				rOStm << (sal_Int32) 0;
1544 				nCount++;
1545 			}
1546 			break;
1547 
1548 			case( META_ROUNDRECT_ACTION ):
1549 			{
1550 				MetaRoundRectAction* pAct = (MetaRoundRectAction*) pAction;
1551 
1552 				rOStm << (sal_Int16) GDI_RECT_ACTION;
1553 				rOStm << (sal_Int32) 28;
1554 				ImplWriteRect( rOStm, pAct->GetRect() );
1555 				rOStm << (sal_Int32) pAct->GetHorzRound();
1556 				rOStm << (sal_Int32) pAct->GetVertRound();
1557 				nCount++;
1558 			}
1559 			break;
1560 
1561 			case( META_ELLIPSE_ACTION ):
1562 			{
1563 				MetaEllipseAction* pAct = (MetaEllipseAction*) pAction;
1564 
1565 				rOStm << (sal_Int16) GDI_ELLIPSE_ACTION;
1566 				rOStm << (sal_Int32) 20;
1567 				ImplWriteRect( rOStm, pAct->GetRect() );
1568 				nCount++;
1569 			}
1570 			break;
1571 
1572 			case( META_ARC_ACTION ):
1573 			{
1574 				MetaArcAction* pAct = (MetaArcAction*) pAction;
1575 
1576 				rOStm << (sal_Int16) GDI_ARC_ACTION;
1577 				rOStm << (sal_Int32) 36;
1578 				ImplWriteRect( rOStm, pAct->GetRect() );
1579 				rOStm << pAct->GetStartPoint();
1580 				rOStm << pAct->GetEndPoint();
1581 				nCount++;
1582 			}
1583 			break;
1584 
1585 			case( META_PIE_ACTION ):
1586 			{
1587 				MetaPieAction* pAct = (MetaPieAction*) pAction;
1588 
1589 				rOStm << (sal_Int16) GDI_PIE_ACTION;
1590 				rOStm << (sal_Int32) 36;
1591 				ImplWriteRect( rOStm, pAct->GetRect() );
1592 				rOStm << pAct->GetStartPoint();
1593 				rOStm << pAct->GetEndPoint();
1594 				nCount++;
1595 			}
1596 			break;
1597 
1598 			case( META_CHORD_ACTION ):
1599 			{
1600 				MetaChordAction*	pAct = (MetaChordAction*) pAction;
1601 				Polygon 			aChordPoly( pAct->GetRect(), pAct->GetStartPoint(),
1602 												pAct->GetEndPoint(), POLY_CHORD );
1603 				const sal_uInt16		nPoints = aChordPoly.GetSize();
1604 
1605 				rOStm << (sal_Int16) GDI_POLYGON_ACTION;
1606 				rOStm << (sal_Int32) ( 8 + ( nPoints << 3 ) );
1607 				rOStm << (sal_Int32) nPoints;
1608 
1609 				for( sal_uInt16 n = 0; n < nPoints; n++ )
1610 					rOStm << aChordPoly[ n ];
1611 				nCount++;
1612 			}
1613 			break;
1614 
1615 			case( META_POLYLINE_ACTION ):
1616 			{
1617                 // #i102224#
1618 				MetaPolyLineAction* pAct = (MetaPolyLineAction*) pAction;
1619                 // #i102224# Here the evtl. curved nature of Polygon was
1620                 // ignored (for all those Years). Adapted to at least write
1621                 // a polygon representing the curve as good as possible
1622  	            Polygon aSimplePoly;
1623  	            pAct->GetPolygon().AdaptiveSubdivide(aSimplePoly);
1624                 const LineInfo& rInfo = pAct->GetLineInfo();
1625  				const sal_uInt16 nPoints(aSimplePoly.GetSize());
1626 				const bool bFatLine(!rInfo.IsDefault() && (LINE_NONE != rInfo.GetStyle()));
1627 				const bool bLineJoin(bFatLine && basegfx::B2DLINEJOIN_ROUND != rInfo.GetLineJoin());
1628                 const bool bLineCap(bFatLine && com::sun::star::drawing::LineCap_BUTT != rInfo.GetLineCap());
1629 				const bool bLineDashDot(LINE_DASH == rInfo.GetStyle());
1630 
1631 				if( bFatLine )
1632 				{
1633 					ImplWritePushAction( rOStm );
1634 					ImplWriteLineColor( rOStm, rLineCol, 1, rInfo.GetWidth() );
1635 
1636 					if(bLineJoin)
1637 					{
1638 						rOStm << (sal_Int16) GDI_LINEJOIN_ACTION;
1639 						rOStm << (sal_Int32) 6;
1640 						rOStm << (sal_Int16) rInfo.GetLineJoin();
1641 					}
1642 
1643                     if(bLineCap)
1644                     {
1645                         rOStm << (sal_Int16) GDI_LINECAP_ACTION;
1646                         rOStm << (sal_Int32) 6;
1647                         rOStm << (sal_Int16) rInfo.GetLineCap();
1648                     }
1649 				}
1650 
1651 				if(bLineDashDot)
1652 				{
1653 					rOStm << (sal_Int16) GDI_LINEDASHDOT_ACTION;
1654 					rOStm << (sal_Int32) 4 + 16;
1655 					rOStm << (sal_Int16)rInfo.GetDashCount();
1656 					rOStm << (sal_Int32)rInfo.GetDashLen();
1657 					rOStm << (sal_Int16)rInfo.GetDotCount();
1658 					rOStm << (sal_Int32)rInfo.GetDotLen();
1659 					rOStm << (sal_Int32)rInfo.GetDistance();
1660 				}
1661 
1662 				rOStm << (sal_Int16) GDI_POLYLINE_ACTION;
1663 				rOStm << (sal_Int32) ( 8 + ( nPoints << 3 ) );
1664 				rOStm << (sal_Int32) nPoints;
1665 
1666 				for( sal_uInt16 n = 0; n < nPoints; n++ )
1667 				{
1668 					rOStm << aSimplePoly[ n ];
1669 				}
1670 
1671 				nCount++;
1672 
1673 				const PolyPolygon aPolyPolygon(pAct->GetPolygon());
1674 				if(ImplWriteExtendedPolyPolygonAction(rOStm, aPolyPolygon, true))
1675 				{
1676 					nCount++;
1677 				}
1678 
1679 				if( bFatLine )
1680 				{
1681 					ImplWritePopAction( rOStm );
1682 					nCount += 3;
1683 
1684 					if(bLineJoin)
1685 					{
1686 						nCount += 1;
1687 					}
1688 
1689                     if(bLineCap)
1690                     {
1691                         nCount += 1;
1692                     }
1693 				}
1694 
1695 				if(bLineDashDot)
1696 				{
1697 					nCount += 1;
1698 				}
1699 			}
1700 			break;
1701 
1702 			case( META_POLYGON_ACTION ):
1703 			{
1704 				MetaPolygonAction* pAct = (MetaPolygonAction*)pAction;
1705                 // #i102224# Here the evtl. curved nature of Polygon was
1706                 // ignored (for all those Years). Adapted to at least write
1707                 // a polygon representing the curve as good as possible
1708  	            Polygon aSimplePoly;
1709  	            pAct->GetPolygon().AdaptiveSubdivide(aSimplePoly);
1710                 const sal_uInt16 nPoints(aSimplePoly.GetSize());
1711 
1712 				rOStm << (sal_Int16) GDI_POLYGON_ACTION;
1713 				rOStm << (sal_Int32) ( 8 + ( nPoints << 3 ) );
1714 				rOStm << (sal_Int32) nPoints;
1715 
1716 				for( sal_uInt16 n = 0; n < nPoints; n++ )
1717 					rOStm << aSimplePoly[ n ];
1718 
1719 				nCount++;
1720 
1721 				const PolyPolygon aPolyPolygon(pAct->GetPolygon());
1722 				if(ImplWriteExtendedPolyPolygonAction(rOStm, aPolyPolygon, true))
1723 				{
1724 					nCount++;
1725 				}
1726 			}
1727 			break;
1728 
1729 			case( META_POLYPOLYGON_ACTION ):
1730 			{
1731 				MetaPolyPolygonAction* pAct = (MetaPolyPolygonAction*) pAction;
1732 				ImplWritePolyPolyAction( rOStm, pAct->GetPolyPolygon() );
1733 				nCount++;
1734 
1735 				if(ImplWriteExtendedPolyPolygonAction(rOStm, pAct->GetPolyPolygon(), true))
1736 				{
1737 					nCount++;
1738 				}
1739 			}
1740 			break;
1741 
1742 			case( META_TEXT_ACTION ):
1743 			{
1744 				MetaTextAction* pAct = (MetaTextAction*) pAction;
1745 				String			aUniText( pAct->GetText() );
1746 				ByteString		aText( aUniText, rActualCharSet );
1747 				const sal_uLong 	nStrLen = aText.Len();
1748 
1749 				if ( ImplWriteUnicodeComment( rOStm, aUniText ) )
1750 					nCount++;
1751 
1752 				rOStm << (sal_Int16) GDI_TEXT_ACTION;
1753 				rOStm << (sal_Int32) ( 24 + ( nStrLen + 1 ) );
1754 				rOStm << pAct->GetPoint();
1755 				rOStm << (sal_Int32) pAct->GetIndex();
1756 				rOStm << (sal_Int32) pAct->GetLen();
1757 				rOStm << (sal_Int32) nStrLen;
1758 				rOStm.Write( aText.GetBuffer(), nStrLen + 1 );
1759 				nCount++;
1760 			}
1761 			break;
1762 
1763 			case( META_TEXTARRAY_ACTION ):
1764 			{
1765 				MetaTextArrayAction*	pAct = (MetaTextArrayAction*)pAction;
1766 				ByteString				aText( pAct->GetText(), rActualCharSet );
1767 				String					aUniText( pAct->GetText(), pAct->GetIndex(), pAct->GetLen() );
1768 				sal_uLong					nAryLen;
1769 				sal_uLong					nLen = pAct->GetLen();
1770 				const sal_uLong 			nTextLen = aText.Len();
1771 				sal_Int32*				pDXArray = pAct->GetDXArray();
1772 
1773 				if ( ImplWriteUnicodeComment( rOStm, aUniText ) )
1774 					nCount++;
1775 
1776 				if( ( nLen + pAct->GetIndex() ) > nTextLen )
1777 				{
1778 					if( pAct->GetIndex() <= nTextLen )
1779 						nLen = nTextLen - pAct->GetIndex();
1780 					else
1781 						nLen = 0UL;
1782 				}
1783 
1784 				if( !pDXArray || !nLen )
1785 					nAryLen = 0;
1786 				else
1787 					nAryLen = nLen;	// #105987# Write out all of DX array
1788 
1789 				rOStm << (sal_Int16) GDI_TEXTARRAY_ACTION;
1790 				rOStm << (sal_Int32) ( 28 + ( nLen + 1 ) + ( nAryLen * 4 ) );
1791 				rOStm << pAct->GetPoint();
1792 				rOStm << (sal_Int32) 0;
1793 				rOStm << (sal_Int32) nLen;
1794 				rOStm << (sal_Int32) nLen;
1795 				rOStm << (sal_Int32) nAryLen;
1796 				rOStm.Write( aText.GetBuffer()+pAct->GetIndex(), nLen + 1 );
1797 
1798 				for( sal_uLong n = 0UL ; n < nAryLen; n++ )
1799 					rOStm << (sal_Int32) pDXArray[ n ];
1800 
1801 				nCount++;
1802 			}
1803 			break;
1804 
1805 			case( META_STRETCHTEXT_ACTION ):
1806 			{
1807 				MetaStretchTextAction*	pAct = (MetaStretchTextAction*) pAction;
1808 				String					aUniText( pAct->GetText() );
1809 				ByteString				aText( aUniText, rActualCharSet );
1810 				const sal_uLong 			nStrLen = aText.Len();
1811 
1812 				if ( ImplWriteUnicodeComment( rOStm, aUniText ) )
1813 					nCount++;
1814 
1815 				rOStm << (sal_Int16) GDI_STRETCHTEXT_ACTION;
1816 				rOStm << (sal_Int32) ( 28 + ( nStrLen + 1 ) );
1817 				rOStm << pAct->GetPoint();
1818 				rOStm << (sal_Int32) pAct->GetIndex();
1819 				rOStm << (sal_Int32) pAct->GetLen();
1820 				rOStm << (sal_Int32) nStrLen;
1821 				rOStm << (sal_Int32) pAct->GetWidth();
1822 				rOStm.Write( aText.GetBuffer(), nStrLen + 1 );
1823 				nCount++;
1824 			}
1825 			break;
1826 
1827 			case( META_BMP_ACTION ):
1828 			{
1829 				MetaBmpAction* pAct = (MetaBmpAction*) pAction;
1830 
1831 				rOStm << (sal_Int16) GDI_BITMAP_ACTION;
1832 				rOStm << (sal_Int32) 12;
1833 				rOStm << pAct->GetPoint();
1834                 WriteDIB(pAct->GetBitmap(), rOStm, false, true);
1835 				nCount++;
1836 			}
1837 			break;
1838 
1839 			case( META_BMPSCALE_ACTION ):
1840 			{
1841 				MetaBmpScaleAction* pAct = (MetaBmpScaleAction*) pAction;
1842 
1843 				rOStm << (sal_Int16) GDI_BITMAPSCALE_ACTION;
1844 				rOStm << (sal_Int32) 20;
1845 				rOStm << pAct->GetPoint();
1846 				rOStm << pAct->GetSize();
1847                 WriteDIB(pAct->GetBitmap(), rOStm, false, true);
1848 				nCount++;
1849 			}
1850 			break;
1851 
1852 			case( META_BMPSCALEPART_ACTION ):
1853 			{
1854 				MetaBmpScalePartAction* pAct = (MetaBmpScalePartAction*) pAction;
1855 
1856 				rOStm << (sal_Int16) GDI_BITMAPSCALEPART_ACTION;
1857 				rOStm << (sal_Int32) 36;
1858 				rOStm << pAct->GetDestPoint();
1859 				rOStm << pAct->GetDestSize();
1860 				rOStm << pAct->GetSrcPoint();
1861 				rOStm << pAct->GetSrcSize();
1862                 WriteDIB(pAct->GetBitmap(), rOStm, false, true);
1863 				nCount++;
1864 			}
1865 			break;
1866 
1867 			case( META_BMPEX_ACTION ):
1868 			{
1869 				MetaBmpExAction*	pAct = (MetaBmpExAction*) pAction;
1870 				const Bitmap		aBmp( Graphic( pAct->GetBitmapEx() ).GetBitmap() );
1871 
1872 				rOStm << (sal_Int16) GDI_BITMAP_ACTION;
1873 				rOStm << (sal_Int32) 12;
1874 				rOStm << pAct->GetPoint();
1875                 WriteDIB(aBmp, rOStm, false, true);
1876 				nCount++;
1877 			}
1878 			break;
1879 
1880 			case( META_BMPEXSCALE_ACTION ):
1881 			{
1882 				MetaBmpExScaleAction*	pAct = (MetaBmpExScaleAction*) pAction;
1883 				const Bitmap			aBmp( Graphic( pAct->GetBitmapEx() ).GetBitmap() );
1884 
1885 				rOStm << (sal_Int16) GDI_BITMAPSCALE_ACTION;
1886 				rOStm << (sal_Int32) 20;
1887 				rOStm << pAct->GetPoint();
1888 				rOStm << pAct->GetSize();
1889                 WriteDIB(aBmp, rOStm, false, true);
1890 				nCount++;
1891 			}
1892 			break;
1893 
1894 			case( META_BMPEXSCALEPART_ACTION ):
1895 			{
1896 				MetaBmpExScalePartAction* pAct = (MetaBmpExScalePartAction*) pAction;
1897 				const Bitmap			aBmp( Graphic( pAct->GetBitmapEx() ).GetBitmap() );
1898 
1899 				rOStm << (sal_Int16) GDI_BITMAPSCALEPART_ACTION;
1900 				rOStm << (sal_Int32) 36;
1901 				rOStm << pAct->GetDestPoint();
1902 				rOStm << pAct->GetDestSize();
1903 				rOStm << pAct->GetSrcPoint();
1904 				rOStm << pAct->GetSrcSize();
1905                 WriteDIB(aBmp, rOStm, false, true);
1906 				nCount++;
1907 			}
1908 			break;
1909 
1910 			case( META_GRADIENT_ACTION ):
1911 			{
1912 				MetaGradientAction* pAct = (MetaGradientAction*) pAction;
1913 				const Gradient& 	rGrad = pAct->GetGradient();
1914 
1915 				rOStm << (sal_Int16) GDI_GRADIENT_ACTION;
1916 				rOStm << (sal_Int32) 46;
1917 				ImplWriteRect( rOStm, pAct->GetRect() );
1918 				rOStm << (sal_Int16) rGrad.GetStyle();
1919 				ImplWriteColor( rOStm, rGrad.GetStartColor() );
1920 				ImplWriteColor( rOStm, rGrad.GetEndColor() );
1921 				rOStm << (sal_Int16) rGrad.GetAngle();
1922 				rOStm << (sal_Int16) rGrad.GetBorder();
1923 				rOStm << (sal_Int16) rGrad.GetOfsX();
1924 				rOStm << (sal_Int16) rGrad.GetOfsY();
1925 				rOStm << (sal_Int16) rGrad.GetStartIntensity();
1926 				rOStm << (sal_Int16) rGrad.GetEndIntensity();
1927 				nCount++;
1928 			}
1929 			break;
1930 
1931 			case( META_GRADIENTEX_ACTION ):
1932 			{
1933 				const MetaGradientExAction* pA = (MetaGradientExAction*) pAction;
1934 				sal_uLong						nOldPos, nNewPos;
1935 
1936 				// write RefPoint comment
1937 				rOStm << (sal_Int16) GDI_GRADIENTEX_COMMENT;
1938 
1939 				// we'll write the ActionSize later
1940 				nOldPos = rOStm.Tell();
1941 				rOStm.SeekRel( 4 );
1942 
1943 				// write data
1944 				rOStm << pA->GetPolyPolygon() << pA->GetGradient();
1945 				rOStm << (sal_Int32) 0; // number of actions that follow this comment
1946 
1947 				// calculate and write ActionSize of comment
1948 				nNewPos = rOStm.Tell();
1949 				rOStm.Seek( nOldPos );
1950 				rOStm << (sal_Int32) ( nNewPos - nOldPos );
1951 				rOStm.Seek( nNewPos );
1952 
1953 				nCount++;
1954 			}
1955 			break;
1956 
1957 			case( META_WALLPAPER_ACTION ):
1958 			{
1959 				MetaWallpaperAction*	pAct = (MetaWallpaperAction*) pAction;
1960 				const Color&			rColor = pAct->GetWallpaper().GetColor();
1961 
1962 				ImplWritePushAction( rOStm );
1963 				ImplWriteLineColor( rOStm, rColor, 1 );
1964 				ImplWriteFillColor( rOStm, rColor, 1 );
1965 
1966 				rOStm << (sal_Int16) GDI_RECT_ACTION;
1967 				rOStm << (sal_Int32) 28;
1968 				ImplWriteRect( rOStm, pAct->GetRect() );
1969 				rOStm << (sal_Int32) 0;
1970 				rOStm << (sal_Int32) 0;
1971 
1972 				ImplWritePopAction( rOStm );
1973 				nCount += 5;
1974 			}
1975 			break;
1976 
1977 			case( META_CLIPREGION_ACTION ):
1978 			{
1979 				MetaClipRegionAction*	pAct = (MetaClipRegionAction*) pAction;
1980 				const Region&			rRegion = pAct->GetRegion();
1981 				Rectangle				aClipRect;
1982 
1983 				rOStm << (sal_Int16) GDI_CLIPREGION_ACTION;
1984 				rOStm << (sal_Int32) 24;
1985 
1986 				if( pAct->IsClipping() )
1987 				{
1988 					aClipRect = rRegion.GetBoundRect();
1989 					rOStm << (sal_Int16) 1;
1990 				}
1991 				else
1992 					rOStm << (sal_Int16) 0;
1993 
1994 				rOStm << (sal_Int16) 0;
1995 				ImplWriteRect( rOStm, aClipRect );
1996 
1997 				if( pAct->IsClipping() )
1998 					ImplWriteRect( rOStm, aClipRect );
1999 
2000 				nCount++;
2001 			}
2002 			break;
2003 
2004 			case( META_ISECTRECTCLIPREGION_ACTION ):
2005 			{
2006 				MetaISectRectClipRegionAction* pAct = (MetaISectRectClipRegionAction*) pAction;
2007 
2008 				rOStm << (sal_Int16) GDI_ISECTCLIPREGION_ACTION;
2009 				rOStm << (sal_Int32) 20;
2010 				rOStm << pAct->GetRect();
2011 				nCount++;
2012 			}
2013 			break;
2014 
2015 			case( META_MOVECLIPREGION_ACTION ):
2016 			{
2017 				MetaMoveClipRegionAction* pAct = (MetaMoveClipRegionAction*) pAction;
2018 
2019 				rOStm << (sal_Int16) GDI_MOVECLIPREGION_ACTION;
2020 				rOStm << (sal_Int32) 12;
2021 				rOStm << (sal_Int32) pAct->GetHorzMove();
2022 				rOStm << (sal_Int32) pAct->GetVertMove();
2023 				nCount++;
2024 			}
2025 			break;
2026 
2027 			case( META_LINECOLOR_ACTION ):
2028 			{
2029 				MetaLineColorAction* pAct = (MetaLineColorAction*) pAction;
2030 				ImplWriteLineColor( rOStm, rLineCol = pAct->GetColor(), pAct->IsSetting() ? 1 : 0 );
2031 				nCount++;
2032 			}
2033 			break;
2034 
2035 			case( META_FILLCOLOR_ACTION ):
2036 			{
2037 				MetaFillColorAction* pAct = (MetaFillColorAction*) pAction;
2038 				ImplWriteFillColor( rOStm, pAct->GetColor(), pAct->IsSetting() ? 1 : 0 );
2039 				nCount++;
2040 			}
2041 			break;
2042 
2043 			case( META_FONT_ACTION ):
2044 			{
2045 				rSaveVDev.SetFont( ( (MetaFontAction*) pAction )->GetFont() );
2046 				ImplWriteFont( rOStm, rSaveVDev.GetFont(), rActualCharSet );
2047 				nCount++;
2048 			}
2049 			break;
2050 
2051 			case( META_TEXTCOLOR_ACTION ):
2052 			{
2053 				Font aSaveFont( rSaveVDev.GetFont() );
2054 
2055 				aSaveFont.SetColor( ( (MetaTextColorAction*) pAction )->GetColor() );
2056 				rSaveVDev.SetFont( aSaveFont );
2057 				ImplWriteFont( rOStm, rSaveVDev.GetFont(), rActualCharSet );
2058 				nCount++;
2059 			}
2060 			break;
2061 
2062 			case( META_TEXTFILLCOLOR_ACTION ):
2063 			{
2064 				MetaTextFillColorAction*	pAct = (MetaTextFillColorAction*) pAction;
2065 				Font						aSaveFont( rSaveVDev.GetFont() );
2066 
2067 				if( pAct->IsSetting() )
2068 					aSaveFont.SetFillColor( pAct->GetColor() );
2069 				else
2070 					aSaveFont.SetFillColor( Color( COL_TRANSPARENT ) );
2071 
2072 				rSaveVDev.SetFont( aSaveFont );
2073 				ImplWriteFont( rOStm, rSaveVDev.GetFont(), rActualCharSet );
2074 				nCount++;
2075 			}
2076 			break;
2077 
2078 			case( META_TEXTALIGN_ACTION ):
2079 			{
2080 				Font aSaveFont( rSaveVDev.GetFont() );
2081 
2082 				aSaveFont.SetAlign( ( (MetaTextAlignAction*) pAction )->GetTextAlign() );
2083 				rSaveVDev.SetFont( aSaveFont );
2084 				ImplWriteFont( rOStm, rSaveVDev.GetFont(), rActualCharSet );
2085 				nCount++;
2086 			}
2087 			break;
2088 
2089 			case( META_MAPMODE_ACTION ):
2090 			{
2091 				MetaMapModeAction* pAct = (MetaMapModeAction*) pAction;
2092 
2093 				rOStm << (sal_Int16) GDI_MAPMODE_ACTION;
2094 				rOStm << (sal_Int32) 30;
2095 				ImplWriteMapMode( rOStm, pAct->GetMapMode() );
2096 				nCount++;
2097 			}
2098 			break;
2099 
2100 			case( META_PUSH_ACTION ):
2101 			{
2102 				ImplWritePushAction( rOStm );
2103 				rLineColStack.Push( new Color( rLineCol ) );
2104 				rSaveVDev.Push();
2105 				nCount++;
2106 			}
2107 			break;
2108 
2109 			case( META_POP_ACTION ):
2110 			{
2111 				Color* pCol = (Color*) rLineColStack.Pop();
2112 
2113 				if( pCol )
2114 				{
2115 					rLineCol = *pCol;
2116 					delete pCol;
2117 				}
2118 
2119 				ImplWritePopAction( rOStm );
2120 				rSaveVDev.Pop();
2121 				nCount++;
2122 			}
2123 			break;
2124 
2125 			case( META_RASTEROP_ACTION ):
2126 			{
2127 				MetaRasterOpAction* pAct = (MetaRasterOpAction*) pAction;
2128 
2129 				if( ( pAct->GetRasterOp() != ROP_0 ) && ( pAct->GetRasterOp() != ROP_1 ) )
2130 				{
2131 					sal_Int16 nRasterOp;
2132 
2133 					// Falls vorher ROP_0/1 gesetzt war, alten
2134 					// Zustand durch Pop erst wieder herstellen
2135 					if( rRop_0_1 )
2136 					{
2137 						ImplWritePopAction( rOStm );
2138 						rSaveVDev.Pop();
2139 						rRop_0_1 = sal_False;
2140 						nCount++;
2141 					}
2142 
2143 					switch( pAct->GetRasterOp() )
2144 					{
2145 						case( ROP_OVERPAINT ) : nRasterOp = 0; break;
2146 						case( ROP_XOR ) :		nRasterOp = 4; break;
2147 						case( ROP_INVERT ): 	nRasterOp = 1; break;
2148 						default:				nRasterOp = 0; break;
2149 					}
2150 
2151 					ImplWriteRasterOpAction( rOStm, nRasterOp );
2152 					nCount++;
2153 				}
2154 				else
2155 				{
2156 					ImplWritePushAction( rOStm );
2157 					rSaveVDev.Push();
2158 
2159 					if( pAct->GetRasterOp() == ROP_0 )
2160 					{
2161 						ImplWriteLineColor( rOStm, COL_BLACK, 1 );
2162 						ImplWriteFillColor( rOStm, COL_BLACK, 1 );
2163 					}
2164 					else
2165 					{
2166 						ImplWriteLineColor( rOStm, COL_WHITE, 1 );
2167 						ImplWriteFillColor( rOStm, COL_WHITE, 1 );
2168 					}
2169 
2170 					ImplWriteRasterOpAction( rOStm, 0 );
2171 					rRop_0_1 = sal_True;
2172 					nCount += 4;
2173 				}
2174 			}
2175 			break;
2176 
2177 			case( META_TRANSPARENT_ACTION ):
2178 			{
2179 				const PolyPolygon&	rPolyPoly = ( (MetaTransparentAction*) pAction )->GetPolyPolygon();
2180 				const sal_Int16 		nTrans = ( (MetaTransparentAction*) pAction )->GetTransparence();
2181 				const sal_Int16 		nBrushStyle = ( nTrans < 38 ) ? 8 : ( nTrans < 63 ) ? 9 : 10;
2182 				sal_uLong				nOldPos, nNewPos;
2183 
2184 				// write transparence comment
2185 				rOStm << (sal_Int16) GDI_TRANSPARENT_COMMENT;
2186 
2187 				// we'll write the ActionSize later
2188 				nOldPos = rOStm.Tell();
2189 				rOStm.SeekRel( 4 );
2190 
2191 				// write comment data
2192 				rOStm << rPolyPoly;
2193 				rOStm << nTrans;
2194 				rOStm << (sal_Int32) 15; // number of actions that follow this comment
2195 
2196 				// calculate and write ActionSize of comment
2197 				nNewPos = rOStm.Tell();
2198 				rOStm.Seek( nOldPos );
2199 				rOStm << (sal_Int32) ( nNewPos - nOldPos );
2200 				rOStm.Seek( nNewPos );
2201 
2202 				{
2203 					// write actions for transparence
2204 					ImplWritePushAction( rOStm );
2205 					{
2206 						ImplWriteRasterOpAction( rOStm, 4 );
2207 						ImplWritePolyPolyAction( rOStm, rPolyPoly );
2208 
2209 						ImplWritePushAction( rOStm );
2210 						{
2211 							ImplWriteRasterOpAction( rOStm, 2 );
2212 							ImplWriteFillColor( rOStm, COL_BLACK, nBrushStyle );
2213 							ImplWritePolyPolyAction( rOStm, rPolyPoly );
2214 						}
2215 						ImplWritePopAction( rOStm );
2216 
2217 						ImplWriteRasterOpAction( rOStm, 4 );
2218 						ImplWritePolyPolyAction( rOStm, rPolyPoly );
2219 					}
2220 					ImplWritePopAction( rOStm );
2221 
2222 					ImplWritePushAction( rOStm );
2223 					{
2224 						ImplWriteFillColor( rOStm, Color(), 0 );
2225 						ImplWritePolyPolyAction( rOStm, rPolyPoly );
2226 					}
2227 					ImplWritePopAction( rOStm );
2228 
2229 #ifdef CVTSVM_WRITE_SUBACTIONCOUNT
2230 					nCount += 15;
2231 #endif
2232 				}
2233 
2234 				nCount++;
2235 			}
2236 			break;
2237 
2238 			case( META_FLOATTRANSPARENT_ACTION ):
2239 			{
2240 				const MetaFloatTransparentAction*	pA = (MetaFloatTransparentAction*) pAction;
2241 				const GDIMetaFile&					rTransMtf = pA->GetGDIMetaFile();
2242 				const Point&						rPos = pA->GetPoint();
2243 				const Size& 						rSize = pA->GetSize();
2244 				const Gradient& 					rGradient = pA->GetGradient();
2245 				sal_uLong								nOldPos, nNewPos;
2246 
2247 				// write RefPoint comment
2248 				rOStm << (sal_Int16) GDI_FLOATTRANSPARENT_COMMENT;
2249 
2250 				// we'll write the ActionSize later
2251 				nOldPos = rOStm.Tell();
2252 				rOStm.SeekRel( 4 );
2253 
2254 				// write comment data
2255 				rOStm << rTransMtf << rPos << rSize << rGradient;
2256 
2257 				// calculate and write ActionSize of comment
2258 				nNewPos = rOStm.Tell();
2259 				rOStm.Seek( nOldPos );
2260 				rOStm << (sal_Int32) ( nNewPos - nOldPos + 4 );
2261 				rOStm.Seek( ( nOldPos = nNewPos ) + 4 );
2262 
2263 				{
2264 					// write actions for float transparence
2265 					sal_uLong			nAddCount;
2266 					GDIMetaFile 	aMtf( rTransMtf );
2267 					const Size		aSrcSize( rTransMtf.GetPrefSize() );
2268 					Point			aSrcPt( rTransMtf.GetPrefMapMode().GetOrigin() );
2269 					const double	fScaleX = aSrcSize.Width() ? (double) rSize.Width() / aSrcSize.Width() : 1.0;
2270 					const double	fScaleY = aSrcSize.Height() ? (double) rSize.Height() / aSrcSize.Height() : 1.0;
2271 					long			nMoveX, nMoveY;
2272 
2273 					if( fScaleX != 1.0 || fScaleY != 1.0 )
2274 					{
2275 						aMtf.Scale( fScaleX, fScaleY );
2276 						aSrcPt.X() = FRound( aSrcPt.X() * fScaleX ), aSrcPt.Y() = FRound( aSrcPt.Y() * fScaleY );
2277 					}
2278 
2279 					nMoveX = rPos.X() - aSrcPt.X(), nMoveY = rPos.Y() - aSrcPt.Y();
2280 
2281 					if( nMoveX || nMoveY )
2282 						aMtf.Move( nMoveX, nMoveY );
2283 
2284 					nAddCount = ImplWriteActions( rOStm, aMtf, rSaveVDev, rRop_0_1, rLineCol, rLineColStack, rActualCharSet );
2285 					nNewPos = rOStm.Tell();
2286 					rOStm.Seek( nOldPos );
2287 					rOStm << (sal_Int32) nAddCount;
2288 					rOStm.Seek( nNewPos );
2289 
2290 #ifdef CVTSVM_WRITE_SUBACTIONCOUNT
2291 					nCount += nAddCount;
2292 #endif
2293 				}
2294 
2295 				nCount++;
2296 			}
2297 			break;
2298 
2299 			case( META_HATCH_ACTION ):
2300 			{
2301 				const MetaHatchAction*	pA = (MetaHatchAction*) pAction;
2302 				const PolyPolygon&		rPolyPoly = pA->GetPolyPolygon();
2303 				const Hatch&			rHatch = pA->GetHatch();
2304 				sal_uLong					nOldPos, nNewPos, nAddCount;
2305 
2306 				// write hatch comment
2307 				rOStm << (sal_Int16) GDI_HATCH_COMMENT;
2308 
2309 				// we'll write the ActionSize later
2310 				nOldPos = rOStm.Tell();
2311 				rOStm.SeekRel( 4 );
2312 
2313 				// write comment data
2314 				rOStm << rPolyPoly;
2315 				rOStm << rHatch;
2316 
2317 				// calculate and write ActionSize of comment
2318 				nNewPos = rOStm.Tell();
2319 				rOStm.Seek( nOldPos );
2320 				rOStm << (sal_Int32) ( nNewPos - nOldPos + 4 );
2321 				rOStm.Seek( ( nOldPos = nNewPos ) + 4 );
2322 
2323 				{
2324 					// write actions for hatch
2325 					VirtualDevice	aVDev;
2326 					GDIMetaFile 	aTmpMtf;
2327 
2328 					aVDev.AddHatchActions( rPolyPoly, rHatch, aTmpMtf );
2329 					nAddCount = ImplWriteActions( rOStm, aTmpMtf, rSaveVDev, rRop_0_1, rLineCol, rLineColStack, rActualCharSet );
2330 					nNewPos = rOStm.Tell();
2331 					rOStm.Seek( nOldPos );
2332 					rOStm << (sal_Int32) nAddCount;
2333 					rOStm.Seek( nNewPos );
2334 
2335 #ifdef CVTSVM_WRITE_SUBACTIONCOUNT
2336 					nCount += nAddCount;
2337 #endif
2338 				}
2339 
2340 				nCount++;
2341 			}
2342 			break;
2343 
2344 			case( META_REFPOINT_ACTION ):
2345 			{
2346 				const MetaRefPointAction*	pA = (MetaRefPointAction*) pAction;
2347 				const Point&				rRefPoint = pA->GetRefPoint();
2348 				const sal_Bool					bSet = pA->IsSetting();
2349 				sal_uLong						nOldPos, nNewPos;
2350 
2351 				// write RefPoint comment
2352 				rOStm << (sal_Int16) GDI_REFPOINT_COMMENT;
2353 
2354 				// we'll write the ActionSize later
2355 				nOldPos = rOStm.Tell();
2356 				rOStm.SeekRel( 4 );
2357 
2358 				// write data
2359 				rOStm << rRefPoint << bSet;
2360 				rOStm << (sal_Int32) 0; // number of actions that follow this comment
2361 
2362 				// calculate and write ActionSize of comment
2363 				nNewPos = rOStm.Tell();
2364 				rOStm.Seek( nOldPos );
2365 				rOStm << (sal_Int32) ( nNewPos - nOldPos );
2366 				rOStm.Seek( nNewPos );
2367 
2368 				nCount++;
2369 			}
2370 			break;
2371 
2372 			case( META_TEXTLINECOLOR_ACTION ):
2373 			{
2374 				const MetaTextLineColorAction*	pA = (MetaTextLineColorAction*) pAction;
2375 				const Color&					rColor = pA->GetColor();
2376 				const sal_Bool						bSet = pA->IsSetting();
2377 				sal_uLong							nOldPos, nNewPos;
2378 
2379 				// write RefPoint comment
2380 				rOStm << (sal_Int16) GDI_TEXTLINECOLOR_COMMENT;
2381 
2382 				// we'll write the ActionSize later
2383 				nOldPos = rOStm.Tell();
2384 				rOStm.SeekRel( 4 );
2385 
2386 				// write data
2387 				rOStm << rColor << bSet;
2388 				rOStm << (sal_Int32) 0; // number of actions that follow this comment
2389 
2390 				// calculate and write ActionSize of comment
2391 				nNewPos = rOStm.Tell();
2392 				rOStm.Seek( nOldPos );
2393 				rOStm << (sal_Int32) ( nNewPos - nOldPos );
2394 				rOStm.Seek( nNewPos );
2395 
2396 				nCount++;
2397 			}
2398 			break;
2399 
2400 #if 0
2401 			case( META_OVERLINECOLOR_ACTION ):
2402 			break;
2403 #endif
2404 
2405 			case( META_TEXTLINE_ACTION ):
2406 			{
2407 				const MetaTextLineAction*	pA = (MetaTextLineAction*) pAction;
2408 				const Point&				rStartPt = pA->GetStartPoint();
2409 				const long					nWidth = pA->GetWidth();
2410 				const FontStrikeout 		eStrikeout = pA->GetStrikeout();
2411 				const FontUnderline 		eUnderline = pA->GetUnderline();
2412 				sal_uLong						nOldPos, nNewPos;
2413 
2414 				// write RefPoint comment
2415 				rOStm << (sal_Int16) GDI_TEXTLINE_COMMENT;
2416 
2417 				// we'll write the ActionSize later
2418 				nOldPos = rOStm.Tell();
2419 				rOStm.SeekRel( 4 );
2420 
2421 				// write data
2422 				rOStm << rStartPt << nWidth <<
2423 					static_cast<sal_uInt32>(eStrikeout) <<
2424 					static_cast<sal_uInt32>(eUnderline);
2425 				rOStm << (sal_Int32) 0; // number of actions that follow this comment
2426 
2427 				// calculate and write ActionSize of comment
2428 				nNewPos = rOStm.Tell();
2429 				rOStm.Seek( nOldPos );
2430 				rOStm << (sal_Int32) ( nNewPos - nOldPos );
2431 				rOStm.Seek( nNewPos );
2432 
2433 				nCount++;
2434 			}
2435 			break;
2436 
2437 			case( META_EPS_ACTION ):
2438 			break;
2439 
2440 			case( META_COMMENT_ACTION ):
2441 			{
2442 				const MetaCommentAction*	pA = (MetaCommentAction*) pAction;
2443 				const sal_uInt32 			nDataSize = pA->GetDataSize();
2444 				sal_uLong						nOldPos, nNewPos;
2445 
2446 				// write RefPoint comment
2447 				rOStm << (sal_Int16) GDI_COMMENT_COMMENT;
2448 
2449 				// we'll write the ActionSize later
2450 				nOldPos = rOStm.Tell();
2451 				rOStm.SeekRel( 4 );
2452 
2453 				// write data
2454 				rOStm << pA->GetComment() << pA->GetValue() << nDataSize;
2455 
2456 				if( nDataSize )
2457 					rOStm.Write( pA->GetData(), nDataSize );
2458 
2459 				rOStm << (sal_Int32) 0; // number of actions that follow this comment
2460 
2461 				// calculate and write ActionSize of comment
2462 				nNewPos = rOStm.Tell();
2463 				rOStm.Seek( nOldPos );
2464 				rOStm << (sal_Int32) ( nNewPos - nOldPos );
2465 				rOStm.Seek( nNewPos );
2466 
2467 				nCount++;
2468 			}
2469 			break;
2470 
2471 #ifdef DBG_UTIL
2472 			default:
2473 			{
2474 				ByteString aStr( "Missing implementation for Action#: " );
2475 				aStr += ByteString::CreateFromInt32( pAction->GetType() );
2476 				aStr += '!';
2477 				DBG_ERROR( aStr.GetBuffer() );
2478 			}
2479 			break;
2480 #endif
2481 
2482 /*
2483 			case( META_TEXTRECT_ACTION ):
2484 			{
2485 				MetaTextRectAction* pAct = (MetaTextRectAction*) pAction;
2486 
2487 				rOStm << ;
2488 				rOStm << ;
2489 
2490 				nCount++;
2491 			}
2492 			break;
2493 */
2494 
2495 /*
2496 			case( META_MASK_ACTION ):
2497 			{
2498 				MetaMaskAction* pAct = (MetaMaskAction*) pAction;
2499 
2500 				rOStm << ;
2501 				rOStm << ;
2502 
2503 				nCount++;
2504 			}
2505 			break;
2506 */
2507 
2508 /*
2509 			case( META_MASKSCALE_ACTION ):
2510 			{
2511 				MetaMaskScaleAction* pAct = (MetaMaskScaleAction*) pAction;
2512 
2513 				rOStm << ;
2514 				rOStm << ;
2515 
2516 				nCount++;
2517 			}
2518 			break;
2519 */
2520 
2521 /*
2522 			case( META_MASKSCALEPART_ACTION ):
2523 			{
2524 				MetaMaskScalePartAction* pAct = (MetaMaskScalePartAction*) pAction;
2525 
2526 				rOStm << ;
2527 				rOStm << ;
2528 
2529 				nCount++;
2530 			}
2531 			break;
2532 */
2533 
2534 /*
2535 			case( META_ISECTREGIONCLIPREGION_ACTION ):
2536 			{
2537 				MetaISectRegionClipRegionAction* pAct = (MetaISectRegionClipRegionAction*) pAction;
2538 
2539 				rOStm << ;
2540 				rOStm << ;
2541 
2542 				nCount++;
2543 			}
2544 			break;
2545 */
2546 		}
2547 	}
2548 
2549 	return nCount;
2550 }
2551