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