vcl/source/gdi/metaact.cxx

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