LCOV - code coverage report
Current view: top level - vcl/source/gdi - metaact.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 2000 0.0 %
Date: 2014-04-14 Functions: 0 573 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10