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