Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1721 insertions, 0 deletions

diff --git a/include/vcl/metaact.hxx b/include/vcl/metaact.hxx
new file mode 100644
index 000000000..fad89ec4b
--- /dev/null
+++ b/include/vcl/metaact.hxx
@@ -0,0 +1,1721 @@
+/* -*- 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 .
+ */
+
+#ifndef INCLUDED_VCL_METAACT_HXX
+#define INCLUDED_VCL_METAACT_HXX
+
+#include <config_options.h>
+#include <memory>
+#include <vcl/dllapi.h>
+#include <vcl/gradient.hxx>
+#include <vcl/hatch.hxx>
+#include <vcl/wall.hxx>
+#include <vcl/font.hxx>
+#include <tools/poly.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/region.hxx>
+#include <vcl/outdevstate.hxx>
+#include <vcl/gdimtf.hxx>
+#include <vcl/gfxlink.hxx>
+#include <vcl/lineinfo.hxx>
+#include <vcl/metaactiontypes.hxx>
+#include <salhelper/simplereferenceobject.hxx>
+#include <rtl/ref.hxx>
+
+class OutputDevice;
+class SvStream;
+enum class DrawTextFlags;
+
+struct ImplMetaReadData
+{
+    rtl_TextEncoding meActualCharSet;
+    int mnParseDepth;
+
+    ImplMetaReadData()
+        : meActualCharSet(RTL_TEXTENCODING_ASCII_US)
+        , mnParseDepth(0)
+    {}
+};
+
+struct ImplMetaWriteData
+{
+    rtl_TextEncoding meActualCharSet;
+
+    ImplMetaWriteData() :
+        meActualCharSet( RTL_TEXTENCODING_ASCII_US )
+    {}
+};
+
+class VCL_DLLPUBLIC MetaAction : public salhelper::SimpleReferenceObject
+{
+private:
+    MetaActionType       mnType;
+
+protected:
+    virtual             ~MetaAction() override;
+
+public:
+                        MetaAction();
+    explicit            MetaAction( MetaActionType nType );
+                        MetaAction( MetaAction const & );
+
+    virtual void        Execute( OutputDevice* pOut );
+
+    oslInterlockedCount GetRefCount() const { return m_nCount; }
+
+    virtual rtl::Reference<MetaAction> Clone();
+
+    virtual void        Move( long nHorzMove, long nVertMove );
+    virtual void        Scale( double fScaleX, double fScaleY );
+
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData );
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData );
+
+    MetaActionType      GetType() const { return mnType; }
+    /** \#i10613# Extracted from Printer::GetPreparedMetaFile. Returns true
+        if given action requires special transparency handling
+    */
+    virtual bool        IsTransparent() const { return false; }
+
+public:
+    static MetaAction*  ReadMetaAction( SvStream& rIStm, ImplMetaReadData* pData );
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaPixelAction final : public MetaAction
+{
+private:
+    Point               maPt;
+    Color               maColor;
+
+public:
+                        MetaPixelAction();
+    MetaPixelAction(MetaPixelAction const &) = default;
+    MetaPixelAction(MetaPixelAction &&) = default;
+    MetaPixelAction & operator =(MetaPixelAction const &) = delete; // due to MetaAction
+    MetaPixelAction & operator =(MetaPixelAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaPixelAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaPixelAction( const Point& rPt, const Color& rColor );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const Point&        GetPoint() const { return maPt; }
+    const Color&        GetColor() const { return maColor; }
+};
+
+class SAL_DLLPUBLIC_RTTI MetaPointAction final : public MetaAction
+{
+private:
+    Point               maPt;
+
+public:
+                        MetaPointAction();
+    MetaPointAction(MetaPointAction const &) = default;
+    MetaPointAction(MetaPointAction &&) = default;
+    MetaPointAction & operator =(MetaPointAction const &) = delete; // due to MetaAction
+    MetaPointAction & operator =(MetaPointAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaPointAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    explicit            MetaPointAction( const Point& );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const Point&        GetPoint() const { return maPt; }
+};
+
+class VCL_DLLPUBLIC MetaLineAction final : public MetaAction
+{
+private:
+
+    LineInfo            maLineInfo;
+    Point               maStartPt;
+    Point               maEndPt;
+
+public:
+                        MetaLineAction();
+    MetaLineAction(MetaLineAction const &) = default;
+    MetaLineAction(MetaLineAction &&) = default;
+    MetaLineAction & operator =(MetaLineAction const &) = delete; // due to MetaAction
+    MetaLineAction & operator =(MetaLineAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaLineAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaLineAction( const Point& rStart, const Point& rEnd );
+                        MetaLineAction( const Point& rStart, const Point& rEnd,
+                                        const LineInfo& rLineInfo );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const Point&        GetStartPoint() const { return maStartPt; }
+    const Point&        GetEndPoint() const { return maEndPt; }
+    const LineInfo&     GetLineInfo() const { return maLineInfo; }
+};
+
+class VCL_DLLPUBLIC MetaRectAction final : public MetaAction
+{
+private:
+
+    tools::Rectangle           maRect;
+
+public:
+                        MetaRectAction();
+    MetaRectAction(MetaRectAction const &) = default;
+    MetaRectAction(MetaRectAction &&) = default;
+    MetaRectAction & operator =(MetaRectAction const &) = delete; // due to MetaAction
+    MetaRectAction & operator =(MetaRectAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaRectAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    explicit            MetaRectAction( const tools::Rectangle& );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const tools::Rectangle&    GetRect() const { return maRect; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaRoundRectAction final : public MetaAction
+{
+private:
+
+    tools::Rectangle           maRect;
+    sal_uInt32          mnHorzRound;
+    sal_uInt32          mnVertRound;
+
+public:
+                        MetaRoundRectAction();
+    MetaRoundRectAction(MetaRoundRectAction const &) = default;
+    MetaRoundRectAction(MetaRoundRectAction &&) = default;
+    MetaRoundRectAction & operator =(MetaRoundRectAction const &) = delete; // due to MetaAction
+    MetaRoundRectAction & operator =(MetaRoundRectAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaRoundRectAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaRoundRectAction( const tools::Rectangle& rRect,
+                                             sal_uInt32 nHorzRound, sal_uInt32 nVertRound );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const tools::Rectangle&    GetRect() const { return maRect; }
+    sal_uInt32          GetHorzRound() const { return mnHorzRound; }
+    sal_uInt32          GetVertRound() const { return mnVertRound; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaEllipseAction final : public MetaAction
+{
+private:
+
+    tools::Rectangle           maRect;
+
+public:
+                        MetaEllipseAction();
+    MetaEllipseAction(MetaEllipseAction const &) = default;
+    MetaEllipseAction(MetaEllipseAction &&) = default;
+    MetaEllipseAction & operator =(MetaEllipseAction const &) = delete; // due to MetaAction
+    MetaEllipseAction & operator =(MetaEllipseAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaEllipseAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    explicit            MetaEllipseAction( const tools::Rectangle& );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const tools::Rectangle&    GetRect() const { return maRect; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaArcAction final : public MetaAction
+{
+private:
+
+    tools::Rectangle           maRect;
+    Point               maStartPt;
+    Point               maEndPt;
+
+public:
+                        MetaArcAction();
+    MetaArcAction(MetaArcAction const &) = default;
+    MetaArcAction(MetaArcAction &&) = default;
+    MetaArcAction & operator =(MetaArcAction const &) = delete; // due to MetaAction
+    MetaArcAction & operator =(MetaArcAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaArcAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaArcAction( const tools::Rectangle& rRect,
+                                       const Point& rStart, const Point& rEnd );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const tools::Rectangle&    GetRect() const { return maRect; }
+    const Point&        GetStartPoint() const { return maStartPt; }
+    const Point&        GetEndPoint() const { return maEndPt; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaPieAction final : public MetaAction
+{
+private:
+
+    tools::Rectangle           maRect;
+    Point               maStartPt;
+    Point               maEndPt;
+
+public:
+                        MetaPieAction();
+    MetaPieAction(MetaPieAction const &) = default;
+    MetaPieAction(MetaPieAction &&) = default;
+    MetaPieAction & operator =(MetaPieAction const &) = delete; // due to MetaAction
+    MetaPieAction & operator =(MetaPieAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaPieAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaPieAction( const tools::Rectangle& rRect,
+                                       const Point& rStart, const Point& rEnd );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const tools::Rectangle&    GetRect() const { return maRect; }
+    const Point&        GetStartPoint() const { return maStartPt; }
+    const Point&        GetEndPoint() const { return maEndPt; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaChordAction final : public MetaAction
+{
+private:
+
+    tools::Rectangle           maRect;
+    Point               maStartPt;
+    Point               maEndPt;
+
+public:
+                        MetaChordAction();
+    MetaChordAction(MetaChordAction const &) = default;
+    MetaChordAction(MetaChordAction &&) = default;
+    MetaChordAction & operator =(MetaChordAction const &) = delete; // due to MetaAction
+    MetaChordAction & operator =(MetaChordAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaChordAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaChordAction( const tools::Rectangle& rRect,
+                                         const Point& rStart, const Point& rEnd );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const tools::Rectangle&    GetRect() const { return maRect; }
+    const Point&        GetStartPoint() const { return maStartPt; }
+    const Point&        GetEndPoint() const { return maEndPt; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaPolyLineAction final : public MetaAction
+{
+private:
+
+    LineInfo            maLineInfo;
+    tools::Polygon      maPoly;
+
+public:
+                        MetaPolyLineAction();
+    MetaPolyLineAction(MetaPolyLineAction const &) = default;
+    MetaPolyLineAction(MetaPolyLineAction &&) = default;
+    MetaPolyLineAction & operator =(MetaPolyLineAction const &) = delete; // due to MetaAction
+    MetaPolyLineAction & operator =(MetaPolyLineAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaPolyLineAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    explicit            MetaPolyLineAction( const tools::Polygon& );
+    explicit            MetaPolyLineAction( const tools::Polygon&, const LineInfo& );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const tools::Polygon& GetPolygon() const { return maPoly; }
+    const LineInfo&     GetLineInfo() const { return maLineInfo; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaPolygonAction final : public MetaAction
+{
+private:
+
+    tools::Polygon      maPoly;
+
+public:
+                        MetaPolygonAction();
+    MetaPolygonAction(MetaPolygonAction const &) = default;
+    MetaPolygonAction(MetaPolygonAction &&) = default;
+    MetaPolygonAction & operator =(MetaPolygonAction const &) = delete; // due to MetaAction
+    MetaPolygonAction & operator =(MetaPolygonAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaPolygonAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    explicit            MetaPolygonAction( const tools::Polygon& );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const tools::Polygon& GetPolygon() const { return maPoly; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaPolyPolygonAction final : public MetaAction
+{
+private:
+
+    tools::PolyPolygon  maPolyPoly;
+
+public:
+                        MetaPolyPolygonAction();
+    MetaPolyPolygonAction(MetaPolyPolygonAction const &) = default;
+    MetaPolyPolygonAction(MetaPolyPolygonAction &&) = default;
+    MetaPolyPolygonAction & operator =(MetaPolyPolygonAction const &) = delete; // due to MetaAction
+    MetaPolyPolygonAction & operator =(MetaPolyPolygonAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaPolyPolygonAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    explicit            MetaPolyPolygonAction( const tools::PolyPolygon& );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const tools::PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }
+};
+
+class SAL_DLLPUBLIC_RTTI MetaTextAction final : public MetaAction
+{
+private:
+
+    Point           maPt;
+    OUString        maStr;
+    sal_Int32       mnIndex;
+    sal_Int32       mnLen;
+
+public:
+                        MetaTextAction();
+    MetaTextAction(MetaTextAction const &) = default;
+    MetaTextAction(MetaTextAction &&) = default;
+    MetaTextAction & operator =(MetaTextAction const &) = delete; // due to MetaAction
+    MetaTextAction & operator =(MetaTextAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaTextAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    MetaTextAction( const Point& rPt, const OUString& rStr,
+                    sal_Int32 nIndex, sal_Int32 nLen );
+
+    virtual void    Move( long nHorzMove, long nVertMove ) override;
+    virtual void    Scale( double fScaleX, double fScaleY ) override;
+
+    const Point&    GetPoint() const { return maPt; }
+    const OUString& GetText() const { return maStr; }
+    sal_Int32       GetIndex() const { return mnIndex; }
+    sal_Int32       GetLen() const { return mnLen; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaTextArrayAction final : public MetaAction
+{
+private:
+
+    Point       maStartPt;
+    OUString    maStr;
+    std::unique_ptr<long[]>
+                mpDXAry;
+    sal_Int32   mnIndex;
+    sal_Int32   mnLen;
+
+    virtual             ~MetaTextArrayAction() override;
+
+public:
+                        MetaTextArrayAction();
+                        MetaTextArrayAction( const MetaTextArrayAction& rAction );
+    MetaTextArrayAction( const Point& rStartPt, const OUString& rStr,
+                         const long* pDXAry, sal_Int32 nIndex,
+                         sal_Int32 nLen );
+
+    virtual void        Execute( OutputDevice* pOut ) override;
+
+    virtual rtl::Reference<MetaAction> Clone() override;
+
+    virtual void    Move( long nHorzMove, long nVertMove ) override;
+    virtual void    Scale( double fScaleX, double fScaleY ) override;
+
+    virtual void    Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void    Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    const Point&    GetPoint() const { return maStartPt; }
+    const OUString& GetText() const { return maStr; }
+    sal_Int32       GetIndex() const { return mnIndex; }
+    sal_Int32       GetLen() const { return mnLen; }
+    long*           GetDXArray() const { return mpDXAry.get(); }
+};
+
+class SAL_DLLPUBLIC_RTTI MetaStretchTextAction final : public MetaAction
+{
+private:
+
+    Point       maPt;
+    OUString    maStr;
+    sal_uInt32  mnWidth;
+    sal_Int32   mnIndex;
+    sal_Int32   mnLen;
+
+public:
+                        MetaStretchTextAction();
+    MetaStretchTextAction(MetaStretchTextAction const &) = default;
+    MetaStretchTextAction(MetaStretchTextAction &&) = default;
+    MetaStretchTextAction & operator =(MetaStretchTextAction const &) = delete; // due to MetaAction
+    MetaStretchTextAction & operator =(MetaStretchTextAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaStretchTextAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    MetaStretchTextAction( const Point& rPt, sal_uInt32 nWidth,
+                           const OUString& rStr,
+                           sal_Int32 nIndex, sal_Int32 nLen );
+
+    virtual void    Move( long nHorzMove, long nVertMove ) override;
+    virtual void    Scale( double fScaleX, double fScaleY ) override;
+
+    const Point&    GetPoint() const { return maPt; }
+    const OUString& GetText() const { return maStr; }
+    sal_uInt32      GetWidth() const { return mnWidth; }
+    sal_Int32       GetIndex() const { return mnIndex; }
+    sal_Int32       GetLen() const { return mnLen; }
+};
+
+class SAL_DLLPUBLIC_RTTI MetaTextRectAction final : public MetaAction
+{
+private:
+
+    tools::Rectangle           maRect;
+    OUString            maStr;
+    DrawTextFlags       mnStyle;
+
+public:
+                        MetaTextRectAction();
+    MetaTextRectAction(MetaTextRectAction const &) = default;
+    MetaTextRectAction(MetaTextRectAction &&) = default;
+    MetaTextRectAction & operator =(MetaTextRectAction const &) = delete; // due to MetaAction
+    MetaTextRectAction & operator =(MetaTextRectAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaTextRectAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    MetaTextRectAction( const tools::Rectangle& rRect,
+                        const OUString& rStr, DrawTextFlags nStyle );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const tools::Rectangle&    GetRect() const { return maRect; }
+    const OUString&     GetText() const { return maStr; }
+    DrawTextFlags       GetStyle() const { return mnStyle; }
+};
+
+class SAL_DLLPUBLIC_RTTI MetaTextLineAction final : public MetaAction
+{
+private:
+
+    Point               maPos;
+    long                mnWidth;
+    FontStrikeout       meStrikeout;
+    FontLineStyle       meUnderline;
+    FontLineStyle       meOverline;
+
+public:
+                        MetaTextLineAction();
+    MetaTextLineAction(MetaTextLineAction const &) = default;
+    MetaTextLineAction(MetaTextLineAction &&) = default;
+    MetaTextLineAction & operator =(MetaTextLineAction const &) = delete; // due to MetaAction
+    MetaTextLineAction & operator =(MetaTextLineAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaTextLineAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaTextLineAction( const Point& rPos, long nWidth,
+                                            FontStrikeout eStrikeout,
+                                            FontLineStyle eUnderline,
+                                            FontLineStyle eOverline );
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const Point&        GetStartPoint() const { return maPos; }
+    long                GetWidth() const { return mnWidth; }
+    FontStrikeout       GetStrikeout() const { return meStrikeout; }
+    FontLineStyle       GetUnderline() const { return meUnderline; }
+    FontLineStyle       GetOverline()  const { return meOverline; }
+};
+
+class VCL_DLLPUBLIC MetaBmpAction final : public MetaAction
+{
+private:
+
+    Bitmap              maBmp;
+    Point               maPt;
+
+public:
+                        MetaBmpAction();
+    MetaBmpAction(MetaBmpAction const &) = default;
+    MetaBmpAction(MetaBmpAction &&) = default;
+    MetaBmpAction & operator =(MetaBmpAction const &) = delete; // due to MetaAction
+    MetaBmpAction & operator =(MetaBmpAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaBmpAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaBmpAction( const Point& rPt, const Bitmap& rBmp );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const Bitmap&       GetBitmap() const { return maBmp; }
+    const Point&        GetPoint() const { return maPt; }
+};
+
+class VCL_DLLPUBLIC MetaBmpScaleAction final : public MetaAction
+{
+private:
+
+    Bitmap              maBmp;
+    Point               maPt;
+    Size                maSz;
+
+public:
+                        MetaBmpScaleAction();
+    MetaBmpScaleAction(MetaBmpScaleAction const &) = default;
+    MetaBmpScaleAction(MetaBmpScaleAction &&) = default;
+    MetaBmpScaleAction & operator =(MetaBmpScaleAction const &) = delete; // due to MetaAction
+    MetaBmpScaleAction & operator =(MetaBmpScaleAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaBmpScaleAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaBmpScaleAction( const Point& rPt, const Size& rSz,
+                                            const Bitmap& rBmp );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const Bitmap&       GetBitmap() const { return maBmp; }
+    const Point&        GetPoint() const { return maPt; }
+    const Size&         GetSize() const { return maSz; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaBmpScalePartAction final : public MetaAction
+{
+private:
+
+    Bitmap              maBmp;
+    Point               maDstPt;
+    Size                maDstSz;
+    Point               maSrcPt;
+    Size                maSrcSz;
+
+public:
+                        MetaBmpScalePartAction();
+    MetaBmpScalePartAction(MetaBmpScalePartAction const &) = default;
+    MetaBmpScalePartAction(MetaBmpScalePartAction &&) = default;
+    MetaBmpScalePartAction & operator =(MetaBmpScalePartAction const &) = delete; // due to MetaAction
+    MetaBmpScalePartAction & operator =(MetaBmpScalePartAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaBmpScalePartAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaBmpScalePartAction( const Point& rDstPt, const Size& rDstSz,
+                                                const Point& rSrcPt, const Size& rSrcSz,
+                                                const Bitmap& rBmp );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const Bitmap&       GetBitmap() const { return maBmp; }
+    const Point&        GetDestPoint() const { return maDstPt; }
+    const Size&         GetDestSize() const { return maDstSz; }
+    const Point&        GetSrcPoint() const { return maSrcPt; }
+    const Size&         GetSrcSize() const { return maSrcSz; }
+};
+
+class VCL_DLLPUBLIC MetaBmpExAction final : public MetaAction
+{
+private:
+
+    BitmapEx            maBmpEx;
+    Point               maPt;
+
+public:
+                        MetaBmpExAction();
+    MetaBmpExAction(MetaBmpExAction const &) = default;
+    MetaBmpExAction(MetaBmpExAction &&) = default;
+    MetaBmpExAction & operator =(MetaBmpExAction const &) = delete; // due to MetaAction
+    MetaBmpExAction & operator =(MetaBmpExAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaBmpExAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaBmpExAction( const Point& rPt, const BitmapEx& rBmpEx );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const BitmapEx&     GetBitmapEx() const { return maBmpEx; }
+    const Point&        GetPoint() const { return maPt; }
+    bool                IsTransparent() const override { return GetBitmapEx().IsTransparent(); }
+};
+
+class VCL_DLLPUBLIC MetaBmpExScaleAction final : public MetaAction
+{
+private:
+
+    BitmapEx            maBmpEx;
+    Point               maPt;
+    Size                maSz;
+
+public:
+                        MetaBmpExScaleAction();
+    MetaBmpExScaleAction(MetaBmpExScaleAction const &) = default;
+    MetaBmpExScaleAction(MetaBmpExScaleAction &&) = default;
+    MetaBmpExScaleAction & operator =(MetaBmpExScaleAction const &) = delete; // due to MetaAction
+    MetaBmpExScaleAction & operator =(MetaBmpExScaleAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaBmpExScaleAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaBmpExScaleAction( const Point& rPt, const Size& rSz,
+                                              const BitmapEx& rBmpEx ) ;
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const BitmapEx&     GetBitmapEx() const { return maBmpEx; }
+    const Point&        GetPoint() const { return maPt; }
+    const Size&         GetSize() const { return maSz; }
+    bool                IsTransparent() const override { return GetBitmapEx().IsTransparent(); }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaBmpExScalePartAction final : public MetaAction
+{
+private:
+
+    BitmapEx            maBmpEx;
+    Point               maDstPt;
+    Size                maDstSz;
+    Point               maSrcPt;
+    Size                maSrcSz;
+
+public:
+                        MetaBmpExScalePartAction();
+    MetaBmpExScalePartAction(MetaBmpExScalePartAction const &) = default;
+    MetaBmpExScalePartAction(MetaBmpExScalePartAction &&) = default;
+    MetaBmpExScalePartAction & operator =(MetaBmpExScalePartAction const &) = delete; // due to MetaAction
+    MetaBmpExScalePartAction & operator =(MetaBmpExScalePartAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaBmpExScalePartAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaBmpExScalePartAction( const Point& rDstPt, const Size& rDstSz,
+                                                  const Point& rSrcPt, const Size& rSrcSz,
+                                                  const BitmapEx& rBmpEx );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const BitmapEx&     GetBitmapEx() const { return maBmpEx; }
+    const Point&        GetDestPoint() const { return maDstPt; }
+    const Size&         GetDestSize() const { return maDstSz; }
+    const Point&        GetSrcPoint() const { return maSrcPt; }
+    const Size&         GetSrcSize() const { return maSrcSz; }
+    bool                IsTransparent() const override { return GetBitmapEx().IsTransparent(); }
+};
+
+class SAL_DLLPUBLIC_RTTI MetaMaskAction final : public MetaAction
+{
+private:
+
+    Bitmap              maBmp;
+    Color               maColor;
+    Point               maPt;
+
+public:
+                        MetaMaskAction();
+    MetaMaskAction(MetaMaskAction const &) = default;
+    MetaMaskAction(MetaMaskAction &&) = default;
+    MetaMaskAction & operator =(MetaMaskAction const &) = delete; // due to MetaAction
+    MetaMaskAction & operator =(MetaMaskAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaMaskAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaMaskAction( const Point& rPt,
+                                        const Bitmap& rBmp,
+                                        const Color& rColor );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const Bitmap&       GetBitmap() const { return maBmp; }
+    const Color&        GetColor() const { return maColor; }
+    const Point&        GetPoint() const { return maPt; }
+};
+
+class SAL_DLLPUBLIC_RTTI MetaMaskScaleAction final : public MetaAction
+{
+private:
+
+    Bitmap              maBmp;
+    Color               maColor;
+    Point               maPt;
+    Size                maSz;
+
+public:
+                        MetaMaskScaleAction();
+    MetaMaskScaleAction(MetaMaskScaleAction const &) = default;
+    MetaMaskScaleAction(MetaMaskScaleAction &&) = default;
+    MetaMaskScaleAction & operator =(MetaMaskScaleAction const &) = delete; // due to MetaAction
+    MetaMaskScaleAction & operator =(MetaMaskScaleAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaMaskScaleAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaMaskScaleAction( const Point& rPt, const Size& rSz,
+                                             const Bitmap& rBmp,
+                                             const Color& rColor );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const Bitmap&       GetBitmap() const { return maBmp; }
+    const Color&        GetColor() const { return maColor; }
+    const Point&        GetPoint() const { return maPt; }
+    const Size&         GetSize() const { return maSz; }
+};
+
+class SAL_DLLPUBLIC_RTTI MetaMaskScalePartAction final : public MetaAction
+{
+private:
+
+    Bitmap              maBmp;
+    Color               maColor;
+    Point               maDstPt;
+    Size                maDstSz;
+    Point               maSrcPt;
+    Size                maSrcSz;
+
+public:
+                        MetaMaskScalePartAction();
+    MetaMaskScalePartAction(MetaMaskScalePartAction const &) = default;
+    MetaMaskScalePartAction(MetaMaskScalePartAction &&) = default;
+    MetaMaskScalePartAction & operator =(MetaMaskScalePartAction const &) = delete; // due to MetaAction
+    MetaMaskScalePartAction & operator =(MetaMaskScalePartAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaMaskScalePartAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaMaskScalePartAction( const Point& rDstPt, const Size& rDstSz,
+                                                 const Point& rSrcPt, const Size& rSrcSz,
+                                                 const Bitmap& rBmp,
+                                                 const Color& rColor );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const Bitmap&       GetBitmap() const { return maBmp; }
+    const Color&        GetColor() const { return maColor; }
+    const Point&        GetDestPoint() const { return maDstPt; }
+    const Size&         GetDestSize() const { return maDstSz; }
+    const Point&        GetSrcPoint() const { return maSrcPt; }
+    const Size&         GetSrcSize() const { return maSrcSz; }
+};
+
+class SAL_DLLPUBLIC_RTTI MetaGradientAction final : public MetaAction
+{
+private:
+
+    tools::Rectangle           maRect;
+    Gradient            maGradient;
+
+public:
+                        MetaGradientAction();
+    MetaGradientAction(MetaGradientAction const &) = default;
+    MetaGradientAction(MetaGradientAction &&) = default;
+    MetaGradientAction & operator =(MetaGradientAction const &) = delete; // due to MetaAction
+    MetaGradientAction & operator =(MetaGradientAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaGradientAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaGradientAction( const tools::Rectangle& rRect, const Gradient& rGradient );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const tools::Rectangle&    GetRect() const { return maRect; }
+    const Gradient&     GetGradient() const { return maGradient; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaGradientExAction final : public MetaAction
+{
+private:
+
+    tools::PolyPolygon  maPolyPoly;
+    Gradient            maGradient;
+
+public:
+                        MetaGradientExAction();
+    MetaGradientExAction(MetaGradientExAction const &) = default;
+    MetaGradientExAction(MetaGradientExAction &&) = default;
+    MetaGradientExAction & operator =(MetaGradientExAction const &) = delete; // due to MetaAction
+    MetaGradientExAction & operator =(MetaGradientExAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaGradientExAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaGradientExAction( const tools::PolyPolygon& rPolyPoly, const Gradient& rGradient );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const tools::PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }
+    const Gradient&     GetGradient() const { return maGradient; }
+};
+
+class SAL_DLLPUBLIC_RTTI MetaHatchAction final : public MetaAction
+{
+private:
+
+    tools::PolyPolygon  maPolyPoly;
+    Hatch               maHatch;
+
+public:
+                        MetaHatchAction();
+    MetaHatchAction(MetaHatchAction const &) = default;
+    MetaHatchAction(MetaHatchAction &&) = default;
+    MetaHatchAction & operator =(MetaHatchAction const &) = delete; // due to MetaAction
+    MetaHatchAction & operator =(MetaHatchAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaHatchAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaHatchAction( const tools::PolyPolygon& rPolyPoly, const Hatch& rHatch );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const tools::PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }
+    const Hatch&        GetHatch() const { return maHatch; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaWallpaperAction final : public MetaAction
+{
+private:
+
+    tools::Rectangle           maRect;
+    Wallpaper           maWallpaper;
+
+public:
+                        MetaWallpaperAction();
+    MetaWallpaperAction(MetaWallpaperAction const &) = default;
+    MetaWallpaperAction(MetaWallpaperAction &&) = default;
+    MetaWallpaperAction & operator =(MetaWallpaperAction const &) = delete; // due to MetaAction
+    MetaWallpaperAction & operator =(MetaWallpaperAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaWallpaperAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaWallpaperAction( const tools::Rectangle& rRect,
+                                             const Wallpaper& rPaper );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const tools::Rectangle&    GetRect() const { return maRect; }
+    const Wallpaper&    GetWallpaper() const { return maWallpaper; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaClipRegionAction final : public MetaAction
+{
+private:
+
+    vcl::Region         maRegion;
+    bool                mbClip;
+
+public:
+                        MetaClipRegionAction();
+    MetaClipRegionAction(MetaClipRegionAction const &) = default;
+    MetaClipRegionAction(MetaClipRegionAction &&) = default;
+    MetaClipRegionAction & operator =(MetaClipRegionAction const &) = delete; // due to MetaAction
+    MetaClipRegionAction & operator =(MetaClipRegionAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaClipRegionAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaClipRegionAction( const vcl::Region& rRegion, bool bClip );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const vcl::Region&  GetRegion() const { return maRegion; }
+    bool                IsClipping() const { return mbClip; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaISectRectClipRegionAction final : public MetaAction
+{
+private:
+
+    tools::Rectangle           maRect;
+
+public:
+                        MetaISectRectClipRegionAction();
+    MetaISectRectClipRegionAction(MetaISectRectClipRegionAction const &) = default;
+    MetaISectRectClipRegionAction(MetaISectRectClipRegionAction &&) = default;
+    MetaISectRectClipRegionAction & operator =(MetaISectRectClipRegionAction const &) = delete; // due to MetaAction
+    MetaISectRectClipRegionAction & operator =(MetaISectRectClipRegionAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaISectRectClipRegionAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    explicit            MetaISectRectClipRegionAction( const tools::Rectangle& );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const tools::Rectangle&    GetRect() const { return maRect; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaISectRegionClipRegionAction final : public MetaAction
+{
+private:
+
+    vcl::Region          maRegion;
+
+public:
+                        MetaISectRegionClipRegionAction();
+    MetaISectRegionClipRegionAction(MetaISectRegionClipRegionAction const &) = default;
+    MetaISectRegionClipRegionAction(MetaISectRegionClipRegionAction &&) = default;
+    MetaISectRegionClipRegionAction & operator =(MetaISectRegionClipRegionAction const &) = delete; // due to MetaAction
+    MetaISectRegionClipRegionAction & operator =(MetaISectRegionClipRegionAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaISectRegionClipRegionAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    explicit            MetaISectRegionClipRegionAction( const vcl::Region& );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const vcl::Region&  GetRegion() const { return maRegion; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaMoveClipRegionAction final : public MetaAction
+{
+private:
+
+    long                mnHorzMove;
+    long                mnVertMove;
+
+public:
+                        MetaMoveClipRegionAction();
+    MetaMoveClipRegionAction(MetaMoveClipRegionAction const &) = default;
+    MetaMoveClipRegionAction(MetaMoveClipRegionAction &&) = default;
+    MetaMoveClipRegionAction & operator =(MetaMoveClipRegionAction const &) = delete; // due to MetaAction
+    MetaMoveClipRegionAction & operator =(MetaMoveClipRegionAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaMoveClipRegionAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaMoveClipRegionAction( long nHorzMove, long nVertMove );
+
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    long                GetHorzMove() const { return mnHorzMove; }
+    long                GetVertMove() const { return mnVertMove; }
+};
+
+class VCL_DLLPUBLIC MetaLineColorAction final : public MetaAction
+{
+private:
+
+    Color               maColor;
+    bool                mbSet;
+
+public:
+                        MetaLineColorAction();
+    MetaLineColorAction(MetaLineColorAction const &) = default;
+    MetaLineColorAction(MetaLineColorAction &&) = default;
+    MetaLineColorAction & operator =(MetaLineColorAction const &) = delete; // due to MetaAction
+    MetaLineColorAction & operator =(MetaLineColorAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaLineColorAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaLineColorAction( const Color& rColor, bool bSet );
+
+    const Color&        GetColor() const { return maColor; }
+    bool                IsSetting() const { return mbSet; }
+};
+
+class VCL_DLLPUBLIC MetaFillColorAction final : public MetaAction
+{
+private:
+
+    Color               maColor;
+    bool                mbSet;
+
+public:
+                        MetaFillColorAction();
+    MetaFillColorAction(MetaFillColorAction const &) = default;
+    MetaFillColorAction(MetaFillColorAction &&) = default;
+    MetaFillColorAction & operator =(MetaFillColorAction const &) = delete; // due to MetaAction
+    MetaFillColorAction & operator =(MetaFillColorAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaFillColorAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaFillColorAction( const Color& rColor, bool bSet );
+
+    const Color&        GetColor() const { return maColor; }
+    bool                IsSetting() const { return mbSet; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaTextColorAction final : public MetaAction
+{
+private:
+
+    Color               maColor;
+
+public:
+                        MetaTextColorAction();
+    MetaTextColorAction(MetaTextColorAction const &) = default;
+    MetaTextColorAction(MetaTextColorAction &&) = default;
+    MetaTextColorAction & operator =(MetaTextColorAction const &) = delete; // due to MetaAction
+    MetaTextColorAction & operator =(MetaTextColorAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaTextColorAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    explicit            MetaTextColorAction( const Color& );
+
+    const Color&        GetColor() const { return maColor; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaTextFillColorAction final : public MetaAction
+{
+private:
+
+    Color               maColor;
+    bool                mbSet;
+
+public:
+                        MetaTextFillColorAction();
+    MetaTextFillColorAction(MetaTextFillColorAction const &) = default;
+    MetaTextFillColorAction(MetaTextFillColorAction &&) = default;
+    MetaTextFillColorAction & operator =(MetaTextFillColorAction const &) = delete; // due to MetaAction
+    MetaTextFillColorAction & operator =(MetaTextFillColorAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaTextFillColorAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaTextFillColorAction( const Color& rColor, bool bSet );
+
+    const Color&        GetColor() const { return maColor; }
+    bool                IsSetting() const { return mbSet; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaTextLineColorAction final : public MetaAction
+{
+private:
+
+    Color               maColor;
+    bool                mbSet;
+
+public:
+                        MetaTextLineColorAction();
+    MetaTextLineColorAction(MetaTextLineColorAction const &) = default;
+    MetaTextLineColorAction(MetaTextLineColorAction &&) = default;
+    MetaTextLineColorAction & operator =(MetaTextLineColorAction const &) = delete; // due to MetaAction
+    MetaTextLineColorAction & operator =(MetaTextLineColorAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaTextLineColorAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaTextLineColorAction( const Color& rColor, bool bSet );
+
+    const Color&        GetColor() const { return maColor; }
+    bool                IsSetting() const { return mbSet; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaOverlineColorAction final : public MetaAction
+{
+private:
+
+    Color               maColor;
+    bool                mbSet;
+
+public:
+                        MetaOverlineColorAction();
+    MetaOverlineColorAction(MetaOverlineColorAction const &) = default;
+    MetaOverlineColorAction(MetaOverlineColorAction &&) = default;
+    MetaOverlineColorAction & operator =(MetaOverlineColorAction const &) = delete; // due to MetaAction
+    MetaOverlineColorAction & operator =(MetaOverlineColorAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaOverlineColorAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaOverlineColorAction( const Color& rColor, bool bSet );
+
+    const Color&        GetColor() const { return maColor; }
+    bool                IsSetting() const { return mbSet; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaTextAlignAction final : public MetaAction
+{
+private:
+
+    TextAlign           maAlign;
+
+public:
+                        MetaTextAlignAction();
+    MetaTextAlignAction(MetaTextAlignAction const &) = default;
+    MetaTextAlignAction(MetaTextAlignAction &&) = default;
+    MetaTextAlignAction & operator =(MetaTextAlignAction const &) = delete; // due to MetaAction
+    MetaTextAlignAction & operator =(MetaTextAlignAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaTextAlignAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    explicit            MetaTextAlignAction( TextAlign eAlign );
+
+    TextAlign           GetTextAlign() const { return maAlign; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaMapModeAction final : public MetaAction
+{
+private:
+
+    MapMode             maMapMode;
+
+public:
+                        MetaMapModeAction();
+    MetaMapModeAction(MetaMapModeAction const &) = default;
+    MetaMapModeAction(MetaMapModeAction &&) = default;
+    MetaMapModeAction & operator =(MetaMapModeAction const &) = delete; // due to MetaAction
+    MetaMapModeAction & operator =(MetaMapModeAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaMapModeAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    explicit            MetaMapModeAction( const MapMode& );
+
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const MapMode&      GetMapMode() const { return maMapMode; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaFontAction final : public MetaAction
+{
+private:
+
+    vcl::Font           maFont;
+
+public:
+                        MetaFontAction();
+    MetaFontAction(MetaFontAction const &) = default;
+    MetaFontAction(MetaFontAction &&) = default;
+    MetaFontAction & operator =(MetaFontAction const &) = delete; // due to MetaAction
+    MetaFontAction & operator =(MetaFontAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaFontAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    explicit            MetaFontAction( const vcl::Font& );
+
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const vcl::Font&    GetFont() const { return maFont; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaPushAction final : public MetaAction
+{
+private:
+
+    PushFlags           mnFlags;
+
+public:
+                        MetaPushAction();
+    MetaPushAction(MetaPushAction const &) = default;
+    MetaPushAction(MetaPushAction &&) = default;
+    MetaPushAction & operator =(MetaPushAction const &) = delete; // due to MetaAction
+    MetaPushAction & operator =(MetaPushAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaPushAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    explicit            MetaPushAction( PushFlags nFlags );
+
+    PushFlags           GetFlags() const { return mnFlags; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaPopAction final : public MetaAction
+{
+public:
+
+                        MetaPopAction();
+    MetaPopAction(MetaPopAction const &) = default;
+    MetaPopAction(MetaPopAction &&) = default;
+    MetaPopAction & operator =(MetaPopAction const &) = delete; // due to MetaAction
+    MetaPopAction & operator =(MetaPopAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaPopAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaRasterOpAction final : public MetaAction
+{
+private:
+
+    RasterOp            meRasterOp;
+
+public:
+                        MetaRasterOpAction();
+    MetaRasterOpAction(MetaRasterOpAction const &) = default;
+    MetaRasterOpAction(MetaRasterOpAction &&) = default;
+    MetaRasterOpAction & operator =(MetaRasterOpAction const &) = delete; // due to MetaAction
+    MetaRasterOpAction & operator =(MetaRasterOpAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaRasterOpAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    explicit            MetaRasterOpAction( RasterOp eRasterOp );
+
+    RasterOp            GetRasterOp() const { return meRasterOp; }
+};
+
+class SAL_DLLPUBLIC_RTTI MetaTransparentAction final : public MetaAction
+{
+private:
+
+    tools::PolyPolygon  maPolyPoly;
+    sal_uInt16          mnTransPercent;
+
+public:
+                        MetaTransparentAction();
+    MetaTransparentAction(MetaTransparentAction const &) = default;
+    MetaTransparentAction(MetaTransparentAction &&) = default;
+    MetaTransparentAction & operator =(MetaTransparentAction const &) = delete; // due to MetaAction
+    MetaTransparentAction & operator =(MetaTransparentAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaTransparentAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaTransparentAction( const tools::PolyPolygon& rPolyPoly, sal_uInt16 nTransPercent );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const tools::PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }
+    sal_uInt16              GetTransparence() const { return mnTransPercent; }
+
+    bool                IsTransparent() const override { return true; }
+};
+
+class SAL_DLLPUBLIC_RTTI MetaFloatTransparentAction final : public MetaAction
+{
+private:
+
+    GDIMetaFile         maMtf;
+    Point               maPoint;
+    Size                maSize;
+    Gradient            maGradient;
+
+public:
+                        MetaFloatTransparentAction();
+    MetaFloatTransparentAction(MetaFloatTransparentAction const &) = default;
+    MetaFloatTransparentAction(MetaFloatTransparentAction &&) = default;
+    MetaFloatTransparentAction & operator =(MetaFloatTransparentAction const &) = delete; // due to MetaAction
+    MetaFloatTransparentAction & operator =(MetaFloatTransparentAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaFloatTransparentAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaFloatTransparentAction( const GDIMetaFile& rMtf, const Point& rPos,
+                                                    const Size& rSize, const Gradient& rGradient );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const GDIMetaFile&  GetGDIMetaFile() const { return maMtf; }
+    const Point&        GetPoint() const { return maPoint; }
+    const Size&         GetSize() const { return maSize; }
+    const Gradient&     GetGradient() const { return maGradient; }
+    bool                IsTransparent() const override { return true; }
+};
+
+class VCL_DLLPUBLIC MetaEPSAction final : public MetaAction
+{
+private:
+
+    GfxLink             maGfxLink;
+    GDIMetaFile         maSubst;
+    Point               maPoint;
+    Size                maSize;
+
+public:
+                        MetaEPSAction();
+    MetaEPSAction(MetaEPSAction const &) = default;
+    MetaEPSAction(MetaEPSAction &&) = default;
+    MetaEPSAction & operator =(MetaEPSAction const &) = delete; // due to MetaAction
+    MetaEPSAction & operator =(MetaEPSAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaEPSAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaEPSAction( const Point& rPoint, const Size& rSize,
+                                       const GfxLink& rGfxLink, const GDIMetaFile& rSubst );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    const GfxLink&      GetLink() const { return maGfxLink; }
+    const GDIMetaFile&  GetSubstitute() const { return maSubst; }
+    const Point&        GetPoint() const { return maPoint; }
+    const Size&         GetSize() const { return maSize; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaRefPointAction final : public MetaAction
+{
+private:
+
+    Point               maRefPoint;
+    bool                mbSet;
+
+public:
+                        MetaRefPointAction();
+    MetaRefPointAction(MetaRefPointAction const &) = default;
+    MetaRefPointAction(MetaRefPointAction &&) = default;
+    MetaRefPointAction & operator =(MetaRefPointAction const &) = delete; // due to MetaAction
+    MetaRefPointAction & operator =(MetaRefPointAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaRefPointAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+                        MetaRefPointAction( const Point& rRefPoint, bool bSet );
+
+    const Point&        GetRefPoint() const { return maRefPoint; }
+    bool                IsSetting() const { return mbSet; }
+};
+
+class VCL_DLLPUBLIC MetaCommentAction final : public MetaAction
+{
+private:
+
+    OString             maComment;
+    sal_Int32           mnValue;
+    sal_uInt32          mnDataSize;
+    std::unique_ptr<sal_uInt8[]>
+                        mpData;
+
+    SAL_DLLPRIVATE void ImplInitDynamicData( const sal_uInt8* pData, sal_uInt32 nDataSize );
+
+private:
+    virtual             ~MetaCommentAction() override;
+
+public:
+    explicit            MetaCommentAction();
+    explicit            MetaCommentAction( const MetaCommentAction& rAct );
+    explicit            MetaCommentAction( const OString& rComment, sal_Int32 nValue = 0, const sal_uInt8* pData = nullptr, sal_uInt32 nDataSize = 0 );
+
+    virtual void        Move( long nHorzMove, long nVertMove ) override;
+    virtual void        Scale( double fScaleX, double fScaleY ) override;
+
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    const OString&      GetComment() const { return maComment; }
+    sal_Int32           GetValue() const { return mnValue; }
+    sal_uInt32          GetDataSize() const { return mnDataSize; }
+    const sal_uInt8*    GetData() const { return mpData.get(); }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaLayoutModeAction final : public MetaAction
+{
+private:
+
+    ComplexTextLayoutFlags  mnLayoutMode;
+
+public:
+                        MetaLayoutModeAction();
+    MetaLayoutModeAction(MetaLayoutModeAction const &) = default;
+    MetaLayoutModeAction(MetaLayoutModeAction &&) = default;
+    MetaLayoutModeAction & operator =(MetaLayoutModeAction const &) = delete; // due to MetaAction
+    MetaLayoutModeAction & operator =(MetaLayoutModeAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaLayoutModeAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    explicit            MetaLayoutModeAction( ComplexTextLayoutFlags nLayoutMode );
+
+    ComplexTextLayoutFlags  GetLayoutMode() const { return mnLayoutMode; }
+};
+
+class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaTextLanguageAction final : public MetaAction
+{
+private:
+
+    LanguageType        meTextLanguage;
+
+public:
+                        MetaTextLanguageAction();
+    MetaTextLanguageAction(MetaTextLanguageAction const &) = default;
+    MetaTextLanguageAction(MetaTextLanguageAction &&) = default;
+    MetaTextLanguageAction & operator =(MetaTextLanguageAction const &) = delete; // due to MetaAction
+    MetaTextLanguageAction & operator =(MetaTextLanguageAction &&) = delete; // due to MetaAction
+private:
+    virtual             ~MetaTextLanguageAction() override;
+public:
+    virtual void        Execute( OutputDevice* pOut ) override;
+    virtual rtl::Reference<MetaAction> Clone() override;
+    virtual void        Write( SvStream& rOStm, ImplMetaWriteData* pData ) override;
+    virtual void        Read( SvStream& rIStm, ImplMetaReadData* pData ) override;
+
+    explicit            MetaTextLanguageAction( LanguageType );
+
+    LanguageType        GetTextLanguage() const { return meTextLanguage; }
+};
+
+#endif // INCLUDED_VCL_METAACT_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */