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