vcl/html/metaact_8hxx_source.html

/* -*- 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 <sal/config.h>


#include <config_options.h>


#include <o3tl/span.hxx>

#include <rtl/ref.hxx>

#include <salhelper/simplereferenceobject.hxx>

#include <tools/poly.hxx>


#include <vcl/dllapi.h>

#include <vcl/rendercontext/State.hxx>

#include <vcl/bitmapex.hxx>

#include <vcl/font.hxx>

#include <vcl/gdimtf.hxx>

#include <vcl/gfxlink.hxx>

#include <vcl/gradient.hxx>

#include <vcl/hatch.hxx>

#include <vcl/lineinfo.hxx>

#include <vcl/metaactiontypes.hxx>

#include <vcl/region.hxx>

#include <vcl/rendercontext/RasterOp.hxx>

#include <vcl/wall.hxx>


#include <memory>


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() const;


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove );

    virtual void        Scale( double fScaleX, double fScaleY );


    MetaActionType      GetType() const { return mnType; }

    virtual bool        IsTransparent() const { return false; }

};


class 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() const override;


                        MetaPixelAction( const Point& rPt, const Color& rColor );


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const Point&        GetPoint() const { return maPt; }

    const Color&        GetColor() const { return maColor; }

    void                SetPoint(const Point& rPt) { maPt = rPt; }

    void                SetColor(Color rColor) { maColor = rColor; }

};


class VCL_DLLPUBLIC 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() const override;


    explicit            MetaPointAction( const Point& );


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const Point&        GetPoint() const { return maPt; }

    void                SetPoint(const Point& rPt) { maPt = rPt; }

};


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() const override;


                        MetaLineAction( const Point& rStart, const Point& rEnd );

                        MetaLineAction( const Point& rStart, const Point& rEnd,

                                        LineInfo aLineInfo );


    virtual void        Move( tools::Long nHorzMove, tools::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; }

    void                SetStartPoint(const Point& rPoint) { maStartPt = rPoint; }

    void                SetEndPoint(const Point& rPoint) { maEndPt = rPoint; }

    void                SetLineInfo(const LineInfo& rLineInfo) { maLineInfo = rLineInfo; }

};


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() const override;


    explicit            MetaRectAction( const tools::Rectangle& );


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const tools::Rectangle&    GetRect() const { return maRect; }

    void                SetRect(const tools::Rectangle& rRect) { maRect = rRect; }

};


class 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() const override;


                        MetaRoundRectAction( const tools::Rectangle& rRect,

                                             sal_uInt32 nHorzRound, sal_uInt32 nVertRound );


    virtual void        Move( tools::Long nHorzMove, tools::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; }

    void                SetRect(const tools::Rectangle& rRect) { maRect = rRect; }

    void                SetHorzRound(sal_uInt32 rHorzRound) { mnHorzRound = rHorzRound; }

    void                SetVertRound(sal_uInt32 rVertRound) { mnVertRound = rVertRound; }

};


class 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() const override;


    explicit            MetaEllipseAction( const tools::Rectangle& );


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const tools::Rectangle&    GetRect() const { return maRect; }

    void                SetRect(const tools::Rectangle& rRect) { maRect = rRect; }

};


class 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() const override;


                        MetaArcAction( const tools::Rectangle& rRect,

                                       const Point& rStart, const Point& rEnd );


    virtual void        Move( tools::Long nHorzMove, tools::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; }

    void                SetRect(const tools::Rectangle& rRect) { maRect = rRect; }

    void                SetStartPoint(const Point& rPoint) { maStartPt = rPoint; }

    void                SetEndPoint(const Point& rPoint) { maEndPt = rPoint; }

};


class 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() const override;


                        MetaPieAction( const tools::Rectangle& rRect,

                                       const Point& rStart, const Point& rEnd );


    virtual void        Move( tools::Long nHorzMove, tools::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; }

    void                SetRect(const tools::Rectangle& rRect) { maRect = rRect; }

    void                SetStartPoint(const Point& rPoint) { maStartPt = rPoint; }

    void                SetEndPoint(const Point& rPoint) { maEndPt = rPoint; }

};


class 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() const override;


                        MetaChordAction( const tools::Rectangle& rRect,

                                         const Point& rStart, const Point& rEnd );


    virtual void        Move( tools::Long nHorzMove, tools::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; }

    void                SetRect(const tools::Rectangle& rRect) { maRect = rRect; }

    void                SetStartPoint(const Point& rPoint) { maStartPt = rPoint; }

    void                SetEndPoint(const Point& rPoint) { maEndPt = rPoint; }

};


class 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() const override;


    explicit            MetaPolyLineAction( tools::Polygon  );

    explicit            MetaPolyLineAction( tools::Polygon , LineInfo  );


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const tools::Polygon& GetPolygon() const { return maPoly; }

    const LineInfo&     GetLineInfo() const { return maLineInfo; }

    void                SetLineInfo(const LineInfo& rLineInfo) { maLineInfo = rLineInfo; }

    void                SetPolygon(const tools::Polygon& rPoly) { maPoly = rPoly; }

};


class 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() const override;


    explicit            MetaPolygonAction( tools::Polygon  );


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const tools::Polygon& GetPolygon() const { return maPoly; }

    void                SetPolygon(const tools::Polygon& rPoly) { maPoly = rPoly; }

};


class 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() const override;


    explicit            MetaPolyPolygonAction( tools::PolyPolygon  );


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const tools::PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }

    void                SetPolyPolygon(const tools::PolyPolygon& rPolyPoly) { maPolyPoly = rPolyPoly; }

};


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() const override;


    MetaTextAction( const Point& rPt, OUString aStr,

                    sal_Int32 nIndex, sal_Int32 nLen );


    virtual void    Move( tools::Long nHorzMove, tools::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; }

    void            SetPoint(const Point& rPt) { maPt = rPt; }

    void            SetText(const OUString& rStr) { maStr = rStr; }

    void            SetIndex(sal_Int32 rIndex) { mnIndex = rIndex; }

    void            SetLen(sal_Int32 rLen) { mnLen = rLen; }

};


class UNLESS_MERGELIBS(VCL_DLLPUBLIC) MetaTextArrayAction final : public MetaAction

{

private:


    Point       maStartPt;

    OUString    maStr;

    std::vector<sal_Int32> maDXAry;

    std::vector<sal_Bool> maKashidaAry;

    sal_Int32   mnIndex;

    sal_Int32   mnLen;


    virtual             ~MetaTextArrayAction() override;


public:

                        MetaTextArrayAction();

                        MetaTextArrayAction( const MetaTextArrayAction& rAction );

    MetaTextArrayAction( const Point& rStartPt, OUString aStr,

                         std::vector<sal_Int32> rDXAry,

                         std::vector<sal_Bool> pKashidaAry,

                         sal_Int32 nIndex,

                         sal_Int32 nLen );

    MetaTextArrayAction( const Point& rStartPt, OUString aStr,

                         o3tl::span<const sal_Int32> pDXAry,

                         o3tl::span<const sal_Bool> pKashidaAry,

                         sal_Int32 nIndex,

                         sal_Int32 nLen );


    virtual void        Execute( OutputDevice* pOut ) override;


    virtual rtl::Reference<MetaAction> Clone() const override;


    virtual void    Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void    Scale( double fScaleX, double fScaleY ) 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; }

    const std::vector<sal_Int32> & GetDXArray() const { return maDXAry; }

    const std::vector<sal_Bool> & GetKashidaArray() const { return maKashidaAry; }

    void            SetPoint(const Point& rPt) { maStartPt = rPt; }

    void            SetText(const OUString& rStr) { maStr = rStr; }

    void            SetIndex(sal_Int32 rIndex) { mnIndex = rIndex; }

    void            SetLen(sal_Int32 rLen) { mnLen = rLen; }

    void            SetDXArray(std::vector<sal_Int32> aArray);

    void            SetKashidaArray(std::vector<sal_Bool> aArray);

};


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() const override;


    MetaStretchTextAction( const Point& rPt, sal_uInt32 nWidth,

                           OUString aStr,

                           sal_Int32 nIndex, sal_Int32 nLen );


    virtual void    Move( tools::Long nHorzMove, tools::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; }

    void            SetPoint(const Point& rPt) { maPt = rPt; }

    void            SetText(const OUString& rStr) { maStr = rStr; }

    void            SetWidth(sal_uInt32 rWidth) { mnWidth = rWidth; }

    void            SetIndex(sal_uInt32 rIndex) { mnIndex = rIndex; }

    void            SetLen(sal_uInt32 rLen) { mnLen = rLen; }

};


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() const override;


    MetaTextRectAction( const tools::Rectangle& rRect,

                        OUString aStr, DrawTextFlags nStyle );


    virtual void        Move( tools::Long nHorzMove, tools::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; }

    void                SetRect(const tools::Rectangle& rRect) { maRect = rRect; }

    void                SetText(const OUString& rStr) { maStr = rStr; }

    void                SetStyle(DrawTextFlags rStyle) { mnStyle = rStyle; }

};


class SAL_DLLPUBLIC_RTTI MetaTextLineAction final : public MetaAction

{

private:


    Point               maPos;

    tools::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() const override;


                        MetaTextLineAction( const Point& rPos, tools::Long nWidth,

                                            FontStrikeout eStrikeout,

                                            FontLineStyle eUnderline,

                                            FontLineStyle eOverline );

    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const Point&        GetStartPoint() const { return maPos; }

    tools::Long                GetWidth() const { return mnWidth; }

    FontStrikeout       GetStrikeout() const { return meStrikeout; }

    FontLineStyle       GetUnderline() const { return meUnderline; }

    FontLineStyle       GetOverline()  const { return meOverline; }

    void                SetStartPoint(const Point& rPos) { maPos = rPos; }

    void                SetWidth(tools::Long rWidth) { mnWidth = rWidth; }

    void                SetStrikeout(FontStrikeout eStrikeout) { meStrikeout = eStrikeout; }

    void                SetUnderline(FontLineStyle eUnderline) { meUnderline = eUnderline; }

    void                SetOverline(FontLineStyle eOverline) { meOverline = eOverline; }

};


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() const override;


                        MetaBmpAction( const Point& rPt, const Bitmap& rBmp );


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const Bitmap&       GetBitmap() const { return maBmp; }

    const Point&        GetPoint() const { return maPt; }

    void                SetBitmap(const Bitmap& rBmp) { maBmp = rBmp; }

    void                SetPoint(const Point& rPt) { maPt = rPt; }

};


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() const override;


                        MetaBmpScaleAction( const Point& rPt, const Size& rSz,

                                            const Bitmap& rBmp );


    virtual void        Move( tools::Long nHorzMove, tools::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; }

    void                SetBitmap(const Bitmap& rBmp) { maBmp = rBmp; }

    void                SetPoint(const Point& rPt) { maPt = rPt; }

    void                SetSize(const Size& rSz) { maSz = rSz; }

};


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() const override;


                        MetaBmpScalePartAction( const Point& rDstPt, const Size& rDstSz,

                                                const Point& rSrcPt, const Size& rSrcSz,

                                                const Bitmap& rBmp );


    virtual void        Move( tools::Long nHorzMove, tools::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; }

    void                SetBitmap(const Bitmap& rBmp) { maBmp = rBmp; }

    void                SetDestPoint(const Point& rPt) { maDstPt = rPt; }

    void                SetDestSize(const Size& rSz) { maDstSz = rSz; }

    void                SetSrcPoint(const Point& rPt) { maSrcPt = rPt; }

    void                SetSrcSize(const Size& rSz) { maSrcSz = rSz; }

};


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() const override;


                        MetaBmpExAction( const Point& rPt, const BitmapEx& rBmpEx );


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const BitmapEx&     GetBitmapEx() const { return maBmpEx; }

    const Point&        GetPoint() const { return maPt; }

    void                SetBitmapEx(BitmapEx rBmpEx) { maBmpEx = rBmpEx; }

    void                SetPoint(const Point& rPt) { maPt = rPt; }

    bool                IsTransparent() const override { return GetBitmapEx().IsAlpha(); }

};


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() const override;


                        MetaBmpExScaleAction( const Point& rPt, const Size& rSz,

                                              const BitmapEx& rBmpEx ) ;


    virtual void        Move( tools::Long nHorzMove, tools::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; }

    void                SetBitmapEx(const BitmapEx& rBmpEx) { maBmpEx = rBmpEx; }

    void                SetPoint(const Point& rPt) { maPt = rPt; }

    void                SetSize(const Size& rSz) { maSz = rSz; }

    bool                IsTransparent() const override { return GetBitmapEx().IsAlpha(); }

};


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() const override;


                        MetaBmpExScalePartAction( const Point& rDstPt, const Size& rDstSz,

                                                  const Point& rSrcPt, const Size& rSrcSz,

                                                  const BitmapEx& rBmpEx );


    virtual void        Move( tools::Long nHorzMove, tools::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; }

    void                SetBitmapEx(const BitmapEx& rBmpEx) { maBmpEx = rBmpEx; }

    void                SetDestPoint(const Point& rDstPt) { maDstPt = rDstPt; }

    void                SetDestSize(const Size& rDstSz) { maDstSz = rDstSz; }

    void                SetSrcPoint(const Point& rSrcPt) { maSrcPt = rSrcPt; }

    void                SetSrcSize(const Size& rSrcSz) { maSrcSz = rSrcSz; }

    bool                IsTransparent() const override { return GetBitmapEx().IsAlpha(); }

};


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() const override;


                        MetaMaskAction( const Point& rPt,

                                        const Bitmap& rBmp,

                                        const Color& rColor );


    virtual void        Move( tools::Long nHorzMove, tools::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; }

    void                SetBitmap(const Bitmap& rBmp) { maBmp = rBmp; }

    void                SetPoint(const Point& rPt) { maPt = rPt; }

};


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() const override;


                        MetaMaskScaleAction( const Point& rPt, const Size& rSz,

                                             const Bitmap& rBmp,

                                             const Color& rColor );


    virtual void        Move( tools::Long nHorzMove, tools::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; }

    void                SetBitmap(const Bitmap& rBmp) { maBmp = rBmp; }

    void                SetPoint(const Point& rPt) { maPt = rPt; }

    void                SetSize(const Size& rSz) { maSz = rSz; }

};


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() const override;


                        MetaMaskScalePartAction( const Point& rDstPt, const Size& rDstSz,

                                                 const Point& rSrcPt, const Size& rSrcSz,

                                                 const Bitmap& rBmp,

                                                 const Color& rColor );


    virtual void        Move( tools::Long nHorzMove, tools::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; }

    void                SetBitmap(const Bitmap& rBmp) { maBmp = rBmp; }

    void                SetColor(Color rColor) { maColor = rColor; }

    void                SetDestPoint(const Point& rPt) { maDstPt = rPt; }

    void                SetDestSize(const Size& rSz) { maDstSz = rSz; }

    void                SetSrcPoint(const Point& rPt) { maSrcPt = rPt; }

    void                SetSrcSize(const Size& rSz) { maSrcSz = rSz; }

};


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() const override;


                        MetaGradientAction( const tools::Rectangle& rRect, Gradient aGradient );


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const tools::Rectangle&    GetRect() const { return maRect; }

    const Gradient&     GetGradient() const { return maGradient; }

    void                SetGradient(const Gradient& rGradient) { maGradient = rGradient; }

    void                SetRect(const tools::Rectangle& rRect) { maRect = rRect; }

};


class 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() const override;


                        MetaGradientExAction( tools::PolyPolygon  rPolyPoly, Gradient aGradient );


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const tools::PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }

    const Gradient&     GetGradient() const { return maGradient; }

    void                SetPolyPolygon(const tools::PolyPolygon& rPolyPoly) { maPolyPoly = rPolyPoly; }

    void                SetGradient(const Gradient& rGradient) { maGradient = rGradient; }

};


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() const override;


                        MetaHatchAction( tools::PolyPolygon aPolyPoly, const Hatch& rHatch );


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const tools::PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }

    const Hatch&        GetHatch() const { return maHatch; }

    void                SetPolyPolygon(const tools::PolyPolygon& rPolyPoly) { maPolyPoly = rPolyPoly; }

    void                SetHatch(const Hatch& rHatch) { maHatch = rHatch; }

};


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() const override;


                        MetaWallpaperAction( const tools::Rectangle& rRect,

                                             const Wallpaper& rPaper );


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const tools::Rectangle&    GetRect() const { return maRect; }

    const Wallpaper&    GetWallpaper() const { return maWallpaper; }

    void                SetWallpaper(const Wallpaper& rWallpaper) { maWallpaper = rWallpaper; }

};


class 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() const override;


                        MetaClipRegionAction( vcl::Region aRegion, bool bClip );


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const vcl::Region&  GetRegion() const { return maRegion; }

    bool                IsClipping() const { return mbClip; }

    void                SetRegion(const vcl::Region& rRegion) { maRegion = rRegion; }

    void                SetClipping(bool bClip) { mbClip = bClip; }

};


class 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() const override;


    explicit            MetaISectRectClipRegionAction( const tools::Rectangle& );


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const tools::Rectangle&    GetRect() const { return maRect; }

    void                SetRect(const tools::Rectangle& rRect) { maRect = rRect; }

};


class 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() const override;


    explicit            MetaISectRegionClipRegionAction( vcl::Region  );


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const vcl::Region&  GetRegion() const { return maRegion; }

    void                SetRegion(const vcl::Region& rRegion) { maRegion = rRegion; }

};


class VCL_DLLPUBLIC MetaMoveClipRegionAction final : public MetaAction

{

private:


    tools::Long                mnHorzMove;

    tools::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() const override;


                        MetaMoveClipRegionAction( tools::Long nHorzMove, tools::Long nVertMove );


    virtual void        Scale( double fScaleX, double fScaleY ) override;


    tools::Long                GetHorzMove() const { return mnHorzMove; }

    tools::Long                GetVertMove() const { return mnVertMove; }

    void                SetHorzMove(tools::Long nHorzMove) { mnHorzMove = nHorzMove; }

    void                SetVertMove(tools::Long nVertMove) { mnVertMove = nVertMove; }

};


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() const override;


                        MetaLineColorAction( const Color& rColor, bool bSet );


    const Color&        GetColor() const { return maColor; }

    bool                IsSetting() const { return mbSet; }

    void                SetColor(const Color& rColor) { maColor = rColor; }

    void                SetSetting(bool rSet) { mbSet = rSet; }

};


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() const override;


                        MetaFillColorAction( const Color& rColor, bool bSet );


    const Color&        GetColor() const { return maColor; }

    bool                IsSetting() const { return mbSet; }

    void                SetSetting(bool rSet) { mbSet = rSet; }

    void                SetColor(Color rColor) { maColor = rColor; }


};


class 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() const override;


    explicit            MetaTextColorAction( const Color& );


    const Color&        GetColor() const { return maColor; }

    void                SetColor(Color rColor) { maColor = rColor; }

};


class 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() const override;


                        MetaTextFillColorAction( const Color& rColor, bool bSet );


    const Color&        GetColor() const { return maColor; }

    void                SetColor(Color rColor) { maColor = rColor; }

    void                SetSetting(bool bSet) { mbSet = bSet; }

    bool                IsSetting() const { return mbSet; }


};


class 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() const override;


                        MetaTextLineColorAction( const Color& rColor, bool bSet );


    const Color&        GetColor() const { return maColor; }

    void                SetColor(const Color& rColor) { maColor = rColor; }

    void                SetSetting(bool bSet) { mbSet = bSet; }

    bool                IsSetting() const { return mbSet; }

};


class 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() const override;


                        MetaOverlineColorAction( const Color& rColor, bool bSet );


    const Color&        GetColor() const { return maColor; }

    void                SetColor(const Color& rColor) { maColor = rColor; }

    void                SetSetting(bool bSet) { mbSet = bSet; }

    bool                IsSetting() const { return mbSet; }

};


class 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() const override;


    explicit            MetaTextAlignAction( TextAlign eAlign );


    TextAlign           GetTextAlign() const { return maAlign; }

    void                SetTextAlign(TextAlign eAlign) { maAlign = eAlign; }

};


class 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() const override;


    explicit            MetaMapModeAction( const MapMode& );


    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const MapMode&      GetMapMode() const { return maMapMode; }

    void                SetMapMode(const MapMode& rMapMode) { maMapMode = rMapMode; }

};


// tdf#127471 decl for friend below

namespace emfio { class ScaledFontDetectCorrectHelper; }


class VCL_DLLPUBLIC MetaFontAction final : public MetaAction

{

private:


    vcl::Font           maFont;


    // tdf#127471 for import correction of own wrong written EMF/WMF files allow correction

    // of FontScale after import. Only from there, so use a friend here and keep the method private

    friend class emfio::ScaledFontDetectCorrectHelper;

    void correctFontScale(tools::Long nNewFontScale) { maFont.SetAverageFontWidth(nNewFontScale); }


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() const override;


    explicit            MetaFontAction( vcl::Font  );


    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const vcl::Font&    GetFont() const { return maFont; }

    void                SetFont(const vcl::Font& rFont) { maFont = rFont; }


};


class VCL_DLLPUBLIC MetaPushAction final : public MetaAction

{

private:


    vcl::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() const override;


    explicit            MetaPushAction( vcl::PushFlags nFlags );


    vcl::PushFlags           GetFlags() const { return mnFlags; }

    void                SetPushFlags(const vcl::PushFlags nFlags) { mnFlags = nFlags; }

};


class 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() const override;

};


class 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() const override;


    explicit            MetaRasterOpAction( RasterOp eRasterOp );


    RasterOp            GetRasterOp() const { return meRasterOp; }

    void                SetRasterOp(const RasterOp eRasterOp) { meRasterOp = eRasterOp; }

};


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() const override;


                        MetaTransparentAction( tools::PolyPolygon aPolyPoly, sal_uInt16 nTransPercent );


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    const tools::PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }

    sal_uInt16              GetTransparence() const { return mnTransPercent; }

    void                SetPolyPolygon(const tools::PolyPolygon& rPolyPoly) { maPolyPoly = rPolyPoly; }

    void                SetTransparence(const sal_uInt16 nTransPercent) { mnTransPercent = nTransPercent; }


    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() const override;


                        MetaFloatTransparentAction( const GDIMetaFile& rMtf, const Point& rPos,

                                                    const Size& rSize, Gradient aGradient );


    virtual void        Move( tools::Long nHorzMove, tools::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; }

    void                SetGDIMetaFile(const GDIMetaFile &rMtf) { maMtf  = rMtf; }

    void                SetPoint(const Point& rPoint) { maPoint = rPoint; }

    void                SetSize(const Size& rSize) { maSize = rSize; }

    void                SetGradient(const Gradient& rGradient) { maGradient = rGradient; }

    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() const override;


                        MetaEPSAction( const Point& rPoint, const Size& rSize,

                                       GfxLink aGfxLink, const GDIMetaFile& rSubst );


    virtual void        Move( tools::Long nHorzMove, tools::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; }

    void                SetLink(const GfxLink& rGfxLink) { maGfxLink = rGfxLink; }

    void                SetSubstitute(const GDIMetaFile& rSubst) { maSubst = rSubst; }

    void                SetPoint(const Point& rPoint) { maPoint = rPoint; }

    void                SetSize(const Size& rSize) { maSize = rSize; }

};


class 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() const override;


                        MetaRefPointAction( const Point& rRefPoint, bool bSet );


    const Point&        GetRefPoint() const { return maRefPoint; }

    void                SetRefPoint(const Point& rRefPoint) { maRefPoint = rRefPoint; }

    void                SetSetting(const bool bSet) { mbSet = bSet; }

    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( OString aComment, sal_Int32 nValue = 0, const sal_uInt8* pData = nullptr, sal_uInt32 nDataSize = 0 );


    virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;

    virtual void        Scale( double fScaleX, double fScaleY ) override;


    virtual void        Execute( OutputDevice* pOut ) override;

    virtual rtl::Reference<MetaAction> Clone() const 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(); }

    void                SetComment(const OString& rComment) { maComment = rComment; }

    void                SetValue(const sal_Int32 nValue) { mnValue = nValue; }

    void                SetDataSize(const sal_Int32 nDataSize) { mnDataSize = nDataSize; }

    void                SetData(const sal_uInt8* pData, const sal_uInt32 nDataSize) { ImplInitDynamicData(pData, nDataSize); }

};


class VCL_DLLPUBLIC MetaLayoutModeAction final : public MetaAction

{

private:


    vcl::text::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() const override;


    explicit            MetaLayoutModeAction( vcl::text::ComplexTextLayoutFlags nLayoutMode );


    vcl::text::ComplexTextLayoutFlags  GetLayoutMode() const { return mnLayoutMode; }

    void                SetLayoutMode(const vcl::text::ComplexTextLayoutFlags nLayoutMode) { mnLayoutMode = nLayoutMode; }

};


class 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() const override;


    explicit            MetaTextLanguageAction( LanguageType );


    LanguageType        GetTextLanguage() const { return meTextLanguage; }

    void                SetTextLanguage(const LanguageType eTextLanguage) { meTextLanguage = eTextLanguage; }

};


#endif // INCLUDED_VCL_METAACT_HXX


/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

maColor
basegfx::BColor maColor

mnIndex
int mnIndex

DrawTextFlags
DrawTextFlags
Definition: DrawTextFlags.hxx:25

RasterOp.hxx

RasterOp
RasterOp
Definition: RasterOp.hxx:23

State.hxx

maPoint
B2DPoint maPoint

bitmapex.hxx

BitmapEx
Definition: bitmapex.hxx:38

BitmapEx::IsAlpha
bool IsAlpha() const
Definition: BitmapEx.cxx:193

Bitmap
Definition: include/vcl/bitmap.hxx:104

Color

GDIMetaFile
Definition: gdimtf.hxx:56

GfxLink
Definition: gfxlink.hxx:62

Gradient
Definition: gradient.hxx:39

Hatch
Definition: hatch.hxx:47

MapMode
Definition: mapmod.hxx:34

MetaAction
Definition: metaact.hxx:73

MetaAction::IsTransparent
virtual bool IsTransparent() const
#i10613# Extracted from Printer::GetPreparedMetaFile.
Definition: metaact.hxx:98

MetaAction::mnType
MetaActionType mnType
Definition: metaact.hxx:75

MetaAction::GetType
MetaActionType GetType() const
Definition: metaact.hxx:94

MetaAction::Execute
virtual void Execute(OutputDevice *pOut)
Definition: metaact.cxx:99

MetaAction::Scale
virtual void Scale(double fScaleX, double fScaleY)
Definition: metaact.cxx:112

MetaAction::Move
virtual void Move(tools::Long nHorzMove, tools::Long nVertMove)
Definition: metaact.cxx:108

MetaAction::Clone
virtual rtl::Reference< MetaAction > Clone() const
Definition: metaact.cxx:103

MetaAction::GetRefCount
oslInterlockedCount GetRefCount() const
Definition: metaact.hxx:87

MetaArcAction
Definition: metaact.hxx:280

MetaArcAction::maStartPt
Point maStartPt
Definition: metaact.hxx:284

MetaArcAction::SetStartPoint
void SetStartPoint(const Point &rPoint)
Definition: metaact.hxx:309

MetaArcAction::MetaArcAction
MetaArcAction(MetaArcAction &&)=default

MetaArcAction::GetStartPoint
const Point & GetStartPoint() const
Definition: metaact.hxx:306

MetaArcAction::SetEndPoint
void SetEndPoint(const Point &rPoint)
Definition: metaact.hxx:310

MetaArcAction::maEndPt
Point maEndPt
Definition: metaact.hxx:285

MetaArcAction::GetRect
const tools::Rectangle & GetRect() const
Definition: metaact.hxx:305

MetaArcAction::maRect
tools::Rectangle maRect
Definition: metaact.hxx:283

MetaArcAction::MetaArcAction
MetaArcAction(MetaArcAction const &)=default

MetaArcAction::GetEndPoint
const Point & GetEndPoint() const
Definition: metaact.hxx:307

MetaArcAction::SetRect
void SetRect(const tools::Rectangle &rRect)
Definition: metaact.hxx:308

MetaBmpAction
Definition: metaact.hxx:668

MetaBmpAction::maBmp
Bitmap maBmp
Definition: metaact.hxx:671

MetaBmpAction::MetaBmpAction
MetaBmpAction(MetaBmpAction const &)=default

MetaBmpAction::GetBitmap
const Bitmap & GetBitmap() const
Definition: metaact.hxx:691

MetaBmpAction::MetaBmpAction
MetaBmpAction(MetaBmpAction &&)=default

MetaBmpAction::SetBitmap
void SetBitmap(const Bitmap &rBmp)
Definition: metaact.hxx:693

MetaBmpAction::GetPoint
const Point & GetPoint() const
Definition: metaact.hxx:692

MetaBmpAction::SetPoint
void SetPoint(const Point &rPt)
Definition: metaact.hxx:694

MetaBmpAction::maPt
Point maPt
Definition: metaact.hxx:672

MetaBmpExAction
Definition: metaact.hxx:773

MetaBmpExAction::SetBitmapEx
void SetBitmapEx(BitmapEx rBmpEx)
Definition: metaact.hxx:798

MetaBmpExAction::MetaBmpExAction
MetaBmpExAction(MetaBmpExAction &&)=default

MetaBmpExAction::MetaBmpExAction
MetaBmpExAction(MetaBmpExAction const &)=default

MetaBmpExAction::IsTransparent
bool IsTransparent() const override
#i10613# Extracted from Printer::GetPreparedMetaFile.
Definition: metaact.hxx:800

MetaBmpExAction::maPt
Point maPt
Definition: metaact.hxx:777

MetaBmpExAction::SetPoint
void SetPoint(const Point &rPt)
Definition: metaact.hxx:799

MetaBmpExAction::GetBitmapEx
const BitmapEx & GetBitmapEx() const
Definition: metaact.hxx:796

MetaBmpExAction::GetPoint
const Point & GetPoint() const
Definition: metaact.hxx:797

MetaBmpExAction::maBmpEx
BitmapEx maBmpEx
Definition: metaact.hxx:776

MetaBmpExScaleAction
Definition: metaact.hxx:804

MetaBmpExScaleAction::GetSize
const Size & GetSize() const
Definition: metaact.hxx:831

MetaBmpExScaleAction::MetaBmpExScaleAction
MetaBmpExScaleAction(MetaBmpExScaleAction const &)=default

MetaBmpExScaleAction::GetPoint
const Point & GetPoint() const
Definition: metaact.hxx:830

MetaBmpExScaleAction::MetaBmpExScaleAction
MetaBmpExScaleAction(MetaBmpExScaleAction &&)=default

MetaBmpExScaleAction::maSz
Size maSz
Definition: metaact.hxx:809

MetaBmpExScaleAction::SetPoint
void SetPoint(const Point &rPt)
Definition: metaact.hxx:833

MetaBmpExScaleAction::maBmpEx
BitmapEx maBmpEx
Definition: metaact.hxx:807

MetaBmpExScaleAction::GetBitmapEx
const BitmapEx & GetBitmapEx() const
Definition: metaact.hxx:829

MetaBmpExScaleAction::SetBitmapEx
void SetBitmapEx(const BitmapEx &rBmpEx)
Definition: metaact.hxx:832

MetaBmpExScaleAction::IsTransparent
bool IsTransparent() const override
#i10613# Extracted from Printer::GetPreparedMetaFile.
Definition: metaact.hxx:835

MetaBmpExScaleAction::maPt
Point maPt
Definition: metaact.hxx:808

MetaBmpExScaleAction::SetSize
void SetSize(const Size &rSz)
Definition: metaact.hxx:834

MetaBmpScaleAction
Definition: metaact.hxx:698

MetaBmpScaleAction::maBmp
Bitmap maBmp
Definition: metaact.hxx:701

MetaBmpScaleAction::maSz
Size maSz
Definition: metaact.hxx:703

MetaBmpScaleAction::SetBitmap
void SetBitmap(const Bitmap &rBmp)
Definition: metaact.hxx:726

MetaBmpScaleAction::MetaBmpScaleAction
MetaBmpScaleAction(MetaBmpScaleAction const &)=default

MetaBmpScaleAction::GetPoint
const Point & GetPoint() const
Definition: metaact.hxx:724

MetaBmpScaleAction::GetSize
const Size & GetSize() const
Definition: metaact.hxx:725

MetaBmpScaleAction::MetaBmpScaleAction
MetaBmpScaleAction(MetaBmpScaleAction &&)=default

MetaBmpScaleAction::GetBitmap
const Bitmap & GetBitmap() const
Definition: metaact.hxx:723

MetaBmpScaleAction::maPt
Point maPt
Definition: metaact.hxx:702

MetaBmpScaleAction::SetSize
void SetSize(const Size &rSz)
Definition: metaact.hxx:728

MetaBmpScaleAction::SetPoint
void SetPoint(const Point &rPt)
Definition: metaact.hxx:727

MetaChordAction
Definition: metaact.hxx:348

MetaChordAction::GetRect
const tools::Rectangle & GetRect() const
Definition: metaact.hxx:373

MetaChordAction::SetRect
void SetRect(const tools::Rectangle &rRect)
Definition: metaact.hxx:376

MetaChordAction::maStartPt
Point maStartPt
Definition: metaact.hxx:352

MetaChordAction::MetaChordAction
MetaChordAction(MetaChordAction const &)=default

MetaChordAction::GetStartPoint
const Point & GetStartPoint() const
Definition: metaact.hxx:374

MetaChordAction::maRect
tools::Rectangle maRect
Definition: metaact.hxx:351

MetaChordAction::maEndPt
Point maEndPt
Definition: metaact.hxx:353

MetaChordAction::SetStartPoint
void SetStartPoint(const Point &rPoint)
Definition: metaact.hxx:377

MetaChordAction::SetEndPoint
void SetEndPoint(const Point &rPoint)
Definition: metaact.hxx:378

MetaChordAction::GetEndPoint
const Point & GetEndPoint() const
Definition: metaact.hxx:375

MetaChordAction::MetaChordAction
MetaChordAction(MetaChordAction &&)=default

MetaClipRegionAction
Definition: metaact.hxx:1117

MetaClipRegionAction::maRegion
vcl::Region maRegion
Definition: metaact.hxx:1120

MetaClipRegionAction::mbClip
bool mbClip
Definition: metaact.hxx:1121

MetaClipRegionAction::GetRegion
const vcl::Region & GetRegion() const
Definition: metaact.hxx:1140

MetaClipRegionAction::SetRegion
void SetRegion(const vcl::Region &rRegion)
Definition: metaact.hxx:1142

MetaClipRegionAction::MetaClipRegionAction
MetaClipRegionAction(MetaClipRegionAction &&)=default

MetaClipRegionAction::IsClipping
bool IsClipping() const
Definition: metaact.hxx:1141

MetaClipRegionAction::SetClipping
void SetClipping(bool bClip)
Definition: metaact.hxx:1143

MetaClipRegionAction::MetaClipRegionAction
MetaClipRegionAction(MetaClipRegionAction const &)=default

MetaCommentAction
Definition: metaact.hxx:1674

MetaCommentAction::mnDataSize
sal_uInt32 mnDataSize
Definition: metaact.hxx:1679

MetaCommentAction::GetValue
sal_Int32 GetValue() const
Definition: metaact.hxx:1700

MetaCommentAction::GetData
const sal_uInt8 * GetData() const
Definition: metaact.hxx:1702

MetaCommentAction::GetComment
const OString & GetComment() const
Definition: metaact.hxx:1699

MetaCommentAction::SetValue
void SetValue(const sal_Int32 nValue)
Definition: metaact.hxx:1704

MetaCommentAction::SetData
void SetData(const sal_uInt8 *pData, const sal_uInt32 nDataSize)
Definition: metaact.hxx:1706

MetaCommentAction::maComment
OString maComment
Definition: metaact.hxx:1677

MetaCommentAction::SetComment
void SetComment(const OString &rComment)
Definition: metaact.hxx:1703

MetaCommentAction::mpData
std::unique_ptr< sal_uInt8[]> mpData
Definition: metaact.hxx:1681

MetaCommentAction::mnValue
sal_Int32 mnValue
Definition: metaact.hxx:1678

MetaCommentAction::SetDataSize
void SetDataSize(const sal_Int32 nDataSize)
Definition: metaact.hxx:1705

MetaCommentAction::GetDataSize
sal_uInt32 GetDataSize() const
Definition: metaact.hxx:1701

MetaEPSAction
Definition: metaact.hxx:1610

MetaEPSAction::SetSize
void SetSize(const Size &rSize)
Definition: metaact.hxx:1643

MetaEPSAction::maGfxLink
GfxLink maGfxLink
Definition: metaact.hxx:1613

MetaEPSAction::GetSubstitute
const GDIMetaFile & GetSubstitute() const
Definition: metaact.hxx:1637

MetaEPSAction::GetPoint
const Point & GetPoint() const
Definition: metaact.hxx:1638

MetaEPSAction::SetSubstitute
void SetSubstitute(const GDIMetaFile &rSubst)
Definition: metaact.hxx:1641

MetaEPSAction::maSize
Size maSize
Definition: metaact.hxx:1616

MetaEPSAction::MetaEPSAction
MetaEPSAction(MetaEPSAction const &)=default

MetaEPSAction::MetaEPSAction
MetaEPSAction(MetaEPSAction &&)=default

MetaEPSAction::SetLink
void SetLink(const GfxLink &rGfxLink)
Definition: metaact.hxx:1640

MetaEPSAction::maPoint
Point maPoint
Definition: metaact.hxx:1615

MetaEPSAction::maSubst
GDIMetaFile maSubst
Definition: metaact.hxx:1614

MetaEPSAction::GetSize
const Size & GetSize() const
Definition: metaact.hxx:1639

MetaEPSAction::SetPoint
void SetPoint(const Point &rPoint)
Definition: metaact.hxx:1642

MetaEPSAction::GetLink
const GfxLink & GetLink() const
Definition: metaact.hxx:1636

MetaEllipseAction
Definition: metaact.hxx:253

MetaEllipseAction::MetaEllipseAction
MetaEllipseAction(MetaEllipseAction const &)=default

MetaEllipseAction::SetRect
void SetRect(const tools::Rectangle &rRect)
Definition: metaact.hxx:276

MetaEllipseAction::GetRect
const tools::Rectangle & GetRect() const
Definition: metaact.hxx:275

MetaEllipseAction::maRect
tools::Rectangle maRect
Definition: metaact.hxx:256

MetaEllipseAction::MetaEllipseAction
MetaEllipseAction(MetaEllipseAction &&)=default

MetaFillColorAction
Definition: metaact.hxx:1257

MetaFillColorAction::SetColor
void SetColor(Color rColor)
Definition: metaact.hxx:1280

MetaFillColorAction::SetSetting
void SetSetting(bool rSet)
Definition: metaact.hxx:1279

MetaFillColorAction::MetaFillColorAction
MetaFillColorAction(MetaFillColorAction const &)=default

MetaFillColorAction::mbSet
bool mbSet
Definition: metaact.hxx:1261

MetaFillColorAction::maColor
Color maColor
Definition: metaact.hxx:1260

MetaFillColorAction::GetColor
const Color & GetColor() const
Definition: metaact.hxx:1277

MetaFillColorAction::IsSetting
bool IsSetting() const
Definition: metaact.hxx:1278

MetaFillColorAction::MetaFillColorAction
MetaFillColorAction(MetaFillColorAction &&)=default

MetaFloatTransparentAction
Definition: metaact.hxx:1572

MetaFloatTransparentAction::SetPoint
void SetPoint(const Point &rPoint)
Definition: metaact.hxx:1603

MetaFloatTransparentAction::SetSize
void SetSize(const Size &rSize)
Definition: metaact.hxx:1604

MetaFloatTransparentAction::SetGDIMetaFile
void SetGDIMetaFile(const GDIMetaFile &rMtf)
Definition: metaact.hxx:1602

MetaFloatTransparentAction::GetGradient
const Gradient & GetGradient() const
Definition: metaact.hxx:1601

MetaFloatTransparentAction::maSize
Size maSize
Definition: metaact.hxx:1577

MetaFloatTransparentAction::GetSize
const Size & GetSize() const
Definition: metaact.hxx:1600

MetaFloatTransparentAction::SetGradient
void SetGradient(const Gradient &rGradient)
Definition: metaact.hxx:1605

MetaFloatTransparentAction::MetaFloatTransparentAction
MetaFloatTransparentAction(MetaFloatTransparentAction &&)=default

MetaFloatTransparentAction::maGradient
Gradient maGradient
Definition: metaact.hxx:1578

MetaFloatTransparentAction::GetGDIMetaFile
const GDIMetaFile & GetGDIMetaFile() const
Definition: metaact.hxx:1598

MetaFloatTransparentAction::IsTransparent
bool IsTransparent() const override
#i10613# Extracted from Printer::GetPreparedMetaFile.
Definition: metaact.hxx:1606

MetaFloatTransparentAction::maMtf
GDIMetaFile maMtf
Definition: metaact.hxx:1575

MetaFloatTransparentAction::GetPoint
const Point & GetPoint() const
Definition: metaact.hxx:1599

MetaFloatTransparentAction::maPoint
Point maPoint
Definition: metaact.hxx:1576

MetaFloatTransparentAction::MetaFloatTransparentAction
MetaFloatTransparentAction(MetaFloatTransparentAction const &)=default

MetaFontAction
Definition: metaact.hxx:1444

MetaFontAction::GetFont
const vcl::Font & GetFont() const
Definition: metaact.hxx:1470

MetaFontAction::SetFont
void SetFont(const vcl::Font &rFont)
Definition: metaact.hxx:1471

MetaFontAction::maFont
vcl::Font maFont
Definition: metaact.hxx:1447

MetaFontAction::MetaFontAction
MetaFontAction(MetaFontAction const &)=default

MetaFontAction::MetaFontAction
MetaFontAction(MetaFontAction &&)=default

MetaFontAction::correctFontScale
void correctFontScale(tools::Long nNewFontScale)
Definition: metaact.hxx:1452

MetaGradientAction
Definition: metaact.hxx:997

MetaGradientAction::MetaGradientAction
MetaGradientAction(MetaGradientAction &&)=default

MetaGradientAction::maGradient
Gradient maGradient
Definition: metaact.hxx:1001

MetaGradientAction::SetRect
void SetRect(const tools::Rectangle &rRect)
Definition: metaact.hxx:1023

MetaGradientAction::GetRect
const tools::Rectangle & GetRect() const
Definition: metaact.hxx:1020

MetaGradientAction::MetaGradientAction
MetaGradientAction(MetaGradientAction const &)=default

MetaGradientAction::maRect
tools::Rectangle maRect
Definition: metaact.hxx:1000

MetaGradientAction::GetGradient
const Gradient & GetGradient() const
Definition: metaact.hxx:1021

MetaGradientAction::SetGradient
void SetGradient(const Gradient &rGradient)
Definition: metaact.hxx:1022

MetaGradientExAction
Definition: metaact.hxx:1027

MetaGradientExAction::MetaGradientExAction
MetaGradientExAction(MetaGradientExAction &&)=default

MetaGradientExAction::MetaGradientExAction
MetaGradientExAction(MetaGradientExAction const &)=default

MetaGradientExAction::GetPolyPolygon
const tools::PolyPolygon & GetPolyPolygon() const
Definition: metaact.hxx:1050

MetaGradientExAction::SetGradient
void SetGradient(const Gradient &rGradient)
Definition: metaact.hxx:1053

MetaGradientExAction::GetGradient
const Gradient & GetGradient() const
Definition: metaact.hxx:1051

MetaGradientExAction::maGradient
Gradient maGradient
Definition: metaact.hxx:1031

MetaGradientExAction::maPolyPoly
tools::PolyPolygon maPolyPoly
Definition: metaact.hxx:1030

MetaGradientExAction::SetPolyPolygon
void SetPolyPolygon(const tools::PolyPolygon &rPolyPoly)
Definition: metaact.hxx:1052

MetaHatchAction
Definition: metaact.hxx:1057

MetaHatchAction::SetPolyPolygon
void SetPolyPolygon(const tools::PolyPolygon &rPolyPoly)
Definition: metaact.hxx:1082

MetaHatchAction::MetaHatchAction
MetaHatchAction(MetaHatchAction &&)=default

MetaHatchAction::GetPolyPolygon
const tools::PolyPolygon & GetPolyPolygon() const
Definition: metaact.hxx:1080

MetaHatchAction::GetHatch
const Hatch & GetHatch() const
Definition: metaact.hxx:1081

MetaHatchAction::maPolyPoly
tools::PolyPolygon maPolyPoly
Definition: metaact.hxx:1060

MetaHatchAction::MetaHatchAction
MetaHatchAction(MetaHatchAction const &)=default

MetaHatchAction::maHatch
Hatch maHatch
Definition: metaact.hxx:1061

MetaHatchAction::SetHatch
void SetHatch(const Hatch &rHatch)
Definition: metaact.hxx:1083

MetaISectRectClipRegionAction
Definition: metaact.hxx:1147

MetaISectRectClipRegionAction::SetRect
void SetRect(const tools::Rectangle &rRect)
Definition: metaact.hxx:1170

MetaISectRectClipRegionAction::MetaISectRectClipRegionAction
MetaISectRectClipRegionAction(MetaISectRectClipRegionAction const &)=default

MetaISectRectClipRegionAction::GetRect
const tools::Rectangle & GetRect() const
Definition: metaact.hxx:1169

MetaISectRectClipRegionAction::MetaISectRectClipRegionAction
MetaISectRectClipRegionAction(MetaISectRectClipRegionAction &&)=default

MetaISectRectClipRegionAction::maRect
tools::Rectangle maRect
Definition: metaact.hxx:1150

MetaISectRegionClipRegionAction
Definition: metaact.hxx:1174

MetaISectRegionClipRegionAction::GetRegion
const vcl::Region & GetRegion() const
Definition: metaact.hxx:1196

MetaISectRegionClipRegionAction::maRegion
vcl::Region maRegion
Definition: metaact.hxx:1177

MetaISectRegionClipRegionAction::MetaISectRegionClipRegionAction
MetaISectRegionClipRegionAction(MetaISectRegionClipRegionAction const &)=default

MetaISectRegionClipRegionAction::SetRegion
void SetRegion(const vcl::Region &rRegion)
Definition: metaact.hxx:1197

MetaISectRegionClipRegionAction::MetaISectRegionClipRegionAction
MetaISectRegionClipRegionAction(MetaISectRegionClipRegionAction &&)=default

MetaLayoutModeAction
Definition: metaact.hxx:1710

MetaLayoutModeAction::SetLayoutMode
void SetLayoutMode(const vcl::text::ComplexTextLayoutFlags nLayoutMode)
Definition: metaact.hxx:1730

MetaLayoutModeAction::MetaLayoutModeAction
MetaLayoutModeAction(MetaLayoutModeAction const &)=default

MetaLayoutModeAction::GetLayoutMode
vcl::text::ComplexTextLayoutFlags GetLayoutMode() const
Definition: metaact.hxx:1729

MetaLayoutModeAction::mnLayoutMode
vcl::text::ComplexTextLayoutFlags mnLayoutMode
Definition: metaact.hxx:1713

MetaLayoutModeAction::MetaLayoutModeAction
MetaLayoutModeAction(MetaLayoutModeAction &&)=default

MetaLineAction
Definition: metaact.hxx:157

MetaLineAction::maLineInfo
LineInfo maLineInfo
Definition: metaact.hxx:160

MetaLineAction::SetEndPoint
void SetEndPoint(const Point &rPoint)
Definition: metaact.hxx:187

MetaLineAction::GetLineInfo
const LineInfo & GetLineInfo() const
Definition: metaact.hxx:185

MetaLineAction::SetLineInfo
void SetLineInfo(const LineInfo &rLineInfo)
Definition: metaact.hxx:188

MetaLineAction::MetaLineAction
MetaLineAction(MetaLineAction &&)=default

MetaLineAction::GetEndPoint
const Point & GetEndPoint() const
Definition: metaact.hxx:184

MetaLineAction::GetStartPoint
const Point & GetStartPoint() const
Definition: metaact.hxx:183

MetaLineAction::maEndPt
Point maEndPt
Definition: metaact.hxx:162

MetaLineAction::SetStartPoint
void SetStartPoint(const Point &rPoint)
Definition: metaact.hxx:186

MetaLineAction::maStartPt
Point maStartPt
Definition: metaact.hxx:161

MetaLineAction::MetaLineAction
MetaLineAction(MetaLineAction const &)=default

MetaLineColorAction
Definition: metaact.hxx:1230

MetaLineColorAction::MetaLineColorAction
MetaLineColorAction(MetaLineColorAction const &)=default

MetaLineColorAction::SetSetting
void SetSetting(bool rSet)
Definition: metaact.hxx:1253

MetaLineColorAction::MetaLineColorAction
MetaLineColorAction(MetaLineColorAction &&)=default

MetaLineColorAction::IsSetting
bool IsSetting() const
Definition: metaact.hxx:1251

MetaLineColorAction::maColor
Color maColor
Definition: metaact.hxx:1233

MetaLineColorAction::mbSet
bool mbSet
Definition: metaact.hxx:1234

MetaLineColorAction::GetColor
const Color & GetColor() const
Definition: metaact.hxx:1250

MetaLineColorAction::SetColor
void SetColor(const Color &rColor)
Definition: metaact.hxx:1252

MetaMapModeAction
Definition: metaact.hxx:1415

MetaMapModeAction::MetaMapModeAction
MetaMapModeAction(MetaMapModeAction const &)=default

MetaMapModeAction::SetMapMode
void SetMapMode(const MapMode &rMapMode)
Definition: metaact.hxx:1437

MetaMapModeAction::maMapMode
MapMode maMapMode
Definition: metaact.hxx:1418

MetaMapModeAction::GetMapMode
const MapMode & GetMapMode() const
Definition: metaact.hxx:1436

MetaMapModeAction::MetaMapModeAction
MetaMapModeAction(MetaMapModeAction &&)=default

MetaMaskAction
Definition: metaact.hxx:881

MetaMaskAction::GetPoint
const Point & GetPoint() const
Definition: metaact.hxx:909

MetaMaskAction::maBmp
Bitmap maBmp
Definition: metaact.hxx:884

MetaMaskAction::maColor
Color maColor
Definition: metaact.hxx:885

MetaMaskAction::MetaMaskAction
MetaMaskAction(MetaMaskAction const &)=default

MetaMaskAction::maPt
Point maPt
Definition: metaact.hxx:886

MetaMaskAction::MetaMaskAction
MetaMaskAction(MetaMaskAction &&)=default

MetaMaskAction::SetBitmap
void SetBitmap(const Bitmap &rBmp)
Definition: metaact.hxx:910

MetaMaskAction::GetBitmap
const Bitmap & GetBitmap() const
Definition: metaact.hxx:907

MetaMaskAction::SetPoint
void SetPoint(const Point &rPt)
Definition: metaact.hxx:911

MetaMaskAction::GetColor
const Color & GetColor() const
Definition: metaact.hxx:908

MetaMaskScaleAction
Definition: metaact.hxx:915

MetaMaskScaleAction::SetPoint
void SetPoint(const Point &rPt)
Definition: metaact.hxx:947

MetaMaskScaleAction::maBmp
Bitmap maBmp
Definition: metaact.hxx:918

MetaMaskScaleAction::SetBitmap
void SetBitmap(const Bitmap &rBmp)
Definition: metaact.hxx:946

MetaMaskScaleAction::MetaMaskScaleAction
MetaMaskScaleAction(MetaMaskScaleAction const &)=default

MetaMaskScaleAction::maSz
Size maSz
Definition: metaact.hxx:921

MetaMaskScaleAction::SetSize
void SetSize(const Size &rSz)
Definition: metaact.hxx:948

MetaMaskScaleAction::GetBitmap
const Bitmap & GetBitmap() const
Definition: metaact.hxx:942

MetaMaskScaleAction::GetPoint
const Point & GetPoint() const
Definition: metaact.hxx:944

MetaMaskScaleAction::MetaMaskScaleAction
MetaMaskScaleAction(MetaMaskScaleAction &&)=default

MetaMaskScaleAction::maColor
Color maColor
Definition: metaact.hxx:919

MetaMaskScaleAction::GetColor
const Color & GetColor() const
Definition: metaact.hxx:943

MetaMaskScaleAction::maPt
Point maPt
Definition: metaact.hxx:920

MetaMaskScaleAction::GetSize
const Size & GetSize() const
Definition: metaact.hxx:945

MetaMaskScalePartAction
Definition: metaact.hxx:952

MetaMaskScalePartAction::SetSrcSize
void SetSrcSize(const Size &rSz)
Definition: metaact.hxx:993

MetaMaskScalePartAction::maSrcSz
Size maSrcSz
Definition: metaact.hxx:960

MetaMaskScalePartAction::SetColor
void SetColor(Color rColor)
Definition: metaact.hxx:989

MetaMaskScalePartAction::maDstPt
Point maDstPt
Definition: metaact.hxx:957

MetaMaskScalePartAction::SetDestPoint
void SetDestPoint(const Point &rPt)
Definition: metaact.hxx:990

MetaMaskScalePartAction::GetBitmap
const Bitmap & GetBitmap() const
Definition: metaact.hxx:982

MetaMaskScalePartAction::GetSrcPoint
const Point & GetSrcPoint() const
Definition: metaact.hxx:986

MetaMaskScalePartAction::maSrcPt
Point maSrcPt
Definition: metaact.hxx:959

MetaMaskScalePartAction::SetSrcPoint
void SetSrcPoint(const Point &rPt)
Definition: metaact.hxx:992

MetaMaskScalePartAction::GetColor
const Color & GetColor() const
Definition: metaact.hxx:983

MetaMaskScalePartAction::GetSrcSize
const Size & GetSrcSize() const
Definition: metaact.hxx:987

MetaMaskScalePartAction::maBmp
Bitmap maBmp
Definition: metaact.hxx:955

MetaMaskScalePartAction::SetBitmap
void SetBitmap(const Bitmap &rBmp)
Definition: metaact.hxx:988

MetaMaskScalePartAction::MetaMaskScalePartAction
MetaMaskScalePartAction(MetaMaskScalePartAction const &)=default

MetaMaskScalePartAction::MetaMaskScalePartAction
MetaMaskScalePartAction(MetaMaskScalePartAction &&)=default

MetaMaskScalePartAction::maColor
Color maColor
Definition: metaact.hxx:956

MetaMaskScalePartAction::maDstSz
Size maDstSz
Definition: metaact.hxx:958

MetaMaskScalePartAction::GetDestPoint
const Point & GetDestPoint() const
Definition: metaact.hxx:984

MetaMaskScalePartAction::SetDestSize
void SetDestSize(const Size &rSz)
Definition: metaact.hxx:991

MetaMaskScalePartAction::GetDestSize
const Size & GetDestSize() const
Definition: metaact.hxx:985

MetaMoveClipRegionAction
Definition: metaact.hxx:1201

MetaMoveClipRegionAction::MetaMoveClipRegionAction
MetaMoveClipRegionAction(MetaMoveClipRegionAction const &)=default

MetaMoveClipRegionAction::GetVertMove
tools::Long GetVertMove() const
Definition: metaact.hxx:1224

MetaMoveClipRegionAction::GetHorzMove
tools::Long GetHorzMove() const
Definition: metaact.hxx:1223

MetaMoveClipRegionAction::SetHorzMove
void SetHorzMove(tools::Long nHorzMove)
Definition: metaact.hxx:1225

MetaMoveClipRegionAction::mnHorzMove
tools::Long mnHorzMove
Definition: metaact.hxx:1204

MetaMoveClipRegionAction::SetVertMove
void SetVertMove(tools::Long nVertMove)
Definition: metaact.hxx:1226

MetaMoveClipRegionAction::mnVertMove
tools::Long mnVertMove
Definition: metaact.hxx:1205

MetaMoveClipRegionAction::MetaMoveClipRegionAction
MetaMoveClipRegionAction(MetaMoveClipRegionAction &&)=default

MetaOverlineColorAction
Definition: metaact.hxx:1364

MetaOverlineColorAction::MetaOverlineColorAction
MetaOverlineColorAction(MetaOverlineColorAction &&)=default

MetaOverlineColorAction::SetSetting
void SetSetting(bool bSet)
Definition: metaact.hxx:1386

MetaOverlineColorAction::GetColor
const Color & GetColor() const
Definition: metaact.hxx:1384

MetaOverlineColorAction::SetColor
void SetColor(const Color &rColor)
Definition: metaact.hxx:1385

MetaOverlineColorAction::mbSet
bool mbSet
Definition: metaact.hxx:1368

MetaOverlineColorAction::maColor
Color maColor
Definition: metaact.hxx:1367

MetaOverlineColorAction::IsSetting
bool IsSetting() const
Definition: metaact.hxx:1387

MetaOverlineColorAction::MetaOverlineColorAction
MetaOverlineColorAction(MetaOverlineColorAction const &)=default

MetaPieAction
Definition: metaact.hxx:314

MetaPieAction::SetRect
void SetRect(const tools::Rectangle &rRect)
Definition: metaact.hxx:342

MetaPieAction::MetaPieAction
MetaPieAction(MetaPieAction &&)=default

MetaPieAction::maStartPt
Point maStartPt
Definition: metaact.hxx:318

MetaPieAction::SetEndPoint
void SetEndPoint(const Point &rPoint)
Definition: metaact.hxx:344

MetaPieAction::MetaPieAction
MetaPieAction(MetaPieAction const &)=default

MetaPieAction::SetStartPoint
void SetStartPoint(const Point &rPoint)
Definition: metaact.hxx:343

MetaPieAction::GetEndPoint
const Point & GetEndPoint() const
Definition: metaact.hxx:341

MetaPieAction::GetStartPoint
const Point & GetStartPoint() const
Definition: metaact.hxx:340

MetaPieAction::maRect
tools::Rectangle maRect
Definition: metaact.hxx:317

MetaPieAction::maEndPt
Point maEndPt
Definition: metaact.hxx:319

MetaPieAction::GetRect
const tools::Rectangle & GetRect() const
Definition: metaact.hxx:339

MetaPixelAction
Definition: metaact.hxx:102

MetaPixelAction::SetPoint
void SetPoint(const Point &rPt)
Definition: metaact.hxx:126

MetaPixelAction::MetaPixelAction
MetaPixelAction(MetaPixelAction &&)=default

MetaPixelAction::GetPoint
const Point & GetPoint() const
Definition: metaact.hxx:124

MetaPixelAction::SetColor
void SetColor(Color rColor)
Definition: metaact.hxx:127

MetaPixelAction::MetaPixelAction
MetaPixelAction(MetaPixelAction const &)=default

MetaPixelAction::GetColor
const Color & GetColor() const
Definition: metaact.hxx:125

MetaPixelAction::maColor
Color maColor
Definition: metaact.hxx:105

MetaPixelAction::maPt
Point maPt
Definition: metaact.hxx:104

MetaPointAction
Definition: metaact.hxx:131

MetaPointAction::MetaPointAction
MetaPointAction(MetaPointAction &&)=default

MetaPointAction::maPt
Point maPt
Definition: metaact.hxx:133

MetaPointAction::MetaPointAction
MetaPointAction(MetaPointAction const &)=default

MetaPointAction::SetPoint
void SetPoint(const Point &rPt)
Definition: metaact.hxx:153

MetaPointAction::GetPoint
const Point & GetPoint() const
Definition: metaact.hxx:152

MetaPolyLineAction
Definition: metaact.hxx:382

MetaPolyLineAction::MetaPolyLineAction
MetaPolyLineAction(MetaPolyLineAction &&)=default

MetaPolyLineAction::SetPolygon
void SetPolygon(const tools::Polygon &rPoly)
Definition: metaact.hxx:409

MetaPolyLineAction::maPoly
tools::Polygon maPoly
Definition: metaact.hxx:386

MetaPolyLineAction::GetLineInfo
const LineInfo & GetLineInfo() const
Definition: metaact.hxx:407

MetaPolyLineAction::maLineInfo
LineInfo maLineInfo
Definition: metaact.hxx:385

MetaPolyLineAction::SetLineInfo
void SetLineInfo(const LineInfo &rLineInfo)
Definition: metaact.hxx:408

MetaPolyLineAction::MetaPolyLineAction
MetaPolyLineAction(MetaPolyLineAction const &)=default

MetaPolyLineAction::GetPolygon
const tools::Polygon & GetPolygon() const
Definition: metaact.hxx:406

MetaPolyPolygonAction
Definition: metaact.hxx:440

MetaPolyPolygonAction::maPolyPoly
tools::PolyPolygon maPolyPoly
Definition: metaact.hxx:443

MetaPolyPolygonAction::SetPolyPolygon
void SetPolyPolygon(const tools::PolyPolygon &rPolyPoly)
Definition: metaact.hxx:463

MetaPolyPolygonAction::MetaPolyPolygonAction
MetaPolyPolygonAction(MetaPolyPolygonAction const &)=default

MetaPolyPolygonAction::GetPolyPolygon
const tools::PolyPolygon & GetPolyPolygon() const
Definition: metaact.hxx:462

MetaPolyPolygonAction::MetaPolyPolygonAction
MetaPolyPolygonAction(MetaPolyPolygonAction &&)=default

MetaPolygonAction
Definition: metaact.hxx:413

MetaPolygonAction::maPoly
tools::Polygon maPoly
Definition: metaact.hxx:416

MetaPolygonAction::MetaPolygonAction
MetaPolygonAction(MetaPolygonAction const &)=default

MetaPolygonAction::MetaPolygonAction
MetaPolygonAction(MetaPolygonAction &&)=default

MetaPolygonAction::GetPolygon
const tools::Polygon & GetPolygon() const
Definition: metaact.hxx:435

MetaPolygonAction::SetPolygon
void SetPolygon(const tools::Polygon &rPoly)
Definition: metaact.hxx:436

MetaPopAction
Definition: metaact.hxx:1500

MetaPopAction::MetaPopAction
MetaPopAction(MetaPopAction &&)=default

MetaPopAction::MetaPopAction
MetaPopAction(MetaPopAction const &)=default

MetaPushAction
Definition: metaact.hxx:1476

MetaPushAction::MetaPushAction
MetaPushAction(MetaPushAction &&)=default

MetaPushAction::MetaPushAction
MetaPushAction(MetaPushAction const &)=default

MetaPushAction::SetPushFlags
void SetPushFlags(const vcl::PushFlags nFlags)
Definition: metaact.hxx:1496

MetaPushAction::mnFlags
vcl::PushFlags mnFlags
Definition: metaact.hxx:1479

MetaPushAction::GetFlags
vcl::PushFlags GetFlags() const
Definition: metaact.hxx:1495

MetaRasterOpAction
Definition: metaact.hxx:1516

MetaRasterOpAction::GetRasterOp
RasterOp GetRasterOp() const
Definition: metaact.hxx:1535

MetaRasterOpAction::MetaRasterOpAction
MetaRasterOpAction(MetaRasterOpAction &&)=default

MetaRasterOpAction::SetRasterOp
void SetRasterOp(const RasterOp eRasterOp)
Definition: metaact.hxx:1536

MetaRasterOpAction::MetaRasterOpAction
MetaRasterOpAction(MetaRasterOpAction const &)=default

MetaRasterOpAction::meRasterOp
RasterOp meRasterOp
Definition: metaact.hxx:1519

MetaRectAction
Definition: metaact.hxx:192

MetaRectAction::MetaRectAction
MetaRectAction(MetaRectAction &&)=default

MetaRectAction::MetaRectAction
MetaRectAction(MetaRectAction const &)=default

MetaRectAction::GetRect
const tools::Rectangle & GetRect() const
Definition: metaact.hxx:214

MetaRectAction::maRect
tools::Rectangle maRect
Definition: metaact.hxx:195

MetaRectAction::SetRect
void SetRect(const tools::Rectangle &rRect)
Definition: metaact.hxx:215

MetaRefPointAction
Definition: metaact.hxx:1647

MetaRefPointAction::mbSet
bool mbSet
Definition: metaact.hxx:1651

MetaRefPointAction::SetRefPoint
void SetRefPoint(const Point &rRefPoint)
Definition: metaact.hxx:1668

MetaRefPointAction::IsSetting
bool IsSetting() const
Definition: metaact.hxx:1670

MetaRefPointAction::SetSetting
void SetSetting(const bool bSet)
Definition: metaact.hxx:1669

MetaRefPointAction::maRefPoint
Point maRefPoint
Definition: metaact.hxx:1650

MetaRefPointAction::GetRefPoint
const Point & GetRefPoint() const
Definition: metaact.hxx:1667

MetaRefPointAction::MetaRefPointAction
MetaRefPointAction(MetaRefPointAction const &)=default

MetaRefPointAction::MetaRefPointAction
MetaRefPointAction(MetaRefPointAction &&)=default

MetaRoundRectAction
Definition: metaact.hxx:219

MetaRoundRectAction::MetaRoundRectAction
MetaRoundRectAction(MetaRoundRectAction &&)=default

MetaRoundRectAction::maRect
tools::Rectangle maRect
Definition: metaact.hxx:222

MetaRoundRectAction::mnHorzRound
sal_uInt32 mnHorzRound
Definition: metaact.hxx:223

MetaRoundRectAction::MetaRoundRectAction
MetaRoundRectAction(MetaRoundRectAction const &)=default

MetaRoundRectAction::SetHorzRound
void SetHorzRound(sal_uInt32 rHorzRound)
Definition: metaact.hxx:248

MetaRoundRectAction::mnVertRound
sal_uInt32 mnVertRound
Definition: metaact.hxx:224

MetaRoundRectAction::GetHorzRound
sal_uInt32 GetHorzRound() const
Definition: metaact.hxx:245

MetaRoundRectAction::SetVertRound
void SetVertRound(sal_uInt32 rVertRound)
Definition: metaact.hxx:249

MetaRoundRectAction::SetRect
void SetRect(const tools::Rectangle &rRect)
Definition: metaact.hxx:247

MetaRoundRectAction::GetVertRound
sal_uInt32 GetVertRound() const
Definition: metaact.hxx:246

MetaRoundRectAction::GetRect
const tools::Rectangle & GetRect() const
Definition: metaact.hxx:244

MetaStretchTextAction
Definition: metaact.hxx:552

MetaStretchTextAction::GetWidth
sal_uInt32 GetWidth() const
Definition: metaact.hxx:582

MetaStretchTextAction::GetLen
sal_Int32 GetLen() const
Definition: metaact.hxx:584

MetaStretchTextAction::SetWidth
void SetWidth(sal_uInt32 rWidth)
Definition: metaact.hxx:587

MetaStretchTextAction::GetIndex
sal_Int32 GetIndex() const
Definition: metaact.hxx:583

MetaStretchTextAction::mnIndex
sal_Int32 mnIndex
Definition: metaact.hxx:558

MetaStretchTextAction::GetText
const OUString & GetText() const
Definition: metaact.hxx:581

MetaStretchTextAction::mnWidth
sal_uInt32 mnWidth
Definition: metaact.hxx:557

MetaStretchTextAction::SetIndex
void SetIndex(sal_uInt32 rIndex)
Definition: metaact.hxx:588

MetaStretchTextAction::SetLen
void SetLen(sal_uInt32 rLen)
Definition: metaact.hxx:589

MetaStretchTextAction::maStr
OUString maStr
Definition: metaact.hxx:556

MetaStretchTextAction::MetaStretchTextAction
MetaStretchTextAction(MetaStretchTextAction &&)=default

MetaStretchTextAction::SetText
void SetText(const OUString &rStr)
Definition: metaact.hxx:586

MetaStretchTextAction::MetaStretchTextAction
MetaStretchTextAction(MetaStretchTextAction const &)=default

MetaStretchTextAction::GetPoint
const Point & GetPoint() const
Definition: metaact.hxx:580

MetaStretchTextAction::mnLen
sal_Int32 mnLen
Definition: metaact.hxx:559

MetaStretchTextAction::maPt
Point maPt
Definition: metaact.hxx:555

MetaStretchTextAction::SetPoint
void SetPoint(const Point &rPt)
Definition: metaact.hxx:585

MetaTextAction
Definition: metaact.hxx:467

MetaTextAction::GetPoint
const Point & GetPoint() const
Definition: metaact.hxx:493

MetaTextAction::MetaTextAction
MetaTextAction(MetaTextAction const &)=default

MetaTextAction::GetLen
sal_Int32 GetLen() const
Definition: metaact.hxx:496

MetaTextAction::maStr
OUString maStr
Definition: metaact.hxx:471

MetaTextAction::SetIndex
void SetIndex(sal_Int32 rIndex)
Definition: metaact.hxx:499

MetaTextAction::SetText
void SetText(const OUString &rStr)
Definition: metaact.hxx:498

MetaTextAction::SetLen
void SetLen(sal_Int32 rLen)
Definition: metaact.hxx:500

MetaTextAction::maPt
Point maPt
Definition: metaact.hxx:470

MetaTextAction::MetaTextAction
MetaTextAction(MetaTextAction &&)=default

MetaTextAction::GetText
const OUString & GetText() const
Definition: metaact.hxx:494

MetaTextAction::mnIndex
sal_Int32 mnIndex
Definition: metaact.hxx:472

MetaTextAction::SetPoint
void SetPoint(const Point &rPt)
Definition: metaact.hxx:497

MetaTextAction::GetIndex
sal_Int32 GetIndex() const
Definition: metaact.hxx:495

MetaTextAction::mnLen
sal_Int32 mnLen
Definition: metaact.hxx:473

MetaTextAlignAction
Definition: metaact.hxx:1391

MetaTextAlignAction::MetaTextAlignAction
MetaTextAlignAction(MetaTextAlignAction &&)=default

MetaTextAlignAction::MetaTextAlignAction
MetaTextAlignAction(MetaTextAlignAction const &)=default

MetaTextAlignAction::SetTextAlign
void SetTextAlign(TextAlign eAlign)
Definition: metaact.hxx:1411

MetaTextAlignAction::GetTextAlign
TextAlign GetTextAlign() const
Definition: metaact.hxx:1410

MetaTextAlignAction::maAlign
TextAlign maAlign
Definition: metaact.hxx:1394

MetaTextColorAction
Definition: metaact.hxx:1285

MetaTextColorAction::MetaTextColorAction
MetaTextColorAction(MetaTextColorAction const &)=default

MetaTextColorAction::SetColor
void SetColor(Color rColor)
Definition: metaact.hxx:1305

MetaTextColorAction::MetaTextColorAction
MetaTextColorAction(MetaTextColorAction &&)=default

MetaTextColorAction::maColor
Color maColor
Definition: metaact.hxx:1288

MetaTextColorAction::GetColor
const Color & GetColor() const
Definition: metaact.hxx:1304

MetaTextFillColorAction
Definition: metaact.hxx:1309

MetaTextFillColorAction::SetColor
void SetColor(Color rColor)
Definition: metaact.hxx:1330

MetaTextFillColorAction::MetaTextFillColorAction
MetaTextFillColorAction(MetaTextFillColorAction &&)=default

MetaTextFillColorAction::mbSet
bool mbSet
Definition: metaact.hxx:1313

MetaTextFillColorAction::MetaTextFillColorAction
MetaTextFillColorAction(MetaTextFillColorAction const &)=default

MetaTextFillColorAction::maColor
Color maColor
Definition: metaact.hxx:1312

MetaTextFillColorAction::IsSetting
bool IsSetting() const
Definition: metaact.hxx:1332

MetaTextFillColorAction::GetColor
const Color & GetColor() const
Definition: metaact.hxx:1329

MetaTextFillColorAction::SetSetting
void SetSetting(bool bSet)
Definition: metaact.hxx:1331

MetaTextLanguageAction
Definition: metaact.hxx:1734

MetaTextLanguageAction::MetaTextLanguageAction
MetaTextLanguageAction(MetaTextLanguageAction const &)=default

MetaTextLanguageAction::meTextLanguage
LanguageType meTextLanguage
Definition: metaact.hxx:1737

MetaTextLanguageAction::GetTextLanguage
LanguageType GetTextLanguage() const
Definition: metaact.hxx:1753

MetaTextLanguageAction::MetaTextLanguageAction
MetaTextLanguageAction(MetaTextLanguageAction &&)=default

MetaTextLanguageAction::SetTextLanguage
void SetTextLanguage(const LanguageType eTextLanguage)
Definition: metaact.hxx:1754

MetaTextLineAction
Definition: metaact.hxx:627

MetaTextLineAction::GetStartPoint
const Point & GetStartPoint() const
Definition: metaact.hxx:655

MetaTextLineAction::GetWidth
tools::Long GetWidth() const
Definition: metaact.hxx:656

MetaTextLineAction::GetUnderline
FontLineStyle GetUnderline() const
Definition: metaact.hxx:658

MetaTextLineAction::SetWidth
void SetWidth(tools::Long rWidth)
Definition: metaact.hxx:661

MetaTextLineAction::SetStartPoint
void SetStartPoint(const Point &rPos)
Definition: metaact.hxx:660

MetaTextLineAction::SetStrikeout
void SetStrikeout(FontStrikeout eStrikeout)
Definition: metaact.hxx:662

MetaTextLineAction::GetOverline
FontLineStyle GetOverline() const
Definition: metaact.hxx:659

MetaTextLineAction::MetaTextLineAction
MetaTextLineAction(MetaTextLineAction &&)=default

MetaTextLineAction::meStrikeout
FontStrikeout meStrikeout
Definition: metaact.hxx:632

MetaTextLineAction::SetOverline
void SetOverline(FontLineStyle eOverline)
Definition: metaact.hxx:664

MetaTextLineAction::mnWidth
tools::Long mnWidth
Definition: metaact.hxx:631

MetaTextLineAction::maPos
Point maPos
Definition: metaact.hxx:630

MetaTextLineAction::meUnderline
FontLineStyle meUnderline
Definition: metaact.hxx:633

MetaTextLineAction::GetStrikeout
FontStrikeout GetStrikeout() const
Definition: metaact.hxx:657

MetaTextLineAction::meOverline
FontLineStyle meOverline
Definition: metaact.hxx:634

MetaTextLineAction::MetaTextLineAction
MetaTextLineAction(MetaTextLineAction const &)=default

MetaTextLineAction::SetUnderline
void SetUnderline(FontLineStyle eUnderline)
Definition: metaact.hxx:663

MetaTextLineColorAction
Definition: metaact.hxx:1337

MetaTextLineColorAction::maColor
Color maColor
Definition: metaact.hxx:1340

MetaTextLineColorAction::mbSet
bool mbSet
Definition: metaact.hxx:1341

MetaTextLineColorAction::IsSetting
bool IsSetting() const
Definition: metaact.hxx:1360

MetaTextLineColorAction::MetaTextLineColorAction
MetaTextLineColorAction(MetaTextLineColorAction &&)=default

MetaTextLineColorAction::SetSetting
void SetSetting(bool bSet)
Definition: metaact.hxx:1359

MetaTextLineColorAction::GetColor
const Color & GetColor() const
Definition: metaact.hxx:1357

MetaTextLineColorAction::MetaTextLineColorAction
MetaTextLineColorAction(MetaTextLineColorAction const &)=default

MetaTextLineColorAction::SetColor
void SetColor(const Color &rColor)
Definition: metaact.hxx:1358

MetaTextRectAction
Definition: metaact.hxx:593

MetaTextRectAction::SetText
void SetText(const OUString &rStr)
Definition: metaact.hxx:622

MetaTextRectAction::GetStyle
DrawTextFlags GetStyle() const
Definition: metaact.hxx:620

MetaTextRectAction::MetaTextRectAction
MetaTextRectAction(MetaTextRectAction const &)=default

MetaTextRectAction::mnStyle
DrawTextFlags mnStyle
Definition: metaact.hxx:598

MetaTextRectAction::MetaTextRectAction
MetaTextRectAction(MetaTextRectAction &&)=default

MetaTextRectAction::GetRect
const tools::Rectangle & GetRect() const
Definition: metaact.hxx:618

MetaTextRectAction::SetRect
void SetRect(const tools::Rectangle &rRect)
Definition: metaact.hxx:621

MetaTextRectAction::maRect
tools::Rectangle maRect
Definition: metaact.hxx:596

MetaTextRectAction::SetStyle
void SetStyle(DrawTextFlags rStyle)
Definition: metaact.hxx:623

MetaTextRectAction::GetText
const OUString & GetText() const
Definition: metaact.hxx:619

MetaTextRectAction::maStr
OUString maStr
Definition: metaact.hxx:597

MetaTransparentAction
Definition: metaact.hxx:1540

MetaTransparentAction::GetTransparence
sal_uInt16 GetTransparence() const
Definition: metaact.hxx:1564

MetaTransparentAction::mnTransPercent
sal_uInt16 mnTransPercent
Definition: metaact.hxx:1544

MetaTransparentAction::IsTransparent
bool IsTransparent() const override
#i10613# Extracted from Printer::GetPreparedMetaFile.
Definition: metaact.hxx:1568

MetaTransparentAction::MetaTransparentAction
MetaTransparentAction(MetaTransparentAction &&)=default

MetaTransparentAction::MetaTransparentAction
MetaTransparentAction(MetaTransparentAction const &)=default

MetaTransparentAction::SetTransparence
void SetTransparence(const sal_uInt16 nTransPercent)
Definition: metaact.hxx:1566

MetaTransparentAction::GetPolyPolygon
const tools::PolyPolygon & GetPolyPolygon() const
Definition: metaact.hxx:1563

MetaTransparentAction::maPolyPoly
tools::PolyPolygon maPolyPoly
Definition: metaact.hxx:1543

MetaTransparentAction::SetPolyPolygon
void SetPolyPolygon(const tools::PolyPolygon &rPolyPoly)
Definition: metaact.hxx:1565

OutputDevice
Some things multiple-inherit from VclAbstractDialog and OutputDevice, so we need to use virtual inher...
Definition: outdev.hxx:171

Size

SvStream

Wallpaper
Definition: wall.hxx:53

emfio::ScaledFontDetectCorrectHelper

o3tl::span< const sal_Int32 >

rtl::Reference

salhelper::SimpleReferenceObject

salhelper::SimpleReferenceObject::m_nCount
oslInterlockedCount m_nCount

salhelper::SimpleReferenceObject::operator=
void operator=(SimpleReferenceObject) SAL_DELETED_FUNCTION

tools::PolyPolygon

tools::Polygon

tools::Rectangle

vcl::Font
Definition: include/vcl/font.hxx:48

vcl::Font::SetAverageFontWidth
void SetAverageFontWidth(tools::Long nWidth)
Definition: font/font.cxx:934

vcl::Region
Definition: region.hxx:41

config.h

SetText
virtual void SetText(const OUString &rStr) override

dllapi.h

VCL_DLLPUBLIC
#define VCL_DLLPUBLIC
Definition: dllapi.h:29

maSize
::basegfx::B2IVector maSize

nValue
sal_Int16 nValue

FontLineStyle
FontLineStyle

FontStrikeout
FontStrikeout

mnFlags
FuncFlags mnFlags

gdimtf.hxx

gfxlink.hxx

gradient.hxx

hatch.hxx

font.hxx

lineinfo.hxx

metaactiontypes.hxx

MetaActionType
MetaActionType
Definition: metaactiontypes.hxx:24

pData
std::unique_ptr< sal_Int32[]> pData

emfio

Clone
css::uno::Reference< css::animations::XAnimationNode > Clone(const css::uno::Reference< css::animations::XAnimationNode > &xSourceNode, const SdPage *pSource=nullptr, const SdPage *pTarget=nullptr)

TextAlign
TextAlign

Execute
const ::avmedia::MediaItem * Execute(const SdrMarkView *pSdrView, SfxRequest const &rReq)

tools::Long
long Long

vcl::drawmode::GetBitmapEx
BitmapEx GetBitmapEx(BitmapEx const &rBitmapEx, DrawModeFlags nDrawMode)
Definition: drawmode.cxx:224

vcl::text::ComplexTextLayoutFlags
ComplexTextLayoutFlags
Definition: State.hxx:76

vcl::PushFlags
PushFlags
Definition: State.hxx:40

poly.hxx

maComment
OUString maComment

region.hxx

mnType
sal_Int32 mnType

SnapKind::Point
@ Point

mnWidth
double mnWidth

rSet
static SfxItemSet & rSet

simplereferenceobject.hxx

mnValue
const double mnValue

span.hxx

ImplMetaReadData
Definition: metaact.hxx:53

ImplMetaReadData::ImplMetaReadData
ImplMetaReadData()
Definition: metaact.hxx:57

ImplMetaReadData::mnParseDepth
int mnParseDepth
Definition: metaact.hxx:55

ImplMetaReadData::meActualCharSet
rtl_TextEncoding meActualCharSet
Definition: metaact.hxx:54

ImplMetaWriteData
Definition: metaact.hxx:64

ImplMetaWriteData::ImplMetaWriteData
ImplMetaWriteData()
Definition: metaact.hxx:67

ImplMetaWriteData::meActualCharSet
rtl_TextEncoding meActualCharSet
Definition: metaact.hxx:65

LineInfo

o3tl::strong_int< sal_uInt16, struct LanguageTypeTag >

SdrHdlKind::Move
@ Move

GetLen
tools::Long GetLen(const Point &rPnt)

sal_uInt8
unsigned char sal_uInt8

wall.hxx

WallpaperStyle::Scale
@ Scale