summaryrefslogtreecommitdiffstats
path: root/vcl/source/gdi/metaact.cxx
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 16:51:28 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 16:51:28 +0000
commit940b4d1848e8c70ab7642901a68594e8016caffc (patch)
treeeb72f344ee6c3d9b80a7ecc079ea79e9fba8676d /vcl/source/gdi/metaact.cxx
parentInitial commit. (diff)
downloadlibreoffice-upstream.tar.xz
libreoffice-upstream.zip
Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'vcl/source/gdi/metaact.cxx')
-rw-r--r--vcl/source/gdi/metaact.cxx3412
1 files changed, 3412 insertions, 0 deletions
diff --git a/vcl/source/gdi/metaact.cxx b/vcl/source/gdi/metaact.cxx
new file mode 100644
index 000000000..0f55e2fbe
--- /dev/null
+++ b/vcl/source/gdi/metaact.cxx
@@ -0,0 +1,3412 @@
+/* -*- 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 <stdio.h>
+#include <string.h>
+#include <osl/thread.h>
+#include <sal/log.hxx>
+#include <tools/stream.hxx>
+#include <tools/vcompat.hxx>
+#include <tools/helpers.hxx>
+#include <vcl/dibtools.hxx>
+#include <vcl/outdev.hxx>
+#include <vcl/metaact.hxx>
+#include <vcl/graphictools.hxx>
+#include <unotools/fontdefs.hxx>
+#include <TypeSerializer.hxx>
+
+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<unsigned int>(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> 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<sal_uInt16>(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<MetaActionType>(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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<sal_uLong>(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<MetaAction> 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<sal_uInt16>(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<DrawTextFlags>(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<MetaAction> 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<FontStrikeout>(nTempStrikeout);
+
+ sal_uInt32 nTempUnderline(0);
+ rIStm.ReadUInt32( nTempUnderline );
+ meUnderline = static_cast<FontLineStyle>(nTempUnderline);
+
+ if (aCompat.GetVersion() >= 2)
+ {
+ sal_uInt32 nTempOverline(0);
+ rIStm.ReadUInt32(nTempOverline);
+ meOverline = static_cast<FontLineStyle>(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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<TextAlign>(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<MetaAction> 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<MetaAction> 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<MetaAction> 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<sal_uInt16>(mnFlags) );
+}
+
+void MetaPushAction::Read( SvStream& rIStm, ImplMetaReadData* )
+{
+ VersionCompat aCompat(rIStm, StreamMode::READ);
+ sal_uInt16 tmp;
+ rIStm.ReadUInt16( tmp );
+ mnFlags = static_cast<PushFlags>(tmp);
+}
+
+MetaPopAction::MetaPopAction() :
+ MetaAction(MetaActionType::POP)
+{}
+
+MetaPopAction::~MetaPopAction()
+{}
+
+void MetaPopAction::Execute( OutputDevice* pOut )
+{
+ pOut->Pop();
+}
+
+rtl::Reference<MetaAction> 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<MetaAction> 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<sal_uInt16>(meRasterOp) );
+}
+
+void MetaRasterOpAction::Read( SvStream& rIStm, ImplMetaReadData* )
+{
+ sal_uInt16 nTmp16(0);
+
+ VersionCompat aCompat(rIStm, StreamMode::READ);
+ rIStm.ReadUInt16( nTmp16 ); meRasterOp = static_cast<RasterOp>(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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<MetaAction> 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<void*>(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<const sal_uInt8*>( 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<void*>(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<const sal_uInt8*>( aDest.GetData() ), aDest.Tell() );
+ } else if( maComment == "EMF_PLUS_HEADER_INFO" ){
+ SvMemoryStream aMemStm( static_cast<void*>(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<const sal_uInt8*>( 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<MetaAction> 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<sal_uInt32>(mnLayoutMode) );
+}
+
+void MetaLayoutModeAction::Read( SvStream& rIStm, ImplMetaReadData* )
+{
+ VersionCompat aCompat(rIStm, StreamMode::READ);
+ sal_uInt32 tmp;
+ rIStm.ReadUInt32( tmp );
+ mnLayoutMode = static_cast<ComplexTextLayoutFlags>(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<MetaAction> 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<sal_uInt16>(meTextLanguage) );
+}
+
+void MetaTextLanguageAction::Read( SvStream& rIStm, ImplMetaReadData* )
+{
+ VersionCompat aCompat(rIStm, StreamMode::READ);
+ sal_uInt16 nTmp = 0;
+ rIStm.ReadUInt16( nTmp );
+ meTextLanguage = static_cast<LanguageType>(nTmp);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-30 00:32:22 +0000