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 <stdio.h>
22 : #include <string.h>
23 : #include <osl/thread.h>
24 : #include <tools/stream.hxx>
25 : #include <tools/vcompat.hxx>
26 : #include <tools/helpers.hxx>
27 : #include <vcl/dibtools.hxx>
28 : #include <vcl/outdev.hxx>
29 : #include <vcl/metaact.hxx>
30 : #include <vcl/graphictools.hxx>
31 : #include <basegfx/matrix/b2dhommatrixtools.hxx>
32 : #include <unotools/fontdefs.hxx>
33 :
34 : namespace
35 : {
36 :
37 : const char *
38 0 : meta_action_name(sal_uInt16 nMetaAction)
39 : {
40 : #ifndef SAL_LOG_INFO
41 : (void) nMetaAction;
42 0 : return "";
43 : #else
44 : switch( nMetaAction )
45 : {
46 : case META_NULL_ACTION: return "NULL";
47 : case META_PIXEL_ACTION: return "PIXEL";
48 : case META_POINT_ACTION: return "POINT";
49 : case META_LINE_ACTION: return "LINE";
50 : case META_RECT_ACTION: return "RECT";
51 : case META_ROUNDRECT_ACTION: return "ROUNDRECT";
52 : case META_ELLIPSE_ACTION: return "ELLIPSE";
53 : case META_ARC_ACTION: return "ARC";
54 : case META_PIE_ACTION: return "PIE";
55 : case META_CHORD_ACTION: return "CHORD";
56 : case META_POLYLINE_ACTION: return "POLYLINE";
57 : case META_POLYGON_ACTION: return "POLYGON";
58 : case META_POLYPOLYGON_ACTION: return "POLYPOLYGON";
59 : case META_TEXT_ACTION: return "TEXT";
60 : case META_TEXTARRAY_ACTION: return "TEXTARRAY";
61 : case META_STRETCHTEXT_ACTION: return "STRETCHTEXT";
62 : case META_TEXTRECT_ACTION: return "TEXTRECT";
63 : case META_BMP_ACTION: return "BMP";
64 : case META_BMPSCALE_ACTION: return "BMPSCALE";
65 : case META_BMPSCALEPART_ACTION: return "BMPSCALEPART";
66 : case META_BMPEX_ACTION: return "BMPEX";
67 : case META_BMPEXSCALE_ACTION: return "BMPEXSCALE";
68 : case META_BMPEXSCALEPART_ACTION: return "BMPEXSCALEPART";
69 : case META_MASK_ACTION: return "MASK";
70 : case META_MASKSCALE_ACTION: return "MASKSCALE";
71 : case META_MASKSCALEPART_ACTION: return "MASKSCALEPART";
72 : case META_GRADIENT_ACTION: return "GRADIENT";
73 : case META_HATCH_ACTION: return "HATCH";
74 : case META_WALLPAPER_ACTION: return "WALLPAPER";
75 : case META_CLIPREGION_ACTION: return "CLIPREGION";
76 : case META_ISECTRECTCLIPREGION_ACTION: return "ISECTRECTCLIPREGION";
77 : case META_ISECTREGIONCLIPREGION_ACTION: return "ISECTREGIONCLIPREGION";
78 : case META_MOVECLIPREGION_ACTION: return "MOVECLIPREGION";
79 : case META_LINECOLOR_ACTION: return "LINECOLOR";
80 : case META_FILLCOLOR_ACTION: return "FILLCOLOR";
81 : case META_TEXTCOLOR_ACTION: return "TEXTCOLOR";
82 : case META_TEXTFILLCOLOR_ACTION: return "TEXTFILLCOLOR";
83 : case META_TEXTALIGN_ACTION: return "TEXTALIGN";
84 : case META_MAPMODE_ACTION: return "MAPMODE";
85 : case META_FONT_ACTION: return "FONT";
86 : case META_PUSH_ACTION: return "PUSH";
87 : case META_POP_ACTION: return "POP";
88 : case META_RASTEROP_ACTION: return "RASTEROP";
89 : case META_TRANSPARENT_ACTION: return "TRANSPARENT";
90 : case META_EPS_ACTION: return "EPS";
91 : case META_REFPOINT_ACTION: return "REFPOINT";
92 : case META_TEXTLINECOLOR_ACTION: return "TEXTLINECOLOR";
93 : case META_TEXTLINE_ACTION: return "TEXTLINE";
94 : case META_FLOATTRANSPARENT_ACTION: return "FLOATTRANSPARENT";
95 : case META_GRADIENTEX_ACTION: return "GRADIENTEX";
96 : case META_LAYOUTMODE_ACTION: return "LAYOUTMODE";
97 : case META_TEXTLANGUAGE_ACTION: return "TEXTLANGUAGE";
98 : case META_OVERLINECOLOR_ACTION: return "OVERLINECOLOR";
99 : case META_COMMENT_ACTION: return "COMMENT";
100 : default:
101 : // Yes, return a pointer to a static buffer. This is a very
102 : // local debugging output function, so no big deal.
103 : static char buffer[6];
104 : sprintf(buffer, "%u", nMetaAction);
105 : return buffer;
106 : }
107 : #endif
108 : }
109 :
110 113662 : inline void ImplScalePoint( Point& rPt, double fScaleX, double fScaleY )
111 : {
112 113662 : rPt.X() = FRound( fScaleX * rPt.X() );
113 113662 : rPt.Y() = FRound( fScaleY * rPt.Y() );
114 113662 : }
115 :
116 66 : inline void ImplScaleRect( Rectangle& rRect, double fScaleX, double fScaleY )
117 : {
118 66 : Point aTL( rRect.TopLeft() );
119 66 : Point aBR( rRect.BottomRight() );
120 :
121 66 : ImplScalePoint( aTL, fScaleX, fScaleY );
122 66 : ImplScalePoint( aBR, fScaleX, fScaleY );
123 :
124 66 : rRect = Rectangle( aTL, aBR );
125 66 : rRect.Justify();
126 66 : }
127 :
128 1656 : inline void ImplScalePoly( Polygon& rPoly, double fScaleX, double fScaleY )
129 : {
130 114824 : for( sal_uInt16 i = 0, nCount = rPoly.GetSize(); i < nCount; i++ )
131 113168 : ImplScalePoint( rPoly[ i ], fScaleX, fScaleY );
132 1656 : }
133 :
134 336 : inline void ImplScaleLineInfo( LineInfo& rLineInfo, double fScaleX, double fScaleY )
135 : {
136 336 : if( !rLineInfo.IsDefault() )
137 : {
138 336 : const double fScale = ( fabs(fScaleX) + fabs(fScaleY) ) * 0.5;
139 :
140 336 : rLineInfo.SetWidth( FRound( fScale * rLineInfo.GetWidth() ) );
141 336 : rLineInfo.SetDashLen( FRound( fScale * rLineInfo.GetDashLen() ) );
142 336 : rLineInfo.SetDotLen( FRound( fScale * rLineInfo.GetDotLen() ) );
143 336 : rLineInfo.SetDistance( FRound( fScale * rLineInfo.GetDistance() ) );
144 : }
145 336 : }
146 :
147 : } //anonymous namespace
148 :
149 0 : MetaAction::MetaAction() :
150 : mnRefCount( 1 ),
151 0 : mnType( META_NULL_ACTION )
152 : {
153 0 : }
154 :
155 1606023 : MetaAction::MetaAction( sal_uInt16 nType ) :
156 : mnRefCount( 1 ),
157 1606023 : mnType( nType )
158 : {
159 1606023 : }
160 :
161 1612411 : MetaAction::~MetaAction()
162 : {
163 1612411 : }
164 :
165 0 : void MetaAction::Execute( OutputDevice* )
166 : {
167 0 : }
168 :
169 0 : MetaAction* MetaAction::Clone()
170 : {
171 0 : return new MetaAction;
172 : }
173 :
174 17570 : void MetaAction::Move( long, long )
175 : {
176 17570 : }
177 :
178 4882 : void MetaAction::Scale( double, double )
179 : {
180 4882 : }
181 :
182 0 : bool MetaAction::Compare( const MetaAction& ) const
183 : {
184 0 : return true;
185 : }
186 :
187 838944 : void MetaAction::Write( SvStream& rOStm, ImplMetaWriteData* )
188 : {
189 838944 : rOStm.WriteUInt16( mnType );
190 838944 : }
191 :
192 0 : void MetaAction::Read( SvStream&, ImplMetaReadData* )
193 : {
194 : // DO NOT read mnType - ReadMetaAction already did that!
195 0 : }
196 :
197 645730 : MetaAction* MetaAction::ReadMetaAction( SvStream& rIStm, ImplMetaReadData* pData )
198 : {
199 645730 : MetaAction* pAction = NULL;
200 645730 : sal_uInt16 nType = 0;
201 :
202 645730 : rIStm.ReadUInt16( nType );
203 :
204 : SAL_INFO("vcl.gdi", "ReadMetaAction " << meta_action_name( nType ));
205 :
206 645730 : switch( nType )
207 : {
208 0 : case META_NULL_ACTION: pAction = new MetaAction; break;
209 0 : case META_PIXEL_ACTION: pAction = new MetaPixelAction; break;
210 0 : case META_POINT_ACTION: pAction = new MetaPointAction; break;
211 0 : case META_LINE_ACTION: pAction = new MetaLineAction; break;
212 4266 : case META_RECT_ACTION: pAction = new MetaRectAction; break;
213 0 : case META_ROUNDRECT_ACTION: pAction = new MetaRoundRectAction; break;
214 0 : case META_ELLIPSE_ACTION: pAction = new MetaEllipseAction; break;
215 0 : case META_ARC_ACTION: pAction = new MetaArcAction; break;
216 0 : case META_PIE_ACTION: pAction = new MetaPieAction; break;
217 0 : case META_CHORD_ACTION: pAction = new MetaChordAction; break;
218 428 : case META_POLYLINE_ACTION: pAction = new MetaPolyLineAction; break;
219 360 : case META_POLYGON_ACTION: pAction = new MetaPolygonAction; break;
220 878 : case META_POLYPOLYGON_ACTION: pAction = new MetaPolyPolygonAction; break;
221 0 : case META_TEXT_ACTION: pAction = new MetaTextAction; break;
222 514 : case META_TEXTARRAY_ACTION: pAction = new MetaTextArrayAction; break;
223 71118 : case META_STRETCHTEXT_ACTION: pAction = new MetaStretchTextAction; break;
224 0 : case META_TEXTRECT_ACTION: pAction = new MetaTextRectAction; break;
225 0 : case META_TEXTLINE_ACTION: pAction = new MetaTextLineAction; break;
226 0 : case META_BMP_ACTION: pAction = new MetaBmpAction; break;
227 724 : case META_BMPSCALE_ACTION: pAction = new MetaBmpScaleAction; break;
228 0 : case META_BMPSCALEPART_ACTION: pAction = new MetaBmpScalePartAction; break;
229 0 : case META_BMPEX_ACTION: pAction = new MetaBmpExAction; break;
230 6 : case META_BMPEXSCALE_ACTION: pAction = new MetaBmpExScaleAction; break;
231 0 : case META_BMPEXSCALEPART_ACTION: pAction = new MetaBmpExScalePartAction; break;
232 0 : case META_MASK_ACTION: pAction = new MetaMaskAction; break;
233 0 : case META_MASKSCALE_ACTION: pAction = new MetaMaskScaleAction; break;
234 0 : case META_MASKSCALEPART_ACTION: pAction = new MetaMaskScalePartAction; break;
235 0 : case META_GRADIENT_ACTION: pAction = new MetaGradientAction; break;
236 0 : case META_GRADIENTEX_ACTION: pAction = new MetaGradientExAction; break;
237 2 : case META_HATCH_ACTION: pAction = new MetaHatchAction; break;
238 0 : case META_WALLPAPER_ACTION: pAction = new MetaWallpaperAction; break;
239 86 : case META_CLIPREGION_ACTION: pAction = new MetaClipRegionAction; break;
240 9750 : case META_ISECTRECTCLIPREGION_ACTION: pAction = new MetaISectRectClipRegionAction; break;
241 1922 : case META_ISECTREGIONCLIPREGION_ACTION: pAction = new MetaISectRegionClipRegionAction; break;
242 0 : case META_MOVECLIPREGION_ACTION: pAction = new MetaMoveClipRegionAction; break;
243 8514 : case META_LINECOLOR_ACTION: pAction = new MetaLineColorAction; break;
244 6380 : case META_FILLCOLOR_ACTION: pAction = new MetaFillColorAction; break;
245 76626 : case META_TEXTCOLOR_ACTION: pAction = new MetaTextColorAction; break;
246 75588 : case META_TEXTFILLCOLOR_ACTION: pAction = new MetaTextFillColorAction; break;
247 2 : case META_TEXTLINECOLOR_ACTION: pAction = new MetaTextLineColorAction; break;
248 2 : case META_OVERLINECOLOR_ACTION: pAction = new MetaOverlineColorAction; break;
249 75586 : case META_TEXTALIGN_ACTION: pAction = new MetaTextAlignAction; break;
250 612 : case META_MAPMODE_ACTION: pAction = new MetaMapModeAction; break;
251 75586 : case META_FONT_ACTION: pAction = new MetaFontAction; break;
252 90456 : case META_PUSH_ACTION: pAction = new MetaPushAction; break;
253 90456 : case META_POP_ACTION: pAction = new MetaPopAction; break;
254 32 : case META_RASTEROP_ACTION: pAction = new MetaRasterOpAction; break;
255 30 : case META_TRANSPARENT_ACTION: pAction = new MetaTransparentAction; break;
256 0 : case META_FLOATTRANSPARENT_ACTION: pAction = new MetaFloatTransparentAction; break;
257 0 : case META_EPS_ACTION: pAction = new MetaEPSAction; break;
258 0 : case META_REFPOINT_ACTION: pAction = new MetaRefPointAction; break;
259 8508 : case META_COMMENT_ACTION: pAction = new MetaCommentAction; break;
260 18504 : case META_LAYOUTMODE_ACTION: pAction = new MetaLayoutModeAction; break;
261 28794 : case META_TEXTLANGUAGE_ACTION: pAction = new MetaTextLanguageAction; break;
262 :
263 : default:
264 : {
265 0 : VersionCompat aCompat(rIStm, STREAM_READ);
266 : }
267 0 : break;
268 : }
269 :
270 645730 : if( pAction )
271 645730 : pAction->Read( rIStm, pData );
272 :
273 645730 : return pAction;
274 : }
275 :
276 0 : MetaPixelAction::MetaPixelAction() :
277 0 : MetaAction(META_PIXEL_ACTION)
278 0 : {}
279 :
280 216 : MetaPixelAction::~MetaPixelAction()
281 216 : {}
282 :
283 108 : MetaPixelAction::MetaPixelAction( const Point& rPt, const Color& rColor ) :
284 : MetaAction ( META_PIXEL_ACTION ),
285 : maPt ( rPt ),
286 108 : maColor ( rColor )
287 108 : {}
288 :
289 0 : void MetaPixelAction::Execute( OutputDevice* pOut )
290 : {
291 0 : pOut->DrawPixel( maPt, maColor );
292 0 : }
293 :
294 0 : MetaAction* MetaPixelAction::Clone()
295 : {
296 0 : MetaAction* pClone = (MetaAction*) new MetaPixelAction( *this );
297 0 : pClone->ResetRefCount();
298 0 : return pClone;
299 : }
300 :
301 0 : void MetaPixelAction::Move( long nHorzMove, long nVertMove )
302 : {
303 0 : maPt.Move( nHorzMove, nVertMove );
304 0 : }
305 :
306 0 : void MetaPixelAction::Scale( double fScaleX, double fScaleY )
307 : {
308 0 : ImplScalePoint( maPt, fScaleX, fScaleY );
309 0 : }
310 :
311 0 : bool MetaPixelAction::Compare( const MetaAction& rMetaAction ) const
312 : {
313 0 : return ( maPt == static_cast<const MetaPixelAction&>(rMetaAction).maPt ) &&
314 0 : ( maColor == static_cast<const MetaPixelAction&>(rMetaAction).maColor );
315 : }
316 :
317 0 : void MetaPixelAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
318 : {
319 0 : MetaAction::Write(rOStm, pData);
320 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
321 0 : WritePair( rOStm, maPt );
322 0 : maColor.Write( rOStm, true );
323 0 : }
324 :
325 0 : void MetaPixelAction::Read( SvStream& rIStm, ImplMetaReadData* )
326 : {
327 0 : VersionCompat aCompat(rIStm, STREAM_READ);
328 0 : ReadPair( rIStm, maPt );
329 0 : maColor.Read( rIStm, true );
330 0 : }
331 :
332 0 : MetaPointAction::MetaPointAction() :
333 0 : MetaAction(META_POINT_ACTION)
334 0 : {}
335 :
336 3912 : MetaPointAction::~MetaPointAction()
337 3912 : {}
338 :
339 1956 : MetaPointAction::MetaPointAction( const Point& rPt ) :
340 : MetaAction ( META_POINT_ACTION ),
341 1956 : maPt ( rPt )
342 1956 : {}
343 :
344 1956 : void MetaPointAction::Execute( OutputDevice* pOut )
345 : {
346 1956 : pOut->DrawPixel( maPt );
347 1956 : }
348 :
349 0 : MetaAction* MetaPointAction::Clone()
350 : {
351 0 : MetaAction* pClone = (MetaAction*) new MetaPointAction( *this );
352 0 : pClone->ResetRefCount();
353 0 : return pClone;
354 : }
355 :
356 0 : void MetaPointAction::Move( long nHorzMove, long nVertMove )
357 : {
358 0 : maPt.Move( nHorzMove, nVertMove );
359 0 : }
360 :
361 0 : void MetaPointAction::Scale( double fScaleX, double fScaleY )
362 : {
363 0 : ImplScalePoint( maPt, fScaleX, fScaleY );
364 0 : }
365 :
366 0 : bool MetaPointAction::Compare( const MetaAction& rMetaAction ) const
367 : {
368 0 : return maPt == static_cast<const MetaPointAction&>(rMetaAction).maPt;
369 : }
370 :
371 0 : void MetaPointAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
372 : {
373 0 : MetaAction::Write(rOStm, pData);
374 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
375 0 : WritePair( rOStm, maPt );
376 0 : }
377 :
378 0 : void MetaPointAction::Read( SvStream& rIStm, ImplMetaReadData* )
379 : {
380 0 : VersionCompat aCompat(rIStm, STREAM_READ);
381 0 : ReadPair( rIStm, maPt );
382 0 : }
383 :
384 0 : MetaLineAction::MetaLineAction() :
385 0 : MetaAction(META_LINE_ACTION)
386 0 : {}
387 :
388 62494 : MetaLineAction::~MetaLineAction()
389 62494 : {}
390 :
391 29325 : MetaLineAction::MetaLineAction( const Point& rStart, const Point& rEnd ) :
392 : MetaAction ( META_LINE_ACTION ),
393 : maStartPt ( rStart ),
394 29325 : maEndPt ( rEnd )
395 29325 : {}
396 :
397 1922 : MetaLineAction::MetaLineAction( const Point& rStart, const Point& rEnd,
398 : const LineInfo& rLineInfo ) :
399 : MetaAction ( META_LINE_ACTION ),
400 : maLineInfo ( rLineInfo ),
401 : maStartPt ( rStart ),
402 1922 : maEndPt ( rEnd )
403 1922 : {}
404 :
405 28323 : void MetaLineAction::Execute( OutputDevice* pOut )
406 : {
407 28323 : if( maLineInfo.IsDefault() )
408 27895 : pOut->DrawLine( maStartPt, maEndPt );
409 : else
410 428 : pOut->DrawLine( maStartPt, maEndPt, maLineInfo );
411 28323 : }
412 :
413 0 : MetaAction* MetaLineAction::Clone()
414 : {
415 0 : MetaAction* pClone = (MetaAction*) new MetaLineAction( *this );
416 0 : pClone->ResetRefCount();
417 0 : return pClone;
418 : }
419 :
420 416 : void MetaLineAction::Move( long nHorzMove, long nVertMove )
421 : {
422 416 : maStartPt.Move( nHorzMove, nVertMove );
423 416 : maEndPt.Move( nHorzMove, nVertMove );
424 416 : }
425 :
426 0 : void MetaLineAction::Scale( double fScaleX, double fScaleY )
427 : {
428 0 : ImplScalePoint( maStartPt, fScaleX, fScaleY );
429 0 : ImplScalePoint( maEndPt, fScaleX, fScaleY );
430 0 : ImplScaleLineInfo( maLineInfo, fScaleX, fScaleY );
431 0 : }
432 :
433 0 : bool MetaLineAction::Compare( const MetaAction& rMetaAction ) const
434 : {
435 0 : return ( maLineInfo == static_cast<const MetaLineAction&>(rMetaAction).maLineInfo ) &&
436 0 : ( maStartPt == static_cast<const MetaLineAction&>(rMetaAction).maStartPt ) &&
437 0 : ( maEndPt == static_cast<const MetaLineAction&>(rMetaAction).maEndPt );
438 : }
439 :
440 4760 : void MetaLineAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
441 : {
442 4760 : MetaAction::Write(rOStm, pData);
443 4760 : VersionCompat aCompat(rOStm, STREAM_WRITE, 2);
444 :
445 4760 : WritePair( rOStm, maStartPt );
446 4760 : WritePair( rOStm, maEndPt ); // Version 1
447 4760 : WriteLineInfo( rOStm, maLineInfo ); // Version 2
448 4760 : }
449 :
450 0 : void MetaLineAction::Read( SvStream& rIStm, ImplMetaReadData* )
451 : {
452 0 : VersionCompat aCompat(rIStm, STREAM_READ);
453 :
454 : // Version 1
455 0 : ReadPair( rIStm, maStartPt );
456 0 : ReadPair( rIStm, maEndPt );
457 :
458 : // Version 2
459 0 : if( aCompat.GetVersion() >= 2 )
460 : {
461 0 : ReadLineInfo( rIStm, maLineInfo );
462 0 : }
463 0 : }
464 :
465 4266 : MetaRectAction::MetaRectAction() :
466 4266 : MetaAction(META_RECT_ACTION)
467 4266 : {}
468 :
469 37428 : MetaRectAction::~MetaRectAction()
470 37428 : {}
471 :
472 14448 : MetaRectAction::MetaRectAction( const Rectangle& rRect ) :
473 : MetaAction ( META_RECT_ACTION ),
474 14448 : maRect ( rRect )
475 14448 : {}
476 :
477 7560 : void MetaRectAction::Execute( OutputDevice* pOut )
478 : {
479 7560 : pOut->DrawRect( maRect );
480 7560 : }
481 :
482 0 : MetaAction* MetaRectAction::Clone()
483 : {
484 0 : MetaAction* pClone = (MetaAction*) new MetaRectAction( *this );
485 0 : pClone->ResetRefCount();
486 0 : return pClone;
487 : }
488 :
489 654 : void MetaRectAction::Move( long nHorzMove, long nVertMove )
490 : {
491 654 : maRect.Move( nHorzMove, nVertMove );
492 654 : }
493 :
494 0 : void MetaRectAction::Scale( double fScaleX, double fScaleY )
495 : {
496 0 : ImplScaleRect( maRect, fScaleX, fScaleY );
497 0 : }
498 :
499 0 : bool MetaRectAction::Compare( const MetaAction& rMetaAction ) const
500 : {
501 0 : return maRect == static_cast<const MetaRectAction&>(rMetaAction).maRect;
502 : }
503 :
504 13806 : void MetaRectAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
505 : {
506 13806 : MetaAction::Write(rOStm, pData);
507 13806 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
508 13806 : WriteRectangle( rOStm, maRect );
509 13806 : }
510 :
511 4266 : void MetaRectAction::Read( SvStream& rIStm, ImplMetaReadData* )
512 : {
513 4266 : VersionCompat aCompat(rIStm, STREAM_READ);
514 4266 : ReadRectangle( rIStm, maRect );
515 4266 : }
516 :
517 0 : MetaRoundRectAction::MetaRoundRectAction() :
518 : MetaAction ( META_ROUNDRECT_ACTION ),
519 : mnHorzRound ( 0 ),
520 0 : mnVertRound ( 0 )
521 0 : {}
522 :
523 0 : MetaRoundRectAction::~MetaRoundRectAction()
524 0 : {}
525 :
526 0 : MetaRoundRectAction::MetaRoundRectAction( const Rectangle& rRect,
527 : sal_uInt32 nHorzRound, sal_uInt32 nVertRound ) :
528 : MetaAction ( META_ROUNDRECT_ACTION ),
529 : maRect ( rRect ),
530 : mnHorzRound ( nHorzRound ),
531 0 : mnVertRound ( nVertRound )
532 0 : {}
533 :
534 0 : void MetaRoundRectAction::Execute( OutputDevice* pOut )
535 : {
536 0 : pOut->DrawRect( maRect, mnHorzRound, mnVertRound );
537 0 : }
538 :
539 0 : MetaAction* MetaRoundRectAction::Clone()
540 : {
541 0 : MetaAction* pClone = (MetaAction*) new MetaRoundRectAction( *this );
542 0 : pClone->ResetRefCount();
543 0 : return pClone;
544 : }
545 :
546 0 : void MetaRoundRectAction::Move( long nHorzMove, long nVertMove )
547 : {
548 0 : maRect.Move( nHorzMove, nVertMove );
549 0 : }
550 :
551 0 : void MetaRoundRectAction::Scale( double fScaleX, double fScaleY )
552 : {
553 0 : ImplScaleRect( maRect, fScaleX, fScaleY );
554 0 : mnHorzRound = FRound( mnHorzRound * fabs(fScaleX) );
555 0 : mnVertRound = FRound( mnVertRound * fabs(fScaleY) );
556 0 : }
557 :
558 0 : bool MetaRoundRectAction::Compare( const MetaAction& rMetaAction ) const
559 : {
560 0 : return ( maRect == static_cast<const MetaRoundRectAction&>(rMetaAction).maRect ) &&
561 0 : ( mnHorzRound == static_cast<const MetaRoundRectAction&>(rMetaAction).mnHorzRound ) &&
562 0 : ( mnVertRound == static_cast<const MetaRoundRectAction&>(rMetaAction).mnVertRound );
563 : }
564 :
565 0 : void MetaRoundRectAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
566 : {
567 0 : MetaAction::Write(rOStm, pData);
568 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
569 0 : WriteRectangle( rOStm, maRect );
570 0 : rOStm.WriteUInt32( mnHorzRound ).WriteUInt32( mnVertRound );
571 0 : }
572 :
573 0 : void MetaRoundRectAction::Read( SvStream& rIStm, ImplMetaReadData* )
574 : {
575 0 : VersionCompat aCompat(rIStm, STREAM_READ);
576 0 : ReadRectangle( rIStm, maRect ).ReadUInt32( mnHorzRound ).ReadUInt32( mnVertRound );
577 0 : }
578 :
579 0 : MetaEllipseAction::MetaEllipseAction() :
580 0 : MetaAction(META_ELLIPSE_ACTION)
581 0 : {}
582 :
583 4 : MetaEllipseAction::~MetaEllipseAction()
584 4 : {}
585 :
586 2 : MetaEllipseAction::MetaEllipseAction( const Rectangle& rRect ) :
587 : MetaAction ( META_ELLIPSE_ACTION ),
588 2 : maRect ( rRect )
589 2 : {}
590 :
591 0 : void MetaEllipseAction::Execute( OutputDevice* pOut )
592 : {
593 0 : pOut->DrawEllipse( maRect );
594 0 : }
595 :
596 0 : MetaAction* MetaEllipseAction::Clone()
597 : {
598 0 : MetaAction* pClone = (MetaAction*) new MetaEllipseAction( *this );
599 0 : pClone->ResetRefCount();
600 0 : return pClone;
601 : }
602 :
603 0 : void MetaEllipseAction::Move( long nHorzMove, long nVertMove )
604 : {
605 0 : maRect.Move( nHorzMove, nVertMove );
606 0 : }
607 :
608 0 : void MetaEllipseAction::Scale( double fScaleX, double fScaleY )
609 : {
610 0 : ImplScaleRect( maRect, fScaleX, fScaleY );
611 0 : }
612 :
613 0 : bool MetaEllipseAction::Compare( const MetaAction& rMetaAction ) const
614 : {
615 0 : return maRect == static_cast<const MetaEllipseAction&>(rMetaAction).maRect;
616 : }
617 :
618 0 : void MetaEllipseAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
619 : {
620 0 : MetaAction::Write(rOStm, pData);
621 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
622 0 : WriteRectangle( rOStm, maRect );
623 0 : }
624 :
625 0 : void MetaEllipseAction::Read( SvStream& rIStm, ImplMetaReadData* )
626 : {
627 0 : VersionCompat aCompat(rIStm, STREAM_READ);
628 0 : ReadRectangle( rIStm, maRect );
629 0 : }
630 :
631 0 : MetaArcAction::MetaArcAction() :
632 0 : MetaAction(META_ARC_ACTION)
633 0 : {}
634 :
635 0 : MetaArcAction::~MetaArcAction()
636 0 : {}
637 :
638 0 : MetaArcAction::MetaArcAction( const Rectangle& rRect,
639 : const Point& rStart, const Point& rEnd ) :
640 : MetaAction ( META_ARC_ACTION ),
641 : maRect ( rRect ),
642 : maStartPt ( rStart ),
643 0 : maEndPt ( rEnd )
644 0 : {}
645 :
646 0 : void MetaArcAction::Execute( OutputDevice* pOut )
647 : {
648 0 : pOut->DrawArc( maRect, maStartPt, maEndPt );
649 0 : }
650 :
651 0 : MetaAction* MetaArcAction::Clone()
652 : {
653 0 : MetaAction* pClone = (MetaAction*) new MetaArcAction( *this );
654 0 : pClone->ResetRefCount();
655 0 : return pClone;
656 : }
657 :
658 0 : void MetaArcAction::Move( long nHorzMove, long nVertMove )
659 : {
660 0 : maRect.Move( nHorzMove, nVertMove );
661 0 : maStartPt.Move( nHorzMove, nVertMove );
662 0 : maEndPt.Move( nHorzMove, nVertMove );
663 0 : }
664 :
665 0 : void MetaArcAction::Scale( double fScaleX, double fScaleY )
666 : {
667 0 : ImplScaleRect( maRect, fScaleX, fScaleY );
668 0 : ImplScalePoint( maStartPt, fScaleX, fScaleY );
669 0 : ImplScalePoint( maEndPt, fScaleX, fScaleY );
670 0 : }
671 :
672 0 : bool MetaArcAction::Compare( const MetaAction& rMetaAction ) const
673 : {
674 0 : return ( maRect == static_cast<const MetaArcAction&>(rMetaAction).maRect ) &&
675 0 : ( maStartPt == static_cast<const MetaArcAction&>(rMetaAction).maStartPt ) &&
676 0 : ( maEndPt == static_cast<const MetaArcAction&>(rMetaAction).maEndPt );
677 : }
678 :
679 0 : void MetaArcAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
680 : {
681 0 : MetaAction::Write(rOStm, pData);
682 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
683 0 : WriteRectangle( rOStm, maRect );
684 0 : WritePair( rOStm, maStartPt );
685 0 : WritePair( rOStm, maEndPt );
686 0 : }
687 :
688 0 : void MetaArcAction::Read( SvStream& rIStm, ImplMetaReadData* )
689 : {
690 0 : VersionCompat aCompat(rIStm, STREAM_READ);
691 0 : ReadRectangle( rIStm, maRect );
692 0 : ReadPair( rIStm, maStartPt );
693 0 : ReadPair( rIStm, maEndPt );
694 0 : }
695 :
696 0 : MetaPieAction::MetaPieAction() :
697 0 : MetaAction(META_PIE_ACTION)
698 0 : {}
699 :
700 0 : MetaPieAction::~MetaPieAction()
701 0 : {}
702 :
703 0 : MetaPieAction::MetaPieAction( const Rectangle& rRect,
704 : const Point& rStart, const Point& rEnd ) :
705 : MetaAction ( META_PIE_ACTION ),
706 : maRect ( rRect ),
707 : maStartPt ( rStart ),
708 0 : maEndPt ( rEnd )
709 0 : {}
710 :
711 0 : void MetaPieAction::Execute( OutputDevice* pOut )
712 : {
713 0 : pOut->DrawPie( maRect, maStartPt, maEndPt );
714 0 : }
715 :
716 0 : MetaAction* MetaPieAction::Clone()
717 : {
718 0 : MetaAction* pClone = (MetaAction*) new MetaPieAction( *this );
719 0 : pClone->ResetRefCount();
720 0 : return pClone;
721 : }
722 :
723 0 : void MetaPieAction::Move( long nHorzMove, long nVertMove )
724 : {
725 0 : maRect.Move( nHorzMove, nVertMove );
726 0 : maStartPt.Move( nHorzMove, nVertMove );
727 0 : maEndPt.Move( nHorzMove, nVertMove );
728 0 : }
729 :
730 0 : void MetaPieAction::Scale( double fScaleX, double fScaleY )
731 : {
732 0 : ImplScaleRect( maRect, fScaleX, fScaleY );
733 0 : ImplScalePoint( maStartPt, fScaleX, fScaleY );
734 0 : ImplScalePoint( maEndPt, fScaleX, fScaleY );
735 0 : }
736 :
737 0 : bool MetaPieAction::Compare( const MetaAction& rMetaAction ) const
738 : {
739 0 : return ( maRect == static_cast<const MetaPieAction&>(rMetaAction).maRect ) &&
740 0 : ( maStartPt == static_cast<const MetaPieAction&>(rMetaAction).maStartPt ) &&
741 0 : ( maEndPt == static_cast<const MetaPieAction&>(rMetaAction).maEndPt );
742 : }
743 :
744 0 : void MetaPieAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
745 : {
746 0 : MetaAction::Write(rOStm, pData);
747 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
748 0 : WriteRectangle( rOStm, maRect );
749 0 : WritePair( rOStm, maStartPt );
750 0 : WritePair( rOStm, maEndPt );
751 0 : }
752 :
753 0 : void MetaPieAction::Read( SvStream& rIStm, ImplMetaReadData* )
754 : {
755 0 : VersionCompat aCompat(rIStm, STREAM_READ);
756 0 : ReadRectangle( rIStm, maRect );
757 0 : ReadPair( rIStm, maStartPt );
758 0 : ReadPair( rIStm, maEndPt );
759 0 : }
760 :
761 0 : MetaChordAction::MetaChordAction() :
762 0 : MetaAction(META_CHORD_ACTION)
763 0 : {}
764 :
765 0 : MetaChordAction::~MetaChordAction()
766 0 : {}
767 :
768 0 : MetaChordAction::MetaChordAction( const Rectangle& rRect,
769 : const Point& rStart, const Point& rEnd ) :
770 : MetaAction ( META_CHORD_ACTION ),
771 : maRect ( rRect ),
772 : maStartPt ( rStart ),
773 0 : maEndPt ( rEnd )
774 0 : {}
775 :
776 0 : void MetaChordAction::Execute( OutputDevice* pOut )
777 : {
778 0 : pOut->DrawChord( maRect, maStartPt, maEndPt );
779 0 : }
780 :
781 0 : MetaAction* MetaChordAction::Clone()
782 : {
783 0 : MetaAction* pClone = (MetaAction*) new MetaChordAction( *this );
784 0 : pClone->ResetRefCount();
785 0 : return pClone;
786 : }
787 :
788 0 : void MetaChordAction::Move( long nHorzMove, long nVertMove )
789 : {
790 0 : maRect.Move( nHorzMove, nVertMove );
791 0 : maStartPt.Move( nHorzMove, nVertMove );
792 0 : maEndPt.Move( nHorzMove, nVertMove );
793 0 : }
794 :
795 0 : void MetaChordAction::Scale( double fScaleX, double fScaleY )
796 : {
797 0 : ImplScaleRect( maRect, fScaleX, fScaleY );
798 0 : ImplScalePoint( maStartPt, fScaleX, fScaleY );
799 0 : ImplScalePoint( maEndPt, fScaleX, fScaleY );
800 0 : }
801 :
802 0 : bool MetaChordAction::Compare( const MetaAction& rMetaAction ) const
803 : {
804 0 : return ( maRect == static_cast<const MetaChordAction&>(rMetaAction).maRect ) &&
805 0 : ( maStartPt == static_cast<const MetaChordAction&>(rMetaAction).maStartPt ) &&
806 0 : ( maEndPt == static_cast<const MetaChordAction&>(rMetaAction).maEndPt );
807 : }
808 :
809 0 : void MetaChordAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
810 : {
811 0 : MetaAction::Write(rOStm, pData);
812 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
813 0 : WriteRectangle( rOStm, maRect );
814 0 : WritePair( rOStm, maStartPt );
815 0 : WritePair( rOStm, maEndPt );
816 0 : }
817 :
818 0 : void MetaChordAction::Read( SvStream& rIStm, ImplMetaReadData* )
819 : {
820 0 : VersionCompat aCompat(rIStm, STREAM_READ);
821 0 : ReadRectangle( rIStm, maRect );
822 0 : ReadPair( rIStm, maStartPt );
823 0 : ReadPair( rIStm, maEndPt );
824 0 : }
825 :
826 428 : MetaPolyLineAction::MetaPolyLineAction() :
827 428 : MetaAction(META_POLYLINE_ACTION)
828 428 : {}
829 :
830 11832 : MetaPolyLineAction::~MetaPolyLineAction()
831 11832 : {}
832 :
833 2 : MetaPolyLineAction::MetaPolyLineAction( const Polygon& rPoly ) :
834 : MetaAction ( META_POLYLINE_ACTION ),
835 2 : maPoly ( rPoly )
836 2 : {}
837 :
838 5150 : MetaPolyLineAction::MetaPolyLineAction( const Polygon& rPoly, const LineInfo& rLineInfo ) :
839 : MetaAction ( META_POLYLINE_ACTION ),
840 : maLineInfo ( rLineInfo ),
841 5150 : maPoly ( rPoly )
842 5150 : {}
843 :
844 1688 : void MetaPolyLineAction::Execute( OutputDevice* pOut )
845 : {
846 1688 : if( maLineInfo.IsDefault() )
847 1450 : pOut->DrawPolyLine( maPoly );
848 : else
849 238 : pOut->DrawPolyLine( maPoly, maLineInfo );
850 1688 : }
851 :
852 336 : MetaAction* MetaPolyLineAction::Clone()
853 : {
854 336 : MetaAction* pClone = (MetaAction*) new MetaPolyLineAction( *this );
855 336 : pClone->ResetRefCount();
856 336 : return pClone;
857 : }
858 :
859 2380 : void MetaPolyLineAction::Move( long nHorzMove, long nVertMove )
860 : {
861 2380 : maPoly.Move( nHorzMove, nVertMove );
862 2380 : }
863 :
864 336 : void MetaPolyLineAction::Scale( double fScaleX, double fScaleY )
865 : {
866 336 : ImplScalePoly( maPoly, fScaleX, fScaleY );
867 336 : ImplScaleLineInfo( maLineInfo, fScaleX, fScaleY );
868 336 : }
869 :
870 0 : bool MetaPolyLineAction::Compare( const MetaAction& rMetaAction ) const
871 : {
872 0 : bool bIsEqual = true;
873 0 : if ( maLineInfo != static_cast<const MetaPolyLineAction&>(rMetaAction).maLineInfo )
874 0 : bIsEqual = false;
875 : else
876 0 : bIsEqual = maPoly.IsEqual(static_cast<const MetaPolyLineAction&>(rMetaAction).maPoly );
877 0 : return bIsEqual;
878 :
879 : }
880 :
881 2990 : void MetaPolyLineAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
882 : {
883 2990 : MetaAction::Write(rOStm, pData);
884 2990 : VersionCompat aCompat(rOStm, STREAM_WRITE, 3);
885 :
886 5980 : Polygon aSimplePoly;
887 2990 : maPoly.AdaptiveSubdivide( aSimplePoly );
888 :
889 2990 : WritePolygon( rOStm, aSimplePoly ); // Version 1
890 2990 : WriteLineInfo( rOStm, maLineInfo ); // Version 2
891 :
892 2990 : sal_uInt8 bHasPolyFlags = maPoly.HasFlags(); // Version 3
893 2990 : rOStm.WriteUChar( bHasPolyFlags );
894 2990 : if ( bHasPolyFlags )
895 3002 : maPoly.Write( rOStm );
896 2990 : }
897 :
898 428 : void MetaPolyLineAction::Read( SvStream& rIStm, ImplMetaReadData* )
899 : {
900 428 : VersionCompat aCompat(rIStm, STREAM_READ);
901 :
902 : // Version 1
903 428 : ReadPolygon( rIStm, maPoly );
904 :
905 : // Version 2
906 428 : if( aCompat.GetVersion() >= 2 )
907 428 : ReadLineInfo( rIStm, maLineInfo );
908 428 : if ( aCompat.GetVersion() >= 3 )
909 : {
910 428 : sal_uInt8 bHasPolyFlags(0);
911 428 : rIStm.ReadUChar( bHasPolyFlags );
912 428 : if ( bHasPolyFlags )
913 8 : maPoly.Read( rIStm );
914 428 : }
915 428 : }
916 :
917 360 : MetaPolygonAction::MetaPolygonAction() :
918 360 : MetaAction(META_POLYGON_ACTION)
919 360 : {}
920 :
921 3540 : MetaPolygonAction::~MetaPolygonAction()
922 3540 : {}
923 :
924 1410 : MetaPolygonAction::MetaPolygonAction( const Polygon& rPoly ) :
925 : MetaAction ( META_POLYGON_ACTION ),
926 1410 : maPoly ( rPoly )
927 1410 : {}
928 :
929 0 : void MetaPolygonAction::Execute( OutputDevice* pOut )
930 : {
931 0 : pOut->DrawPolygon( maPoly );
932 0 : }
933 :
934 0 : MetaAction* MetaPolygonAction::Clone()
935 : {
936 0 : MetaAction* pClone = (MetaAction*) new MetaPolygonAction( *this );
937 0 : pClone->ResetRefCount();
938 0 : return pClone;
939 : }
940 :
941 0 : void MetaPolygonAction::Move( long nHorzMove, long nVertMove )
942 : {
943 0 : maPoly.Move( nHorzMove, nVertMove );
944 0 : }
945 :
946 0 : void MetaPolygonAction::Scale( double fScaleX, double fScaleY )
947 : {
948 0 : ImplScalePoly( maPoly, fScaleX, fScaleY );
949 0 : }
950 :
951 0 : bool MetaPolygonAction::Compare( const MetaAction& rMetaAction ) const
952 : {
953 0 : return maPoly.IsEqual(static_cast<const MetaPolygonAction&>(rMetaAction).maPoly );
954 : }
955 :
956 3366 : void MetaPolygonAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
957 : {
958 3366 : MetaAction::Write(rOStm, pData);
959 3366 : VersionCompat aCompat(rOStm, STREAM_WRITE, 2);
960 :
961 6732 : Polygon aSimplePoly; // Version 1
962 3366 : maPoly.AdaptiveSubdivide( aSimplePoly );
963 3366 : WritePolygon( rOStm, aSimplePoly );
964 :
965 3366 : sal_uInt8 bHasPolyFlags = maPoly.HasFlags(); // Version 2
966 3366 : rOStm.WriteUChar( bHasPolyFlags );
967 3366 : if ( bHasPolyFlags )
968 3390 : maPoly.Write( rOStm );
969 3366 : }
970 :
971 360 : void MetaPolygonAction::Read( SvStream& rIStm, ImplMetaReadData* )
972 : {
973 360 : VersionCompat aCompat(rIStm, STREAM_READ);
974 :
975 360 : ReadPolygon( rIStm, maPoly ); // Version 1
976 :
977 360 : if( aCompat.GetVersion() >= 2 ) // Version 2
978 : {
979 360 : sal_uInt8 bHasPolyFlags(0);
980 360 : rIStm.ReadUChar( bHasPolyFlags );
981 360 : if ( bHasPolyFlags )
982 0 : maPoly.Read( rIStm );
983 360 : }
984 360 : }
985 :
986 878 : MetaPolyPolygonAction::MetaPolyPolygonAction() :
987 878 : MetaAction(META_POLYPOLYGON_ACTION)
988 878 : {}
989 :
990 10094 : MetaPolyPolygonAction::~MetaPolyPolygonAction()
991 10094 : {}
992 :
993 3543 : MetaPolyPolygonAction::MetaPolyPolygonAction( const tools::PolyPolygon& rPolyPoly ) :
994 : MetaAction ( META_POLYPOLYGON_ACTION ),
995 3543 : maPolyPoly ( rPolyPoly )
996 3543 : {}
997 :
998 468 : void MetaPolyPolygonAction::Execute( OutputDevice* pOut )
999 : {
1000 468 : pOut->DrawPolyPolygon( maPolyPoly );
1001 468 : }
1002 :
1003 626 : MetaAction* MetaPolyPolygonAction::Clone()
1004 : {
1005 626 : MetaAction* pClone = (MetaAction*) new MetaPolyPolygonAction( *this );
1006 626 : pClone->ResetRefCount();
1007 626 : return pClone;
1008 : }
1009 :
1010 1248 : void MetaPolyPolygonAction::Move( long nHorzMove, long nVertMove )
1011 : {
1012 1248 : maPolyPoly.Move( nHorzMove, nVertMove );
1013 1248 : }
1014 :
1015 626 : void MetaPolyPolygonAction::Scale( double fScaleX, double fScaleY )
1016 : {
1017 1850 : for( sal_uInt16 i = 0, nCount = maPolyPoly.Count(); i < nCount; i++ )
1018 1224 : ImplScalePoly( maPolyPoly[ i ], fScaleX, fScaleY );
1019 626 : }
1020 :
1021 0 : bool MetaPolyPolygonAction::Compare( const MetaAction& rMetaAction ) const
1022 : {
1023 0 : return maPolyPoly.IsEqual(static_cast<const MetaPolyPolygonAction&>(rMetaAction).maPolyPoly );
1024 : }
1025 :
1026 4466 : void MetaPolyPolygonAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
1027 : {
1028 4466 : MetaAction::Write(rOStm, pData);
1029 4466 : VersionCompat aCompat(rOStm, STREAM_WRITE, 2);
1030 :
1031 4466 : sal_uInt16 nNumberOfComplexPolygons = 0;
1032 4466 : sal_uInt16 i, nPolyCount = maPolyPoly.Count();
1033 :
1034 8932 : Polygon aSimplePoly; // Version 1
1035 4466 : rOStm.WriteUInt16( nPolyCount );
1036 11982 : for ( i = 0; i < nPolyCount; i++ )
1037 : {
1038 7516 : const Polygon& rPoly = maPolyPoly.GetObject( i );
1039 7516 : if ( rPoly.HasFlags() )
1040 194 : nNumberOfComplexPolygons++;
1041 7516 : rPoly.AdaptiveSubdivide( aSimplePoly );
1042 7516 : WritePolygon( rOStm, aSimplePoly );
1043 : }
1044 :
1045 4466 : rOStm.WriteUInt16( nNumberOfComplexPolygons ); // Version 2
1046 4672 : for ( i = 0; nNumberOfComplexPolygons && ( i < nPolyCount ); i++ )
1047 : {
1048 206 : const Polygon& rPoly = maPolyPoly.GetObject( i );
1049 206 : if ( rPoly.HasFlags() )
1050 : {
1051 194 : rOStm.WriteUInt16( i );
1052 194 : rPoly.Write( rOStm );
1053 :
1054 194 : nNumberOfComplexPolygons--;
1055 : }
1056 4466 : }
1057 4466 : }
1058 :
1059 878 : void MetaPolyPolygonAction::Read( SvStream& rIStm, ImplMetaReadData* )
1060 : {
1061 878 : VersionCompat aCompat(rIStm, STREAM_READ);
1062 878 : ReadPolyPolygon( rIStm, maPolyPoly ); // Version 1
1063 :
1064 878 : if ( aCompat.GetVersion() >= 2 ) // Version 2
1065 : {
1066 878 : sal_uInt16 nNumberOfComplexPolygons(0);
1067 878 : rIStm.ReadUInt16( nNumberOfComplexPolygons );
1068 884 : for (sal_uInt16 i = 0; i < nNumberOfComplexPolygons; ++i)
1069 : {
1070 6 : sal_uInt16 nIndex(0);
1071 6 : rIStm.ReadUInt16( nIndex );
1072 6 : Polygon aPoly;
1073 6 : aPoly.Read( rIStm );
1074 6 : if (nIndex >= maPolyPoly.Count())
1075 : {
1076 : SAL_WARN("vcl.gdi", "svm contains polygon index " << nIndex
1077 : << " outside possible range " << maPolyPoly.Count());
1078 0 : continue;
1079 : }
1080 6 : maPolyPoly.Replace( aPoly, nIndex );
1081 6 : }
1082 878 : }
1083 878 : }
1084 :
1085 0 : MetaTextAction::MetaTextAction() :
1086 : MetaAction ( META_TEXT_ACTION ),
1087 : mnIndex ( 0 ),
1088 0 : mnLen ( 0 )
1089 0 : {}
1090 :
1091 8650 : MetaTextAction::~MetaTextAction()
1092 8650 : {}
1093 :
1094 4325 : MetaTextAction::MetaTextAction( const Point& rPt, const OUString& rStr,
1095 : sal_Int32 nIndex, sal_Int32 nLen ) :
1096 : MetaAction ( META_TEXT_ACTION ),
1097 : maPt ( rPt ),
1098 : maStr ( rStr ),
1099 : mnIndex ( nIndex ),
1100 4325 : mnLen ( nLen )
1101 4325 : {}
1102 :
1103 1531 : void MetaTextAction::Execute( OutputDevice* pOut )
1104 : {
1105 1531 : pOut->DrawText( maPt, maStr, mnIndex, mnLen );
1106 1531 : }
1107 :
1108 0 : MetaAction* MetaTextAction::Clone()
1109 : {
1110 0 : MetaAction* pClone = (MetaAction*) new MetaTextAction( *this );
1111 0 : pClone->ResetRefCount();
1112 0 : return pClone;
1113 : }
1114 :
1115 0 : void MetaTextAction::Move( long nHorzMove, long nVertMove )
1116 : {
1117 0 : maPt.Move( nHorzMove, nVertMove );
1118 0 : }
1119 :
1120 0 : void MetaTextAction::Scale( double fScaleX, double fScaleY )
1121 : {
1122 0 : ImplScalePoint( maPt, fScaleX, fScaleY );
1123 0 : }
1124 :
1125 0 : bool MetaTextAction::Compare( const MetaAction& rMetaAction ) const
1126 : {
1127 0 : return ( maPt == static_cast<const MetaTextAction&>(rMetaAction).maPt ) &&
1128 0 : ( maStr == static_cast<const MetaTextAction&>(rMetaAction).maStr ) &&
1129 0 : ( mnIndex == static_cast<const MetaTextAction&>(rMetaAction).mnIndex ) &&
1130 0 : ( mnLen == static_cast<const MetaTextAction&>(rMetaAction).mnLen );
1131 : }
1132 :
1133 6566 : void MetaTextAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
1134 : {
1135 6566 : MetaAction::Write(rOStm, pData);
1136 6566 : VersionCompat aCompat(rOStm, STREAM_WRITE, 2);
1137 6566 : WritePair( rOStm, maPt );
1138 6566 : rOStm.WriteUniOrByteString( maStr, pData->meActualCharSet );
1139 6566 : rOStm.WriteUInt16(mnIndex);
1140 6566 : rOStm.WriteUInt16(mnLen);
1141 :
1142 6566 : write_uInt16_lenPrefixed_uInt16s_FromOUString(rOStm, maStr); // version 2
1143 6566 : }
1144 :
1145 0 : void MetaTextAction::Read( SvStream& rIStm, ImplMetaReadData* pData )
1146 : {
1147 0 : VersionCompat aCompat(rIStm, STREAM_READ);
1148 0 : ReadPair( rIStm, maPt );
1149 0 : maStr = rIStm.ReadUniOrByteString(pData->meActualCharSet);
1150 0 : sal_uInt16 nTmpIndex(0);
1151 0 : rIStm.ReadUInt16(nTmpIndex);
1152 0 : mnIndex = nTmpIndex;
1153 0 : sal_uInt16 nTmpLen(0);
1154 0 : rIStm.ReadUInt16(nTmpLen);
1155 0 : mnLen = nTmpLen;
1156 :
1157 0 : if ( aCompat.GetVersion() >= 2 ) // Version 2
1158 0 : maStr = read_uInt16_lenPrefixed_uInt16s_ToOUString(rIStm);
1159 0 : }
1160 :
1161 514 : MetaTextArrayAction::MetaTextArrayAction() :
1162 : MetaAction ( META_TEXTARRAY_ACTION ),
1163 : mpDXAry ( NULL ),
1164 : mnIndex ( 0 ),
1165 514 : mnLen ( 0 )
1166 514 : {}
1167 :
1168 308 : MetaTextArrayAction::MetaTextArrayAction( const MetaTextArrayAction& rAction ) :
1169 : MetaAction ( META_TEXTARRAY_ACTION ),
1170 : maStartPt ( rAction.maStartPt ),
1171 : maStr ( rAction.maStr ),
1172 : mnIndex ( rAction.mnIndex ),
1173 308 : mnLen ( rAction.mnLen )
1174 : {
1175 308 : if( rAction.mpDXAry )
1176 : {
1177 308 : const sal_Int32 nAryLen = mnLen;
1178 :
1179 308 : mpDXAry = new long[ nAryLen ];
1180 308 : memcpy( mpDXAry, rAction.mpDXAry, nAryLen * sizeof( long ) );
1181 : }
1182 : else
1183 0 : mpDXAry = NULL;
1184 308 : }
1185 :
1186 5333 : MetaTextArrayAction::MetaTextArrayAction( const Point& rStartPt,
1187 : const OUString& rStr,
1188 : const long* pDXAry,
1189 : sal_Int32 nIndex,
1190 : sal_Int32 nLen ) :
1191 : MetaAction ( META_TEXTARRAY_ACTION ),
1192 : maStartPt ( rStartPt ),
1193 : maStr ( rStr ),
1194 : mnIndex ( nIndex ),
1195 5333 : mnLen ( nLen )
1196 : {
1197 5333 : const sal_Int32 nAryLen = pDXAry ? mnLen : 0;
1198 :
1199 5333 : if( nAryLen )
1200 : {
1201 5333 : mpDXAry = new long[ nAryLen ];
1202 5333 : memcpy( mpDXAry, pDXAry, nAryLen * sizeof(long) );
1203 : }
1204 : else
1205 0 : mpDXAry = NULL;
1206 5333 : }
1207 :
1208 18465 : MetaTextArrayAction::~MetaTextArrayAction()
1209 : {
1210 6155 : delete[] mpDXAry;
1211 12310 : }
1212 :
1213 1547 : void MetaTextArrayAction::Execute( OutputDevice* pOut )
1214 : {
1215 1547 : pOut->DrawTextArray( maStartPt, maStr, mpDXAry, mnIndex, mnLen );
1216 1547 : }
1217 :
1218 308 : MetaAction* MetaTextArrayAction::Clone()
1219 : {
1220 308 : MetaAction* pClone = (MetaAction*) new MetaTextArrayAction( *this );
1221 308 : pClone->ResetRefCount();
1222 308 : return pClone;
1223 : }
1224 :
1225 860 : void MetaTextArrayAction::Move( long nHorzMove, long nVertMove )
1226 : {
1227 860 : maStartPt.Move( nHorzMove, nVertMove );
1228 860 : }
1229 :
1230 308 : void MetaTextArrayAction::Scale( double fScaleX, double fScaleY )
1231 : {
1232 308 : ImplScalePoint( maStartPt, fScaleX, fScaleY );
1233 :
1234 308 : if ( mpDXAry && mnLen )
1235 : {
1236 5072 : for ( sal_uInt16 i = 0, nCount = mnLen; i < nCount; i++ )
1237 4764 : mpDXAry[ i ] = FRound( mpDXAry[ i ] * fabs(fScaleX) );
1238 : }
1239 308 : }
1240 :
1241 0 : bool MetaTextArrayAction::Compare( const MetaAction& rMetaAction ) const
1242 : {
1243 0 : return ( maStartPt == static_cast<const MetaTextArrayAction&>(rMetaAction).maStartPt ) &&
1244 0 : ( maStr == static_cast<const MetaTextArrayAction&>(rMetaAction).maStr ) &&
1245 0 : ( mnIndex == static_cast<const MetaTextArrayAction&>(rMetaAction).mnIndex ) &&
1246 0 : ( mnLen == static_cast<const MetaTextArrayAction&>(rMetaAction).mnLen ) &&
1247 0 : ( memcmp( mpDXAry, static_cast<const MetaTextArrayAction&>(rMetaAction).mpDXAry, mnLen ) == 0 );
1248 : }
1249 :
1250 11496 : void MetaTextArrayAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
1251 : {
1252 11496 : const sal_Int32 nAryLen = mpDXAry ? mnLen : 0;
1253 :
1254 11496 : MetaAction::Write(rOStm, pData);
1255 11496 : VersionCompat aCompat(rOStm, STREAM_WRITE, 2);
1256 11496 : WritePair( rOStm, maStartPt );
1257 11496 : rOStm.WriteUniOrByteString( maStr, pData->meActualCharSet );
1258 11496 : rOStm.WriteUInt16(mnIndex);
1259 11496 : rOStm.WriteUInt16(mnLen);
1260 11496 : rOStm.WriteInt32(nAryLen);
1261 :
1262 85578 : for (sal_Int32 i = 0; i < nAryLen; ++i)
1263 74082 : rOStm.WriteInt32( mpDXAry[ i ] );
1264 :
1265 11496 : write_uInt16_lenPrefixed_uInt16s_FromOUString(rOStm, maStr); // version 2
1266 11496 : }
1267 :
1268 514 : void MetaTextArrayAction::Read( SvStream& rIStm, ImplMetaReadData* pData )
1269 : {
1270 514 : delete[] mpDXAry;
1271 :
1272 514 : VersionCompat aCompat(rIStm, STREAM_READ);
1273 514 : ReadPair( rIStm, maStartPt );
1274 514 : maStr = rIStm.ReadUniOrByteString(pData->meActualCharSet);
1275 514 : sal_uInt16 nTmpIndex(0);
1276 514 : rIStm.ReadUInt16(nTmpIndex);
1277 514 : mnIndex = nTmpIndex;
1278 514 : sal_uInt16 nTmpLen(0);
1279 514 : rIStm.ReadUInt16(nTmpLen);
1280 514 : mnLen = nTmpLen;
1281 514 : sal_Int32 nAryLen(0);
1282 514 : rIStm.ReadInt32(nAryLen);
1283 :
1284 514 : if ( mnIndex + mnLen > maStr.getLength() )
1285 : {
1286 0 : mnIndex = 0;
1287 0 : mpDXAry = 0;
1288 0 : return;
1289 : }
1290 :
1291 514 : if( nAryLen )
1292 : {
1293 : // #i9762#, #106172# Ensure that DX array is at least mnLen entries long
1294 514 : if ( mnLen >= nAryLen )
1295 : {
1296 514 : mpDXAry = new (std::nothrow)long[ mnLen ];
1297 514 : if ( mpDXAry )
1298 : {
1299 : sal_Int32 i;
1300 : sal_Int32 val;
1301 8264 : for( i = 0; i < nAryLen; i++ )
1302 : {
1303 7750 : rIStm.ReadInt32( val);
1304 7750 : mpDXAry[ i ] = val;
1305 : }
1306 : // #106172# setup remainder
1307 514 : for( ; i < mnLen; i++ )
1308 0 : mpDXAry[ i ] = 0;
1309 : }
1310 : }
1311 : else
1312 : {
1313 0 : mpDXAry = NULL;
1314 0 : return;
1315 : }
1316 : }
1317 : else
1318 0 : mpDXAry = NULL;
1319 :
1320 514 : if ( aCompat.GetVersion() >= 2 ) // Version 2
1321 : {
1322 514 : maStr = read_uInt16_lenPrefixed_uInt16s_ToOUString(rIStm);
1323 :
1324 514 : if ( mnIndex + mnLen > maStr.getLength() )
1325 : {
1326 0 : mnIndex = 0;
1327 0 : delete[] mpDXAry, mpDXAry = NULL;
1328 : }
1329 514 : }
1330 : }
1331 :
1332 71118 : MetaStretchTextAction::MetaStretchTextAction() :
1333 : MetaAction ( META_STRETCHTEXT_ACTION ),
1334 : mnWidth ( 0 ),
1335 : mnIndex ( 0 ),
1336 71118 : mnLen ( 0 )
1337 71118 : {}
1338 :
1339 284476 : MetaStretchTextAction::~MetaStretchTextAction()
1340 284476 : {}
1341 :
1342 71120 : MetaStretchTextAction::MetaStretchTextAction( const Point& rPt, sal_uInt32 nWidth,
1343 : const OUString& rStr,
1344 : sal_Int32 nIndex, sal_Int32 nLen ) :
1345 : MetaAction ( META_STRETCHTEXT_ACTION ),
1346 : maPt ( rPt ),
1347 : maStr ( rStr ),
1348 : mnWidth ( nWidth ),
1349 : mnIndex ( nIndex ),
1350 71120 : mnLen ( nLen )
1351 71120 : {}
1352 :
1353 772 : void MetaStretchTextAction::Execute( OutputDevice* pOut )
1354 : {
1355 772 : pOut->DrawStretchText( maPt, mnWidth, maStr, mnIndex, mnLen );
1356 772 : }
1357 :
1358 0 : MetaAction* MetaStretchTextAction::Clone()
1359 : {
1360 0 : MetaAction* pClone = (MetaAction*) new MetaStretchTextAction( *this );
1361 0 : pClone->ResetRefCount();
1362 0 : return pClone;
1363 : }
1364 :
1365 0 : void MetaStretchTextAction::Move( long nHorzMove, long nVertMove )
1366 : {
1367 0 : maPt.Move( nHorzMove, nVertMove );
1368 0 : }
1369 :
1370 0 : void MetaStretchTextAction::Scale( double fScaleX, double fScaleY )
1371 : {
1372 0 : ImplScalePoint( maPt, fScaleX, fScaleY );
1373 0 : mnWidth = (sal_uLong)FRound( mnWidth * fabs(fScaleX) );
1374 0 : }
1375 :
1376 0 : bool MetaStretchTextAction::Compare( const MetaAction& rMetaAction ) const
1377 : {
1378 0 : return ( maPt == static_cast<const MetaStretchTextAction&>(rMetaAction).maPt ) &&
1379 0 : ( maStr == static_cast<const MetaStretchTextAction&>(rMetaAction).maStr ) &&
1380 0 : ( mnWidth == static_cast<const MetaStretchTextAction&>(rMetaAction).mnWidth ) &&
1381 0 : ( mnIndex == static_cast<const MetaStretchTextAction&>(rMetaAction).mnIndex ) &&
1382 0 : ( mnLen == static_cast<const MetaStretchTextAction&>(rMetaAction).mnLen );
1383 : }
1384 :
1385 75304 : void MetaStretchTextAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
1386 : {
1387 75304 : MetaAction::Write(rOStm, pData);
1388 75304 : VersionCompat aCompat(rOStm, STREAM_WRITE, 2);
1389 75304 : WritePair( rOStm, maPt );
1390 75304 : rOStm.WriteUniOrByteString( maStr, pData->meActualCharSet );
1391 75304 : rOStm.WriteUInt32( mnWidth );
1392 75304 : rOStm.WriteUInt16( mnIndex );
1393 75304 : rOStm.WriteUInt16( mnLen );
1394 :
1395 75304 : write_uInt16_lenPrefixed_uInt16s_FromOUString(rOStm, maStr); // version 2
1396 75304 : }
1397 :
1398 71118 : void MetaStretchTextAction::Read( SvStream& rIStm, ImplMetaReadData* pData )
1399 : {
1400 71118 : VersionCompat aCompat(rIStm, STREAM_READ);
1401 71118 : ReadPair( rIStm, maPt );
1402 71118 : maStr = rIStm.ReadUniOrByteString(pData->meActualCharSet);
1403 71118 : rIStm.ReadUInt32( mnWidth );
1404 71118 : sal_uInt16 nTmpIndex(0);
1405 71118 : rIStm.ReadUInt16(nTmpIndex);
1406 71118 : mnIndex = nTmpIndex;
1407 71118 : sal_uInt16 nTmpLen(0);
1408 71118 : rIStm.ReadUInt16(nTmpLen);
1409 71118 : mnLen = nTmpLen;
1410 :
1411 71118 : if ( aCompat.GetVersion() >= 2 ) // Version 2
1412 71118 : maStr = read_uInt16_lenPrefixed_uInt16s_ToOUString(rIStm);
1413 71118 : }
1414 :
1415 0 : MetaTextRectAction::MetaTextRectAction() :
1416 : MetaAction ( META_TEXTRECT_ACTION ),
1417 0 : mnStyle ( 0 )
1418 0 : {}
1419 :
1420 1638 : MetaTextRectAction::~MetaTextRectAction()
1421 1638 : {}
1422 :
1423 819 : MetaTextRectAction::MetaTextRectAction( const Rectangle& rRect,
1424 : const OUString& rStr, sal_uInt16 nStyle ) :
1425 : MetaAction ( META_TEXTRECT_ACTION ),
1426 : maRect ( rRect ),
1427 : maStr ( rStr ),
1428 819 : mnStyle ( nStyle )
1429 819 : {}
1430 :
1431 817 : void MetaTextRectAction::Execute( OutputDevice* pOut )
1432 : {
1433 817 : pOut->DrawText( maRect, maStr, mnStyle );
1434 817 : }
1435 :
1436 0 : MetaAction* MetaTextRectAction::Clone()
1437 : {
1438 0 : MetaAction* pClone = (MetaAction*) new MetaTextRectAction( *this );
1439 0 : pClone->ResetRefCount();
1440 0 : return pClone;
1441 : }
1442 :
1443 0 : void MetaTextRectAction::Move( long nHorzMove, long nVertMove )
1444 : {
1445 0 : maRect.Move( nHorzMove, nVertMove );
1446 0 : }
1447 :
1448 0 : void MetaTextRectAction::Scale( double fScaleX, double fScaleY )
1449 : {
1450 0 : ImplScaleRect( maRect, fScaleX, fScaleY );
1451 0 : }
1452 :
1453 0 : bool MetaTextRectAction::Compare( const MetaAction& rMetaAction ) const
1454 : {
1455 0 : return ( maRect == static_cast<const MetaTextRectAction&>(rMetaAction).maRect ) &&
1456 0 : ( maStr == static_cast<const MetaTextRectAction&>(rMetaAction).maStr ) &&
1457 0 : ( mnStyle == static_cast<const MetaTextRectAction&>(rMetaAction).mnStyle );
1458 : }
1459 :
1460 0 : void MetaTextRectAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
1461 : {
1462 0 : MetaAction::Write(rOStm, pData);
1463 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 2);
1464 0 : WriteRectangle( rOStm, maRect );
1465 0 : rOStm.WriteUniOrByteString( maStr, pData->meActualCharSet );
1466 0 : rOStm.WriteUInt16( mnStyle );
1467 :
1468 0 : write_uInt16_lenPrefixed_uInt16s_FromOUString(rOStm, maStr); // version 2
1469 0 : }
1470 :
1471 0 : void MetaTextRectAction::Read( SvStream& rIStm, ImplMetaReadData* pData )
1472 : {
1473 0 : VersionCompat aCompat(rIStm, STREAM_READ);
1474 0 : ReadRectangle( rIStm, maRect );
1475 0 : maStr = rIStm.ReadUniOrByteString(pData->meActualCharSet);
1476 0 : rIStm .ReadUInt16( mnStyle );
1477 :
1478 0 : if ( aCompat.GetVersion() >= 2 ) // Version 2
1479 0 : maStr = read_uInt16_lenPrefixed_uInt16s_ToOUString(rIStm);
1480 0 : }
1481 :
1482 0 : MetaTextLineAction::MetaTextLineAction() :
1483 : MetaAction ( META_TEXTLINE_ACTION ),
1484 : mnWidth ( 0 ),
1485 : meStrikeout ( STRIKEOUT_NONE ),
1486 : meUnderline ( UNDERLINE_NONE ),
1487 0 : meOverline ( UNDERLINE_NONE )
1488 0 : {}
1489 :
1490 0 : MetaTextLineAction::~MetaTextLineAction()
1491 0 : {}
1492 :
1493 0 : MetaTextLineAction::MetaTextLineAction( const Point& rPos, long nWidth,
1494 : FontStrikeout eStrikeout,
1495 : FontUnderline eUnderline,
1496 : FontUnderline eOverline ) :
1497 : MetaAction ( META_TEXTLINE_ACTION ),
1498 : maPos ( rPos ),
1499 : mnWidth ( nWidth ),
1500 : meStrikeout ( eStrikeout ),
1501 : meUnderline ( eUnderline ),
1502 0 : meOverline ( eOverline )
1503 0 : {}
1504 :
1505 0 : void MetaTextLineAction::Execute( OutputDevice* pOut )
1506 : {
1507 0 : pOut->DrawTextLine( maPos, mnWidth, meStrikeout, meUnderline, meOverline );
1508 0 : }
1509 :
1510 0 : MetaAction* MetaTextLineAction::Clone()
1511 : {
1512 0 : MetaAction* pClone = (MetaAction*)new MetaTextLineAction( *this );
1513 0 : pClone->ResetRefCount();
1514 0 : return pClone;
1515 : }
1516 :
1517 0 : void MetaTextLineAction::Move( long nHorzMove, long nVertMove )
1518 : {
1519 0 : maPos.Move( nHorzMove, nVertMove );
1520 0 : }
1521 :
1522 0 : void MetaTextLineAction::Scale( double fScaleX, double fScaleY )
1523 : {
1524 0 : ImplScalePoint( maPos, fScaleX, fScaleY );
1525 0 : mnWidth = FRound( mnWidth * fabs(fScaleX) );
1526 0 : }
1527 :
1528 0 : bool MetaTextLineAction::Compare( const MetaAction& rMetaAction ) const
1529 : {
1530 0 : return ( maPos == static_cast<const MetaTextLineAction&>(rMetaAction).maPos ) &&
1531 0 : ( mnWidth == static_cast<const MetaTextLineAction&>(rMetaAction).mnWidth ) &&
1532 0 : ( meStrikeout == static_cast<const MetaTextLineAction&>(rMetaAction).meStrikeout ) &&
1533 0 : ( meUnderline == static_cast<const MetaTextLineAction&>(rMetaAction).meUnderline ) &&
1534 0 : ( meOverline == static_cast<const MetaTextLineAction&>(rMetaAction).meOverline );
1535 : }
1536 :
1537 0 : void MetaTextLineAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
1538 : {
1539 0 : MetaAction::Write(rOStm, pData);
1540 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 2);
1541 :
1542 0 : WritePair( rOStm, maPos );
1543 0 : rOStm.WriteInt32( mnWidth );
1544 0 : rOStm.WriteUInt32( meStrikeout );
1545 0 : rOStm.WriteUInt32( meUnderline );
1546 : // new in version 2
1547 0 : rOStm.WriteUInt32( meOverline );
1548 0 : }
1549 :
1550 0 : void MetaTextLineAction::Read( SvStream& rIStm, ImplMetaReadData* )
1551 : {
1552 0 : VersionCompat aCompat(rIStm, STREAM_READ);
1553 :
1554 0 : sal_Int32 nTempWidth(0);
1555 0 : ReadPair( rIStm, maPos );
1556 0 : rIStm.ReadInt32( nTempWidth );
1557 0 : mnWidth = nTempWidth;
1558 0 : sal_uInt32 nTempStrikeout(0);
1559 0 : rIStm.ReadUInt32( nTempStrikeout );
1560 0 : meStrikeout = (FontStrikeout)nTempStrikeout;
1561 0 : sal_uInt32 nTempUnderline(0);
1562 0 : rIStm.ReadUInt32( nTempUnderline );
1563 0 : meUnderline = (FontUnderline)nTempUnderline;
1564 0 : if ( aCompat.GetVersion() >= 2 ) {
1565 0 : sal_uInt32 nTempUnderline2(0);
1566 0 : rIStm.ReadUInt32(nTempUnderline2);
1567 0 : meUnderline = (FontUnderline)nTempUnderline2;
1568 0 : }
1569 0 : }
1570 :
1571 0 : MetaBmpAction::MetaBmpAction() :
1572 0 : MetaAction(META_BMP_ACTION)
1573 0 : {}
1574 :
1575 0 : MetaBmpAction::~MetaBmpAction()
1576 0 : {}
1577 :
1578 0 : MetaBmpAction::MetaBmpAction( const Point& rPt, const Bitmap& rBmp ) :
1579 : MetaAction ( META_BMP_ACTION ),
1580 : maBmp ( rBmp ),
1581 0 : maPt ( rPt )
1582 0 : {}
1583 :
1584 0 : void MetaBmpAction::Execute( OutputDevice* pOut )
1585 : {
1586 0 : pOut->DrawBitmap( maPt, maBmp );
1587 0 : }
1588 :
1589 0 : MetaAction* MetaBmpAction::Clone()
1590 : {
1591 0 : MetaAction* pClone = (MetaAction*) new MetaBmpAction( *this );
1592 0 : pClone->ResetRefCount();
1593 0 : return pClone;
1594 : }
1595 :
1596 0 : void MetaBmpAction::Move( long nHorzMove, long nVertMove )
1597 : {
1598 0 : maPt.Move( nHorzMove, nVertMove );
1599 0 : }
1600 :
1601 0 : void MetaBmpAction::Scale( double fScaleX, double fScaleY )
1602 : {
1603 0 : ImplScalePoint( maPt, fScaleX, fScaleY );
1604 0 : }
1605 :
1606 0 : bool MetaBmpAction::Compare( const MetaAction& rMetaAction ) const
1607 : {
1608 0 : return maBmp.IsEqual(static_cast<const MetaBmpAction&>(rMetaAction).maBmp ) &&
1609 0 : ( maPt == static_cast<const MetaBmpAction&>(rMetaAction).maPt );
1610 : }
1611 :
1612 0 : void MetaBmpAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
1613 : {
1614 0 : if( !!maBmp )
1615 : {
1616 0 : MetaAction::Write(rOStm, pData);
1617 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
1618 0 : WriteDIB(maBmp, rOStm, false, true);
1619 0 : WritePair( rOStm, maPt );
1620 : }
1621 0 : }
1622 :
1623 0 : void MetaBmpAction::Read( SvStream& rIStm, ImplMetaReadData* )
1624 : {
1625 0 : VersionCompat aCompat(rIStm, STREAM_READ);
1626 0 : ReadDIB(maBmp, rIStm, true);
1627 0 : ReadPair( rIStm, maPt );
1628 0 : }
1629 :
1630 724 : MetaBmpScaleAction::MetaBmpScaleAction() :
1631 724 : MetaAction(META_BMPSCALE_ACTION)
1632 724 : {}
1633 :
1634 3776 : MetaBmpScaleAction::~MetaBmpScaleAction()
1635 3776 : {}
1636 :
1637 1104 : MetaBmpScaleAction::MetaBmpScaleAction( const Point& rPt, const Size& rSz,
1638 : const Bitmap& rBmp ) :
1639 : MetaAction ( META_BMPSCALE_ACTION ),
1640 : maBmp ( rBmp ),
1641 : maPt ( rPt ),
1642 1104 : maSz ( rSz )
1643 1104 : {}
1644 :
1645 680 : void MetaBmpScaleAction::Execute( OutputDevice* pOut )
1646 : {
1647 680 : pOut->DrawBitmap( maPt, maSz, maBmp );
1648 680 : }
1649 :
1650 60 : MetaAction* MetaBmpScaleAction::Clone()
1651 : {
1652 60 : MetaAction* pClone = (MetaAction*) new MetaBmpScaleAction( *this );
1653 60 : pClone->ResetRefCount();
1654 60 : return pClone;
1655 : }
1656 :
1657 136 : void MetaBmpScaleAction::Move( long nHorzMove, long nVertMove )
1658 : {
1659 136 : maPt.Move( nHorzMove, nVertMove );
1660 136 : }
1661 :
1662 60 : void MetaBmpScaleAction::Scale( double fScaleX, double fScaleY )
1663 : {
1664 60 : Rectangle aRectangle(maPt, maSz);
1665 60 : ImplScaleRect( aRectangle, fScaleX, fScaleY );
1666 60 : maPt = aRectangle.TopLeft();
1667 60 : maSz = aRectangle.GetSize();
1668 60 : }
1669 :
1670 0 : bool MetaBmpScaleAction::Compare( const MetaAction& rMetaAction ) const
1671 : {
1672 0 : return ( maBmp.IsEqual(static_cast<const MetaBmpScaleAction&>(rMetaAction).maBmp )) &&
1673 0 : ( maPt == static_cast<const MetaBmpScaleAction&>(rMetaAction).maPt ) &&
1674 0 : ( maSz == static_cast<const MetaBmpScaleAction&>(rMetaAction).maSz );
1675 : }
1676 :
1677 754 : void MetaBmpScaleAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
1678 : {
1679 754 : if( !!maBmp )
1680 : {
1681 754 : MetaAction::Write(rOStm, pData);
1682 754 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
1683 754 : WriteDIB(maBmp, rOStm, false, true);
1684 754 : WritePair( rOStm, maPt );
1685 754 : WritePair( rOStm, maSz );
1686 : }
1687 754 : }
1688 :
1689 724 : void MetaBmpScaleAction::Read( SvStream& rIStm, ImplMetaReadData* )
1690 : {
1691 724 : VersionCompat aCompat(rIStm, STREAM_READ);
1692 724 : ReadDIB(maBmp, rIStm, true);
1693 724 : ReadPair( rIStm, maPt );
1694 724 : ReadPair( rIStm, maSz );
1695 724 : }
1696 :
1697 0 : MetaBmpScalePartAction::MetaBmpScalePartAction() :
1698 0 : MetaAction(META_BMPSCALEPART_ACTION)
1699 0 : {}
1700 :
1701 0 : MetaBmpScalePartAction::~MetaBmpScalePartAction()
1702 0 : {}
1703 :
1704 0 : MetaBmpScalePartAction::MetaBmpScalePartAction( const Point& rDstPt, const Size& rDstSz,
1705 : const Point& rSrcPt, const Size& rSrcSz,
1706 : const Bitmap& rBmp ) :
1707 : MetaAction ( META_BMPSCALEPART_ACTION ),
1708 : maBmp ( rBmp ),
1709 : maDstPt ( rDstPt ),
1710 : maDstSz ( rDstSz ),
1711 : maSrcPt ( rSrcPt ),
1712 0 : maSrcSz ( rSrcSz )
1713 0 : {}
1714 :
1715 0 : void MetaBmpScalePartAction::Execute( OutputDevice* pOut )
1716 : {
1717 0 : pOut->DrawBitmap( maDstPt, maDstSz, maSrcPt, maSrcSz, maBmp );
1718 0 : }
1719 :
1720 0 : MetaAction* MetaBmpScalePartAction::Clone()
1721 : {
1722 0 : MetaAction* pClone = (MetaAction*) new MetaBmpScalePartAction( *this );
1723 0 : pClone->ResetRefCount();
1724 0 : return pClone;
1725 : }
1726 :
1727 0 : void MetaBmpScalePartAction::Move( long nHorzMove, long nVertMove )
1728 : {
1729 0 : maDstPt.Move( nHorzMove, nVertMove );
1730 0 : }
1731 :
1732 0 : void MetaBmpScalePartAction::Scale( double fScaleX, double fScaleY )
1733 : {
1734 0 : Rectangle aRectangle(maDstPt, maDstSz);
1735 0 : ImplScaleRect( aRectangle, fScaleX, fScaleY );
1736 0 : maDstPt = aRectangle.TopLeft();
1737 0 : maDstSz = aRectangle.GetSize();
1738 0 : }
1739 :
1740 0 : bool MetaBmpScalePartAction::Compare( const MetaAction& rMetaAction ) const
1741 : {
1742 0 : return ( maBmp.IsEqual(static_cast<const MetaBmpScalePartAction&>(rMetaAction).maBmp )) &&
1743 0 : ( maDstPt == static_cast<const MetaBmpScalePartAction&>(rMetaAction).maDstPt ) &&
1744 0 : ( maDstSz == static_cast<const MetaBmpScalePartAction&>(rMetaAction).maDstSz ) &&
1745 0 : ( maSrcPt == static_cast<const MetaBmpScalePartAction&>(rMetaAction).maSrcPt ) &&
1746 0 : ( maSrcSz == static_cast<const MetaBmpScalePartAction&>(rMetaAction).maSrcSz );
1747 : }
1748 :
1749 0 : void MetaBmpScalePartAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
1750 : {
1751 0 : if( !!maBmp )
1752 : {
1753 0 : MetaAction::Write(rOStm, pData);
1754 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
1755 0 : WriteDIB(maBmp, rOStm, false, true);
1756 0 : WritePair( rOStm, maDstPt );
1757 0 : WritePair( rOStm, maDstSz );
1758 0 : WritePair( rOStm, maSrcPt );
1759 0 : WritePair( rOStm, maSrcSz );
1760 : }
1761 0 : }
1762 :
1763 0 : void MetaBmpScalePartAction::Read( SvStream& rIStm, ImplMetaReadData* )
1764 : {
1765 0 : VersionCompat aCompat(rIStm, STREAM_READ);
1766 0 : ReadDIB(maBmp, rIStm, true);
1767 0 : ReadPair( rIStm, maDstPt );
1768 0 : ReadPair( rIStm, maDstSz );
1769 0 : ReadPair( rIStm, maSrcPt );
1770 0 : ReadPair( rIStm, maSrcSz );
1771 0 : }
1772 :
1773 0 : MetaBmpExAction::MetaBmpExAction() :
1774 0 : MetaAction(META_BMPEX_ACTION)
1775 0 : {}
1776 :
1777 12 : MetaBmpExAction::~MetaBmpExAction()
1778 12 : {}
1779 :
1780 6 : MetaBmpExAction::MetaBmpExAction( const Point& rPt, const BitmapEx& rBmpEx ) :
1781 : MetaAction ( META_BMPEX_ACTION ),
1782 : maBmpEx ( rBmpEx ),
1783 6 : maPt ( rPt )
1784 6 : {}
1785 :
1786 2 : void MetaBmpExAction::Execute( OutputDevice* pOut )
1787 : {
1788 2 : pOut->DrawBitmapEx( maPt, maBmpEx );
1789 2 : }
1790 :
1791 0 : MetaAction* MetaBmpExAction::Clone()
1792 : {
1793 0 : MetaBmpExAction* pClone = new MetaBmpExAction( *this );
1794 0 : pClone->ResetRefCount();
1795 0 : return pClone;
1796 : }
1797 :
1798 4 : void MetaBmpExAction::Move( long nHorzMove, long nVertMove )
1799 : {
1800 4 : maPt.Move( nHorzMove, nVertMove );
1801 4 : }
1802 :
1803 0 : void MetaBmpExAction::Scale( double fScaleX, double fScaleY )
1804 : {
1805 0 : ImplScalePoint( maPt, fScaleX, fScaleY );
1806 0 : }
1807 :
1808 0 : bool MetaBmpExAction::Compare( const MetaAction& rMetaAction ) const
1809 : {
1810 0 : return ( maBmpEx.IsEqual(static_cast<const MetaBmpExAction&>(rMetaAction).maBmpEx )) &&
1811 0 : ( maPt == static_cast<const MetaBmpExAction&>(rMetaAction).maPt );
1812 : }
1813 :
1814 0 : void MetaBmpExAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
1815 : {
1816 0 : if( !!maBmpEx.GetBitmap() )
1817 : {
1818 0 : MetaAction::Write(rOStm, pData);
1819 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
1820 0 : WriteDIBBitmapEx(maBmpEx, rOStm);
1821 0 : WritePair( rOStm, maPt );
1822 : }
1823 0 : }
1824 :
1825 0 : void MetaBmpExAction::Read( SvStream& rIStm, ImplMetaReadData* )
1826 : {
1827 0 : VersionCompat aCompat(rIStm, STREAM_READ);
1828 0 : ReadDIBBitmapEx(maBmpEx, rIStm);
1829 0 : ReadPair( rIStm, maPt );
1830 0 : }
1831 :
1832 6 : MetaBmpExScaleAction::MetaBmpExScaleAction() :
1833 6 : MetaAction(META_BMPEXSCALE_ACTION)
1834 6 : {}
1835 :
1836 372 : MetaBmpExScaleAction::~MetaBmpExScaleAction()
1837 372 : {}
1838 :
1839 174 : MetaBmpExScaleAction::MetaBmpExScaleAction( const Point& rPt, const Size& rSz,
1840 : const BitmapEx& rBmpEx ) :
1841 : MetaAction ( META_BMPEXSCALE_ACTION ),
1842 : maBmpEx ( rBmpEx ),
1843 : maPt ( rPt ),
1844 174 : maSz ( rSz )
1845 174 : {}
1846 :
1847 84 : void MetaBmpExScaleAction::Execute( OutputDevice* pOut )
1848 : {
1849 84 : pOut->DrawBitmapEx( maPt, maSz, maBmpEx );
1850 84 : }
1851 :
1852 6 : MetaAction* MetaBmpExScaleAction::Clone()
1853 : {
1854 6 : MetaAction* pClone = (MetaAction*) new MetaBmpExScaleAction( *this );
1855 6 : pClone->ResetRefCount();
1856 6 : return pClone;
1857 : }
1858 :
1859 72 : void MetaBmpExScaleAction::Move( long nHorzMove, long nVertMove )
1860 : {
1861 72 : maPt.Move( nHorzMove, nVertMove );
1862 72 : }
1863 :
1864 6 : void MetaBmpExScaleAction::Scale( double fScaleX, double fScaleY )
1865 : {
1866 6 : Rectangle aRectangle(maPt, maSz);
1867 6 : ImplScaleRect( aRectangle, fScaleX, fScaleY );
1868 6 : maPt = aRectangle.TopLeft();
1869 6 : maSz = aRectangle.GetSize();
1870 6 : }
1871 :
1872 0 : bool MetaBmpExScaleAction::Compare( const MetaAction& rMetaAction ) const
1873 : {
1874 0 : return ( maBmpEx.IsEqual(static_cast<const MetaBmpExScaleAction&>(rMetaAction).maBmpEx )) &&
1875 0 : ( maPt == static_cast<const MetaBmpExScaleAction&>(rMetaAction).maPt ) &&
1876 0 : ( maSz == static_cast<const MetaBmpExScaleAction&>(rMetaAction).maSz );
1877 : }
1878 :
1879 22 : void MetaBmpExScaleAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
1880 : {
1881 22 : if( !!maBmpEx.GetBitmap() )
1882 : {
1883 22 : MetaAction::Write(rOStm, pData);
1884 22 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
1885 22 : WriteDIBBitmapEx(maBmpEx, rOStm);
1886 22 : WritePair( rOStm, maPt );
1887 22 : WritePair( rOStm, maSz );
1888 : }
1889 22 : }
1890 :
1891 6 : void MetaBmpExScaleAction::Read( SvStream& rIStm, ImplMetaReadData* )
1892 : {
1893 6 : VersionCompat aCompat(rIStm, STREAM_READ);
1894 6 : ReadDIBBitmapEx(maBmpEx, rIStm);
1895 6 : ReadPair( rIStm, maPt );
1896 6 : ReadPair( rIStm, maSz );
1897 6 : }
1898 :
1899 0 : MetaBmpExScalePartAction::MetaBmpExScalePartAction() :
1900 0 : MetaAction(META_BMPEXSCALEPART_ACTION)
1901 0 : {}
1902 :
1903 766 : MetaBmpExScalePartAction::~MetaBmpExScalePartAction()
1904 766 : {}
1905 :
1906 383 : MetaBmpExScalePartAction::MetaBmpExScalePartAction( const Point& rDstPt, const Size& rDstSz,
1907 : const Point& rSrcPt, const Size& rSrcSz,
1908 : const BitmapEx& rBmpEx ) :
1909 : MetaAction ( META_BMPEXSCALEPART_ACTION ),
1910 : maBmpEx ( rBmpEx ),
1911 : maDstPt ( rDstPt ),
1912 : maDstSz ( rDstSz ),
1913 : maSrcPt ( rSrcPt ),
1914 383 : maSrcSz ( rSrcSz )
1915 383 : {}
1916 :
1917 383 : void MetaBmpExScalePartAction::Execute( OutputDevice* pOut )
1918 : {
1919 383 : pOut->DrawBitmapEx( maDstPt, maDstSz, maSrcPt, maSrcSz, maBmpEx );
1920 383 : }
1921 :
1922 0 : MetaAction* MetaBmpExScalePartAction::Clone()
1923 : {
1924 0 : MetaAction* pClone = (MetaAction*) new MetaBmpExScalePartAction( *this );
1925 0 : pClone->ResetRefCount();
1926 0 : return pClone;
1927 : }
1928 :
1929 0 : void MetaBmpExScalePartAction::Move( long nHorzMove, long nVertMove )
1930 : {
1931 0 : maDstPt.Move( nHorzMove, nVertMove );
1932 0 : }
1933 :
1934 0 : void MetaBmpExScalePartAction::Scale( double fScaleX, double fScaleY )
1935 : {
1936 0 : Rectangle aRectangle(maDstPt, maDstSz);
1937 0 : ImplScaleRect( aRectangle, fScaleX, fScaleY );
1938 0 : maDstPt = aRectangle.TopLeft();
1939 0 : maDstSz = aRectangle.GetSize();
1940 0 : }
1941 :
1942 0 : bool MetaBmpExScalePartAction::Compare( const MetaAction& rMetaAction ) const
1943 : {
1944 0 : return ( maBmpEx.IsEqual(static_cast<const MetaBmpExScalePartAction&>(rMetaAction).maBmpEx )) &&
1945 0 : ( maDstPt == static_cast<const MetaBmpExScalePartAction&>(rMetaAction).maDstPt ) &&
1946 0 : ( maDstSz == static_cast<const MetaBmpExScalePartAction&>(rMetaAction).maDstSz ) &&
1947 0 : ( maSrcPt == static_cast<const MetaBmpExScalePartAction&>(rMetaAction).maSrcPt ) &&
1948 0 : ( maSrcSz == static_cast<const MetaBmpExScalePartAction&>(rMetaAction).maSrcSz );
1949 : }
1950 :
1951 0 : void MetaBmpExScalePartAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
1952 : {
1953 0 : if( !!maBmpEx.GetBitmap() )
1954 : {
1955 0 : MetaAction::Write(rOStm, pData);
1956 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
1957 0 : WriteDIBBitmapEx(maBmpEx, rOStm);
1958 0 : WritePair( rOStm, maDstPt );
1959 0 : WritePair( rOStm, maDstSz );
1960 0 : WritePair( rOStm, maSrcPt );
1961 0 : WritePair( rOStm, maSrcSz );
1962 : }
1963 0 : }
1964 :
1965 0 : void MetaBmpExScalePartAction::Read( SvStream& rIStm, ImplMetaReadData* )
1966 : {
1967 0 : VersionCompat aCompat(rIStm, STREAM_READ);
1968 0 : ReadDIBBitmapEx(maBmpEx, rIStm);
1969 0 : ReadPair( rIStm, maDstPt );
1970 0 : ReadPair( rIStm, maDstSz );
1971 0 : ReadPair( rIStm, maSrcPt );
1972 0 : ReadPair( rIStm, maSrcSz );
1973 0 : }
1974 :
1975 0 : MetaMaskAction::MetaMaskAction() :
1976 0 : MetaAction(META_MASK_ACTION)
1977 0 : {}
1978 :
1979 0 : MetaMaskAction::~MetaMaskAction()
1980 0 : {}
1981 :
1982 0 : MetaMaskAction::MetaMaskAction( const Point& rPt,
1983 : const Bitmap& rBmp,
1984 : const Color& rColor ) :
1985 : MetaAction ( META_MASK_ACTION ),
1986 : maBmp ( rBmp ),
1987 : maColor ( rColor ),
1988 0 : maPt ( rPt )
1989 0 : {}
1990 :
1991 0 : void MetaMaskAction::Execute( OutputDevice* pOut )
1992 : {
1993 0 : pOut->DrawMask( maPt, maBmp, maColor );
1994 0 : }
1995 :
1996 0 : MetaAction* MetaMaskAction::Clone()
1997 : {
1998 0 : MetaAction* pClone = (MetaAction*) new MetaMaskAction( *this );
1999 0 : pClone->ResetRefCount();
2000 0 : return pClone;
2001 : }
2002 :
2003 0 : void MetaMaskAction::Move( long nHorzMove, long nVertMove )
2004 : {
2005 0 : maPt.Move( nHorzMove, nVertMove );
2006 0 : }
2007 :
2008 0 : void MetaMaskAction::Scale( double fScaleX, double fScaleY )
2009 : {
2010 0 : ImplScalePoint( maPt, fScaleX, fScaleY );
2011 0 : }
2012 :
2013 0 : bool MetaMaskAction::Compare( const MetaAction& rMetaAction ) const
2014 : {
2015 0 : return ( maBmp.IsEqual(static_cast<const MetaMaskAction&>(rMetaAction).maBmp )) &&
2016 0 : ( maColor == static_cast<const MetaMaskAction&>(rMetaAction).maColor ) &&
2017 0 : ( maPt == static_cast<const MetaMaskAction&>(rMetaAction).maPt );
2018 : }
2019 :
2020 0 : void MetaMaskAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
2021 : {
2022 0 : if( !!maBmp )
2023 : {
2024 0 : MetaAction::Write(rOStm, pData);
2025 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
2026 0 : WriteDIB(maBmp, rOStm, false, true);
2027 0 : WritePair( rOStm, maPt );
2028 : }
2029 0 : }
2030 :
2031 0 : void MetaMaskAction::Read( SvStream& rIStm, ImplMetaReadData* )
2032 : {
2033 0 : VersionCompat aCompat(rIStm, STREAM_READ);
2034 0 : ReadDIB(maBmp, rIStm, true);
2035 0 : ReadPair( rIStm, maPt );
2036 0 : }
2037 :
2038 0 : MetaMaskScaleAction::MetaMaskScaleAction() :
2039 0 : MetaAction(META_MASKSCALE_ACTION)
2040 0 : {}
2041 :
2042 0 : MetaMaskScaleAction::~MetaMaskScaleAction()
2043 0 : {}
2044 :
2045 0 : MetaMaskScaleAction::MetaMaskScaleAction( const Point& rPt, const Size& rSz,
2046 : const Bitmap& rBmp,
2047 : const Color& rColor ) :
2048 : MetaAction ( META_MASKSCALE_ACTION ),
2049 : maBmp ( rBmp ),
2050 : maColor ( rColor ),
2051 : maPt ( rPt ),
2052 0 : maSz ( rSz )
2053 0 : {}
2054 :
2055 0 : void MetaMaskScaleAction::Execute( OutputDevice* pOut )
2056 : {
2057 0 : pOut->DrawMask( maPt, maSz, maBmp, maColor );
2058 0 : }
2059 :
2060 0 : MetaAction* MetaMaskScaleAction::Clone()
2061 : {
2062 0 : MetaAction* pClone = (MetaAction*) new MetaMaskScaleAction( *this );
2063 0 : pClone->ResetRefCount();
2064 0 : return pClone;
2065 : }
2066 :
2067 0 : void MetaMaskScaleAction::Move( long nHorzMove, long nVertMove )
2068 : {
2069 0 : maPt.Move( nHorzMove, nVertMove );
2070 0 : }
2071 :
2072 0 : void MetaMaskScaleAction::Scale( double fScaleX, double fScaleY )
2073 : {
2074 0 : Rectangle aRectangle(maPt, maSz);
2075 0 : ImplScaleRect( aRectangle, fScaleX, fScaleY );
2076 0 : maPt = aRectangle.TopLeft();
2077 0 : maSz = aRectangle.GetSize();
2078 0 : }
2079 :
2080 0 : bool MetaMaskScaleAction::Compare( const MetaAction& rMetaAction ) const
2081 : {
2082 0 : return ( maBmp.IsEqual(static_cast<const MetaMaskScaleAction&>(rMetaAction).maBmp )) &&
2083 0 : ( maColor == static_cast<const MetaMaskScaleAction&>(rMetaAction).maColor ) &&
2084 0 : ( maPt == static_cast<const MetaMaskScaleAction&>(rMetaAction).maPt ) &&
2085 0 : ( maSz == static_cast<const MetaMaskScaleAction&>(rMetaAction).maSz );
2086 : }
2087 :
2088 0 : void MetaMaskScaleAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
2089 : {
2090 0 : if( !!maBmp )
2091 : {
2092 0 : MetaAction::Write(rOStm, pData);
2093 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
2094 0 : WriteDIB(maBmp, rOStm, false, true);
2095 0 : WritePair( rOStm, maPt );
2096 0 : WritePair( rOStm, maSz );
2097 : }
2098 0 : }
2099 :
2100 0 : void MetaMaskScaleAction::Read( SvStream& rIStm, ImplMetaReadData* )
2101 : {
2102 0 : VersionCompat aCompat(rIStm, STREAM_READ);
2103 0 : ReadDIB(maBmp, rIStm, true);
2104 0 : ReadPair( rIStm, maPt );
2105 0 : ReadPair( rIStm, maSz );
2106 0 : }
2107 :
2108 0 : MetaMaskScalePartAction::MetaMaskScalePartAction() :
2109 0 : MetaAction(META_MASKSCALEPART_ACTION)
2110 0 : {}
2111 :
2112 0 : MetaMaskScalePartAction::~MetaMaskScalePartAction()
2113 0 : {}
2114 :
2115 0 : MetaMaskScalePartAction::MetaMaskScalePartAction( const Point& rDstPt, const Size& rDstSz,
2116 : const Point& rSrcPt, const Size& rSrcSz,
2117 : const Bitmap& rBmp,
2118 : const Color& rColor ) :
2119 : MetaAction ( META_MASKSCALEPART_ACTION ),
2120 : maBmp ( rBmp ),
2121 : maColor ( rColor ),
2122 : maDstPt ( rDstPt ),
2123 : maDstSz ( rDstSz ),
2124 : maSrcPt ( rSrcPt ),
2125 0 : maSrcSz ( rSrcSz )
2126 0 : {}
2127 :
2128 0 : void MetaMaskScalePartAction::Execute( OutputDevice* pOut )
2129 : {
2130 0 : pOut->DrawMask( maDstPt, maDstSz, maSrcPt, maSrcSz, maBmp, maColor, META_MASKSCALE_ACTION );
2131 0 : }
2132 :
2133 0 : MetaAction* MetaMaskScalePartAction::Clone()
2134 : {
2135 0 : MetaAction* pClone = (MetaAction*) new MetaMaskScalePartAction( *this );
2136 0 : pClone->ResetRefCount();
2137 0 : return pClone;
2138 : }
2139 :
2140 0 : void MetaMaskScalePartAction::Move( long nHorzMove, long nVertMove )
2141 : {
2142 0 : maDstPt.Move( nHorzMove, nVertMove );
2143 0 : }
2144 :
2145 0 : void MetaMaskScalePartAction::Scale( double fScaleX, double fScaleY )
2146 : {
2147 0 : Rectangle aRectangle(maDstPt, maDstSz);
2148 0 : ImplScaleRect( aRectangle, fScaleX, fScaleY );
2149 0 : maDstPt = aRectangle.TopLeft();
2150 0 : maDstSz = aRectangle.GetSize();
2151 0 : }
2152 :
2153 0 : bool MetaMaskScalePartAction::Compare( const MetaAction& rMetaAction ) const
2154 : {
2155 0 : return ( maBmp.IsEqual(static_cast<const MetaMaskScalePartAction&>(rMetaAction).maBmp )) &&
2156 0 : ( maColor == static_cast<const MetaMaskScalePartAction&>(rMetaAction).maColor ) &&
2157 0 : ( maDstPt == static_cast<const MetaMaskScalePartAction&>(rMetaAction).maDstPt ) &&
2158 0 : ( maDstSz == static_cast<const MetaMaskScalePartAction&>(rMetaAction).maDstSz ) &&
2159 0 : ( maSrcPt == static_cast<const MetaMaskScalePartAction&>(rMetaAction).maSrcPt ) &&
2160 0 : ( maSrcSz == static_cast<const MetaMaskScalePartAction&>(rMetaAction).maSrcSz );
2161 : }
2162 :
2163 0 : void MetaMaskScalePartAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
2164 : {
2165 0 : if( !!maBmp )
2166 : {
2167 0 : MetaAction::Write(rOStm, pData);
2168 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
2169 0 : WriteDIB(maBmp, rOStm, false, true);
2170 0 : maColor.Write( rOStm, true );
2171 0 : WritePair( rOStm, maDstPt );
2172 0 : WritePair( rOStm, maDstSz );
2173 0 : WritePair( rOStm, maSrcPt );
2174 0 : WritePair( rOStm, maSrcSz );
2175 : }
2176 0 : }
2177 :
2178 0 : void MetaMaskScalePartAction::Read( SvStream& rIStm, ImplMetaReadData* )
2179 : {
2180 0 : VersionCompat aCompat(rIStm, STREAM_READ);
2181 0 : ReadDIB(maBmp, rIStm, true);
2182 0 : maColor.Read( rIStm, true );
2183 0 : ReadPair( rIStm, maDstPt );
2184 0 : ReadPair( rIStm, maDstSz );
2185 0 : ReadPair( rIStm, maSrcPt );
2186 0 : ReadPair( rIStm, maSrcSz );
2187 0 : }
2188 :
2189 0 : MetaGradientAction::MetaGradientAction() :
2190 0 : MetaAction(META_GRADIENT_ACTION)
2191 0 : {}
2192 :
2193 24 : MetaGradientAction::~MetaGradientAction()
2194 24 : {}
2195 :
2196 12 : MetaGradientAction::MetaGradientAction( const Rectangle& rRect, const Gradient& rGradient ) :
2197 : MetaAction ( META_GRADIENT_ACTION ),
2198 : maRect ( rRect ),
2199 12 : maGradient ( rGradient )
2200 12 : {}
2201 :
2202 0 : void MetaGradientAction::Execute( OutputDevice* pOut )
2203 : {
2204 0 : pOut->DrawGradient( maRect, maGradient );
2205 0 : }
2206 :
2207 0 : MetaAction* MetaGradientAction::Clone()
2208 : {
2209 0 : MetaAction* pClone = (MetaAction*) new MetaGradientAction( *this );
2210 0 : pClone->ResetRefCount();
2211 0 : return pClone;
2212 : }
2213 :
2214 12 : void MetaGradientAction::Move( long nHorzMove, long nVertMove )
2215 : {
2216 12 : maRect.Move( nHorzMove, nVertMove );
2217 12 : }
2218 :
2219 0 : void MetaGradientAction::Scale( double fScaleX, double fScaleY )
2220 : {
2221 0 : ImplScaleRect( maRect, fScaleX, fScaleY );
2222 0 : }
2223 :
2224 0 : bool MetaGradientAction::Compare( const MetaAction& rMetaAction ) const
2225 : {
2226 0 : return ( maRect == static_cast<const MetaGradientAction&>(rMetaAction).maRect ) &&
2227 0 : ( maGradient == static_cast<const MetaGradientAction&>(rMetaAction).maGradient );
2228 : }
2229 :
2230 0 : void MetaGradientAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
2231 : {
2232 0 : MetaAction::Write(rOStm, pData);
2233 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
2234 0 : WriteRectangle( rOStm, maRect );
2235 0 : WriteGradient( rOStm, maGradient );
2236 0 : }
2237 :
2238 0 : void MetaGradientAction::Read( SvStream& rIStm, ImplMetaReadData* )
2239 : {
2240 0 : VersionCompat aCompat(rIStm, STREAM_READ);
2241 0 : ReadRectangle( rIStm, maRect );
2242 0 : ReadGradient( rIStm, maGradient );
2243 0 : }
2244 :
2245 0 : MetaGradientExAction::MetaGradientExAction() :
2246 0 : MetaAction ( META_GRADIENTEX_ACTION )
2247 0 : {}
2248 :
2249 12 : MetaGradientExAction::MetaGradientExAction( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient ) :
2250 : MetaAction ( META_GRADIENTEX_ACTION ),
2251 : maPolyPoly ( rPolyPoly ),
2252 12 : maGradient ( rGradient )
2253 12 : {}
2254 :
2255 24 : MetaGradientExAction::~MetaGradientExAction()
2256 24 : {}
2257 :
2258 0 : void MetaGradientExAction::Execute( OutputDevice* pOut )
2259 : {
2260 0 : if( pOut->GetConnectMetaFile() )
2261 : {
2262 0 : Duplicate();
2263 0 : pOut->GetConnectMetaFile()->AddAction( this );
2264 : }
2265 0 : }
2266 :
2267 0 : MetaAction* MetaGradientExAction::Clone()
2268 : {
2269 0 : MetaAction* pClone = (MetaAction*) new MetaGradientExAction( *this );
2270 0 : pClone->ResetRefCount();
2271 0 : return pClone;
2272 : }
2273 :
2274 12 : void MetaGradientExAction::Move( long nHorzMove, long nVertMove )
2275 : {
2276 12 : maPolyPoly.Move( nHorzMove, nVertMove );
2277 12 : }
2278 :
2279 0 : void MetaGradientExAction::Scale( double fScaleX, double fScaleY )
2280 : {
2281 0 : for( sal_uInt16 i = 0, nCount = maPolyPoly.Count(); i < nCount; i++ )
2282 0 : ImplScalePoly( maPolyPoly[ i ], fScaleX, fScaleY );
2283 0 : }
2284 :
2285 0 : bool MetaGradientExAction::Compare( const MetaAction& rMetaAction ) const
2286 : {
2287 0 : return ( maPolyPoly == static_cast<const MetaGradientExAction&>(rMetaAction).maPolyPoly ) &&
2288 0 : ( maGradient == static_cast<const MetaGradientExAction&>(rMetaAction).maGradient );
2289 : }
2290 :
2291 0 : void MetaGradientExAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
2292 : {
2293 0 : MetaAction::Write(rOStm, pData);
2294 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
2295 :
2296 : // #i105373# see comment at MetaTransparentAction::Write
2297 0 : tools::PolyPolygon aNoCurvePolyPolygon;
2298 0 : maPolyPoly.AdaptiveSubdivide(aNoCurvePolyPolygon);
2299 :
2300 0 : WritePolyPolygon( rOStm, aNoCurvePolyPolygon );
2301 0 : WriteGradient( rOStm, maGradient );
2302 0 : }
2303 :
2304 0 : void MetaGradientExAction::Read( SvStream& rIStm, ImplMetaReadData* )
2305 : {
2306 0 : VersionCompat aCompat(rIStm, STREAM_READ);
2307 0 : ReadPolyPolygon( rIStm, maPolyPoly );
2308 0 : ReadGradient( rIStm, maGradient );
2309 0 : }
2310 :
2311 2 : MetaHatchAction::MetaHatchAction() :
2312 2 : MetaAction(META_HATCH_ACTION)
2313 2 : {}
2314 :
2315 68 : MetaHatchAction::~MetaHatchAction()
2316 68 : {}
2317 :
2318 30 : MetaHatchAction::MetaHatchAction( const tools::PolyPolygon& rPolyPoly, const Hatch& rHatch ) :
2319 : MetaAction ( META_HATCH_ACTION ),
2320 : maPolyPoly ( rPolyPoly ),
2321 30 : maHatch ( rHatch )
2322 30 : {}
2323 :
2324 0 : void MetaHatchAction::Execute( OutputDevice* pOut )
2325 : {
2326 0 : pOut->DrawHatch( maPolyPoly, maHatch );
2327 0 : }
2328 :
2329 2 : MetaAction* MetaHatchAction::Clone()
2330 : {
2331 2 : MetaAction* pClone = (MetaAction*) new MetaHatchAction( *this );
2332 2 : pClone->ResetRefCount();
2333 2 : return pClone;
2334 : }
2335 :
2336 0 : void MetaHatchAction::Move( long nHorzMove, long nVertMove )
2337 : {
2338 0 : maPolyPoly.Move( nHorzMove, nVertMove );
2339 0 : }
2340 :
2341 2 : void MetaHatchAction::Scale( double fScaleX, double fScaleY )
2342 : {
2343 8 : for( sal_uInt16 i = 0, nCount = maPolyPoly.Count(); i < nCount; i++ )
2344 6 : ImplScalePoly( maPolyPoly[ i ], fScaleX, fScaleY );
2345 2 : }
2346 :
2347 0 : bool MetaHatchAction::Compare( const MetaAction& rMetaAction ) const
2348 : {
2349 0 : return ( maPolyPoly == static_cast<const MetaHatchAction&>(rMetaAction).maPolyPoly ) &&
2350 0 : ( maHatch == static_cast<const MetaHatchAction&>(rMetaAction).maHatch );
2351 : }
2352 :
2353 62 : void MetaHatchAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
2354 : {
2355 62 : MetaAction::Write(rOStm, pData);
2356 62 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
2357 :
2358 : // #i105373# see comment at MetaTransparentAction::Write
2359 124 : tools::PolyPolygon aNoCurvePolyPolygon;
2360 62 : maPolyPoly.AdaptiveSubdivide(aNoCurvePolyPolygon);
2361 :
2362 62 : WritePolyPolygon( rOStm, aNoCurvePolyPolygon );
2363 124 : WriteHatch( rOStm, maHatch );
2364 62 : }
2365 :
2366 2 : void MetaHatchAction::Read( SvStream& rIStm, ImplMetaReadData* )
2367 : {
2368 2 : VersionCompat aCompat(rIStm, STREAM_READ);
2369 2 : ReadPolyPolygon( rIStm, maPolyPoly );
2370 2 : ReadHatch( rIStm, maHatch );
2371 2 : }
2372 :
2373 0 : MetaWallpaperAction::MetaWallpaperAction() :
2374 0 : MetaAction(META_WALLPAPER_ACTION)
2375 0 : {}
2376 :
2377 3734 : MetaWallpaperAction::~MetaWallpaperAction()
2378 3734 : {}
2379 :
2380 1867 : MetaWallpaperAction::MetaWallpaperAction( const Rectangle& rRect,
2381 : const Wallpaper& rPaper ) :
2382 : MetaAction ( META_WALLPAPER_ACTION ),
2383 : maRect ( rRect ),
2384 1867 : maWallpaper ( rPaper )
2385 1867 : {}
2386 :
2387 1867 : void MetaWallpaperAction::Execute( OutputDevice* pOut )
2388 : {
2389 1867 : pOut->DrawWallpaper( maRect, maWallpaper );
2390 1867 : }
2391 :
2392 0 : MetaAction* MetaWallpaperAction::Clone()
2393 : {
2394 0 : MetaAction* pClone = (MetaAction*) new MetaWallpaperAction( *this );
2395 0 : pClone->ResetRefCount();
2396 0 : return pClone;
2397 : }
2398 :
2399 0 : void MetaWallpaperAction::Move( long nHorzMove, long nVertMove )
2400 : {
2401 0 : maRect.Move( nHorzMove, nVertMove );
2402 0 : }
2403 :
2404 0 : void MetaWallpaperAction::Scale( double fScaleX, double fScaleY )
2405 : {
2406 0 : ImplScaleRect( maRect, fScaleX, fScaleY );
2407 0 : }
2408 :
2409 0 : bool MetaWallpaperAction::Compare( const MetaAction& rMetaAction ) const
2410 : {
2411 0 : return ( maRect == static_cast<const MetaWallpaperAction&>(rMetaAction).maRect ) &&
2412 0 : ( maWallpaper == static_cast<const MetaWallpaperAction&>(rMetaAction).maWallpaper );
2413 : }
2414 :
2415 0 : void MetaWallpaperAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
2416 : {
2417 0 : MetaAction::Write(rOStm, pData);
2418 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
2419 :
2420 0 : WriteWallpaper( rOStm, maWallpaper );
2421 0 : }
2422 :
2423 0 : void MetaWallpaperAction::Read( SvStream& rIStm, ImplMetaReadData* )
2424 : {
2425 0 : VersionCompat aCompat(rIStm, STREAM_READ);
2426 0 : ReadWallpaper( rIStm, maWallpaper );
2427 0 : }
2428 :
2429 86 : MetaClipRegionAction::MetaClipRegionAction() :
2430 : MetaAction ( META_CLIPREGION_ACTION ),
2431 86 : mbClip ( false )
2432 86 : {}
2433 :
2434 15256 : MetaClipRegionAction::~MetaClipRegionAction()
2435 15256 : {}
2436 :
2437 7458 : MetaClipRegionAction::MetaClipRegionAction( const vcl::Region& rRegion, bool bClip ) :
2438 : MetaAction ( META_CLIPREGION_ACTION ),
2439 : maRegion ( rRegion ),
2440 7458 : mbClip ( bClip )
2441 7458 : {}
2442 :
2443 6758 : void MetaClipRegionAction::Execute( OutputDevice* pOut )
2444 : {
2445 6758 : if( mbClip )
2446 6677 : pOut->SetClipRegion( maRegion );
2447 : else
2448 81 : pOut->SetClipRegion();
2449 6758 : }
2450 :
2451 84 : MetaAction* MetaClipRegionAction::Clone()
2452 : {
2453 84 : MetaAction* pClone = (MetaAction*) new MetaClipRegionAction( *this );
2454 84 : pClone->ResetRefCount();
2455 84 : return pClone;
2456 : }
2457 :
2458 8 : void MetaClipRegionAction::Move( long nHorzMove, long nVertMove )
2459 : {
2460 8 : maRegion.Move( nHorzMove, nVertMove );
2461 8 : }
2462 :
2463 84 : void MetaClipRegionAction::Scale( double fScaleX, double fScaleY )
2464 : {
2465 84 : maRegion.Scale( fScaleX, fScaleY );
2466 84 : }
2467 :
2468 0 : bool MetaClipRegionAction::Compare( const MetaAction& rMetaAction ) const
2469 : {
2470 0 : return ( maRegion == static_cast<const MetaClipRegionAction&>(rMetaAction).maRegion ) &&
2471 0 : ( mbClip == static_cast<const MetaClipRegionAction&>(rMetaAction).mbClip );
2472 : }
2473 :
2474 1488 : void MetaClipRegionAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
2475 : {
2476 1488 : MetaAction::Write(rOStm, pData);
2477 1488 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
2478 :
2479 1488 : WriteRegion( rOStm, maRegion );
2480 1488 : rOStm.WriteUChar( mbClip );
2481 1488 : }
2482 :
2483 86 : void MetaClipRegionAction::Read( SvStream& rIStm, ImplMetaReadData* )
2484 : {
2485 86 : VersionCompat aCompat(rIStm, STREAM_READ);
2486 86 : ReadRegion( rIStm, maRegion );
2487 86 : rIStm.ReadCharAsBool( mbClip );
2488 86 : }
2489 :
2490 9750 : MetaISectRectClipRegionAction::MetaISectRectClipRegionAction() :
2491 9750 : MetaAction(META_ISECTRECTCLIPREGION_ACTION)
2492 9750 : {}
2493 :
2494 41824 : MetaISectRectClipRegionAction::~MetaISectRectClipRegionAction()
2495 41824 : {}
2496 :
2497 11162 : MetaISectRectClipRegionAction::MetaISectRectClipRegionAction( const Rectangle& rRect ) :
2498 : MetaAction ( META_ISECTRECTCLIPREGION_ACTION ),
2499 11162 : maRect ( rRect )
2500 11162 : {}
2501 :
2502 1064 : void MetaISectRectClipRegionAction::Execute( OutputDevice* pOut )
2503 : {
2504 1064 : pOut->IntersectClipRegion( maRect );
2505 1064 : }
2506 :
2507 0 : MetaAction* MetaISectRectClipRegionAction::Clone()
2508 : {
2509 0 : MetaAction* pClone = (MetaAction*) new MetaISectRectClipRegionAction( *this );
2510 0 : pClone->ResetRefCount();
2511 0 : return pClone;
2512 : }
2513 :
2514 104 : void MetaISectRectClipRegionAction::Move( long nHorzMove, long nVertMove )
2515 : {
2516 104 : maRect.Move( nHorzMove, nVertMove );
2517 104 : }
2518 :
2519 0 : void MetaISectRectClipRegionAction::Scale( double fScaleX, double fScaleY )
2520 : {
2521 0 : ImplScaleRect( maRect, fScaleX, fScaleY );
2522 0 : }
2523 :
2524 0 : bool MetaISectRectClipRegionAction::Compare( const MetaAction& rMetaAction ) const
2525 : {
2526 0 : return maRect == static_cast<const MetaISectRectClipRegionAction&>(rMetaAction).maRect;
2527 : }
2528 :
2529 11730 : void MetaISectRectClipRegionAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
2530 : {
2531 11730 : MetaAction::Write(rOStm, pData);
2532 11730 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
2533 11730 : WriteRectangle( rOStm, maRect );
2534 11730 : }
2535 :
2536 9750 : void MetaISectRectClipRegionAction::Read( SvStream& rIStm, ImplMetaReadData* )
2537 : {
2538 9750 : VersionCompat aCompat(rIStm, STREAM_READ);
2539 9750 : ReadRectangle( rIStm, maRect );
2540 9750 : }
2541 :
2542 1922 : MetaISectRegionClipRegionAction::MetaISectRegionClipRegionAction() :
2543 1922 : MetaAction(META_ISECTREGIONCLIPREGION_ACTION)
2544 1922 : {}
2545 :
2546 8640 : MetaISectRegionClipRegionAction::~MetaISectRegionClipRegionAction()
2547 8640 : {}
2548 :
2549 2398 : MetaISectRegionClipRegionAction::MetaISectRegionClipRegionAction( const vcl::Region& rRegion ) :
2550 : MetaAction ( META_ISECTREGIONCLIPREGION_ACTION ),
2551 2398 : maRegion ( rRegion )
2552 : {
2553 2398 : }
2554 :
2555 504 : void MetaISectRegionClipRegionAction::Execute( OutputDevice* pOut )
2556 : {
2557 504 : pOut->IntersectClipRegion( maRegion );
2558 504 : }
2559 :
2560 0 : MetaAction* MetaISectRegionClipRegionAction::Clone()
2561 : {
2562 0 : MetaAction* pClone = (MetaAction*) new MetaISectRegionClipRegionAction( *this );
2563 0 : pClone->ResetRefCount();
2564 0 : return pClone;
2565 : }
2566 :
2567 12 : void MetaISectRegionClipRegionAction::Move( long nHorzMove, long nVertMove )
2568 : {
2569 12 : maRegion.Move( nHorzMove, nVertMove );
2570 12 : }
2571 :
2572 0 : void MetaISectRegionClipRegionAction::Scale( double fScaleX, double fScaleY )
2573 : {
2574 0 : maRegion.Scale( fScaleX, fScaleY );
2575 0 : }
2576 :
2577 0 : bool MetaISectRegionClipRegionAction::Compare( const MetaAction& rMetaAction ) const
2578 : {
2579 0 : return maRegion == static_cast<const MetaISectRegionClipRegionAction&>(rMetaAction).maRegion;
2580 : }
2581 :
2582 1956 : void MetaISectRegionClipRegionAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
2583 : {
2584 1956 : MetaAction::Write(rOStm, pData);
2585 1956 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
2586 1956 : WriteRegion( rOStm, maRegion );
2587 1956 : }
2588 :
2589 1922 : void MetaISectRegionClipRegionAction::Read( SvStream& rIStm, ImplMetaReadData* )
2590 : {
2591 1922 : VersionCompat aCompat(rIStm, STREAM_READ);
2592 1922 : ReadRegion( rIStm, maRegion );
2593 1922 : }
2594 :
2595 0 : MetaMoveClipRegionAction::MetaMoveClipRegionAction() :
2596 : MetaAction ( META_MOVECLIPREGION_ACTION ),
2597 : mnHorzMove ( 0 ),
2598 0 : mnVertMove ( 0 )
2599 0 : {}
2600 :
2601 0 : MetaMoveClipRegionAction::~MetaMoveClipRegionAction()
2602 0 : {}
2603 :
2604 0 : MetaMoveClipRegionAction::MetaMoveClipRegionAction( long nHorzMove, long nVertMove ) :
2605 : MetaAction ( META_MOVECLIPREGION_ACTION ),
2606 : mnHorzMove ( nHorzMove ),
2607 0 : mnVertMove ( nVertMove )
2608 0 : {}
2609 :
2610 0 : void MetaMoveClipRegionAction::Execute( OutputDevice* pOut )
2611 : {
2612 0 : pOut->MoveClipRegion( mnHorzMove, mnVertMove );
2613 0 : }
2614 :
2615 0 : MetaAction* MetaMoveClipRegionAction::Clone()
2616 : {
2617 0 : MetaAction* pClone = (MetaAction*) new MetaMoveClipRegionAction( *this );
2618 0 : pClone->ResetRefCount();
2619 0 : return pClone;
2620 : }
2621 :
2622 0 : void MetaMoveClipRegionAction::Scale( double fScaleX, double fScaleY )
2623 : {
2624 0 : mnHorzMove = FRound( mnHorzMove * fScaleX );
2625 0 : mnVertMove = FRound( mnVertMove * fScaleY );
2626 0 : }
2627 :
2628 0 : bool MetaMoveClipRegionAction::Compare( const MetaAction& rMetaAction ) const
2629 : {
2630 0 : return ( mnHorzMove == static_cast<const MetaMoveClipRegionAction&>(rMetaAction).mnHorzMove ) &&
2631 0 : ( mnVertMove == static_cast<const MetaMoveClipRegionAction&>(rMetaAction).mnVertMove );
2632 : }
2633 :
2634 0 : void MetaMoveClipRegionAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
2635 : {
2636 0 : MetaAction::Write(rOStm, pData);
2637 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
2638 0 : rOStm.WriteInt32( mnHorzMove ).WriteInt32( mnVertMove );
2639 0 : }
2640 :
2641 0 : void MetaMoveClipRegionAction::Read( SvStream& rIStm, ImplMetaReadData* )
2642 : {
2643 0 : VersionCompat aCompat(rIStm, STREAM_READ);
2644 0 : sal_Int32 nTmpHM(0), nTmpVM(0);
2645 0 : rIStm.ReadInt32( nTmpHM ).ReadInt32( nTmpVM );
2646 0 : mnHorzMove = nTmpHM;
2647 0 : mnVertMove = nTmpVM;
2648 0 : }
2649 :
2650 8514 : MetaLineColorAction::MetaLineColorAction() :
2651 : MetaAction ( META_LINECOLOR_ACTION ),
2652 8514 : mbSet ( false )
2653 8514 : {}
2654 :
2655 138028 : MetaLineColorAction::~MetaLineColorAction()
2656 138028 : {}
2657 :
2658 58228 : MetaLineColorAction::MetaLineColorAction( const Color& rColor, bool bSet ) :
2659 : MetaAction ( META_LINECOLOR_ACTION ),
2660 : maColor ( rColor ),
2661 58228 : mbSet ( bSet )
2662 58228 : {}
2663 :
2664 41389 : void MetaLineColorAction::Execute( OutputDevice* pOut )
2665 : {
2666 41389 : if( mbSet )
2667 32975 : pOut->SetLineColor( maColor );
2668 : else
2669 8414 : pOut->SetLineColor();
2670 41389 : }
2671 :
2672 2272 : MetaAction* MetaLineColorAction::Clone()
2673 : {
2674 2272 : MetaAction* pClone = (MetaAction*) new MetaLineColorAction( *this );
2675 2272 : pClone->ResetRefCount();
2676 2272 : return pClone;
2677 : }
2678 :
2679 0 : bool MetaLineColorAction::Compare( const MetaAction& rMetaAction ) const
2680 : {
2681 0 : return ( maColor == static_cast<const MetaLineColorAction&>(rMetaAction).maColor ) &&
2682 0 : ( mbSet == static_cast<const MetaLineColorAction&>(rMetaAction).mbSet );
2683 : }
2684 :
2685 29658 : void MetaLineColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
2686 : {
2687 29658 : MetaAction::Write(rOStm, pData);
2688 29658 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
2689 29658 : maColor.Write( rOStm, true );
2690 29658 : rOStm.WriteUChar( mbSet );
2691 29658 : }
2692 :
2693 8514 : void MetaLineColorAction::Read( SvStream& rIStm, ImplMetaReadData* )
2694 : {
2695 8514 : VersionCompat aCompat(rIStm, STREAM_READ);
2696 8514 : maColor.Read( rIStm, true );
2697 8514 : rIStm.ReadCharAsBool( mbSet );
2698 8514 : }
2699 :
2700 6380 : MetaFillColorAction::MetaFillColorAction() :
2701 : MetaAction ( META_FILLCOLOR_ACTION ),
2702 6380 : mbSet ( false )
2703 6380 : {}
2704 :
2705 95970 : MetaFillColorAction::~MetaFillColorAction()
2706 95970 : {}
2707 :
2708 40141 : MetaFillColorAction::MetaFillColorAction( const Color& rColor, bool bSet ) :
2709 : MetaAction ( META_FILLCOLOR_ACTION ),
2710 : maColor ( rColor ),
2711 40141 : mbSet ( bSet )
2712 40141 : {}
2713 :
2714 28729 : void MetaFillColorAction::Execute( OutputDevice* pOut )
2715 : {
2716 28729 : if( mbSet )
2717 25693 : pOut->SetFillColor( maColor );
2718 : else
2719 3036 : pOut->SetFillColor();
2720 28729 : }
2721 :
2722 1464 : MetaAction* MetaFillColorAction::Clone()
2723 : {
2724 1464 : MetaAction* pClone = (MetaAction*) new MetaFillColorAction( *this );
2725 1464 : pClone->ResetRefCount();
2726 1464 : return pClone;
2727 : }
2728 :
2729 0 : bool MetaFillColorAction::Compare( const MetaAction& rMetaAction ) const
2730 : {
2731 0 : return ( maColor == static_cast<const MetaFillColorAction&>(rMetaAction).maColor ) &&
2732 0 : ( mbSet == static_cast<const MetaFillColorAction&>(rMetaAction).mbSet );
2733 : }
2734 :
2735 18706 : void MetaFillColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
2736 : {
2737 18706 : MetaAction::Write(rOStm, pData);
2738 18706 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
2739 18706 : maColor.Write( rOStm, true );
2740 18706 : rOStm.WriteUChar( mbSet );
2741 18706 : }
2742 :
2743 6380 : void MetaFillColorAction::Read( SvStream& rIStm, ImplMetaReadData* )
2744 : {
2745 6380 : VersionCompat aCompat(rIStm, STREAM_READ);
2746 6380 : maColor.Read( rIStm, true );
2747 6380 : rIStm.ReadCharAsBool( mbSet );
2748 6380 : }
2749 :
2750 76626 : MetaTextColorAction::MetaTextColorAction() :
2751 76626 : MetaAction(META_TEXTCOLOR_ACTION)
2752 76626 : {}
2753 :
2754 329426 : MetaTextColorAction::~MetaTextColorAction()
2755 329426 : {}
2756 :
2757 87779 : MetaTextColorAction::MetaTextColorAction( const Color& rColor ) :
2758 : MetaAction ( META_TEXTCOLOR_ACTION ),
2759 87779 : maColor ( rColor )
2760 87779 : {}
2761 :
2762 12071 : void MetaTextColorAction::Execute( OutputDevice* pOut )
2763 : {
2764 12071 : pOut->SetTextColor( maColor );
2765 12071 : }
2766 :
2767 308 : MetaAction* MetaTextColorAction::Clone()
2768 : {
2769 308 : MetaAction* pClone = (MetaAction*) new MetaTextColorAction( *this );
2770 308 : pClone->ResetRefCount();
2771 308 : return pClone;
2772 : }
2773 :
2774 0 : bool MetaTextColorAction::Compare( const MetaAction& rMetaAction ) const
2775 : {
2776 0 : return maColor == static_cast<const MetaTextColorAction&>(rMetaAction).maColor;
2777 : }
2778 :
2779 83990 : void MetaTextColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
2780 : {
2781 83990 : MetaAction::Write(rOStm, pData);
2782 83990 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
2783 83990 : maColor.Write( rOStm, true );
2784 83990 : }
2785 :
2786 76626 : void MetaTextColorAction::Read( SvStream& rIStm, ImplMetaReadData* )
2787 : {
2788 76626 : VersionCompat aCompat(rIStm, STREAM_READ);
2789 76626 : maColor.Read( rIStm, true );
2790 76626 : }
2791 :
2792 75588 : MetaTextFillColorAction::MetaTextFillColorAction() :
2793 : MetaAction ( META_TEXTFILLCOLOR_ACTION ),
2794 75588 : mbSet ( false )
2795 75588 : {}
2796 :
2797 342634 : MetaTextFillColorAction::~MetaTextFillColorAction()
2798 342634 : {}
2799 :
2800 95421 : MetaTextFillColorAction::MetaTextFillColorAction( const Color& rColor, bool bSet ) :
2801 : MetaAction ( META_TEXTFILLCOLOR_ACTION ),
2802 : maColor ( rColor ),
2803 95421 : mbSet ( bSet )
2804 95421 : {}
2805 :
2806 19787 : void MetaTextFillColorAction::Execute( OutputDevice* pOut )
2807 : {
2808 19787 : if( mbSet )
2809 1605 : pOut->SetTextFillColor( maColor );
2810 : else
2811 18182 : pOut->SetTextFillColor();
2812 19787 : }
2813 :
2814 308 : MetaAction* MetaTextFillColorAction::Clone()
2815 : {
2816 308 : MetaAction* pClone = (MetaAction*) new MetaTextFillColorAction( *this );
2817 308 : pClone->ResetRefCount();
2818 308 : return pClone;
2819 : }
2820 :
2821 0 : bool MetaTextFillColorAction::Compare( const MetaAction& rMetaAction ) const
2822 : {
2823 0 : return ( maColor == static_cast<const MetaTextFillColorAction&>(rMetaAction).maColor ) &&
2824 0 : ( mbSet == static_cast<const MetaTextFillColorAction&>(rMetaAction).mbSet );
2825 : }
2826 :
2827 86410 : void MetaTextFillColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
2828 : {
2829 86410 : MetaAction::Write(rOStm, pData);
2830 86410 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
2831 86410 : maColor.Write( rOStm, true );
2832 86410 : rOStm.WriteUChar( mbSet );
2833 86410 : }
2834 :
2835 75588 : void MetaTextFillColorAction::Read( SvStream& rIStm, ImplMetaReadData* )
2836 : {
2837 75588 : VersionCompat aCompat(rIStm, STREAM_READ);
2838 75588 : maColor.Read( rIStm, true );
2839 75588 : rIStm.ReadCharAsBool( mbSet );
2840 75588 : }
2841 :
2842 2 : MetaTextLineColorAction::MetaTextLineColorAction() :
2843 : MetaAction ( META_TEXTLINECOLOR_ACTION ),
2844 2 : mbSet ( false )
2845 2 : {}
2846 :
2847 13290 : MetaTextLineColorAction::~MetaTextLineColorAction()
2848 13290 : {}
2849 :
2850 6643 : MetaTextLineColorAction::MetaTextLineColorAction( const Color& rColor, bool bSet ) :
2851 : MetaAction ( META_TEXTLINECOLOR_ACTION ),
2852 : maColor ( rColor ),
2853 6643 : mbSet ( bSet )
2854 6643 : {}
2855 :
2856 6645 : void MetaTextLineColorAction::Execute( OutputDevice* pOut )
2857 : {
2858 6645 : if( mbSet )
2859 14 : pOut->SetTextLineColor( maColor );
2860 : else
2861 6631 : pOut->SetTextLineColor();
2862 6645 : }
2863 :
2864 0 : MetaAction* MetaTextLineColorAction::Clone()
2865 : {
2866 0 : MetaAction* pClone = (MetaAction*) new MetaTextLineColorAction( *this );
2867 0 : pClone->ResetRefCount();
2868 0 : return pClone;
2869 : }
2870 :
2871 0 : bool MetaTextLineColorAction::Compare( const MetaAction& rMetaAction ) const
2872 : {
2873 0 : return ( maColor == static_cast<const MetaTextLineColorAction&>(rMetaAction).maColor ) &&
2874 0 : ( mbSet == static_cast<const MetaTextLineColorAction&>(rMetaAction).mbSet );
2875 : }
2876 :
2877 0 : void MetaTextLineColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
2878 : {
2879 0 : MetaAction::Write(rOStm, pData);
2880 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
2881 0 : maColor.Write( rOStm, true );
2882 0 : rOStm.WriteUChar( mbSet );
2883 0 : }
2884 :
2885 2 : void MetaTextLineColorAction::Read( SvStream& rIStm, ImplMetaReadData* )
2886 : {
2887 2 : VersionCompat aCompat(rIStm, STREAM_READ);
2888 2 : maColor.Read( rIStm, true );
2889 2 : rIStm.ReadCharAsBool( mbSet );
2890 2 : }
2891 :
2892 2 : MetaOverlineColorAction::MetaOverlineColorAction() :
2893 : MetaAction ( META_OVERLINECOLOR_ACTION ),
2894 2 : mbSet ( false )
2895 2 : {}
2896 :
2897 13290 : MetaOverlineColorAction::~MetaOverlineColorAction()
2898 13290 : {}
2899 :
2900 6643 : MetaOverlineColorAction::MetaOverlineColorAction( const Color& rColor, bool bSet ) :
2901 : MetaAction ( META_OVERLINECOLOR_ACTION ),
2902 : maColor ( rColor ),
2903 6643 : mbSet ( bSet )
2904 6643 : {}
2905 :
2906 6643 : void MetaOverlineColorAction::Execute( OutputDevice* pOut )
2907 : {
2908 6643 : if( mbSet )
2909 12 : pOut->SetOverlineColor( maColor );
2910 : else
2911 6631 : pOut->SetOverlineColor();
2912 6643 : }
2913 :
2914 0 : MetaAction* MetaOverlineColorAction::Clone()
2915 : {
2916 0 : MetaAction* pClone = (MetaAction*) new MetaOverlineColorAction( *this );
2917 0 : pClone->ResetRefCount();
2918 0 : return pClone;
2919 : }
2920 :
2921 0 : bool MetaOverlineColorAction::Compare( const MetaAction& rMetaAction ) const
2922 : {
2923 0 : return ( maColor == static_cast<const MetaOverlineColorAction&>(rMetaAction).maColor ) &&
2924 0 : ( mbSet == static_cast<const MetaOverlineColorAction&>(rMetaAction).mbSet );
2925 : }
2926 :
2927 0 : void MetaOverlineColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
2928 : {
2929 0 : MetaAction::Write(rOStm, pData);
2930 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
2931 0 : maColor.Write( rOStm, true );
2932 0 : rOStm.WriteUChar( mbSet );
2933 0 : }
2934 :
2935 2 : void MetaOverlineColorAction::Read( SvStream& rIStm, ImplMetaReadData* )
2936 : {
2937 2 : VersionCompat aCompat(rIStm, STREAM_READ);
2938 2 : maColor.Read( rIStm, true );
2939 2 : rIStm.ReadCharAsBool( mbSet );
2940 2 : }
2941 :
2942 75586 : MetaTextAlignAction::MetaTextAlignAction() :
2943 : MetaAction ( META_TEXTALIGN_ACTION ),
2944 75586 : maAlign ( ALIGN_TOP )
2945 75586 : {}
2946 :
2947 338828 : MetaTextAlignAction::~MetaTextAlignAction()
2948 338828 : {}
2949 :
2950 93520 : MetaTextAlignAction::MetaTextAlignAction( TextAlign aAlign ) :
2951 : MetaAction ( META_TEXTALIGN_ACTION ),
2952 93520 : maAlign ( aAlign )
2953 93520 : {}
2954 :
2955 17980 : void MetaTextAlignAction::Execute( OutputDevice* pOut )
2956 : {
2957 17980 : pOut->SetTextAlign( maAlign );
2958 17980 : }
2959 :
2960 308 : MetaAction* MetaTextAlignAction::Clone()
2961 : {
2962 308 : MetaAction* pClone = (MetaAction*) new MetaTextAlignAction( *this );
2963 308 : pClone->ResetRefCount();
2964 308 : return pClone;
2965 : }
2966 :
2967 0 : bool MetaTextAlignAction::Compare( const MetaAction& rMetaAction ) const
2968 : {
2969 0 : return maAlign == static_cast<const MetaTextAlignAction&>(rMetaAction).maAlign;
2970 : }
2971 :
2972 85880 : void MetaTextAlignAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
2973 : {
2974 85880 : MetaAction::Write(rOStm, pData);
2975 85880 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
2976 85880 : rOStm.WriteUInt16( maAlign );
2977 85880 : }
2978 :
2979 75586 : void MetaTextAlignAction::Read( SvStream& rIStm, ImplMetaReadData* )
2980 : {
2981 75586 : sal_uInt16 nTmp16(0);
2982 :
2983 75586 : VersionCompat aCompat(rIStm, STREAM_READ);
2984 75586 : rIStm.ReadUInt16( nTmp16 ); maAlign = (TextAlign) nTmp16;
2985 75586 : }
2986 :
2987 612 : MetaMapModeAction::MetaMapModeAction() :
2988 612 : MetaAction(META_MAPMODE_ACTION)
2989 612 : {}
2990 :
2991 3314 : MetaMapModeAction::~MetaMapModeAction()
2992 3314 : {}
2993 :
2994 991 : MetaMapModeAction::MetaMapModeAction( const MapMode& rMapMode ) :
2995 : MetaAction ( META_MAPMODE_ACTION ),
2996 991 : maMapMode ( rMapMode )
2997 991 : {}
2998 :
2999 431 : void MetaMapModeAction::Execute( OutputDevice* pOut )
3000 : {
3001 431 : pOut->SetMapMode( maMapMode );
3002 431 : }
3003 :
3004 54 : MetaAction* MetaMapModeAction::Clone()
3005 : {
3006 54 : MetaAction* pClone = (MetaAction*) new MetaMapModeAction( *this );
3007 54 : pClone->ResetRefCount();
3008 54 : return pClone;
3009 : }
3010 :
3011 54 : void MetaMapModeAction::Scale( double fScaleX, double fScaleY )
3012 : {
3013 54 : Point aPoint( maMapMode.GetOrigin() );
3014 :
3015 54 : ImplScalePoint( aPoint, fScaleX, fScaleY );
3016 54 : maMapMode.SetOrigin( aPoint );
3017 54 : }
3018 :
3019 0 : bool MetaMapModeAction::Compare( const MetaAction& rMetaAction ) const
3020 : {
3021 0 : return maMapMode == static_cast<const MetaMapModeAction&>(rMetaAction).maMapMode;
3022 : }
3023 :
3024 802 : void MetaMapModeAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
3025 : {
3026 802 : MetaAction::Write(rOStm, pData);
3027 802 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
3028 802 : WriteMapMode( rOStm, maMapMode );
3029 802 : }
3030 :
3031 612 : void MetaMapModeAction::Read( SvStream& rIStm, ImplMetaReadData* )
3032 : {
3033 612 : VersionCompat aCompat(rIStm, STREAM_READ);
3034 612 : ReadMapMode( rIStm, maMapMode );
3035 612 : }
3036 :
3037 75586 : MetaFontAction::MetaFontAction() :
3038 75586 : MetaAction(META_FONT_ACTION)
3039 75586 : {}
3040 :
3041 324562 : MetaFontAction::~MetaFontAction()
3042 324562 : {}
3043 :
3044 86387 : MetaFontAction::MetaFontAction( const vcl::Font& rFont ) :
3045 : MetaAction ( META_FONT_ACTION ),
3046 86387 : maFont ( rFont )
3047 : {
3048 : // #96876: because RTL_TEXTENCODING_SYMBOL is often set at the StarSymbol font,
3049 : // we change the textencoding to RTL_TEXTENCODING_UNICODE here, which seems
3050 : // to be the right way; changing the textencoding at other sources
3051 : // is too dangerous at the moment
3052 172774 : if ( IsStarSymbol( maFont.GetName() )
3053 86387 : && ( maFont.GetCharSet() != RTL_TEXTENCODING_UNICODE ) )
3054 : {
3055 6 : maFont.SetCharSet( RTL_TEXTENCODING_UNICODE );
3056 : }
3057 86387 : }
3058 :
3059 10955 : void MetaFontAction::Execute( OutputDevice* pOut )
3060 : {
3061 10955 : pOut->SetFont( maFont );
3062 10955 : }
3063 :
3064 308 : MetaAction* MetaFontAction::Clone()
3065 : {
3066 308 : MetaAction* pClone = (MetaAction*) new MetaFontAction( *this );
3067 308 : pClone->ResetRefCount();
3068 308 : return pClone;
3069 : }
3070 :
3071 308 : void MetaFontAction::Scale( double fScaleX, double fScaleY )
3072 : {
3073 : const Size aSize(
3074 616 : FRound(maFont.GetSize().Width() * fabs(fScaleX)),
3075 924 : FRound(maFont.GetSize().Height() * fabs(fScaleY)));
3076 308 : maFont.SetSize( aSize );
3077 308 : }
3078 :
3079 0 : bool MetaFontAction::Compare( const MetaAction& rMetaAction ) const
3080 : {
3081 0 : return maFont == static_cast<const MetaFontAction&>(rMetaAction).maFont;
3082 : }
3083 :
3084 85426 : void MetaFontAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
3085 : {
3086 85426 : MetaAction::Write(rOStm, pData);
3087 85426 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
3088 85426 : WriteFont( rOStm, maFont );
3089 85426 : pData->meActualCharSet = maFont.GetCharSet();
3090 85426 : if ( pData->meActualCharSet == RTL_TEXTENCODING_DONTKNOW )
3091 48664 : pData->meActualCharSet = osl_getThreadTextEncoding();
3092 85426 : }
3093 :
3094 75586 : void MetaFontAction::Read( SvStream& rIStm, ImplMetaReadData* pData )
3095 : {
3096 75586 : VersionCompat aCompat(rIStm, STREAM_READ);
3097 75586 : ReadFont( rIStm, maFont );
3098 75586 : pData->meActualCharSet = maFont.GetCharSet();
3099 75586 : if ( pData->meActualCharSet == RTL_TEXTENCODING_DONTKNOW )
3100 45958 : pData->meActualCharSet = osl_getThreadTextEncoding();
3101 75586 : }
3102 :
3103 90456 : MetaPushAction::MetaPushAction() :
3104 : MetaAction ( META_PUSH_ACTION ),
3105 90456 : mnFlags ( PushFlags::NONE )
3106 90456 : {}
3107 :
3108 384500 : MetaPushAction::~MetaPushAction()
3109 384500 : {}
3110 :
3111 101710 : MetaPushAction::MetaPushAction( PushFlags nFlags ) :
3112 : MetaAction ( META_PUSH_ACTION ),
3113 101710 : mnFlags ( nFlags )
3114 101710 : {}
3115 :
3116 12590 : void MetaPushAction::Execute( OutputDevice* pOut )
3117 : {
3118 12590 : pOut->Push( mnFlags );
3119 12590 : }
3120 :
3121 84 : MetaAction* MetaPushAction::Clone()
3122 : {
3123 84 : MetaAction* pClone = (MetaAction*) new MetaPushAction( *this );
3124 84 : pClone->ResetRefCount();
3125 84 : return pClone;
3126 : }
3127 :
3128 0 : bool MetaPushAction::Compare( const MetaAction& rMetaAction ) const
3129 : {
3130 0 : return mnFlags == static_cast<const MetaPushAction&>(rMetaAction).mnFlags;
3131 : }
3132 :
3133 101246 : void MetaPushAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
3134 : {
3135 101246 : MetaAction::Write(rOStm, pData);
3136 101246 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
3137 101246 : rOStm.WriteUInt16( static_cast<sal_uInt16>(mnFlags) );
3138 101246 : }
3139 :
3140 90456 : void MetaPushAction::Read( SvStream& rIStm, ImplMetaReadData* )
3141 : {
3142 90456 : VersionCompat aCompat(rIStm, STREAM_READ);
3143 : sal_uInt16 tmp;
3144 90456 : rIStm.ReadUInt16( tmp );
3145 90456 : mnFlags = static_cast<PushFlags>(tmp);
3146 90456 : }
3147 :
3148 192166 : MetaPopAction::MetaPopAction() :
3149 192166 : MetaAction(META_POP_ACTION)
3150 192166 : {}
3151 :
3152 384500 : MetaPopAction::~MetaPopAction()
3153 384500 : {}
3154 :
3155 12590 : void MetaPopAction::Execute( OutputDevice* pOut )
3156 : {
3157 12590 : pOut->Pop();
3158 12590 : }
3159 :
3160 84 : MetaAction* MetaPopAction::Clone()
3161 : {
3162 84 : MetaAction* pClone = (MetaAction*) new MetaPopAction( *this );
3163 84 : pClone->ResetRefCount();
3164 84 : return pClone;
3165 : }
3166 :
3167 101246 : void MetaPopAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
3168 : {
3169 101246 : MetaAction::Write(rOStm, pData);
3170 101246 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
3171 101246 : }
3172 :
3173 90456 : void MetaPopAction::Read( SvStream& rIStm, ImplMetaReadData* )
3174 : {
3175 90456 : VersionCompat aCompat(rIStm, STREAM_READ);
3176 90456 : }
3177 :
3178 32 : MetaRasterOpAction::MetaRasterOpAction() :
3179 : MetaAction ( META_RASTEROP_ACTION ),
3180 32 : meRasterOp ( ROP_OVERPAINT )
3181 32 : {}
3182 :
3183 35052 : MetaRasterOpAction::~MetaRasterOpAction()
3184 35052 : {}
3185 :
3186 17494 : MetaRasterOpAction::MetaRasterOpAction( RasterOp eRasterOp ) :
3187 : MetaAction ( META_RASTEROP_ACTION ),
3188 17494 : meRasterOp ( eRasterOp )
3189 : {
3190 17494 : }
3191 :
3192 11731 : void MetaRasterOpAction::Execute( OutputDevice* pOut )
3193 : {
3194 11731 : pOut->SetRasterOp( meRasterOp );
3195 11731 : }
3196 :
3197 0 : MetaAction* MetaRasterOpAction::Clone()
3198 : {
3199 0 : MetaAction* pClone = (MetaAction*) new MetaRasterOpAction( *this );
3200 0 : pClone->ResetRefCount();
3201 0 : return pClone;
3202 : }
3203 :
3204 0 : bool MetaRasterOpAction::Compare( const MetaAction& rMetaAction ) const
3205 : {
3206 0 : return meRasterOp == static_cast<const MetaRasterOpAction&>(rMetaAction).meRasterOp;
3207 : }
3208 :
3209 28272 : void MetaRasterOpAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
3210 : {
3211 28272 : MetaAction::Write(rOStm, pData);
3212 28272 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
3213 28272 : rOStm.WriteUInt16( meRasterOp );
3214 28272 : }
3215 :
3216 32 : void MetaRasterOpAction::Read( SvStream& rIStm, ImplMetaReadData* )
3217 : {
3218 32 : sal_uInt16 nTmp16(0);
3219 :
3220 32 : VersionCompat aCompat(rIStm, STREAM_READ);
3221 32 : rIStm.ReadUInt16( nTmp16 ); meRasterOp = (RasterOp) nTmp16;
3222 32 : }
3223 :
3224 30 : MetaTransparentAction::MetaTransparentAction() :
3225 : MetaAction ( META_TRANSPARENT_ACTION ),
3226 30 : mnTransPercent ( 0 )
3227 30 : {}
3228 :
3229 276 : MetaTransparentAction::~MetaTransparentAction()
3230 276 : {}
3231 :
3232 78 : MetaTransparentAction::MetaTransparentAction( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nTransPercent ) :
3233 : MetaAction ( META_TRANSPARENT_ACTION ),
3234 : maPolyPoly ( rPolyPoly ),
3235 78 : mnTransPercent ( nTransPercent )
3236 78 : {}
3237 :
3238 2 : void MetaTransparentAction::Execute( OutputDevice* pOut )
3239 : {
3240 2 : pOut->DrawTransparent( maPolyPoly, mnTransPercent );
3241 2 : }
3242 :
3243 30 : MetaAction* MetaTransparentAction::Clone()
3244 : {
3245 30 : MetaAction* pClone = (MetaAction*) new MetaTransparentAction( *this );
3246 30 : pClone->ResetRefCount();
3247 30 : return pClone;
3248 : }
3249 :
3250 46 : void MetaTransparentAction::Move( long nHorzMove, long nVertMove )
3251 : {
3252 46 : maPolyPoly.Move( nHorzMove, nVertMove );
3253 46 : }
3254 :
3255 30 : void MetaTransparentAction::Scale( double fScaleX, double fScaleY )
3256 : {
3257 120 : for( sal_uInt16 i = 0, nCount = maPolyPoly.Count(); i < nCount; i++ )
3258 90 : ImplScalePoly( maPolyPoly[ i ], fScaleX, fScaleY );
3259 30 : }
3260 :
3261 0 : bool MetaTransparentAction::Compare( const MetaAction& rMetaAction ) const
3262 : {
3263 0 : return ( maPolyPoly == static_cast<const MetaTransparentAction&>(rMetaAction).maPolyPoly ) &&
3264 0 : ( mnTransPercent == static_cast<const MetaTransparentAction&>(rMetaAction).mnTransPercent );
3265 : }
3266 :
3267 90 : void MetaTransparentAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
3268 : {
3269 90 : MetaAction::Write(rOStm, pData);
3270 90 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
3271 :
3272 : // #i105373# The tools::PolyPolygon in this action may be a curve; this
3273 : // was ignored until now what is an error. To make older office
3274 : // versions work with MetaFiles, i opt for applying AdaptiveSubdivide
3275 : // to the PolyPoylgon.
3276 : // The alternative would be to really write the curve information
3277 : // like in MetaPolyPolygonAction::Write (where someone extended it
3278 : // correctly, but not here :-( ).
3279 : // The golden solution would be to combine both, but i think it's
3280 : // not necessary; a good subdivision will be sufficient.
3281 180 : tools::PolyPolygon aNoCurvePolyPolygon;
3282 90 : maPolyPoly.AdaptiveSubdivide(aNoCurvePolyPolygon);
3283 :
3284 90 : WritePolyPolygon( rOStm, aNoCurvePolyPolygon );
3285 180 : rOStm.WriteUInt16( mnTransPercent );
3286 90 : }
3287 :
3288 30 : void MetaTransparentAction::Read( SvStream& rIStm, ImplMetaReadData* )
3289 : {
3290 30 : VersionCompat aCompat(rIStm, STREAM_READ);
3291 30 : ReadPolyPolygon( rIStm, maPolyPoly );
3292 30 : rIStm.ReadUInt16( mnTransPercent );
3293 30 : }
3294 :
3295 0 : MetaFloatTransparentAction::MetaFloatTransparentAction() :
3296 0 : MetaAction(META_FLOATTRANSPARENT_ACTION)
3297 0 : {}
3298 :
3299 0 : MetaFloatTransparentAction::~MetaFloatTransparentAction()
3300 0 : {}
3301 :
3302 0 : MetaFloatTransparentAction::MetaFloatTransparentAction( const GDIMetaFile& rMtf, const Point& rPos,
3303 : const Size& rSize, const Gradient& rGradient ) :
3304 : MetaAction ( META_FLOATTRANSPARENT_ACTION ),
3305 : maMtf ( rMtf ),
3306 : maPoint ( rPos ),
3307 : maSize ( rSize ),
3308 0 : maGradient ( rGradient )
3309 0 : {}
3310 :
3311 0 : void MetaFloatTransparentAction::Execute( OutputDevice* pOut )
3312 : {
3313 0 : pOut->DrawTransparent( maMtf, maPoint, maSize, maGradient );
3314 0 : }
3315 :
3316 0 : MetaAction* MetaFloatTransparentAction::Clone()
3317 : {
3318 0 : MetaAction* pClone = (MetaAction*) new MetaFloatTransparentAction( *this );
3319 0 : pClone->ResetRefCount();
3320 0 : return pClone;
3321 : }
3322 :
3323 0 : void MetaFloatTransparentAction::Move( long nHorzMove, long nVertMove )
3324 : {
3325 0 : maPoint.Move( nHorzMove, nVertMove );
3326 0 : }
3327 :
3328 0 : void MetaFloatTransparentAction::Scale( double fScaleX, double fScaleY )
3329 : {
3330 0 : Rectangle aRectangle(maPoint, maSize);
3331 0 : ImplScaleRect( aRectangle, fScaleX, fScaleY );
3332 0 : maPoint = aRectangle.TopLeft();
3333 0 : maSize = aRectangle.GetSize();
3334 0 : }
3335 :
3336 0 : bool MetaFloatTransparentAction::Compare( const MetaAction& rMetaAction ) const
3337 : {
3338 0 : return ( maMtf == static_cast<const MetaFloatTransparentAction&>(rMetaAction).maMtf ) &&
3339 0 : ( maPoint == static_cast<const MetaFloatTransparentAction&>(rMetaAction).maPoint ) &&
3340 0 : ( maSize == static_cast<const MetaFloatTransparentAction&>(rMetaAction).maSize ) &&
3341 0 : ( maGradient == static_cast<const MetaFloatTransparentAction&>(rMetaAction).maGradient );
3342 : }
3343 :
3344 0 : void MetaFloatTransparentAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
3345 : {
3346 0 : MetaAction::Write(rOStm, pData);
3347 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
3348 :
3349 0 : maMtf.Write( rOStm );
3350 0 : WritePair( rOStm, maPoint );
3351 0 : WritePair( rOStm, maSize );
3352 0 : WriteGradient( rOStm, maGradient );
3353 0 : }
3354 :
3355 0 : void MetaFloatTransparentAction::Read( SvStream& rIStm, ImplMetaReadData* )
3356 : {
3357 0 : VersionCompat aCompat(rIStm, STREAM_READ);
3358 0 : ReadGDIMetaFile( rIStm, maMtf );
3359 0 : ReadPair( rIStm, maPoint );
3360 0 : ReadPair( rIStm, maSize );
3361 0 : ReadGradient( rIStm, maGradient );
3362 0 : }
3363 :
3364 0 : MetaEPSAction::MetaEPSAction() :
3365 0 : MetaAction(META_EPS_ACTION)
3366 0 : {}
3367 :
3368 8 : MetaEPSAction::~MetaEPSAction()
3369 8 : {}
3370 :
3371 4 : MetaEPSAction::MetaEPSAction( const Point& rPoint, const Size& rSize,
3372 : const GfxLink& rGfxLink, const GDIMetaFile& rSubst ) :
3373 : MetaAction ( META_EPS_ACTION ),
3374 : maGfxLink ( rGfxLink ),
3375 : maSubst ( rSubst ),
3376 : maPoint ( rPoint ),
3377 4 : maSize ( rSize )
3378 4 : {}
3379 :
3380 0 : void MetaEPSAction::Execute( OutputDevice* pOut )
3381 : {
3382 0 : pOut->DrawEPS( maPoint, maSize, maGfxLink, &maSubst );
3383 0 : }
3384 :
3385 0 : MetaAction* MetaEPSAction::Clone()
3386 : {
3387 0 : MetaAction* pClone = (MetaAction*) new MetaEPSAction( *this );
3388 0 : pClone->ResetRefCount();
3389 0 : return pClone;
3390 : }
3391 :
3392 0 : void MetaEPSAction::Move( long nHorzMove, long nVertMove )
3393 : {
3394 0 : maPoint.Move( nHorzMove, nVertMove );
3395 0 : }
3396 :
3397 0 : void MetaEPSAction::Scale( double fScaleX, double fScaleY )
3398 : {
3399 0 : Rectangle aRectangle(maPoint, maSize);
3400 0 : ImplScaleRect( aRectangle, fScaleX, fScaleY );
3401 0 : maPoint = aRectangle.TopLeft();
3402 0 : maSize = aRectangle.GetSize();
3403 0 : }
3404 :
3405 0 : bool MetaEPSAction::Compare( const MetaAction& rMetaAction ) const
3406 : {
3407 0 : return ( maGfxLink.IsEqual(static_cast<const MetaEPSAction&>(rMetaAction).maGfxLink )) &&
3408 0 : ( maSubst == static_cast<const MetaEPSAction&>(rMetaAction).maSubst ) &&
3409 0 : ( maPoint == static_cast<const MetaEPSAction&>(rMetaAction).maPoint ) &&
3410 0 : ( maSize == static_cast<const MetaEPSAction&>(rMetaAction).maSize );
3411 : }
3412 :
3413 0 : void MetaEPSAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
3414 : {
3415 0 : MetaAction::Write(rOStm, pData);
3416 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
3417 :
3418 0 : WriteGfxLink( rOStm, maGfxLink );
3419 0 : WritePair( rOStm, maPoint );
3420 0 : WritePair( rOStm, maSize );
3421 0 : maSubst.Write( rOStm );
3422 0 : }
3423 :
3424 0 : void MetaEPSAction::Read( SvStream& rIStm, ImplMetaReadData* )
3425 : {
3426 0 : VersionCompat aCompat(rIStm, STREAM_READ);
3427 0 : ReadGfxLink( rIStm, maGfxLink );
3428 0 : ReadPair( rIStm, maPoint );
3429 0 : ReadPair( rIStm, maSize );
3430 0 : ReadGDIMetaFile( rIStm, maSubst );
3431 0 : }
3432 :
3433 0 : MetaRefPointAction::MetaRefPointAction() :
3434 : MetaAction ( META_REFPOINT_ACTION ),
3435 0 : mbSet ( false )
3436 0 : {}
3437 :
3438 13262 : MetaRefPointAction::~MetaRefPointAction()
3439 13262 : {}
3440 :
3441 6631 : MetaRefPointAction::MetaRefPointAction( const Point& rRefPoint, bool bSet ) :
3442 : MetaAction ( META_REFPOINT_ACTION ),
3443 : maRefPoint ( rRefPoint ),
3444 6631 : mbSet ( bSet )
3445 6631 : {}
3446 :
3447 6631 : void MetaRefPointAction::Execute( OutputDevice* pOut )
3448 : {
3449 6631 : if( mbSet )
3450 0 : pOut->SetRefPoint( maRefPoint );
3451 : else
3452 6631 : pOut->SetRefPoint();
3453 6631 : }
3454 :
3455 0 : MetaAction* MetaRefPointAction::Clone()
3456 : {
3457 0 : MetaAction* pClone = (MetaAction*) new MetaRefPointAction( *this );
3458 0 : pClone->ResetRefCount();
3459 0 : return pClone;
3460 : }
3461 :
3462 0 : bool MetaRefPointAction::Compare( const MetaAction& rMetaAction ) const
3463 : {
3464 0 : return ( maRefPoint == static_cast<const MetaRefPointAction&>(rMetaAction).maRefPoint ) &&
3465 0 : ( mbSet == static_cast<const MetaRefPointAction&>(rMetaAction).mbSet );
3466 : }
3467 :
3468 0 : void MetaRefPointAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
3469 : {
3470 0 : MetaAction::Write(rOStm, pData);
3471 0 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
3472 :
3473 0 : WritePair( rOStm, maRefPoint );
3474 0 : rOStm.WriteUChar( mbSet );
3475 0 : }
3476 :
3477 0 : void MetaRefPointAction::Read( SvStream& rIStm, ImplMetaReadData* )
3478 : {
3479 0 : VersionCompat aCompat(rIStm, STREAM_READ);
3480 0 : ReadPair( rIStm, maRefPoint ).ReadCharAsBool( mbSet );
3481 0 : }
3482 :
3483 8508 : MetaCommentAction::MetaCommentAction( sal_Int32 nValue ) :
3484 : MetaAction ( META_COMMENT_ACTION ),
3485 8508 : mnValue ( nValue )
3486 : {
3487 8508 : ImplInitDynamicData( NULL, 0UL );
3488 8508 : }
3489 :
3490 8480 : MetaCommentAction::MetaCommentAction( const MetaCommentAction& rAct ) :
3491 : MetaAction ( META_COMMENT_ACTION ),
3492 : maComment ( rAct.maComment ),
3493 8480 : mnValue ( rAct.mnValue )
3494 : {
3495 8480 : ImplInitDynamicData( rAct.mpData, rAct.mnDataSize );
3496 8480 : }
3497 :
3498 20712 : MetaCommentAction::MetaCommentAction( const OString& rComment, sal_Int32 nValue, const sal_uInt8* pData, sal_uInt32 nDataSize ) :
3499 : MetaAction ( META_COMMENT_ACTION ),
3500 : maComment ( rComment ),
3501 20712 : mnValue ( nValue )
3502 : {
3503 20712 : ImplInitDynamicData( pData, nDataSize );
3504 20712 : }
3505 :
3506 113100 : MetaCommentAction::~MetaCommentAction()
3507 : {
3508 37700 : if ( mpData )
3509 6932 : delete[] mpData;
3510 75400 : }
3511 :
3512 40606 : void MetaCommentAction::ImplInitDynamicData( const sal_uInt8* pData, sal_uInt32 nDataSize )
3513 : {
3514 40606 : if ( nDataSize && pData )
3515 : {
3516 8856 : mnDataSize = nDataSize, mpData = new sal_uInt8[ mnDataSize ];
3517 8856 : memcpy( mpData, pData, mnDataSize );
3518 : }
3519 : else
3520 : {
3521 31750 : mnDataSize = 0;
3522 31750 : mpData = NULL;
3523 : }
3524 40606 : }
3525 :
3526 3448 : void MetaCommentAction::Execute( OutputDevice* pOut )
3527 : {
3528 3448 : if ( pOut->GetConnectMetaFile() )
3529 : {
3530 822 : Duplicate();
3531 822 : pOut->GetConnectMetaFile()->AddAction( this );
3532 : }
3533 3448 : }
3534 :
3535 8480 : MetaAction* MetaCommentAction::Clone()
3536 : {
3537 8480 : MetaAction* pClone = (MetaAction*) new MetaCommentAction( *this );
3538 8480 : pClone->ResetRefCount();
3539 8480 : return pClone;
3540 : }
3541 :
3542 10202 : void MetaCommentAction::Move( long nXMove, long nYMove )
3543 : {
3544 10202 : if ( nXMove || nYMove )
3545 : {
3546 8448 : if ( mnDataSize && mpData )
3547 : {
3548 2026 : bool bPathStroke = (maComment == "XPATHSTROKE_SEQ_BEGIN");
3549 2026 : if ( bPathStroke || maComment == "XPATHFILL_SEQ_BEGIN" )
3550 : {
3551 2018 : SvMemoryStream aMemStm( (void*)mpData, mnDataSize, STREAM_READ );
3552 4036 : SvMemoryStream aDest;
3553 2018 : if ( bPathStroke )
3554 : {
3555 2006 : SvtGraphicStroke aStroke;
3556 2006 : ReadSvtGraphicStroke( aMemStm, aStroke );
3557 :
3558 4012 : Polygon aPath;
3559 2006 : aStroke.getPath( aPath );
3560 2006 : aPath.Move( nXMove, nYMove );
3561 2006 : aStroke.setPath( aPath );
3562 :
3563 4012 : tools::PolyPolygon aStartArrow;
3564 2006 : aStroke.getStartArrow(aStartArrow);
3565 2006 : aStartArrow.Move(nXMove, nYMove);
3566 2006 : aStroke.setStartArrow(aStartArrow);
3567 :
3568 4012 : tools::PolyPolygon aEndArrow;
3569 2006 : aStroke.getEndArrow(aEndArrow);
3570 2006 : aEndArrow.Move(nXMove, nYMove);
3571 2006 : aStroke.setEndArrow(aEndArrow);
3572 :
3573 4012 : WriteSvtGraphicStroke( aDest, aStroke );
3574 : }
3575 : else
3576 : {
3577 12 : SvtGraphicFill aFill;
3578 12 : ReadSvtGraphicFill( aMemStm, aFill );
3579 :
3580 24 : tools::PolyPolygon aPath;
3581 12 : aFill.getPath( aPath );
3582 12 : aPath.Move( nXMove, nYMove );
3583 12 : aFill.setPath( aPath );
3584 :
3585 24 : WriteSvtGraphicFill( aDest, aFill );
3586 : }
3587 2018 : delete[] mpData;
3588 4036 : ImplInitDynamicData( static_cast<const sal_uInt8*>( aDest.GetData() ), aDest.Tell() );
3589 : }
3590 : }
3591 : }
3592 10202 : }
3593 :
3594 : // SJ: 25.07.06 #i56656# we are not able to mirrorcertain kind of
3595 : // comments properly, especially the XPATHSTROKE and XPATHFILL lead to
3596 : // problems, so it is better to remove these comments when mirroring
3597 : // FIXME: fake comment to apply the next hunk in the right location
3598 7930 : void MetaCommentAction::Scale( double fXScale, double fYScale )
3599 : {
3600 7930 : if ( ( fXScale != 1.0 ) || ( fYScale != 1.0 ) )
3601 : {
3602 7930 : if ( mnDataSize && mpData )
3603 : {
3604 888 : bool bPathStroke = (maComment == "XPATHSTROKE_SEQ_BEGIN");
3605 888 : if ( bPathStroke || maComment == "XPATHFILL_SEQ_BEGIN" )
3606 : {
3607 888 : SvMemoryStream aMemStm( (void*)mpData, mnDataSize, STREAM_READ );
3608 1776 : SvMemoryStream aDest;
3609 888 : if ( bPathStroke )
3610 : {
3611 808 : SvtGraphicStroke aStroke;
3612 808 : ReadSvtGraphicStroke( aMemStm, aStroke );
3613 808 : aStroke.scale( fXScale, fYScale );
3614 808 : WriteSvtGraphicStroke( aDest, aStroke );
3615 : }
3616 : else
3617 : {
3618 80 : SvtGraphicFill aFill;
3619 80 : ReadSvtGraphicFill( aMemStm, aFill );
3620 160 : tools::PolyPolygon aPath;
3621 80 : aFill.getPath( aPath );
3622 80 : aPath.Scale( fXScale, fYScale );
3623 80 : aFill.setPath( aPath );
3624 160 : WriteSvtGraphicFill( aDest, aFill );
3625 : }
3626 888 : delete[] mpData;
3627 1776 : ImplInitDynamicData( static_cast<const sal_uInt8*>( aDest.GetData() ), aDest.Tell() );
3628 0 : } else if( maComment == "EMF_PLUS_HEADER_INFO" ){
3629 0 : SvMemoryStream aMemStm( (void*)mpData, mnDataSize, STREAM_READ );
3630 0 : SvMemoryStream aDest;
3631 :
3632 0 : sal_Int32 nLeft(0), nRight(0), nTop(0), nBottom(0);
3633 0 : sal_Int32 nPixX(0), nPixY(0), nMillX(0), nMillY(0);
3634 0 : float m11(0), m12(0), m21(0), m22(0), mdx(0), mdy(0);
3635 :
3636 : // read data
3637 0 : aMemStm.ReadInt32( nLeft ).ReadInt32( nTop ).ReadInt32( nRight ).ReadInt32( nBottom );
3638 0 : aMemStm.ReadInt32( nPixX ).ReadInt32( nPixY ).ReadInt32( nMillX ).ReadInt32( nMillY );
3639 0 : aMemStm.ReadFloat( m11 ).ReadFloat( m12 ).ReadFloat( m21 ).ReadFloat( m22 ).ReadFloat( mdx ).ReadFloat( mdy );
3640 :
3641 : // add scale to the transformation
3642 0 : m11 *= fXScale;
3643 0 : m12 *= fXScale;
3644 0 : m22 *= fYScale;
3645 0 : m21 *= fYScale;
3646 :
3647 : // prepare new data
3648 0 : aDest.WriteInt32( nLeft ).WriteInt32( nTop ).WriteInt32( nRight ).WriteInt32( nBottom );
3649 0 : aDest.WriteInt32( nPixX ).WriteInt32( nPixY ).WriteInt32( nMillX ).WriteInt32( nMillY );
3650 0 : aDest.WriteFloat( m11 ).WriteFloat( m12 ).WriteFloat( m21 ).WriteFloat( m22 ).WriteFloat( mdx ).WriteFloat( mdy );
3651 :
3652 : // save them
3653 0 : ImplInitDynamicData( static_cast<const sal_uInt8*>( aDest.GetData() ), aDest.Tell() );
3654 : }
3655 : }
3656 : }
3657 7930 : }
3658 :
3659 0 : bool MetaCommentAction::Compare( const MetaAction& rMetaAction ) const
3660 : {
3661 0 : return ( maComment == static_cast<const MetaCommentAction&>(rMetaAction).maComment ) &&
3662 0 : ( mnValue == static_cast<const MetaCommentAction&>(rMetaAction).mnValue ) &&
3663 0 : ( mnDataSize == static_cast<const MetaCommentAction&>(rMetaAction).mnDataSize ) &&
3664 0 : ( memcmp( mpData, static_cast<const MetaCommentAction&>(rMetaAction).mpData, mnDataSize ) == 0 );
3665 : }
3666 :
3667 27906 : void MetaCommentAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
3668 : {
3669 27906 : MetaAction::Write(rOStm, pData);
3670 27906 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
3671 27906 : write_uInt16_lenPrefixed_uInt8s_FromOString(rOStm, maComment);
3672 27906 : rOStm.WriteInt32( mnValue ).WriteUInt32( mnDataSize );
3673 :
3674 27906 : if ( mnDataSize )
3675 5372 : rOStm.Write( mpData, mnDataSize );
3676 27906 : }
3677 :
3678 8508 : void MetaCommentAction::Read( SvStream& rIStm, ImplMetaReadData* )
3679 : {
3680 8508 : VersionCompat aCompat(rIStm, STREAM_READ);
3681 8508 : maComment = read_uInt16_lenPrefixed_uInt8s_ToOString(rIStm);
3682 8508 : rIStm.ReadInt32( mnValue ).ReadUInt32( mnDataSize );
3683 :
3684 : SAL_INFO("vcl.gdi", "MetaCommentAction::Read " << maComment);
3685 :
3686 8508 : delete[] mpData;
3687 :
3688 8508 : if( mnDataSize )
3689 : {
3690 982 : mpData = new sal_uInt8[ mnDataSize ];
3691 982 : rIStm.Read( mpData, mnDataSize );
3692 : }
3693 : else
3694 7526 : mpData = NULL;
3695 8508 : }
3696 :
3697 18504 : MetaLayoutModeAction::MetaLayoutModeAction() :
3698 : MetaAction ( META_LAYOUTMODE_ACTION ),
3699 18504 : mnLayoutMode( TEXT_LAYOUT_DEFAULT )
3700 18504 : {}
3701 :
3702 89466 : MetaLayoutModeAction::~MetaLayoutModeAction()
3703 89466 : {}
3704 :
3705 26229 : MetaLayoutModeAction::MetaLayoutModeAction( ComplexTextLayoutMode nLayoutMode ) :
3706 : MetaAction ( META_LAYOUTMODE_ACTION ),
3707 26229 : mnLayoutMode( nLayoutMode )
3708 26229 : {}
3709 :
3710 7765 : void MetaLayoutModeAction::Execute( OutputDevice* pOut )
3711 : {
3712 7765 : pOut->SetLayoutMode( mnLayoutMode );
3713 7765 : }
3714 :
3715 0 : MetaAction* MetaLayoutModeAction::Clone()
3716 : {
3717 0 : MetaAction* pClone = (MetaAction*) new MetaLayoutModeAction( *this );
3718 0 : pClone->ResetRefCount();
3719 0 : return pClone;
3720 : }
3721 :
3722 0 : bool MetaLayoutModeAction::Compare( const MetaAction& rMetaAction ) const
3723 : {
3724 0 : return mnLayoutMode == static_cast<const MetaLayoutModeAction&>(rMetaAction).mnLayoutMode;
3725 : }
3726 :
3727 19728 : void MetaLayoutModeAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
3728 : {
3729 19728 : MetaAction::Write(rOStm, pData);
3730 19728 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
3731 19728 : rOStm.WriteUInt32( mnLayoutMode );
3732 19728 : }
3733 :
3734 18504 : void MetaLayoutModeAction::Read( SvStream& rIStm, ImplMetaReadData* )
3735 : {
3736 18504 : VersionCompat aCompat(rIStm, STREAM_READ);
3737 : sal_uInt32 tmp;
3738 18504 : rIStm.ReadUInt32( tmp );
3739 18504 : mnLayoutMode = static_cast<ComplexTextLayoutMode>(tmp);
3740 18504 : }
3741 :
3742 28794 : MetaTextLanguageAction::MetaTextLanguageAction() :
3743 : MetaAction ( META_TEXTLANGUAGE_ACTION ),
3744 28794 : meTextLanguage( LANGUAGE_DONTKNOW )
3745 28794 : {}
3746 :
3747 131926 : MetaTextLanguageAction::~MetaTextLanguageAction()
3748 131926 : {}
3749 :
3750 37115 : MetaTextLanguageAction::MetaTextLanguageAction( LanguageType eTextLanguage ) :
3751 : MetaAction ( META_TEXTLANGUAGE_ACTION ),
3752 37115 : meTextLanguage( eTextLanguage )
3753 37115 : {}
3754 :
3755 8195 : void MetaTextLanguageAction::Execute( OutputDevice* pOut )
3756 : {
3757 8195 : pOut->SetDigitLanguage( meTextLanguage );
3758 8195 : }
3759 :
3760 54 : MetaAction* MetaTextLanguageAction::Clone()
3761 : {
3762 54 : MetaAction* pClone = (MetaAction*) new MetaTextLanguageAction( *this );
3763 54 : pClone->ResetRefCount();
3764 54 : return pClone;
3765 : }
3766 :
3767 0 : bool MetaTextLanguageAction::Compare( const MetaAction& rMetaAction ) const
3768 : {
3769 0 : return meTextLanguage == static_cast<const MetaTextLanguageAction&>(rMetaAction).meTextLanguage;
3770 : }
3771 :
3772 30818 : void MetaTextLanguageAction::Write( SvStream& rOStm, ImplMetaWriteData* pData )
3773 : {
3774 30818 : MetaAction::Write(rOStm, pData);
3775 30818 : VersionCompat aCompat(rOStm, STREAM_WRITE, 1);
3776 30818 : rOStm.WriteUInt16( meTextLanguage );
3777 30818 : }
3778 :
3779 28794 : void MetaTextLanguageAction::Read( SvStream& rIStm, ImplMetaReadData* )
3780 : {
3781 28794 : VersionCompat aCompat(rIStm, STREAM_READ);
3782 28794 : rIStm.ReadUInt16( meTextLanguage );
3783 30027 : }
3784 :
3785 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
