/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * This file is part of the LibreOffice project. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. * * This file incorporates work covered by the following license notice: * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed * with this work for additional information regarding copyright * ownership. The ASF licenses this file to you under the Apache * License, Version 2.0 (the "License"); you may not use this file * except in compliance with the License. You may obtain a copy of * the License at http://www.apache.org/licenses/LICENSE-2.0 . */ #include #include #include #include #include #include #include #include #include #include #include #include #include namespace { const char * meta_action_name(MetaActionType nMetaAction) { #ifndef SAL_LOG_INFO (void) nMetaAction; return ""; #else switch( nMetaAction ) { case MetaActionType::NONE: return "NULL"; case MetaActionType::PIXEL: return "PIXEL"; case MetaActionType::POINT: return "POINT"; case MetaActionType::LINE: return "LINE"; case MetaActionType::RECT: return "RECT"; case MetaActionType::ROUNDRECT: return "ROUNDRECT"; case MetaActionType::ELLIPSE: return "ELLIPSE"; case MetaActionType::ARC: return "ARC"; case MetaActionType::PIE: return "PIE"; case MetaActionType::CHORD: return "CHORD"; case MetaActionType::POLYLINE: return "POLYLINE"; case MetaActionType::POLYGON: return "POLYGON"; case MetaActionType::POLYPOLYGON: return "POLYPOLYGON"; case MetaActionType::TEXT: return "TEXT"; case MetaActionType::TEXTARRAY: return "TEXTARRAY"; case MetaActionType::STRETCHTEXT: return "STRETCHTEXT"; case MetaActionType::TEXTRECT: return "TEXTRECT"; case MetaActionType::BMP: return "BMP"; case MetaActionType::BMPSCALE: return "BMPSCALE"; case MetaActionType::BMPSCALEPART: return "BMPSCALEPART"; case MetaActionType::BMPEX: return "BMPEX"; case MetaActionType::BMPEXSCALE: return "BMPEXSCALE"; case MetaActionType::BMPEXSCALEPART: return "BMPEXSCALEPART"; case MetaActionType::MASK: return "MASK"; case MetaActionType::MASKSCALE: return "MASKSCALE"; case MetaActionType::MASKSCALEPART: return "MASKSCALEPART"; case MetaActionType::GRADIENT: return "GRADIENT"; case MetaActionType::HATCH: return "HATCH"; case MetaActionType::WALLPAPER: return "WALLPAPER"; case MetaActionType::CLIPREGION: return "CLIPREGION"; case MetaActionType::ISECTRECTCLIPREGION: return "ISECTRECTCLIPREGION"; case MetaActionType::ISECTREGIONCLIPREGION: return "ISECTREGIONCLIPREGION"; case MetaActionType::MOVECLIPREGION: return "MOVECLIPREGION"; case MetaActionType::LINECOLOR: return "LINECOLOR"; case MetaActionType::FILLCOLOR: return "FILLCOLOR"; case MetaActionType::TEXTCOLOR: return "TEXTCOLOR"; case MetaActionType::TEXTFILLCOLOR: return "TEXTFILLCOLOR"; case MetaActionType::TEXTALIGN: return "TEXTALIGN"; case MetaActionType::MAPMODE: return "MAPMODE"; case MetaActionType::FONT: return "FONT"; case MetaActionType::PUSH: return "PUSH"; case MetaActionType::POP: return "POP"; case MetaActionType::RASTEROP: return "RASTEROP"; case MetaActionType::Transparent: return "TRANSPARENT"; case MetaActionType::EPS: return "EPS"; case MetaActionType::REFPOINT: return "REFPOINT"; case MetaActionType::TEXTLINECOLOR: return "TEXTLINECOLOR"; case MetaActionType::TEXTLINE: return "TEXTLINE"; case MetaActionType::FLOATTRANSPARENT: return "FLOATTRANSPARENT"; case MetaActionType::GRADIENTEX: return "GRADIENTEX"; case MetaActionType::LAYOUTMODE: return "LAYOUTMODE"; case MetaActionType::TEXTLANGUAGE: return "TEXTLANGUAGE"; case MetaActionType::OVERLINECOLOR: return "OVERLINECOLOR"; case MetaActionType::COMMENT: return "COMMENT"; default: // Yes, return a pointer to a static buffer. This is a very // local debugging output function, so no big deal. static char buffer[11]; sprintf(buffer, "%u", static_cast(nMetaAction)); return buffer; } #endif } void ImplScalePoint( Point& rPt, double fScaleX, double fScaleY ) { rPt.setX( FRound( fScaleX * rPt.X() ) ); rPt.setY( FRound( fScaleY * rPt.Y() ) ); } void ImplScaleRect( tools::Rectangle& rRect, double fScaleX, double fScaleY ) { Point aTL( rRect.TopLeft() ); Point aBR( rRect.BottomRight() ); ImplScalePoint( aTL, fScaleX, fScaleY ); ImplScalePoint( aBR, fScaleX, fScaleY ); rRect = tools::Rectangle( aTL, aBR ); rRect.Justify(); } void ImplScalePoly( tools::Polygon& rPoly, double fScaleX, double fScaleY ) { for( sal_uInt16 i = 0, nCount = rPoly.GetSize(); i < nCount; i++ ) ImplScalePoint( rPoly[ i ], fScaleX, fScaleY ); } void ImplScaleLineInfo( LineInfo& rLineInfo, double fScaleX, double fScaleY ) { if( !rLineInfo.IsDefault() ) { const double fScale = ( fabs(fScaleX) + fabs(fScaleY) ) * 0.5; rLineInfo.SetWidth( FRound( fScale * rLineInfo.GetWidth() ) ); rLineInfo.SetDashLen( FRound( fScale * rLineInfo.GetDashLen() ) ); rLineInfo.SetDotLen( FRound( fScale * rLineInfo.GetDotLen() ) ); rLineInfo.SetDistance( FRound( fScale * rLineInfo.GetDistance() ) ); } } } //anonymous namespace MetaAction::MetaAction() : mnType( MetaActionType::NONE ) { } MetaAction::MetaAction( MetaActionType nType ) : mnType( nType ) { } MetaAction::MetaAction( MetaAction const & rOther ) : SimpleReferenceObject(), mnType( rOther.mnType ) { } MetaAction::~MetaAction() { } void MetaAction::Execute( OutputDevice* ) { } rtl::Reference MetaAction::Clone() { return new MetaAction; } void MetaAction::Move( long, long ) { } void MetaAction::Scale( double, double ) { } void MetaAction::Write( SvStream& rOStm, ImplMetaWriteData* ) { rOStm.WriteUInt16( static_cast(mnType) ); } void MetaAction::Read( SvStream&, ImplMetaReadData* ) { // DO NOT read mnType - ReadMetaAction already did that! } MetaAction* MetaAction::ReadMetaAction( SvStream& rIStm, ImplMetaReadData* pData ) { MetaAction* pAction = nullptr; sal_uInt16 nTmp = 0; rIStm.ReadUInt16( nTmp ); MetaActionType nType = static_cast(nTmp); SAL_INFO("vcl.gdi", "ReadMetaAction " << meta_action_name( nType )); switch( nType ) { case MetaActionType::NONE: pAction = new MetaAction; break; case MetaActionType::PIXEL: pAction = new MetaPixelAction; break; case MetaActionType::POINT: pAction = new MetaPointAction; break; case MetaActionType::LINE: pAction = new MetaLineAction; break; case MetaActionType::RECT: pAction = new MetaRectAction; break; case MetaActionType::ROUNDRECT: pAction = new MetaRoundRectAction; break; case MetaActionType::ELLIPSE: pAction = new MetaEllipseAction; break; case MetaActionType::ARC: pAction = new MetaArcAction; break; case MetaActionType::PIE: pAction = new MetaPieAction; break; case MetaActionType::CHORD: pAction = new MetaChordAction; break; case MetaActionType::POLYLINE: pAction = new MetaPolyLineAction; break; case MetaActionType::POLYGON: pAction = new MetaPolygonAction; break; case MetaActionType::POLYPOLYGON: pAction = new MetaPolyPolygonAction; break; case MetaActionType::TEXT: pAction = new MetaTextAction; break; case MetaActionType::TEXTARRAY: pAction = new MetaTextArrayAction; break; case MetaActionType::STRETCHTEXT: pAction = new MetaStretchTextAction; break; case MetaActionType::TEXTRECT: pAction = new MetaTextRectAction; break; case MetaActionType::TEXTLINE: pAction = new MetaTextLineAction; break; case MetaActionType::BMP: pAction = new MetaBmpAction; break; case MetaActionType::BMPSCALE: pAction = new MetaBmpScaleAction; break; case MetaActionType::BMPSCALEPART: pAction = new MetaBmpScalePartAction; break; case MetaActionType::BMPEX: pAction = new MetaBmpExAction; break; case MetaActionType::BMPEXSCALE: pAction = new MetaBmpExScaleAction; break; case MetaActionType::BMPEXSCALEPART: pAction = new MetaBmpExScalePartAction; break; case MetaActionType::MASK: pAction = new MetaMaskAction; break; case MetaActionType::MASKSCALE: pAction = new MetaMaskScaleAction; break; case MetaActionType::MASKSCALEPART: pAction = new MetaMaskScalePartAction; break; case MetaActionType::GRADIENT: pAction = new MetaGradientAction; break; case MetaActionType::GRADIENTEX: pAction = new MetaGradientExAction; break; case MetaActionType::HATCH: pAction = new MetaHatchAction; break; case MetaActionType::WALLPAPER: pAction = new MetaWallpaperAction; break; case MetaActionType::CLIPREGION: pAction = new MetaClipRegionAction; break; case MetaActionType::ISECTRECTCLIPREGION: pAction = new MetaISectRectClipRegionAction; break; case MetaActionType::ISECTREGIONCLIPREGION: pAction = new MetaISectRegionClipRegionAction; break; case MetaActionType::MOVECLIPREGION: pAction = new MetaMoveClipRegionAction; break; case MetaActionType::LINECOLOR: pAction = new MetaLineColorAction; break; case MetaActionType::FILLCOLOR: pAction = new MetaFillColorAction; break; case MetaActionType::TEXTCOLOR: pAction = new MetaTextColorAction; break; case MetaActionType::TEXTFILLCOLOR: pAction = new MetaTextFillColorAction; break; case MetaActionType::TEXTLINECOLOR: pAction = new MetaTextLineColorAction; break; case MetaActionType::OVERLINECOLOR: pAction = new MetaOverlineColorAction; break; case MetaActionType::TEXTALIGN: pAction = new MetaTextAlignAction; break; case MetaActionType::MAPMODE: pAction = new MetaMapModeAction; break; case MetaActionType::FONT: pAction = new MetaFontAction; break; case MetaActionType::PUSH: pAction = new MetaPushAction; break; case MetaActionType::POP: pAction = new MetaPopAction; break; case MetaActionType::RASTEROP: pAction = new MetaRasterOpAction; break; case MetaActionType::Transparent: pAction = new MetaTransparentAction; break; case MetaActionType::FLOATTRANSPARENT: pAction = new MetaFloatTransparentAction; break; case MetaActionType::EPS: pAction = new MetaEPSAction; break; case MetaActionType::REFPOINT: pAction = new MetaRefPointAction; break; case MetaActionType::COMMENT: pAction = new MetaCommentAction; break; case MetaActionType::LAYOUTMODE: pAction = new MetaLayoutModeAction; break; case MetaActionType::TEXTLANGUAGE: pAction = new MetaTextLanguageAction; break; default: { VersionCompat aCompat(rIStm, StreamMode::READ); } break; } if( pAction ) pAction->Read( rIStm, pData ); return pAction; } MetaPixelAction::MetaPixelAction() : MetaAction(MetaActionType::PIXEL) {} MetaPixelAction::~MetaPixelAction() {} MetaPixelAction::MetaPixelAction( const Point& rPt, const Color& rColor ) : MetaAction ( MetaActionType::PIXEL ), maPt ( rPt ), maColor ( rColor ) {} void MetaPixelAction::Execute( OutputDevice* pOut ) { pOut->DrawPixel( maPt, maColor ); } rtl::Reference MetaPixelAction::Clone() { return new MetaPixelAction( *this ); } void MetaPixelAction::Move( long nHorzMove, long nVertMove ) { maPt.Move( nHorzMove, nVertMove ); } void MetaPixelAction::Scale( double fScaleX, double fScaleY ) { ImplScalePoint( maPt, fScaleX, fScaleY ); } void MetaPixelAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); TypeSerializer aSerializer(rOStm); aSerializer.writePoint(maPt); rOStm.WriteUInt32(maColor.mValue); } void MetaPixelAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); TypeSerializer aSerializer(rIStm); aSerializer.readPoint(maPt); rIStm.ReadUInt32(maColor.mValue); } MetaPointAction::MetaPointAction() : MetaAction(MetaActionType::POINT) {} MetaPointAction::~MetaPointAction() {} MetaPointAction::MetaPointAction( const Point& rPt ) : MetaAction ( MetaActionType::POINT ), maPt ( rPt ) {} void MetaPointAction::Execute( OutputDevice* pOut ) { pOut->DrawPixel( maPt ); } rtl::Reference MetaPointAction::Clone() { return new MetaPointAction( *this ); } void MetaPointAction::Move( long nHorzMove, long nVertMove ) { maPt.Move( nHorzMove, nVertMove ); } void MetaPointAction::Scale( double fScaleX, double fScaleY ) { ImplScalePoint( maPt, fScaleX, fScaleY ); } void MetaPointAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); TypeSerializer aSerializer(rOStm); aSerializer.writePoint(maPt); } void MetaPointAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); TypeSerializer aSerializer(rIStm); aSerializer.readPoint(maPt); } MetaLineAction::MetaLineAction() : MetaAction(MetaActionType::LINE) {} MetaLineAction::~MetaLineAction() {} MetaLineAction::MetaLineAction( const Point& rStart, const Point& rEnd ) : MetaAction ( MetaActionType::LINE ), maStartPt ( rStart ), maEndPt ( rEnd ) {} MetaLineAction::MetaLineAction( const Point& rStart, const Point& rEnd, const LineInfo& rLineInfo ) : MetaAction ( MetaActionType::LINE ), maLineInfo ( rLineInfo ), maStartPt ( rStart ), maEndPt ( rEnd ) {} void MetaLineAction::Execute( OutputDevice* pOut ) { if( maLineInfo.IsDefault() ) pOut->DrawLine( maStartPt, maEndPt ); else pOut->DrawLine( maStartPt, maEndPt, maLineInfo ); } rtl::Reference MetaLineAction::Clone() { return new MetaLineAction( *this ); } void MetaLineAction::Move( long nHorzMove, long nVertMove ) { maStartPt.Move( nHorzMove, nVertMove ); maEndPt.Move( nHorzMove, nVertMove ); } void MetaLineAction::Scale( double fScaleX, double fScaleY ) { ImplScalePoint( maStartPt, fScaleX, fScaleY ); ImplScalePoint( maEndPt, fScaleX, fScaleY ); ImplScaleLineInfo( maLineInfo, fScaleX, fScaleY ); } void MetaLineAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 2); // Version 1 TypeSerializer aSerializer(rOStm); aSerializer.writePoint(maStartPt); aSerializer.writePoint(maEndPt); // Version 2 WriteLineInfo( rOStm, maLineInfo ); } void MetaLineAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); // Version 1 TypeSerializer aSerializer(rIStm); aSerializer.readPoint(maStartPt); aSerializer.readPoint(maEndPt); // Version 2 if( aCompat.GetVersion() >= 2 ) { ReadLineInfo( rIStm, maLineInfo ); } } MetaRectAction::MetaRectAction() : MetaAction(MetaActionType::RECT) {} MetaRectAction::~MetaRectAction() {} MetaRectAction::MetaRectAction( const tools::Rectangle& rRect ) : MetaAction ( MetaActionType::RECT ), maRect ( rRect ) {} void MetaRectAction::Execute( OutputDevice* pOut ) { pOut->DrawRect( maRect ); } rtl::Reference MetaRectAction::Clone() { return new MetaRectAction( *this ); } void MetaRectAction::Move( long nHorzMove, long nVertMove ) { maRect.Move( nHorzMove, nVertMove ); } void MetaRectAction::Scale( double fScaleX, double fScaleY ) { ImplScaleRect( maRect, fScaleX, fScaleY ); } void MetaRectAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); TypeSerializer aSerializer(rOStm); aSerializer.writeRectangle(maRect); } void MetaRectAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); TypeSerializer aSerializer(rIStm); aSerializer.readRectangle(maRect); } MetaRoundRectAction::MetaRoundRectAction() : MetaAction ( MetaActionType::ROUNDRECT ), mnHorzRound ( 0 ), mnVertRound ( 0 ) {} MetaRoundRectAction::~MetaRoundRectAction() {} MetaRoundRectAction::MetaRoundRectAction( const tools::Rectangle& rRect, sal_uInt32 nHorzRound, sal_uInt32 nVertRound ) : MetaAction ( MetaActionType::ROUNDRECT ), maRect ( rRect ), mnHorzRound ( nHorzRound ), mnVertRound ( nVertRound ) {} void MetaRoundRectAction::Execute( OutputDevice* pOut ) { pOut->DrawRect( maRect, mnHorzRound, mnVertRound ); } rtl::Reference MetaRoundRectAction::Clone() { return new MetaRoundRectAction( *this ); } void MetaRoundRectAction::Move( long nHorzMove, long nVertMove ) { maRect.Move( nHorzMove, nVertMove ); } void MetaRoundRectAction::Scale( double fScaleX, double fScaleY ) { ImplScaleRect( maRect, fScaleX, fScaleY ); mnHorzRound = FRound( mnHorzRound * fabs(fScaleX) ); mnVertRound = FRound( mnVertRound * fabs(fScaleY) ); } void MetaRoundRectAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); TypeSerializer aSerializer(rOStm); aSerializer.writeRectangle(maRect); rOStm.WriteUInt32( mnHorzRound ).WriteUInt32( mnVertRound ); } void MetaRoundRectAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); TypeSerializer aSerializer(rIStm); aSerializer.readRectangle(maRect); rIStm.ReadUInt32( mnHorzRound ).ReadUInt32( mnVertRound ); } MetaEllipseAction::MetaEllipseAction() : MetaAction(MetaActionType::ELLIPSE) {} MetaEllipseAction::~MetaEllipseAction() {} MetaEllipseAction::MetaEllipseAction( const tools::Rectangle& rRect ) : MetaAction ( MetaActionType::ELLIPSE ), maRect ( rRect ) {} void MetaEllipseAction::Execute( OutputDevice* pOut ) { pOut->DrawEllipse( maRect ); } rtl::Reference MetaEllipseAction::Clone() { return new MetaEllipseAction( *this ); } void MetaEllipseAction::Move( long nHorzMove, long nVertMove ) { maRect.Move( nHorzMove, nVertMove ); } void MetaEllipseAction::Scale( double fScaleX, double fScaleY ) { ImplScaleRect( maRect, fScaleX, fScaleY ); } void MetaEllipseAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); TypeSerializer aSerializer(rOStm); aSerializer.writeRectangle(maRect); } void MetaEllipseAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); TypeSerializer aSerializer(rIStm); aSerializer.readRectangle(maRect); } MetaArcAction::MetaArcAction() : MetaAction(MetaActionType::ARC) {} MetaArcAction::~MetaArcAction() {} MetaArcAction::MetaArcAction( const tools::Rectangle& rRect, const Point& rStart, const Point& rEnd ) : MetaAction ( MetaActionType::ARC ), maRect ( rRect ), maStartPt ( rStart ), maEndPt ( rEnd ) {} void MetaArcAction::Execute( OutputDevice* pOut ) { pOut->DrawArc( maRect, maStartPt, maEndPt ); } rtl::Reference MetaArcAction::Clone() { return new MetaArcAction( *this ); } void MetaArcAction::Move( long nHorzMove, long nVertMove ) { maRect.Move( nHorzMove, nVertMove ); maStartPt.Move( nHorzMove, nVertMove ); maEndPt.Move( nHorzMove, nVertMove ); } void MetaArcAction::Scale( double fScaleX, double fScaleY ) { ImplScaleRect( maRect, fScaleX, fScaleY ); ImplScalePoint( maStartPt, fScaleX, fScaleY ); ImplScalePoint( maEndPt, fScaleX, fScaleY ); } void MetaArcAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); TypeSerializer aSerializer(rOStm); aSerializer.writeRectangle(maRect); aSerializer.writePoint(maStartPt); aSerializer.writePoint(maEndPt); } void MetaArcAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); TypeSerializer aSerializer(rIStm); aSerializer.readRectangle(maRect); aSerializer.readPoint(maStartPt); aSerializer.readPoint(maEndPt); } MetaPieAction::MetaPieAction() : MetaAction(MetaActionType::PIE) {} MetaPieAction::~MetaPieAction() {} MetaPieAction::MetaPieAction( const tools::Rectangle& rRect, const Point& rStart, const Point& rEnd ) : MetaAction ( MetaActionType::PIE ), maRect ( rRect ), maStartPt ( rStart ), maEndPt ( rEnd ) {} void MetaPieAction::Execute( OutputDevice* pOut ) { pOut->DrawPie( maRect, maStartPt, maEndPt ); } rtl::Reference MetaPieAction::Clone() { return new MetaPieAction( *this ); } void MetaPieAction::Move( long nHorzMove, long nVertMove ) { maRect.Move( nHorzMove, nVertMove ); maStartPt.Move( nHorzMove, nVertMove ); maEndPt.Move( nHorzMove, nVertMove ); } void MetaPieAction::Scale( double fScaleX, double fScaleY ) { ImplScaleRect( maRect, fScaleX, fScaleY ); ImplScalePoint( maStartPt, fScaleX, fScaleY ); ImplScalePoint( maEndPt, fScaleX, fScaleY ); } void MetaPieAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); TypeSerializer aSerializer(rOStm); aSerializer.writeRectangle(maRect); aSerializer.writePoint(maStartPt); aSerializer.writePoint(maEndPt); } void MetaPieAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); TypeSerializer aSerializer(rIStm); aSerializer.readRectangle(maRect); aSerializer.readPoint(maStartPt); aSerializer.readPoint(maEndPt); } MetaChordAction::MetaChordAction() : MetaAction(MetaActionType::CHORD) {} MetaChordAction::~MetaChordAction() {} MetaChordAction::MetaChordAction( const tools::Rectangle& rRect, const Point& rStart, const Point& rEnd ) : MetaAction ( MetaActionType::CHORD ), maRect ( rRect ), maStartPt ( rStart ), maEndPt ( rEnd ) {} void MetaChordAction::Execute( OutputDevice* pOut ) { pOut->DrawChord( maRect, maStartPt, maEndPt ); } rtl::Reference MetaChordAction::Clone() { return new MetaChordAction( *this ); } void MetaChordAction::Move( long nHorzMove, long nVertMove ) { maRect.Move( nHorzMove, nVertMove ); maStartPt.Move( nHorzMove, nVertMove ); maEndPt.Move( nHorzMove, nVertMove ); } void MetaChordAction::Scale( double fScaleX, double fScaleY ) { ImplScaleRect( maRect, fScaleX, fScaleY ); ImplScalePoint( maStartPt, fScaleX, fScaleY ); ImplScalePoint( maEndPt, fScaleX, fScaleY ); } void MetaChordAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); TypeSerializer aSerializer(rOStm); aSerializer.writeRectangle(maRect); aSerializer.writePoint(maStartPt); aSerializer.writePoint(maEndPt); } void MetaChordAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); TypeSerializer aSerializer(rIStm); aSerializer.readRectangle(maRect); aSerializer.readPoint(maStartPt); aSerializer.readPoint(maEndPt); } MetaPolyLineAction::MetaPolyLineAction() : MetaAction(MetaActionType::POLYLINE) {} MetaPolyLineAction::~MetaPolyLineAction() {} MetaPolyLineAction::MetaPolyLineAction( const tools::Polygon& rPoly ) : MetaAction ( MetaActionType::POLYLINE ), maPoly ( rPoly ) {} MetaPolyLineAction::MetaPolyLineAction( const tools::Polygon& rPoly, const LineInfo& rLineInfo ) : MetaAction ( MetaActionType::POLYLINE ), maLineInfo ( rLineInfo ), maPoly ( rPoly ) {} void MetaPolyLineAction::Execute( OutputDevice* pOut ) { if( maLineInfo.IsDefault() ) pOut->DrawPolyLine( maPoly ); else pOut->DrawPolyLine( maPoly, maLineInfo ); } rtl::Reference MetaPolyLineAction::Clone() { return new MetaPolyLineAction( *this ); } void MetaPolyLineAction::Move( long nHorzMove, long nVertMove ) { maPoly.Move( nHorzMove, nVertMove ); } void MetaPolyLineAction::Scale( double fScaleX, double fScaleY ) { ImplScalePoly( maPoly, fScaleX, fScaleY ); ImplScaleLineInfo( maLineInfo, fScaleX, fScaleY ); } void MetaPolyLineAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 3); tools::Polygon aSimplePoly; maPoly.AdaptiveSubdivide( aSimplePoly ); WritePolygon( rOStm, aSimplePoly ); // Version 1 WriteLineInfo( rOStm, maLineInfo ); // Version 2 bool bHasPolyFlags = maPoly.HasFlags(); // Version 3 rOStm.WriteBool( bHasPolyFlags ); if ( bHasPolyFlags ) maPoly.Write( rOStm ); } void MetaPolyLineAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); // Version 1 ReadPolygon( rIStm, maPoly ); // Version 2 if( aCompat.GetVersion() >= 2 ) ReadLineInfo( rIStm, maLineInfo ); if ( aCompat.GetVersion() >= 3 ) { sal_uInt8 bHasPolyFlags(0); rIStm.ReadUChar( bHasPolyFlags ); if ( bHasPolyFlags ) maPoly.Read( rIStm ); } } MetaPolygonAction::MetaPolygonAction() : MetaAction(MetaActionType::POLYGON) {} MetaPolygonAction::~MetaPolygonAction() {} MetaPolygonAction::MetaPolygonAction( const tools::Polygon& rPoly ) : MetaAction ( MetaActionType::POLYGON ), maPoly ( rPoly ) {} void MetaPolygonAction::Execute( OutputDevice* pOut ) { pOut->DrawPolygon( maPoly ); } rtl::Reference MetaPolygonAction::Clone() { return new MetaPolygonAction( *this ); } void MetaPolygonAction::Move( long nHorzMove, long nVertMove ) { maPoly.Move( nHorzMove, nVertMove ); } void MetaPolygonAction::Scale( double fScaleX, double fScaleY ) { ImplScalePoly( maPoly, fScaleX, fScaleY ); } void MetaPolygonAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 2); tools::Polygon aSimplePoly; // Version 1 maPoly.AdaptiveSubdivide( aSimplePoly ); WritePolygon( rOStm, aSimplePoly ); bool bHasPolyFlags = maPoly.HasFlags(); // Version 2 rOStm.WriteBool( bHasPolyFlags ); if ( bHasPolyFlags ) maPoly.Write( rOStm ); } void MetaPolygonAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadPolygon( rIStm, maPoly ); // Version 1 if( aCompat.GetVersion() >= 2 ) // Version 2 { sal_uInt8 bHasPolyFlags(0); rIStm.ReadUChar( bHasPolyFlags ); if ( bHasPolyFlags ) maPoly.Read( rIStm ); } } MetaPolyPolygonAction::MetaPolyPolygonAction() : MetaAction(MetaActionType::POLYPOLYGON) {} MetaPolyPolygonAction::~MetaPolyPolygonAction() {} MetaPolyPolygonAction::MetaPolyPolygonAction( const tools::PolyPolygon& rPolyPoly ) : MetaAction ( MetaActionType::POLYPOLYGON ), maPolyPoly ( rPolyPoly ) {} void MetaPolyPolygonAction::Execute( OutputDevice* pOut ) { pOut->DrawPolyPolygon( maPolyPoly ); } rtl::Reference MetaPolyPolygonAction::Clone() { return new MetaPolyPolygonAction( *this ); } void MetaPolyPolygonAction::Move( long nHorzMove, long nVertMove ) { maPolyPoly.Move( nHorzMove, nVertMove ); } void MetaPolyPolygonAction::Scale( double fScaleX, double fScaleY ) { for( sal_uInt16 i = 0, nCount = maPolyPoly.Count(); i < nCount; i++ ) ImplScalePoly( maPolyPoly[ i ], fScaleX, fScaleY ); } void MetaPolyPolygonAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 2); sal_uInt16 nNumberOfComplexPolygons = 0; sal_uInt16 i, nPolyCount = maPolyPoly.Count(); tools::Polygon aSimplePoly; // Version 1 rOStm.WriteUInt16( nPolyCount ); for ( i = 0; i < nPolyCount; i++ ) { const tools::Polygon& rPoly = maPolyPoly.GetObject( i ); if ( rPoly.HasFlags() ) nNumberOfComplexPolygons++; rPoly.AdaptiveSubdivide( aSimplePoly ); WritePolygon( rOStm, aSimplePoly ); } rOStm.WriteUInt16( nNumberOfComplexPolygons ); // Version 2 for ( i = 0; nNumberOfComplexPolygons && ( i < nPolyCount ); i++ ) { const tools::Polygon& rPoly = maPolyPoly.GetObject( i ); if ( rPoly.HasFlags() ) { rOStm.WriteUInt16( i ); rPoly.Write( rOStm ); nNumberOfComplexPolygons--; } } } void MetaPolyPolygonAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadPolyPolygon( rIStm, maPolyPoly ); // Version 1 if ( aCompat.GetVersion() >= 2 ) // Version 2 { sal_uInt16 nNumberOfComplexPolygons(0); rIStm.ReadUInt16( nNumberOfComplexPolygons ); const size_t nMinRecordSize = sizeof(sal_uInt16); const size_t nMaxRecords = rIStm.remainingSize() / nMinRecordSize; if (nNumberOfComplexPolygons > nMaxRecords) { SAL_WARN("vcl.gdi", "Parsing error: " << nMaxRecords << " max possible entries, but " << nNumberOfComplexPolygons << " claimed, truncating"); nNumberOfComplexPolygons = nMaxRecords; } for (sal_uInt16 i = 0; i < nNumberOfComplexPolygons; ++i) { sal_uInt16 nIndex(0); rIStm.ReadUInt16( nIndex ); tools::Polygon aPoly; aPoly.Read( rIStm ); if (nIndex >= maPolyPoly.Count()) { SAL_WARN("vcl.gdi", "svm contains polygon index " << nIndex << " outside possible range " << maPolyPoly.Count()); continue; } maPolyPoly.Replace( aPoly, nIndex ); } } } MetaTextAction::MetaTextAction() : MetaAction ( MetaActionType::TEXT ), mnIndex ( 0 ), mnLen ( 0 ) {} MetaTextAction::~MetaTextAction() {} MetaTextAction::MetaTextAction( const Point& rPt, const OUString& rStr, sal_Int32 nIndex, sal_Int32 nLen ) : MetaAction ( MetaActionType::TEXT ), maPt ( rPt ), maStr ( rStr ), mnIndex ( nIndex ), mnLen ( nLen ) {} void MetaTextAction::Execute( OutputDevice* pOut ) { pOut->DrawText( maPt, maStr, mnIndex, mnLen ); } rtl::Reference MetaTextAction::Clone() { return new MetaTextAction( *this ); } void MetaTextAction::Move( long nHorzMove, long nVertMove ) { maPt.Move( nHorzMove, nVertMove ); } void MetaTextAction::Scale( double fScaleX, double fScaleY ) { ImplScalePoint( maPt, fScaleX, fScaleY ); } void MetaTextAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 2); TypeSerializer aSerializer(rOStm); aSerializer.writePoint(maPt); rOStm.WriteUniOrByteString( maStr, pData->meActualCharSet ); rOStm.WriteUInt16(mnIndex); rOStm.WriteUInt16(mnLen); write_uInt16_lenPrefixed_uInt16s_FromOUString(rOStm, maStr); // version 2 } void MetaTextAction::Read( SvStream& rIStm, ImplMetaReadData* pData ) { VersionCompat aCompat(rIStm, StreamMode::READ); TypeSerializer aSerializer(rIStm); aSerializer.readPoint(maPt); maStr = rIStm.ReadUniOrByteString(pData->meActualCharSet); sal_uInt16 nTmpIndex(0); rIStm.ReadUInt16(nTmpIndex); mnIndex = nTmpIndex; sal_uInt16 nTmpLen(0); rIStm.ReadUInt16(nTmpLen); mnLen = nTmpLen; if ( aCompat.GetVersion() >= 2 ) // Version 2 maStr = read_uInt16_lenPrefixed_uInt16s_ToOUString(rIStm); } MetaTextArrayAction::MetaTextArrayAction() : MetaAction ( MetaActionType::TEXTARRAY ), mnIndex ( 0 ), mnLen ( 0 ) {} MetaTextArrayAction::MetaTextArrayAction( const MetaTextArrayAction& rAction ) : MetaAction ( MetaActionType::TEXTARRAY ), maStartPt ( rAction.maStartPt ), maStr ( rAction.maStr ), mnIndex ( rAction.mnIndex ), mnLen ( rAction.mnLen ) { if( rAction.mpDXAry ) { mpDXAry.reset( new long[ mnLen ] ); memcpy( mpDXAry.get(), rAction.mpDXAry.get(), mnLen * sizeof( long ) ); } } MetaTextArrayAction::MetaTextArrayAction( const Point& rStartPt, const OUString& rStr, const long* pDXAry, sal_Int32 nIndex, sal_Int32 nLen ) : MetaAction ( MetaActionType::TEXTARRAY ), maStartPt ( rStartPt ), maStr ( rStr ), mnIndex ( nIndex ), mnLen ( nLen ) { const sal_Int32 nAryLen = pDXAry ? mnLen : 0; if (nAryLen > 0) { mpDXAry.reset( new long[ nAryLen ] ); memcpy( mpDXAry.get(), pDXAry, nAryLen * sizeof(long) ); } } MetaTextArrayAction::~MetaTextArrayAction() { } void MetaTextArrayAction::Execute( OutputDevice* pOut ) { pOut->DrawTextArray( maStartPt, maStr, mpDXAry.get(), mnIndex, mnLen ); } rtl::Reference MetaTextArrayAction::Clone() { return new MetaTextArrayAction( *this ); } void MetaTextArrayAction::Move( long nHorzMove, long nVertMove ) { maStartPt.Move( nHorzMove, nVertMove ); } void MetaTextArrayAction::Scale( double fScaleX, double fScaleY ) { ImplScalePoint( maStartPt, fScaleX, fScaleY ); if ( mpDXAry && mnLen ) { for ( sal_uInt16 i = 0, nCount = mnLen; i < nCount; i++ ) mpDXAry[ i ] = FRound( mpDXAry[ i ] * fabs(fScaleX) ); } } void MetaTextArrayAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { const sal_Int32 nAryLen = mpDXAry ? mnLen : 0; MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 2); TypeSerializer aSerializer(rOStm); aSerializer.writePoint(maStartPt); rOStm.WriteUniOrByteString( maStr, pData->meActualCharSet ); rOStm.WriteUInt16(mnIndex); rOStm.WriteUInt16(mnLen); rOStm.WriteInt32(nAryLen); for (sal_Int32 i = 0; i < nAryLen; ++i) rOStm.WriteInt32( mpDXAry[ i ] ); write_uInt16_lenPrefixed_uInt16s_FromOUString(rOStm, maStr); // version 2 } void MetaTextArrayAction::Read( SvStream& rIStm, ImplMetaReadData* pData ) { mpDXAry.reset(); VersionCompat aCompat(rIStm, StreamMode::READ); TypeSerializer aSerializer(rIStm); aSerializer.readPoint(maStartPt); maStr = rIStm.ReadUniOrByteString(pData->meActualCharSet); sal_uInt16 nTmpIndex(0); rIStm.ReadUInt16(nTmpIndex); mnIndex = nTmpIndex; sal_uInt16 nTmpLen(0); rIStm.ReadUInt16(nTmpLen); mnLen = nTmpLen; sal_Int32 nAryLen(0); rIStm.ReadInt32(nAryLen); if (mnLen > maStr.getLength() - mnIndex) { mnIndex = 0; mpDXAry = nullptr; return; } if( nAryLen ) { // #i9762#, #106172# Ensure that DX array is at least mnLen entries long if ( mnLen >= nAryLen ) { mpDXAry.reset( new (std::nothrow)long[ mnLen ] ); if ( mpDXAry ) { sal_Int32 i; sal_Int32 val; for( i = 0; i < nAryLen; i++ ) { rIStm.ReadInt32( val); mpDXAry[ i ] = val; } // #106172# setup remainder for( ; i < mnLen; i++ ) mpDXAry[ i ] = 0; } } else { mpDXAry = nullptr; return; } } else mpDXAry = nullptr; if ( aCompat.GetVersion() >= 2 ) // Version 2 { maStr = read_uInt16_lenPrefixed_uInt16s_ToOUString(rIStm); if ( mnIndex + mnLen > maStr.getLength() ) { mnIndex = 0; mpDXAry.reset(); } } } MetaStretchTextAction::MetaStretchTextAction() : MetaAction ( MetaActionType::STRETCHTEXT ), mnWidth ( 0 ), mnIndex ( 0 ), mnLen ( 0 ) {} MetaStretchTextAction::~MetaStretchTextAction() {} MetaStretchTextAction::MetaStretchTextAction( const Point& rPt, sal_uInt32 nWidth, const OUString& rStr, sal_Int32 nIndex, sal_Int32 nLen ) : MetaAction ( MetaActionType::STRETCHTEXT ), maPt ( rPt ), maStr ( rStr ), mnWidth ( nWidth ), mnIndex ( nIndex ), mnLen ( nLen ) {} void MetaStretchTextAction::Execute( OutputDevice* pOut ) { pOut->DrawStretchText( maPt, mnWidth, maStr, mnIndex, mnLen ); } rtl::Reference MetaStretchTextAction::Clone() { return new MetaStretchTextAction( *this ); } void MetaStretchTextAction::Move( long nHorzMove, long nVertMove ) { maPt.Move( nHorzMove, nVertMove ); } void MetaStretchTextAction::Scale( double fScaleX, double fScaleY ) { ImplScalePoint( maPt, fScaleX, fScaleY ); mnWidth = static_cast(FRound( mnWidth * fabs(fScaleX) )); } void MetaStretchTextAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 2); TypeSerializer aSerializer(rOStm); aSerializer.writePoint(maPt); rOStm.WriteUniOrByteString( maStr, pData->meActualCharSet ); rOStm.WriteUInt32( mnWidth ); rOStm.WriteUInt16( mnIndex ); rOStm.WriteUInt16( mnLen ); write_uInt16_lenPrefixed_uInt16s_FromOUString(rOStm, maStr); // version 2 } void MetaStretchTextAction::Read( SvStream& rIStm, ImplMetaReadData* pData ) { VersionCompat aCompat(rIStm, StreamMode::READ); TypeSerializer aSerializer(rIStm); aSerializer.readPoint(maPt); maStr = rIStm.ReadUniOrByteString(pData->meActualCharSet); rIStm.ReadUInt32( mnWidth ); sal_uInt16 nTmpIndex(0); rIStm.ReadUInt16(nTmpIndex); mnIndex = nTmpIndex; sal_uInt16 nTmpLen(0); rIStm.ReadUInt16(nTmpLen); mnLen = nTmpLen; if ( aCompat.GetVersion() >= 2 ) // Version 2 maStr = read_uInt16_lenPrefixed_uInt16s_ToOUString(rIStm); } MetaTextRectAction::MetaTextRectAction() : MetaAction ( MetaActionType::TEXTRECT ), mnStyle ( DrawTextFlags::NONE ) {} MetaTextRectAction::~MetaTextRectAction() {} MetaTextRectAction::MetaTextRectAction( const tools::Rectangle& rRect, const OUString& rStr, DrawTextFlags nStyle ) : MetaAction ( MetaActionType::TEXTRECT ), maRect ( rRect ), maStr ( rStr ), mnStyle ( nStyle ) {} void MetaTextRectAction::Execute( OutputDevice* pOut ) { pOut->DrawText( maRect, maStr, mnStyle ); } rtl::Reference MetaTextRectAction::Clone() { return new MetaTextRectAction( *this ); } void MetaTextRectAction::Move( long nHorzMove, long nVertMove ) { maRect.Move( nHorzMove, nVertMove ); } void MetaTextRectAction::Scale( double fScaleX, double fScaleY ) { ImplScaleRect( maRect, fScaleX, fScaleY ); } void MetaTextRectAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 2); TypeSerializer aSerializer(rOStm); aSerializer.writeRectangle(maRect); rOStm.WriteUniOrByteString( maStr, pData->meActualCharSet ); rOStm.WriteUInt16( static_cast(mnStyle) ); write_uInt16_lenPrefixed_uInt16s_FromOUString(rOStm, maStr); // version 2 } void MetaTextRectAction::Read( SvStream& rIStm, ImplMetaReadData* pData ) { VersionCompat aCompat(rIStm, StreamMode::READ); TypeSerializer aSerializer(rIStm); aSerializer.readRectangle(maRect); maStr = rIStm.ReadUniOrByteString(pData->meActualCharSet); sal_uInt16 nTmp; rIStm .ReadUInt16( nTmp ); mnStyle = static_cast(nTmp); if ( aCompat.GetVersion() >= 2 ) // Version 2 maStr = read_uInt16_lenPrefixed_uInt16s_ToOUString(rIStm); } MetaTextLineAction::MetaTextLineAction() : MetaAction ( MetaActionType::TEXTLINE ), mnWidth ( 0 ), meStrikeout ( STRIKEOUT_NONE ), meUnderline ( LINESTYLE_NONE ), meOverline ( LINESTYLE_NONE ) {} MetaTextLineAction::~MetaTextLineAction() {} MetaTextLineAction::MetaTextLineAction( const Point& rPos, long nWidth, FontStrikeout eStrikeout, FontLineStyle eUnderline, FontLineStyle eOverline ) : MetaAction ( MetaActionType::TEXTLINE ), maPos ( rPos ), mnWidth ( nWidth ), meStrikeout ( eStrikeout ), meUnderline ( eUnderline ), meOverline ( eOverline ) {} void MetaTextLineAction::Execute( OutputDevice* pOut ) { pOut->DrawTextLine( maPos, mnWidth, meStrikeout, meUnderline, meOverline ); } rtl::Reference MetaTextLineAction::Clone() { return new MetaTextLineAction( *this ); } void MetaTextLineAction::Move( long nHorzMove, long nVertMove ) { maPos.Move( nHorzMove, nVertMove ); } void MetaTextLineAction::Scale( double fScaleX, double fScaleY ) { ImplScalePoint( maPos, fScaleX, fScaleY ); mnWidth = FRound( mnWidth * fabs(fScaleX) ); } void MetaTextLineAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 2); TypeSerializer aSerializer(rOStm); aSerializer.writePoint(maPos); rOStm.WriteInt32( mnWidth ); rOStm.WriteUInt32( meStrikeout ); rOStm.WriteUInt32( meUnderline ); // new in version 2 rOStm.WriteUInt32( meOverline ); } void MetaTextLineAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); sal_Int32 nTempWidth(0); TypeSerializer aSerializer(rIStm); aSerializer.readPoint(maPos); rIStm.ReadInt32(nTempWidth); mnWidth = nTempWidth; sal_uInt32 nTempStrikeout(0); rIStm.ReadUInt32( nTempStrikeout ); meStrikeout = static_cast(nTempStrikeout); sal_uInt32 nTempUnderline(0); rIStm.ReadUInt32( nTempUnderline ); meUnderline = static_cast(nTempUnderline); if (aCompat.GetVersion() >= 2) { sal_uInt32 nTempOverline(0); rIStm.ReadUInt32(nTempOverline); meOverline = static_cast(nTempOverline); } } MetaBmpAction::MetaBmpAction() : MetaAction(MetaActionType::BMP) {} MetaBmpAction::~MetaBmpAction() {} MetaBmpAction::MetaBmpAction( const Point& rPt, const Bitmap& rBmp ) : MetaAction ( MetaActionType::BMP ), maBmp ( rBmp ), maPt ( rPt ) {} void MetaBmpAction::Execute( OutputDevice* pOut ) { pOut->DrawBitmap( maPt, maBmp ); } rtl::Reference MetaBmpAction::Clone() { return new MetaBmpAction( *this ); } void MetaBmpAction::Move( long nHorzMove, long nVertMove ) { maPt.Move( nHorzMove, nVertMove ); } void MetaBmpAction::Scale( double fScaleX, double fScaleY ) { ImplScalePoint( maPt, fScaleX, fScaleY ); } void MetaBmpAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { if( !!maBmp ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); WriteDIB(maBmp, rOStm, false, true); TypeSerializer aSerializer(rOStm); aSerializer.writePoint(maPt); } } void MetaBmpAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadDIB(maBmp, rIStm, true); TypeSerializer aSerializer(rIStm); aSerializer.readPoint(maPt); } MetaBmpScaleAction::MetaBmpScaleAction() : MetaAction(MetaActionType::BMPSCALE) {} MetaBmpScaleAction::~MetaBmpScaleAction() {} MetaBmpScaleAction::MetaBmpScaleAction( const Point& rPt, const Size& rSz, const Bitmap& rBmp ) : MetaAction ( MetaActionType::BMPSCALE ), maBmp ( rBmp ), maPt ( rPt ), maSz ( rSz ) {} void MetaBmpScaleAction::Execute( OutputDevice* pOut ) { pOut->DrawBitmap( maPt, maSz, maBmp ); } rtl::Reference MetaBmpScaleAction::Clone() { return new MetaBmpScaleAction( *this ); } void MetaBmpScaleAction::Move( long nHorzMove, long nVertMove ) { maPt.Move( nHorzMove, nVertMove ); } void MetaBmpScaleAction::Scale( double fScaleX, double fScaleY ) { tools::Rectangle aRectangle(maPt, maSz); ImplScaleRect( aRectangle, fScaleX, fScaleY ); maPt = aRectangle.TopLeft(); maSz = aRectangle.GetSize(); } void MetaBmpScaleAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { if( !!maBmp ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); WriteDIB(maBmp, rOStm, false, true); TypeSerializer aSerializer(rOStm); aSerializer.writePoint(maPt); aSerializer.writeSize(maSz); } } void MetaBmpScaleAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadDIB(maBmp, rIStm, true); TypeSerializer aSerializer(rIStm); aSerializer.readPoint(maPt); aSerializer.readSize(maSz); } MetaBmpScalePartAction::MetaBmpScalePartAction() : MetaAction(MetaActionType::BMPSCALEPART) {} MetaBmpScalePartAction::~MetaBmpScalePartAction() {} MetaBmpScalePartAction::MetaBmpScalePartAction( const Point& rDstPt, const Size& rDstSz, const Point& rSrcPt, const Size& rSrcSz, const Bitmap& rBmp ) : MetaAction ( MetaActionType::BMPSCALEPART ), maBmp ( rBmp ), maDstPt ( rDstPt ), maDstSz ( rDstSz ), maSrcPt ( rSrcPt ), maSrcSz ( rSrcSz ) {} void MetaBmpScalePartAction::Execute( OutputDevice* pOut ) { pOut->DrawBitmap( maDstPt, maDstSz, maSrcPt, maSrcSz, maBmp ); } rtl::Reference MetaBmpScalePartAction::Clone() { return new MetaBmpScalePartAction( *this ); } void MetaBmpScalePartAction::Move( long nHorzMove, long nVertMove ) { maDstPt.Move( nHorzMove, nVertMove ); } void MetaBmpScalePartAction::Scale( double fScaleX, double fScaleY ) { tools::Rectangle aRectangle(maDstPt, maDstSz); ImplScaleRect( aRectangle, fScaleX, fScaleY ); maDstPt = aRectangle.TopLeft(); maDstSz = aRectangle.GetSize(); } void MetaBmpScalePartAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { if( !!maBmp ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); WriteDIB(maBmp, rOStm, false, true); TypeSerializer aSerializer(rOStm); aSerializer.writePoint(maDstPt); aSerializer.writeSize(maDstSz); aSerializer.writePoint(maSrcPt); aSerializer.writeSize(maSrcSz); } } void MetaBmpScalePartAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadDIB(maBmp, rIStm, true); TypeSerializer aSerializer(rIStm); aSerializer.readPoint(maDstPt); aSerializer.readSize(maDstSz); aSerializer.readPoint(maSrcPt); aSerializer.readSize(maSrcSz); } MetaBmpExAction::MetaBmpExAction() : MetaAction(MetaActionType::BMPEX) {} MetaBmpExAction::~MetaBmpExAction() {} MetaBmpExAction::MetaBmpExAction( const Point& rPt, const BitmapEx& rBmpEx ) : MetaAction ( MetaActionType::BMPEX ), maBmpEx ( rBmpEx ), maPt ( rPt ) {} void MetaBmpExAction::Execute( OutputDevice* pOut ) { pOut->DrawBitmapEx( maPt, maBmpEx ); } rtl::Reference MetaBmpExAction::Clone() { return new MetaBmpExAction( *this ); } void MetaBmpExAction::Move( long nHorzMove, long nVertMove ) { maPt.Move( nHorzMove, nVertMove ); } void MetaBmpExAction::Scale( double fScaleX, double fScaleY ) { ImplScalePoint( maPt, fScaleX, fScaleY ); } void MetaBmpExAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { if( !!maBmpEx.GetBitmap() ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); WriteDIBBitmapEx(maBmpEx, rOStm); TypeSerializer aSerializer(rOStm); aSerializer.writePoint(maPt); } } void MetaBmpExAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadDIBBitmapEx(maBmpEx, rIStm); TypeSerializer aSerializer(rIStm); aSerializer.readPoint(maPt); } MetaBmpExScaleAction::MetaBmpExScaleAction() : MetaAction(MetaActionType::BMPEXSCALE) {} MetaBmpExScaleAction::~MetaBmpExScaleAction() {} MetaBmpExScaleAction::MetaBmpExScaleAction( const Point& rPt, const Size& rSz, const BitmapEx& rBmpEx ) : MetaAction ( MetaActionType::BMPEXSCALE ), maBmpEx ( rBmpEx ), maPt ( rPt ), maSz ( rSz ) {} void MetaBmpExScaleAction::Execute( OutputDevice* pOut ) { pOut->DrawBitmapEx( maPt, maSz, maBmpEx ); } rtl::Reference MetaBmpExScaleAction::Clone() { return new MetaBmpExScaleAction( *this ); } void MetaBmpExScaleAction::Move( long nHorzMove, long nVertMove ) { maPt.Move( nHorzMove, nVertMove ); } void MetaBmpExScaleAction::Scale( double fScaleX, double fScaleY ) { tools::Rectangle aRectangle(maPt, maSz); ImplScaleRect( aRectangle, fScaleX, fScaleY ); maPt = aRectangle.TopLeft(); maSz = aRectangle.GetSize(); } void MetaBmpExScaleAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { if( !!maBmpEx.GetBitmap() ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); WriteDIBBitmapEx(maBmpEx, rOStm); TypeSerializer aSerializer(rOStm); aSerializer.writePoint(maPt); aSerializer.writeSize(maSz); } } void MetaBmpExScaleAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadDIBBitmapEx(maBmpEx, rIStm); TypeSerializer aSerializer(rIStm); aSerializer.readPoint(maPt); aSerializer.readSize(maSz); } MetaBmpExScalePartAction::MetaBmpExScalePartAction() : MetaAction(MetaActionType::BMPEXSCALEPART) {} MetaBmpExScalePartAction::~MetaBmpExScalePartAction() {} MetaBmpExScalePartAction::MetaBmpExScalePartAction( const Point& rDstPt, const Size& rDstSz, const Point& rSrcPt, const Size& rSrcSz, const BitmapEx& rBmpEx ) : MetaAction ( MetaActionType::BMPEXSCALEPART ), maBmpEx ( rBmpEx ), maDstPt ( rDstPt ), maDstSz ( rDstSz ), maSrcPt ( rSrcPt ), maSrcSz ( rSrcSz ) {} void MetaBmpExScalePartAction::Execute( OutputDevice* pOut ) { pOut->DrawBitmapEx( maDstPt, maDstSz, maSrcPt, maSrcSz, maBmpEx ); } rtl::Reference MetaBmpExScalePartAction::Clone() { return new MetaBmpExScalePartAction( *this ); } void MetaBmpExScalePartAction::Move( long nHorzMove, long nVertMove ) { maDstPt.Move( nHorzMove, nVertMove ); } void MetaBmpExScalePartAction::Scale( double fScaleX, double fScaleY ) { tools::Rectangle aRectangle(maDstPt, maDstSz); ImplScaleRect( aRectangle, fScaleX, fScaleY ); maDstPt = aRectangle.TopLeft(); maDstSz = aRectangle.GetSize(); } void MetaBmpExScalePartAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { if( !!maBmpEx.GetBitmap() ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); WriteDIBBitmapEx(maBmpEx, rOStm); TypeSerializer aSerializer(rOStm); aSerializer.writePoint(maDstPt); aSerializer.writeSize(maDstSz); aSerializer.writePoint(maSrcPt); aSerializer.writeSize(maSrcSz); } } void MetaBmpExScalePartAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadDIBBitmapEx(maBmpEx, rIStm); TypeSerializer aSerializer(rIStm); aSerializer.readPoint(maDstPt); aSerializer.readSize(maDstSz); aSerializer.readPoint(maSrcPt); aSerializer.readSize(maSrcSz); } MetaMaskAction::MetaMaskAction() : MetaAction(MetaActionType::MASK) {} MetaMaskAction::~MetaMaskAction() {} MetaMaskAction::MetaMaskAction( const Point& rPt, const Bitmap& rBmp, const Color& rColor ) : MetaAction ( MetaActionType::MASK ), maBmp ( rBmp ), maColor ( rColor ), maPt ( rPt ) {} void MetaMaskAction::Execute( OutputDevice* pOut ) { pOut->DrawMask( maPt, maBmp, maColor ); } rtl::Reference MetaMaskAction::Clone() { return new MetaMaskAction( *this ); } void MetaMaskAction::Move( long nHorzMove, long nVertMove ) { maPt.Move( nHorzMove, nVertMove ); } void MetaMaskAction::Scale( double fScaleX, double fScaleY ) { ImplScalePoint( maPt, fScaleX, fScaleY ); } void MetaMaskAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { if( !!maBmp ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); WriteDIB(maBmp, rOStm, false, true); TypeSerializer aSerializer(rOStm); aSerializer.writePoint(maPt); } } void MetaMaskAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadDIB(maBmp, rIStm, true); TypeSerializer aSerializer(rIStm); aSerializer.readPoint(maPt); } MetaMaskScaleAction::MetaMaskScaleAction() : MetaAction(MetaActionType::MASKSCALE) {} MetaMaskScaleAction::~MetaMaskScaleAction() {} MetaMaskScaleAction::MetaMaskScaleAction( const Point& rPt, const Size& rSz, const Bitmap& rBmp, const Color& rColor ) : MetaAction ( MetaActionType::MASKSCALE ), maBmp ( rBmp ), maColor ( rColor ), maPt ( rPt ), maSz ( rSz ) {} void MetaMaskScaleAction::Execute( OutputDevice* pOut ) { pOut->DrawMask( maPt, maSz, maBmp, maColor ); } rtl::Reference MetaMaskScaleAction::Clone() { return new MetaMaskScaleAction( *this ); } void MetaMaskScaleAction::Move( long nHorzMove, long nVertMove ) { maPt.Move( nHorzMove, nVertMove ); } void MetaMaskScaleAction::Scale( double fScaleX, double fScaleY ) { tools::Rectangle aRectangle(maPt, maSz); ImplScaleRect( aRectangle, fScaleX, fScaleY ); maPt = aRectangle.TopLeft(); maSz = aRectangle.GetSize(); } void MetaMaskScaleAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { if( !!maBmp ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); WriteDIB(maBmp, rOStm, false, true); TypeSerializer aSerializer(rOStm); aSerializer.writePoint(maPt); aSerializer.writeSize(maSz); } } void MetaMaskScaleAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadDIB(maBmp, rIStm, true); TypeSerializer aSerializer(rIStm); aSerializer.readPoint(maPt); aSerializer.readSize(maSz); } MetaMaskScalePartAction::MetaMaskScalePartAction() : MetaAction(MetaActionType::MASKSCALEPART) {} MetaMaskScalePartAction::~MetaMaskScalePartAction() {} MetaMaskScalePartAction::MetaMaskScalePartAction( const Point& rDstPt, const Size& rDstSz, const Point& rSrcPt, const Size& rSrcSz, const Bitmap& rBmp, const Color& rColor ) : MetaAction ( MetaActionType::MASKSCALEPART ), maBmp ( rBmp ), maColor ( rColor ), maDstPt ( rDstPt ), maDstSz ( rDstSz ), maSrcPt ( rSrcPt ), maSrcSz ( rSrcSz ) {} void MetaMaskScalePartAction::Execute( OutputDevice* pOut ) { pOut->DrawMask( maDstPt, maDstSz, maSrcPt, maSrcSz, maBmp, maColor, MetaActionType::MASKSCALE ); } rtl::Reference MetaMaskScalePartAction::Clone() { return new MetaMaskScalePartAction( *this ); } void MetaMaskScalePartAction::Move( long nHorzMove, long nVertMove ) { maDstPt.Move( nHorzMove, nVertMove ); } void MetaMaskScalePartAction::Scale( double fScaleX, double fScaleY ) { tools::Rectangle aRectangle(maDstPt, maDstSz); ImplScaleRect( aRectangle, fScaleX, fScaleY ); maDstPt = aRectangle.TopLeft(); maDstSz = aRectangle.GetSize(); } void MetaMaskScalePartAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { if( !!maBmp ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); WriteDIB(maBmp, rOStm, false, true); rOStm.WriteUInt32(maColor.mValue); TypeSerializer aSerializer(rOStm); aSerializer.writePoint(maDstPt); aSerializer.writeSize(maDstSz); aSerializer.writePoint(maSrcPt); aSerializer.writeSize(maSrcSz); } } void MetaMaskScalePartAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadDIB(maBmp, rIStm, true); rIStm.ReadUInt32(maColor.mValue); TypeSerializer aSerializer(rIStm); aSerializer.readPoint(maDstPt); aSerializer.readSize(maDstSz); aSerializer.readPoint(maSrcPt); aSerializer.readSize(maSrcSz); } MetaGradientAction::MetaGradientAction() : MetaAction(MetaActionType::GRADIENT) {} MetaGradientAction::~MetaGradientAction() {} MetaGradientAction::MetaGradientAction( const tools::Rectangle& rRect, const Gradient& rGradient ) : MetaAction ( MetaActionType::GRADIENT ), maRect ( rRect ), maGradient ( rGradient ) {} void MetaGradientAction::Execute( OutputDevice* pOut ) { pOut->DrawGradient( maRect, maGradient ); } rtl::Reference MetaGradientAction::Clone() { return new MetaGradientAction( *this ); } void MetaGradientAction::Move( long nHorzMove, long nVertMove ) { maRect.Move( nHorzMove, nVertMove ); } void MetaGradientAction::Scale( double fScaleX, double fScaleY ) { ImplScaleRect( maRect, fScaleX, fScaleY ); } void MetaGradientAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); TypeSerializer aSerializer(rOStm); aSerializer.writeRectangle(maRect); aSerializer.writeGradient(maGradient); } void MetaGradientAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); TypeSerializer aSerializer(rIStm); aSerializer.readRectangle(maRect); aSerializer.readGradient(maGradient); } MetaGradientExAction::MetaGradientExAction() : MetaAction ( MetaActionType::GRADIENTEX ) {} MetaGradientExAction::MetaGradientExAction( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient ) : MetaAction ( MetaActionType::GRADIENTEX ), maPolyPoly ( rPolyPoly ), maGradient ( rGradient ) {} MetaGradientExAction::~MetaGradientExAction() {} void MetaGradientExAction::Execute( OutputDevice* pOut ) { if( pOut->GetConnectMetaFile() ) { pOut->GetConnectMetaFile()->AddAction( this ); } } rtl::Reference MetaGradientExAction::Clone() { return new MetaGradientExAction( *this ); } void MetaGradientExAction::Move( long nHorzMove, long nVertMove ) { maPolyPoly.Move( nHorzMove, nVertMove ); } void MetaGradientExAction::Scale( double fScaleX, double fScaleY ) { for( sal_uInt16 i = 0, nCount = maPolyPoly.Count(); i < nCount; i++ ) ImplScalePoly( maPolyPoly[ i ], fScaleX, fScaleY ); } void MetaGradientExAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); // #i105373# see comment at MetaTransparentAction::Write tools::PolyPolygon aNoCurvePolyPolygon; maPolyPoly.AdaptiveSubdivide(aNoCurvePolyPolygon); WritePolyPolygon( rOStm, aNoCurvePolyPolygon ); TypeSerializer aSerializer(rOStm); aSerializer.writeGradient(maGradient); } void MetaGradientExAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadPolyPolygon( rIStm, maPolyPoly ); TypeSerializer aSerializer(rIStm); aSerializer.readGradient(maGradient); } MetaHatchAction::MetaHatchAction() : MetaAction(MetaActionType::HATCH) {} MetaHatchAction::~MetaHatchAction() {} MetaHatchAction::MetaHatchAction( const tools::PolyPolygon& rPolyPoly, const Hatch& rHatch ) : MetaAction ( MetaActionType::HATCH ), maPolyPoly ( rPolyPoly ), maHatch ( rHatch ) {} void MetaHatchAction::Execute( OutputDevice* pOut ) { pOut->DrawHatch( maPolyPoly, maHatch ); } rtl::Reference MetaHatchAction::Clone() { return new MetaHatchAction( *this ); } void MetaHatchAction::Move( long nHorzMove, long nVertMove ) { maPolyPoly.Move( nHorzMove, nVertMove ); } void MetaHatchAction::Scale( double fScaleX, double fScaleY ) { for( sal_uInt16 i = 0, nCount = maPolyPoly.Count(); i < nCount; i++ ) ImplScalePoly( maPolyPoly[ i ], fScaleX, fScaleY ); } void MetaHatchAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); // #i105373# see comment at MetaTransparentAction::Write tools::PolyPolygon aNoCurvePolyPolygon; maPolyPoly.AdaptiveSubdivide(aNoCurvePolyPolygon); WritePolyPolygon( rOStm, aNoCurvePolyPolygon ); WriteHatch( rOStm, maHatch ); } void MetaHatchAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadPolyPolygon( rIStm, maPolyPoly ); ReadHatch( rIStm, maHatch ); } MetaWallpaperAction::MetaWallpaperAction() : MetaAction(MetaActionType::WALLPAPER) {} MetaWallpaperAction::~MetaWallpaperAction() {} MetaWallpaperAction::MetaWallpaperAction( const tools::Rectangle& rRect, const Wallpaper& rPaper ) : MetaAction ( MetaActionType::WALLPAPER ), maRect ( rRect ), maWallpaper ( rPaper ) {} void MetaWallpaperAction::Execute( OutputDevice* pOut ) { pOut->DrawWallpaper( maRect, maWallpaper ); } rtl::Reference MetaWallpaperAction::Clone() { return new MetaWallpaperAction( *this ); } void MetaWallpaperAction::Move( long nHorzMove, long nVertMove ) { maRect.Move( nHorzMove, nVertMove ); } void MetaWallpaperAction::Scale( double fScaleX, double fScaleY ) { ImplScaleRect( maRect, fScaleX, fScaleY ); } void MetaWallpaperAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); WriteWallpaper( rOStm, maWallpaper ); } void MetaWallpaperAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadWallpaper( rIStm, maWallpaper ); } MetaClipRegionAction::MetaClipRegionAction() : MetaAction ( MetaActionType::CLIPREGION ), mbClip ( false ) {} MetaClipRegionAction::~MetaClipRegionAction() {} MetaClipRegionAction::MetaClipRegionAction( const vcl::Region& rRegion, bool bClip ) : MetaAction ( MetaActionType::CLIPREGION ), maRegion ( rRegion ), mbClip ( bClip ) {} void MetaClipRegionAction::Execute( OutputDevice* pOut ) { if( mbClip ) pOut->SetClipRegion( maRegion ); else pOut->SetClipRegion(); } rtl::Reference MetaClipRegionAction::Clone() { return new MetaClipRegionAction( *this ); } void MetaClipRegionAction::Move( long nHorzMove, long nVertMove ) { maRegion.Move( nHorzMove, nVertMove ); } void MetaClipRegionAction::Scale( double fScaleX, double fScaleY ) { maRegion.Scale( fScaleX, fScaleY ); } void MetaClipRegionAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); WriteRegion( rOStm, maRegion ); rOStm.WriteBool( mbClip ); } void MetaClipRegionAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadRegion( rIStm, maRegion ); rIStm.ReadCharAsBool( mbClip ); } MetaISectRectClipRegionAction::MetaISectRectClipRegionAction() : MetaAction(MetaActionType::ISECTRECTCLIPREGION) {} MetaISectRectClipRegionAction::~MetaISectRectClipRegionAction() {} MetaISectRectClipRegionAction::MetaISectRectClipRegionAction( const tools::Rectangle& rRect ) : MetaAction ( MetaActionType::ISECTRECTCLIPREGION ), maRect ( rRect ) {} void MetaISectRectClipRegionAction::Execute( OutputDevice* pOut ) { pOut->IntersectClipRegion( maRect ); } rtl::Reference MetaISectRectClipRegionAction::Clone() { return new MetaISectRectClipRegionAction( *this ); } void MetaISectRectClipRegionAction::Move( long nHorzMove, long nVertMove ) { maRect.Move( nHorzMove, nVertMove ); } void MetaISectRectClipRegionAction::Scale( double fScaleX, double fScaleY ) { ImplScaleRect( maRect, fScaleX, fScaleY ); } void MetaISectRectClipRegionAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); TypeSerializer aSerializer(rOStm); aSerializer.writeRectangle(maRect); } void MetaISectRectClipRegionAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); TypeSerializer aSerializer(rIStm); aSerializer.readRectangle(maRect); } MetaISectRegionClipRegionAction::MetaISectRegionClipRegionAction() : MetaAction(MetaActionType::ISECTREGIONCLIPREGION) {} MetaISectRegionClipRegionAction::~MetaISectRegionClipRegionAction() {} MetaISectRegionClipRegionAction::MetaISectRegionClipRegionAction( const vcl::Region& rRegion ) : MetaAction ( MetaActionType::ISECTREGIONCLIPREGION ), maRegion ( rRegion ) { } void MetaISectRegionClipRegionAction::Execute( OutputDevice* pOut ) { pOut->IntersectClipRegion( maRegion ); } rtl::Reference MetaISectRegionClipRegionAction::Clone() { return new MetaISectRegionClipRegionAction( *this ); } void MetaISectRegionClipRegionAction::Move( long nHorzMove, long nVertMove ) { maRegion.Move( nHorzMove, nVertMove ); } void MetaISectRegionClipRegionAction::Scale( double fScaleX, double fScaleY ) { maRegion.Scale( fScaleX, fScaleY ); } void MetaISectRegionClipRegionAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); WriteRegion( rOStm, maRegion ); } void MetaISectRegionClipRegionAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadRegion( rIStm, maRegion ); } MetaMoveClipRegionAction::MetaMoveClipRegionAction() : MetaAction ( MetaActionType::MOVECLIPREGION ), mnHorzMove ( 0 ), mnVertMove ( 0 ) {} MetaMoveClipRegionAction::~MetaMoveClipRegionAction() {} MetaMoveClipRegionAction::MetaMoveClipRegionAction( long nHorzMove, long nVertMove ) : MetaAction ( MetaActionType::MOVECLIPREGION ), mnHorzMove ( nHorzMove ), mnVertMove ( nVertMove ) {} void MetaMoveClipRegionAction::Execute( OutputDevice* pOut ) { pOut->MoveClipRegion( mnHorzMove, mnVertMove ); } rtl::Reference MetaMoveClipRegionAction::Clone() { return new MetaMoveClipRegionAction( *this ); } void MetaMoveClipRegionAction::Scale( double fScaleX, double fScaleY ) { mnHorzMove = FRound( mnHorzMove * fScaleX ); mnVertMove = FRound( mnVertMove * fScaleY ); } void MetaMoveClipRegionAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); rOStm.WriteInt32( mnHorzMove ).WriteInt32( mnVertMove ); } void MetaMoveClipRegionAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); sal_Int32 nTmpHM(0), nTmpVM(0); rIStm.ReadInt32( nTmpHM ).ReadInt32( nTmpVM ); mnHorzMove = nTmpHM; mnVertMove = nTmpVM; } MetaLineColorAction::MetaLineColorAction() : MetaAction ( MetaActionType::LINECOLOR ), mbSet ( false ) {} MetaLineColorAction::~MetaLineColorAction() {} MetaLineColorAction::MetaLineColorAction( const Color& rColor, bool bSet ) : MetaAction ( MetaActionType::LINECOLOR ), maColor ( rColor ), mbSet ( bSet ) {} void MetaLineColorAction::Execute( OutputDevice* pOut ) { if( mbSet ) pOut->SetLineColor( maColor ); else pOut->SetLineColor(); } rtl::Reference MetaLineColorAction::Clone() { return new MetaLineColorAction( *this ); } void MetaLineColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); rOStm.WriteUInt32(maColor.mValue); rOStm.WriteBool( mbSet ); } void MetaLineColorAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); rIStm.ReadUInt32(maColor.mValue); rIStm.ReadCharAsBool( mbSet ); } MetaFillColorAction::MetaFillColorAction() : MetaAction ( MetaActionType::FILLCOLOR ), mbSet ( false ) {} MetaFillColorAction::~MetaFillColorAction() {} MetaFillColorAction::MetaFillColorAction( const Color& rColor, bool bSet ) : MetaAction ( MetaActionType::FILLCOLOR ), maColor ( rColor ), mbSet ( bSet ) {} void MetaFillColorAction::Execute( OutputDevice* pOut ) { if( mbSet ) pOut->SetFillColor( maColor ); else pOut->SetFillColor(); } rtl::Reference MetaFillColorAction::Clone() { return new MetaFillColorAction( *this ); } void MetaFillColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); rOStm.WriteUInt32(maColor.mValue); rOStm.WriteBool( mbSet ); } void MetaFillColorAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); rIStm.ReadUInt32(maColor.mValue); rIStm.ReadCharAsBool( mbSet ); } MetaTextColorAction::MetaTextColorAction() : MetaAction(MetaActionType::TEXTCOLOR) {} MetaTextColorAction::~MetaTextColorAction() {} MetaTextColorAction::MetaTextColorAction( const Color& rColor ) : MetaAction ( MetaActionType::TEXTCOLOR ), maColor ( rColor ) {} void MetaTextColorAction::Execute( OutputDevice* pOut ) { pOut->SetTextColor( maColor ); } rtl::Reference MetaTextColorAction::Clone() { return new MetaTextColorAction( *this ); } void MetaTextColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); rOStm.WriteUInt32(maColor.mValue); } void MetaTextColorAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); rIStm.ReadUInt32(maColor.mValue); } MetaTextFillColorAction::MetaTextFillColorAction() : MetaAction ( MetaActionType::TEXTFILLCOLOR ), mbSet ( false ) {} MetaTextFillColorAction::~MetaTextFillColorAction() {} MetaTextFillColorAction::MetaTextFillColorAction( const Color& rColor, bool bSet ) : MetaAction ( MetaActionType::TEXTFILLCOLOR ), maColor ( rColor ), mbSet ( bSet ) {} void MetaTextFillColorAction::Execute( OutputDevice* pOut ) { if( mbSet ) pOut->SetTextFillColor( maColor ); else pOut->SetTextFillColor(); } rtl::Reference MetaTextFillColorAction::Clone() { return new MetaTextFillColorAction( *this ); } void MetaTextFillColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); rOStm.WriteUInt32(maColor.mValue); rOStm.WriteBool( mbSet ); } void MetaTextFillColorAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); rIStm.ReadUInt32(maColor.mValue); rIStm.ReadCharAsBool( mbSet ); } MetaTextLineColorAction::MetaTextLineColorAction() : MetaAction ( MetaActionType::TEXTLINECOLOR ), mbSet ( false ) {} MetaTextLineColorAction::~MetaTextLineColorAction() {} MetaTextLineColorAction::MetaTextLineColorAction( const Color& rColor, bool bSet ) : MetaAction ( MetaActionType::TEXTLINECOLOR ), maColor ( rColor ), mbSet ( bSet ) {} void MetaTextLineColorAction::Execute( OutputDevice* pOut ) { if( mbSet ) pOut->SetTextLineColor( maColor ); else pOut->SetTextLineColor(); } rtl::Reference MetaTextLineColorAction::Clone() { return new MetaTextLineColorAction( *this ); } void MetaTextLineColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); rOStm.WriteUInt32(maColor.mValue); rOStm.WriteBool( mbSet ); } void MetaTextLineColorAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); rIStm.ReadUInt32(maColor.mValue); rIStm.ReadCharAsBool( mbSet ); } MetaOverlineColorAction::MetaOverlineColorAction() : MetaAction ( MetaActionType::OVERLINECOLOR ), mbSet ( false ) {} MetaOverlineColorAction::~MetaOverlineColorAction() {} MetaOverlineColorAction::MetaOverlineColorAction( const Color& rColor, bool bSet ) : MetaAction ( MetaActionType::OVERLINECOLOR ), maColor ( rColor ), mbSet ( bSet ) {} void MetaOverlineColorAction::Execute( OutputDevice* pOut ) { if( mbSet ) pOut->SetOverlineColor( maColor ); else pOut->SetOverlineColor(); } rtl::Reference MetaOverlineColorAction::Clone() { return new MetaOverlineColorAction( *this ); } void MetaOverlineColorAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); rOStm.WriteUInt32(maColor.mValue); rOStm.WriteBool( mbSet ); } void MetaOverlineColorAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); rIStm.ReadUInt32(maColor.mValue); rIStm.ReadCharAsBool( mbSet ); } MetaTextAlignAction::MetaTextAlignAction() : MetaAction ( MetaActionType::TEXTALIGN ), maAlign ( ALIGN_TOP ) {} MetaTextAlignAction::~MetaTextAlignAction() {} MetaTextAlignAction::MetaTextAlignAction( TextAlign aAlign ) : MetaAction ( MetaActionType::TEXTALIGN ), maAlign ( aAlign ) {} void MetaTextAlignAction::Execute( OutputDevice* pOut ) { pOut->SetTextAlign( maAlign ); } rtl::Reference MetaTextAlignAction::Clone() { return new MetaTextAlignAction( *this ); } void MetaTextAlignAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); rOStm.WriteUInt16( maAlign ); } void MetaTextAlignAction::Read( SvStream& rIStm, ImplMetaReadData* ) { sal_uInt16 nTmp16(0); VersionCompat aCompat(rIStm, StreamMode::READ); rIStm.ReadUInt16( nTmp16 ); maAlign = static_cast(nTmp16); } MetaMapModeAction::MetaMapModeAction() : MetaAction(MetaActionType::MAPMODE) {} MetaMapModeAction::~MetaMapModeAction() {} MetaMapModeAction::MetaMapModeAction( const MapMode& rMapMode ) : MetaAction ( MetaActionType::MAPMODE ), maMapMode ( rMapMode ) {} void MetaMapModeAction::Execute( OutputDevice* pOut ) { pOut->SetMapMode( maMapMode ); } rtl::Reference MetaMapModeAction::Clone() { return new MetaMapModeAction( *this ); } void MetaMapModeAction::Scale( double fScaleX, double fScaleY ) { Point aPoint( maMapMode.GetOrigin() ); ImplScalePoint( aPoint, fScaleX, fScaleY ); maMapMode.SetOrigin( aPoint ); } void MetaMapModeAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); WriteMapMode( rOStm, maMapMode ); } void MetaMapModeAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadMapMode( rIStm, maMapMode ); } MetaFontAction::MetaFontAction() : MetaAction(MetaActionType::FONT) {} MetaFontAction::~MetaFontAction() {} MetaFontAction::MetaFontAction( const vcl::Font& rFont ) : MetaAction ( MetaActionType::FONT ), maFont ( rFont ) { // #96876: because RTL_TEXTENCODING_SYMBOL is often set at the StarSymbol font, // we change the textencoding to RTL_TEXTENCODING_UNICODE here, which seems // to be the right way; changing the textencoding at other sources // is too dangerous at the moment if ( IsStarSymbol( maFont.GetFamilyName() ) && ( maFont.GetCharSet() != RTL_TEXTENCODING_UNICODE ) ) { maFont.SetCharSet( RTL_TEXTENCODING_UNICODE ); } } void MetaFontAction::Execute( OutputDevice* pOut ) { pOut->SetFont( maFont ); } rtl::Reference MetaFontAction::Clone() { return new MetaFontAction( *this ); } void MetaFontAction::Scale( double fScaleX, double fScaleY ) { const Size aSize( FRound(maFont.GetFontSize().Width() * fabs(fScaleX)), FRound(maFont.GetFontSize().Height() * fabs(fScaleY))); maFont.SetFontSize( aSize ); } void MetaFontAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); WriteFont( rOStm, maFont ); pData->meActualCharSet = maFont.GetCharSet(); if ( pData->meActualCharSet == RTL_TEXTENCODING_DONTKNOW ) pData->meActualCharSet = osl_getThreadTextEncoding(); } void MetaFontAction::Read( SvStream& rIStm, ImplMetaReadData* pData ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadFont( rIStm, maFont ); pData->meActualCharSet = maFont.GetCharSet(); if ( pData->meActualCharSet == RTL_TEXTENCODING_DONTKNOW ) pData->meActualCharSet = osl_getThreadTextEncoding(); } MetaPushAction::MetaPushAction() : MetaAction ( MetaActionType::PUSH ), mnFlags ( PushFlags::NONE ) {} MetaPushAction::~MetaPushAction() {} MetaPushAction::MetaPushAction( PushFlags nFlags ) : MetaAction ( MetaActionType::PUSH ), mnFlags ( nFlags ) {} void MetaPushAction::Execute( OutputDevice* pOut ) { pOut->Push( mnFlags ); } rtl::Reference MetaPushAction::Clone() { return new MetaPushAction( *this ); } void MetaPushAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); rOStm.WriteUInt16( static_cast(mnFlags) ); } void MetaPushAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); sal_uInt16 tmp; rIStm.ReadUInt16( tmp ); mnFlags = static_cast(tmp); } MetaPopAction::MetaPopAction() : MetaAction(MetaActionType::POP) {} MetaPopAction::~MetaPopAction() {} void MetaPopAction::Execute( OutputDevice* pOut ) { pOut->Pop(); } rtl::Reference MetaPopAction::Clone() { return new MetaPopAction( *this ); } void MetaPopAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); } void MetaPopAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); } MetaRasterOpAction::MetaRasterOpAction() : MetaAction ( MetaActionType::RASTEROP ), meRasterOp ( RasterOp::OverPaint ) {} MetaRasterOpAction::~MetaRasterOpAction() {} MetaRasterOpAction::MetaRasterOpAction( RasterOp eRasterOp ) : MetaAction ( MetaActionType::RASTEROP ), meRasterOp ( eRasterOp ) { } void MetaRasterOpAction::Execute( OutputDevice* pOut ) { pOut->SetRasterOp( meRasterOp ); } rtl::Reference MetaRasterOpAction::Clone() { return new MetaRasterOpAction( *this ); } void MetaRasterOpAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); rOStm.WriteUInt16( static_cast(meRasterOp) ); } void MetaRasterOpAction::Read( SvStream& rIStm, ImplMetaReadData* ) { sal_uInt16 nTmp16(0); VersionCompat aCompat(rIStm, StreamMode::READ); rIStm.ReadUInt16( nTmp16 ); meRasterOp = static_cast(nTmp16); } MetaTransparentAction::MetaTransparentAction() : MetaAction ( MetaActionType::Transparent ), mnTransPercent ( 0 ) {} MetaTransparentAction::~MetaTransparentAction() {} MetaTransparentAction::MetaTransparentAction( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nTransPercent ) : MetaAction ( MetaActionType::Transparent ), maPolyPoly ( rPolyPoly ), mnTransPercent ( nTransPercent ) {} void MetaTransparentAction::Execute( OutputDevice* pOut ) { pOut->DrawTransparent( maPolyPoly, mnTransPercent ); } rtl::Reference MetaTransparentAction::Clone() { return new MetaTransparentAction( *this ); } void MetaTransparentAction::Move( long nHorzMove, long nVertMove ) { maPolyPoly.Move( nHorzMove, nVertMove ); } void MetaTransparentAction::Scale( double fScaleX, double fScaleY ) { for( sal_uInt16 i = 0, nCount = maPolyPoly.Count(); i < nCount; i++ ) ImplScalePoly( maPolyPoly[ i ], fScaleX, fScaleY ); } void MetaTransparentAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); // #i105373# The tools::PolyPolygon in this action may be a curve; this // was ignored until now what is an error. To make older office // versions work with MetaFiles, i opt for applying AdaptiveSubdivide // to the PolyPolygon. // The alternative would be to really write the curve information // like in MetaPolyPolygonAction::Write (where someone extended it // correctly, but not here :-( ). // The golden solution would be to combine both, but i think it's // not necessary; a good subdivision will be sufficient. tools::PolyPolygon aNoCurvePolyPolygon; maPolyPoly.AdaptiveSubdivide(aNoCurvePolyPolygon); WritePolyPolygon( rOStm, aNoCurvePolyPolygon ); rOStm.WriteUInt16( mnTransPercent ); } void MetaTransparentAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadPolyPolygon( rIStm, maPolyPoly ); rIStm.ReadUInt16( mnTransPercent ); } MetaFloatTransparentAction::MetaFloatTransparentAction() : MetaAction(MetaActionType::FLOATTRANSPARENT) {} MetaFloatTransparentAction::~MetaFloatTransparentAction() {} MetaFloatTransparentAction::MetaFloatTransparentAction( const GDIMetaFile& rMtf, const Point& rPos, const Size& rSize, const Gradient& rGradient ) : MetaAction ( MetaActionType::FLOATTRANSPARENT ), maMtf ( rMtf ), maPoint ( rPos ), maSize ( rSize ), maGradient ( rGradient ) {} void MetaFloatTransparentAction::Execute( OutputDevice* pOut ) { pOut->DrawTransparent( maMtf, maPoint, maSize, maGradient ); } rtl::Reference MetaFloatTransparentAction::Clone() { return new MetaFloatTransparentAction( *this ); } void MetaFloatTransparentAction::Move( long nHorzMove, long nVertMove ) { maPoint.Move( nHorzMove, nVertMove ); } void MetaFloatTransparentAction::Scale( double fScaleX, double fScaleY ) { tools::Rectangle aRectangle(maPoint, maSize); ImplScaleRect( aRectangle, fScaleX, fScaleY ); maPoint = aRectangle.TopLeft(); maSize = aRectangle.GetSize(); } void MetaFloatTransparentAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); maMtf.Write( rOStm ); TypeSerializer aSerializer(rOStm); aSerializer.writePoint(maPoint); aSerializer.writeSize(maSize); aSerializer.writeGradient(maGradient); } void MetaFloatTransparentAction::Read(SvStream& rIStm, ImplMetaReadData* pData) { VersionCompat aCompat(rIStm, StreamMode::READ); ReadGDIMetaFile(rIStm, maMtf, pData); TypeSerializer aSerializer(rIStm); aSerializer.readPoint(maPoint); aSerializer.readSize(maSize); aSerializer.readGradient(maGradient); } MetaEPSAction::MetaEPSAction() : MetaAction(MetaActionType::EPS) {} MetaEPSAction::~MetaEPSAction() {} MetaEPSAction::MetaEPSAction( const Point& rPoint, const Size& rSize, const GfxLink& rGfxLink, const GDIMetaFile& rSubst ) : MetaAction ( MetaActionType::EPS ), maGfxLink ( rGfxLink ), maSubst ( rSubst ), maPoint ( rPoint ), maSize ( rSize ) {} void MetaEPSAction::Execute( OutputDevice* pOut ) { pOut->DrawEPS( maPoint, maSize, maGfxLink, &maSubst ); } rtl::Reference MetaEPSAction::Clone() { return new MetaEPSAction( *this ); } void MetaEPSAction::Move( long nHorzMove, long nVertMove ) { maPoint.Move( nHorzMove, nVertMove ); } void MetaEPSAction::Scale( double fScaleX, double fScaleY ) { tools::Rectangle aRectangle(maPoint, maSize); ImplScaleRect( aRectangle, fScaleX, fScaleY ); maPoint = aRectangle.TopLeft(); maSize = aRectangle.GetSize(); } void MetaEPSAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); TypeSerializer aSerializer(rOStm); aSerializer.writeGfxLink(maGfxLink); aSerializer.writePoint(maPoint); aSerializer.writeSize(maSize); maSubst.Write( rOStm ); } void MetaEPSAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); TypeSerializer aSerializer(rIStm); aSerializer.readGfxLink(maGfxLink); aSerializer.readPoint(maPoint); aSerializer.readSize(maSize); ReadGDIMetaFile( rIStm, maSubst ); } MetaRefPointAction::MetaRefPointAction() : MetaAction ( MetaActionType::REFPOINT ), mbSet ( false ) {} MetaRefPointAction::~MetaRefPointAction() {} MetaRefPointAction::MetaRefPointAction( const Point& rRefPoint, bool bSet ) : MetaAction ( MetaActionType::REFPOINT ), maRefPoint ( rRefPoint ), mbSet ( bSet ) {} void MetaRefPointAction::Execute( OutputDevice* pOut ) { if( mbSet ) pOut->SetRefPoint( maRefPoint ); else pOut->SetRefPoint(); } rtl::Reference MetaRefPointAction::Clone() { return new MetaRefPointAction( *this ); } void MetaRefPointAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); TypeSerializer aSerializer(rOStm); aSerializer.writePoint(maRefPoint); rOStm.WriteBool( mbSet ); } void MetaRefPointAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); TypeSerializer aSerializer(rIStm); aSerializer.readPoint(maRefPoint); rIStm.ReadCharAsBool( mbSet ); } MetaCommentAction::MetaCommentAction() : MetaAction ( MetaActionType::COMMENT ), mnValue ( 0 ) { ImplInitDynamicData( nullptr, 0UL ); } MetaCommentAction::MetaCommentAction( const MetaCommentAction& rAct ) : MetaAction ( MetaActionType::COMMENT ), maComment ( rAct.maComment ), mnValue ( rAct.mnValue ) { ImplInitDynamicData( rAct.mpData.get(), rAct.mnDataSize ); } MetaCommentAction::MetaCommentAction( const OString& rComment, sal_Int32 nValue, const sal_uInt8* pData, sal_uInt32 nDataSize ) : MetaAction ( MetaActionType::COMMENT ), maComment ( rComment ), mnValue ( nValue ) { ImplInitDynamicData( pData, nDataSize ); } MetaCommentAction::~MetaCommentAction() { } void MetaCommentAction::ImplInitDynamicData( const sal_uInt8* pData, sal_uInt32 nDataSize ) { if ( nDataSize && pData ) { mnDataSize = nDataSize; mpData.reset( new sal_uInt8[ mnDataSize ] ); memcpy( mpData.get(), pData, mnDataSize ); } else { mnDataSize = 0; mpData = nullptr; } } void MetaCommentAction::Execute( OutputDevice* pOut ) { if ( pOut->GetConnectMetaFile() ) { pOut->GetConnectMetaFile()->AddAction( this ); } } rtl::Reference MetaCommentAction::Clone() { return new MetaCommentAction( *this ); } void MetaCommentAction::Move( long nXMove, long nYMove ) { if ( nXMove || nYMove ) { if ( mnDataSize && mpData ) { bool bPathStroke = (maComment == "XPATHSTROKE_SEQ_BEGIN"); if ( bPathStroke || maComment == "XPATHFILL_SEQ_BEGIN" ) { SvMemoryStream aMemStm( static_cast(mpData.get()), mnDataSize, StreamMode::READ ); SvMemoryStream aDest; if ( bPathStroke ) { SvtGraphicStroke aStroke; ReadSvtGraphicStroke( aMemStm, aStroke ); tools::Polygon aPath; aStroke.getPath( aPath ); aPath.Move( nXMove, nYMove ); aStroke.setPath( aPath ); tools::PolyPolygon aStartArrow; aStroke.getStartArrow(aStartArrow); aStartArrow.Move(nXMove, nYMove); aStroke.setStartArrow(aStartArrow); tools::PolyPolygon aEndArrow; aStroke.getEndArrow(aEndArrow); aEndArrow.Move(nXMove, nYMove); aStroke.setEndArrow(aEndArrow); WriteSvtGraphicStroke( aDest, aStroke ); } else { SvtGraphicFill aFill; ReadSvtGraphicFill( aMemStm, aFill ); tools::PolyPolygon aPath; aFill.getPath( aPath ); aPath.Move( nXMove, nYMove ); aFill.setPath( aPath ); WriteSvtGraphicFill( aDest, aFill ); } mpData.reset(); ImplInitDynamicData( static_cast( aDest.GetData() ), aDest.Tell() ); } } } } // SJ: 25.07.06 #i56656# we are not able to mirror certain kind of // comments properly, especially the XPATHSTROKE and XPATHFILL lead to // problems, so it is better to remove these comments when mirroring // FIXME: fake comment to apply the next hunk in the right location void MetaCommentAction::Scale( double fXScale, double fYScale ) { if ( ( fXScale != 1.0 ) || ( fYScale != 1.0 ) ) { if ( mnDataSize && mpData ) { bool bPathStroke = (maComment == "XPATHSTROKE_SEQ_BEGIN"); if ( bPathStroke || maComment == "XPATHFILL_SEQ_BEGIN" ) { SvMemoryStream aMemStm( static_cast(mpData.get()), mnDataSize, StreamMode::READ ); SvMemoryStream aDest; if ( bPathStroke ) { SvtGraphicStroke aStroke; ReadSvtGraphicStroke( aMemStm, aStroke ); aStroke.scale( fXScale, fYScale ); WriteSvtGraphicStroke( aDest, aStroke ); } else { SvtGraphicFill aFill; ReadSvtGraphicFill( aMemStm, aFill ); tools::PolyPolygon aPath; aFill.getPath( aPath ); aPath.Scale( fXScale, fYScale ); aFill.setPath( aPath ); WriteSvtGraphicFill( aDest, aFill ); } mpData.reset(); ImplInitDynamicData( static_cast( aDest.GetData() ), aDest.Tell() ); } else if( maComment == "EMF_PLUS_HEADER_INFO" ){ SvMemoryStream aMemStm( static_cast(mpData.get()), mnDataSize, StreamMode::READ ); SvMemoryStream aDest; sal_Int32 nLeft(0), nRight(0), nTop(0), nBottom(0); sal_Int32 nPixX(0), nPixY(0), nMillX(0), nMillY(0); float m11(0), m12(0), m21(0), m22(0), mdx(0), mdy(0); // read data aMemStm.ReadInt32( nLeft ).ReadInt32( nTop ).ReadInt32( nRight ).ReadInt32( nBottom ); aMemStm.ReadInt32( nPixX ).ReadInt32( nPixY ).ReadInt32( nMillX ).ReadInt32( nMillY ); aMemStm.ReadFloat( m11 ).ReadFloat( m12 ).ReadFloat( m21 ).ReadFloat( m22 ).ReadFloat( mdx ).ReadFloat( mdy ); // add scale to the transformation m11 *= fXScale; m12 *= fXScale; m22 *= fYScale; m21 *= fYScale; // prepare new data aDest.WriteInt32( nLeft ).WriteInt32( nTop ).WriteInt32( nRight ).WriteInt32( nBottom ); aDest.WriteInt32( nPixX ).WriteInt32( nPixY ).WriteInt32( nMillX ).WriteInt32( nMillY ); aDest.WriteFloat( m11 ).WriteFloat( m12 ).WriteFloat( m21 ).WriteFloat( m22 ).WriteFloat( mdx ).WriteFloat( mdy ); // save them ImplInitDynamicData( static_cast( aDest.GetData() ), aDest.Tell() ); } } } } void MetaCommentAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); write_uInt16_lenPrefixed_uInt8s_FromOString(rOStm, maComment); rOStm.WriteInt32( mnValue ).WriteUInt32( mnDataSize ); if ( mnDataSize ) rOStm.WriteBytes( mpData.get(), mnDataSize ); } void MetaCommentAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); maComment = read_uInt16_lenPrefixed_uInt8s_ToOString(rIStm); rIStm.ReadInt32( mnValue ).ReadUInt32( mnDataSize ); if (mnDataSize > rIStm.remainingSize()) { SAL_WARN("vcl.gdi", "Parsing error: " << rIStm.remainingSize() << " available data, but " << mnDataSize << " claimed, truncating"); mnDataSize = rIStm.remainingSize(); } SAL_INFO("vcl.gdi", "MetaCommentAction::Read " << maComment); mpData.reset(); if( mnDataSize ) { mpData.reset(new sal_uInt8[ mnDataSize ]); rIStm.ReadBytes(mpData.get(), mnDataSize); } } MetaLayoutModeAction::MetaLayoutModeAction() : MetaAction ( MetaActionType::LAYOUTMODE ), mnLayoutMode( ComplexTextLayoutFlags::Default ) {} MetaLayoutModeAction::~MetaLayoutModeAction() {} MetaLayoutModeAction::MetaLayoutModeAction( ComplexTextLayoutFlags nLayoutMode ) : MetaAction ( MetaActionType::LAYOUTMODE ), mnLayoutMode( nLayoutMode ) {} void MetaLayoutModeAction::Execute( OutputDevice* pOut ) { pOut->SetLayoutMode( mnLayoutMode ); } rtl::Reference MetaLayoutModeAction::Clone() { return new MetaLayoutModeAction( *this ); } void MetaLayoutModeAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); rOStm.WriteUInt32( static_cast(mnLayoutMode) ); } void MetaLayoutModeAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); sal_uInt32 tmp; rIStm.ReadUInt32( tmp ); mnLayoutMode = static_cast(tmp); } MetaTextLanguageAction::MetaTextLanguageAction() : MetaAction ( MetaActionType::TEXTLANGUAGE ), meTextLanguage( LANGUAGE_DONTKNOW ) {} MetaTextLanguageAction::~MetaTextLanguageAction() {} MetaTextLanguageAction::MetaTextLanguageAction( LanguageType eTextLanguage ) : MetaAction ( MetaActionType::TEXTLANGUAGE ), meTextLanguage( eTextLanguage ) {} void MetaTextLanguageAction::Execute( OutputDevice* pOut ) { pOut->SetDigitLanguage( meTextLanguage ); } rtl::Reference MetaTextLanguageAction::Clone() { return new MetaTextLanguageAction( *this ); } void MetaTextLanguageAction::Write( SvStream& rOStm, ImplMetaWriteData* pData ) { MetaAction::Write(rOStm, pData); VersionCompat aCompat(rOStm, StreamMode::WRITE, 1); rOStm.WriteUInt16( static_cast(meTextLanguage) ); } void MetaTextLanguageAction::Read( SvStream& rIStm, ImplMetaReadData* ) { VersionCompat aCompat(rIStm, StreamMode::READ); sal_uInt16 nTmp = 0; rIStm.ReadUInt16( nTmp ); meTextLanguage = static_cast(nTmp); } /* vim:set shiftwidth=4 softtabstop=4 expandtab: */