include/vcl/metaact.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_VCL_METAACT_HXX
  21 #define INCLUDED_VCL_METAACT_HXX
  22
  23 #include <sal/config.h>
  24
  25 #include <config_options.h>
  26
  27 #include <o3tl/span.hxx>
  28 #include <rtl/ref.hxx>
  29 #include <salhelper/simplereferenceobject.hxx>
  30 #include <tools/poly.hxx>
  31
  32 #include <vcl/dllapi.h>
  33 #include <vcl/rendercontext/State.hxx>
  34 #include <vcl/bitmapex.hxx>
  35 #include <vcl/font.hxx>
  36 #include <vcl/gdimtf.hxx>
  37 #include <vcl/gfxlink.hxx>
  38 #include <vcl/gradient.hxx>
  39 #include <vcl/hatch.hxx>
  40 #include <vcl/kernarray.hxx>
  41 #include <vcl/lineinfo.hxx>
  42 #include <vcl/metaactiontypes.hxx>
  43 #include <vcl/region.hxx>
  44 #include <vcl/rendercontext/RasterOp.hxx>
  45 #include <vcl/wall.hxx>
  46 #include <basegfx/utils/bgradient.hxx>
  47
  48 #include <memory>
  49
  50 class OutputDevice;
  51 class SvStream;
  52 enum class DrawTextFlags;
  53
  54 struct ImplMetaReadData
  55 {
  56     rtl_TextEncoding meActualCharSet;
  57     int mnParseDepth;
  58
  59     ImplMetaReadData()
  60         : meActualCharSet(RTL_TEXTENCODING_ASCII_US)
  61         , mnParseDepth(0)
  62     {}
  63 };
  64
  65 struct ImplMetaWriteData
  66 {
  67     rtl_TextEncoding meActualCharSet;
  68
  69     ImplMetaWriteData() :
  70         meActualCharSet( RTL_TEXTENCODING_ASCII_US )
  71     {}
  72 };
  73
  74 class VCL_DLLPUBLIC MetaAction : public salhelper::SimpleReferenceObject
  75 {
  76 private:
  77     MetaActionType       mnType;
  78
  79 protected:
  80     virtual             ~MetaAction() override;
  81
  82 public:
  83                         MetaAction();
  84     explicit            MetaAction( MetaActionType nType );
  85                         MetaAction( MetaAction const & );
  86
  87     virtual void        Execute( OutputDevice* pOut );
  88
  89     oslInterlockedCount GetRefCount() const { return m_nCount; }
  90
  91     virtual rtl::Reference<MetaAction> Clone() const;
  92
  93     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove );
  94     virtual void        Scale( double fScaleX, double fScaleY );
  95
  96     MetaActionType      GetType() const { return mnType; }
  97     /** \#i10613# Extracted from Printer::GetPreparedMetaFile. Returns true
  98         if given action requires special transparency handling
  99     */
 100     virtual bool        IsTransparent() const { return false; }
 101 };
 102
 103 class VCL_DLLPUBLIC MetaPixelAction final : public MetaAction
 104 {
 105 private:
 106     Point               maPt;
 107     Color               maColor;
 108
 109 public:
 110                         MetaPixelAction();
 111     MetaPixelAction(MetaPixelAction const &) = default;
 112     MetaPixelAction(MetaPixelAction &&) = default;
 113     MetaPixelAction & operator =(MetaPixelAction const &) = delete; // due to MetaAction
 114     MetaPixelAction & operator =(MetaPixelAction &&) = delete; // due to MetaAction
 115 private:
 116     virtual             ~MetaPixelAction() override;
 117 public:
 118     virtual void        Execute( OutputDevice* pOut ) override;
 119     virtual rtl::Reference<MetaAction> Clone() const override;
 120
 121                         MetaPixelAction( const Point& rPt, const Color& rColor );
 122
 123     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 124     virtual void        Scale( double fScaleX, double fScaleY ) override;
 125
 126     const Point&        GetPoint() const { return maPt; }
 127     const Color&        GetColor() const { return maColor; }
 128     void                SetPoint(const Point& rPt) { maPt = rPt; }
 129     void                SetColor(Color rColor) { maColor = rColor; }
 130 };
 131
 132 class VCL_DLLPUBLIC MetaPointAction final : public MetaAction
 133 {
 134 private:
 135     Point               maPt;
 136
 137 public:
 138                         MetaPointAction();
 139     MetaPointAction(MetaPointAction const &) = default;
 140     MetaPointAction(MetaPointAction &&) = default;
 141     MetaPointAction & operator =(MetaPointAction const &) = delete; // due to MetaAction
 142     MetaPointAction & operator =(MetaPointAction &&) = delete; // due to MetaAction
 143 private:
 144     virtual             ~MetaPointAction() override;
 145 public:
 146     virtual void        Execute( OutputDevice* pOut ) override;
 147     virtual rtl::Reference<MetaAction> Clone() const override;
 148
 149     explicit            MetaPointAction( const Point& );
 150
 151     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 152     virtual void        Scale( double fScaleX, double fScaleY ) override;
 153
 154     const Point&        GetPoint() const { return maPt; }
 155     void                SetPoint(const Point& rPt) { maPt = rPt; }
 156 };
 157
 158 class VCL_DLLPUBLIC MetaLineAction final : public MetaAction
 159 {
 160 private:
 161
 162     LineInfo            maLineInfo;
 163     Point               maStartPt;
 164     Point               maEndPt;
 165
 166 public:
 167                         MetaLineAction();
 168     MetaLineAction(MetaLineAction const &) = default;
 169     MetaLineAction(MetaLineAction &&) = default;
 170     MetaLineAction & operator =(MetaLineAction const &) = delete; // due to MetaAction
 171     MetaLineAction & operator =(MetaLineAction &&) = delete; // due to MetaAction
 172 private:
 173     virtual             ~MetaLineAction() override;
 174 public:
 175     virtual void        Execute( OutputDevice* pOut ) override;
 176     virtual rtl::Reference<MetaAction> Clone() const override;
 177
 178                         MetaLineAction( const Point& rStart, const Point& rEnd );
 179                         MetaLineAction( const Point& rStart, const Point& rEnd,
 180                                         LineInfo aLineInfo );
 181
 182     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 183     virtual void        Scale( double fScaleX, double fScaleY ) override;
 184
 185     const Point&        GetStartPoint() const { return maStartPt; }
 186     const Point&        GetEndPoint() const { return maEndPt; }
 187     const LineInfo&     GetLineInfo() const { return maLineInfo; }
 188     void                SetStartPoint(const Point& rPoint) { maStartPt = rPoint; }
 189     void                SetEndPoint(const Point& rPoint) { maEndPt = rPoint; }
 190     void                SetLineInfo(const LineInfo& rLineInfo) { maLineInfo = rLineInfo; }
 191 };
 192
 193 class VCL_DLLPUBLIC MetaRectAction final : public MetaAction
 194 {
 195 private:
 196
 197     tools::Rectangle           maRect;
 198
 199 public:
 200                         MetaRectAction();
 201     MetaRectAction(MetaRectAction const &) = default;
 202     MetaRectAction(MetaRectAction &&) = default;
 203     MetaRectAction & operator =(MetaRectAction const &) = delete; // due to MetaAction
 204     MetaRectAction & operator =(MetaRectAction &&) = delete; // due to MetaAction
 205 private:
 206     virtual             ~MetaRectAction() override;
 207 public:
 208     virtual void        Execute( OutputDevice* pOut ) override;
 209     virtual rtl::Reference<MetaAction> Clone() const override;
 210
 211     explicit            MetaRectAction( const tools::Rectangle& );
 212
 213     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 214     virtual void        Scale( double fScaleX, double fScaleY ) override;
 215
 216     const tools::Rectangle&    GetRect() const { return maRect; }
 217     void                SetRect(const tools::Rectangle& rRect) { maRect = rRect; }
 218 };
 219
 220 class VCL_DLLPUBLIC MetaRoundRectAction final : public MetaAction
 221 {
 222 private:
 223
 224     tools::Rectangle           maRect;
 225     sal_uInt32          mnHorzRound;
 226     sal_uInt32          mnVertRound;
 227
 228 public:
 229                         MetaRoundRectAction();
 230     MetaRoundRectAction(MetaRoundRectAction const &) = default;
 231     MetaRoundRectAction(MetaRoundRectAction &&) = default;
 232     MetaRoundRectAction & operator =(MetaRoundRectAction const &) = delete; // due to MetaAction
 233     MetaRoundRectAction & operator =(MetaRoundRectAction &&) = delete; // due to MetaAction
 234 private:
 235     virtual             ~MetaRoundRectAction() override;
 236 public:
 237     virtual void        Execute( OutputDevice* pOut ) override;
 238     virtual rtl::Reference<MetaAction> Clone() const override;
 239
 240                         MetaRoundRectAction( const tools::Rectangle& rRect,
 241                                              sal_uInt32 nHorzRound, sal_uInt32 nVertRound );
 242
 243     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 244     virtual void        Scale( double fScaleX, double fScaleY ) override;
 245
 246     const tools::Rectangle&    GetRect() const { return maRect; }
 247     sal_uInt32          GetHorzRound() const { return mnHorzRound; }
 248     sal_uInt32          GetVertRound() const { return mnVertRound; }
 249     void                SetRect(const tools::Rectangle& rRect) { maRect = rRect; }
 250     void                SetHorzRound(sal_uInt32 rHorzRound) { mnHorzRound = rHorzRound; }
 251     void                SetVertRound(sal_uInt32 rVertRound) { mnVertRound = rVertRound; }
 252 };
 253
 254 class VCL_DLLPUBLIC MetaEllipseAction final : public MetaAction
 255 {
 256 private:
 257
 258     tools::Rectangle           maRect;
 259
 260 public:
 261                         MetaEllipseAction();
 262     MetaEllipseAction(MetaEllipseAction const &) = default;
 263     MetaEllipseAction(MetaEllipseAction &&) = default;
 264     MetaEllipseAction & operator =(MetaEllipseAction const &) = delete; // due to MetaAction
 265     MetaEllipseAction & operator =(MetaEllipseAction &&) = delete; // due to MetaAction
 266 private:
 267     virtual             ~MetaEllipseAction() override;
 268 public:
 269     virtual void        Execute( OutputDevice* pOut ) override;
 270     virtual rtl::Reference<MetaAction> Clone() const override;
 271
 272     explicit            MetaEllipseAction( const tools::Rectangle& );
 273
 274     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 275     virtual void        Scale( double fScaleX, double fScaleY ) override;
 276
 277     const tools::Rectangle&    GetRect() const { return maRect; }
 278     void                SetRect(const tools::Rectangle& rRect) { maRect = rRect; }
 279 };
 280
 281 class VCL_DLLPUBLIC MetaArcAction final : public MetaAction
 282 {
 283 private:
 284
 285     tools::Rectangle           maRect;
 286     Point               maStartPt;
 287     Point               maEndPt;
 288
 289 public:
 290                         MetaArcAction();
 291     MetaArcAction(MetaArcAction const &) = default;
 292     MetaArcAction(MetaArcAction &&) = default;
 293     MetaArcAction & operator =(MetaArcAction const &) = delete; // due to MetaAction
 294     MetaArcAction & operator =(MetaArcAction &&) = delete; // due to MetaAction
 295 private:
 296     virtual             ~MetaArcAction() override;
 297 public:
 298     virtual void        Execute( OutputDevice* pOut ) override;
 299     virtual rtl::Reference<MetaAction> Clone() const override;
 300
 301                         MetaArcAction( const tools::Rectangle& rRect,
 302                                        const Point& rStart, const Point& rEnd );
 303
 304     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 305     virtual void        Scale( double fScaleX, double fScaleY ) override;
 306
 307     const tools::Rectangle&    GetRect() const { return maRect; }
 308     const Point&        GetStartPoint() const { return maStartPt; }
 309     const Point&        GetEndPoint() const { return maEndPt; }
 310     void                SetRect(const tools::Rectangle& rRect) { maRect = rRect; }
 311     void                SetStartPoint(const Point& rPoint) { maStartPt = rPoint; }
 312     void                SetEndPoint(const Point& rPoint) { maEndPt = rPoint; }
 313 };
 314
 315 class VCL_DLLPUBLIC MetaPieAction final : public MetaAction
 316 {
 317 private:
 318
 319     tools::Rectangle           maRect;
 320     Point               maStartPt;
 321     Point               maEndPt;
 322
 323 public:
 324                         MetaPieAction();
 325     MetaPieAction(MetaPieAction const &) = default;
 326     MetaPieAction(MetaPieAction &&) = default;
 327     MetaPieAction & operator =(MetaPieAction const &) = delete; // due to MetaAction
 328     MetaPieAction & operator =(MetaPieAction &&) = delete; // due to MetaAction
 329 private:
 330     virtual             ~MetaPieAction() override;
 331 public:
 332     virtual void        Execute( OutputDevice* pOut ) override;
 333     virtual rtl::Reference<MetaAction> Clone() const override;
 334
 335                         MetaPieAction( const tools::Rectangle& rRect,
 336                                        const Point& rStart, const Point& rEnd );
 337
 338     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 339     virtual void        Scale( double fScaleX, double fScaleY ) override;
 340
 341     const tools::Rectangle&    GetRect() const { return maRect; }
 342     const Point&        GetStartPoint() const { return maStartPt; }
 343     const Point&        GetEndPoint() const { return maEndPt; }
 344     void                SetRect(const tools::Rectangle& rRect) { maRect = rRect; }
 345     void                SetStartPoint(const Point& rPoint) { maStartPt = rPoint; }
 346     void                SetEndPoint(const Point& rPoint) { maEndPt = rPoint; }
 347 };
 348
 349 class VCL_DLLPUBLIC MetaChordAction final : public MetaAction
 350 {
 351 private:
 352
 353     tools::Rectangle           maRect;
 354     Point               maStartPt;
 355     Point               maEndPt;
 356
 357 public:
 358                         MetaChordAction();
 359     MetaChordAction(MetaChordAction const &) = default;
 360     MetaChordAction(MetaChordAction &&) = default;
 361     MetaChordAction & operator =(MetaChordAction const &) = delete; // due to MetaAction
 362     MetaChordAction & operator =(MetaChordAction &&) = delete; // due to MetaAction
 363 private:
 364     virtual             ~MetaChordAction() override;
 365 public:
 366     virtual void        Execute( OutputDevice* pOut ) override;
 367     virtual rtl::Reference<MetaAction> Clone() const override;
 368
 369                         MetaChordAction( const tools::Rectangle& rRect,
 370                                          const Point& rStart, const Point& rEnd );
 371
 372     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 373     virtual void        Scale( double fScaleX, double fScaleY ) override;
 374
 375     const tools::Rectangle&    GetRect() const { return maRect; }
 376     const Point&        GetStartPoint() const { return maStartPt; }
 377     const Point&        GetEndPoint() const { return maEndPt; }
 378     void                SetRect(const tools::Rectangle& rRect) { maRect = rRect; }
 379     void                SetStartPoint(const Point& rPoint) { maStartPt = rPoint; }
 380     void                SetEndPoint(const Point& rPoint) { maEndPt = rPoint; }
 381 };
 382
 383 class VCL_DLLPUBLIC MetaPolyLineAction final : public MetaAction
 384 {
 385 private:
 386
 387     LineInfo            maLineInfo;
 388     tools::Polygon      maPoly;
 389
 390 public:
 391                         MetaPolyLineAction();
 392     MetaPolyLineAction(MetaPolyLineAction const &) = default;
 393     MetaPolyLineAction(MetaPolyLineAction &&) = default;
 394     MetaPolyLineAction & operator =(MetaPolyLineAction const &) = delete; // due to MetaAction
 395     MetaPolyLineAction & operator =(MetaPolyLineAction &&) = delete; // due to MetaAction
 396 private:
 397     virtual             ~MetaPolyLineAction() override;
 398 public:
 399     virtual void        Execute( OutputDevice* pOut ) override;
 400     virtual rtl::Reference<MetaAction> Clone() const override;
 401
 402     explicit            MetaPolyLineAction( tools::Polygon  );
 403     explicit            MetaPolyLineAction( tools::Polygon , LineInfo  );
 404
 405     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 406     virtual void        Scale( double fScaleX, double fScaleY ) override;
 407
 408     const tools::Polygon& GetPolygon() const { return maPoly; }
 409     const LineInfo&     GetLineInfo() const { return maLineInfo; }
 410     void                SetLineInfo(const LineInfo& rLineInfo) { maLineInfo = rLineInfo; }
 411     void                SetPolygon(const tools::Polygon& rPoly) { maPoly = rPoly; }
 412 };
 413
 414 class VCL_DLLPUBLIC MetaPolygonAction final : public MetaAction
 415 {
 416 private:
 417
 418     tools::Polygon      maPoly;
 419
 420 public:
 421                         MetaPolygonAction();
 422     MetaPolygonAction(MetaPolygonAction const &) = default;
 423     MetaPolygonAction(MetaPolygonAction &&) = default;
 424     MetaPolygonAction & operator =(MetaPolygonAction const &) = delete; // due to MetaAction
 425     MetaPolygonAction & operator =(MetaPolygonAction &&) = delete; // due to MetaAction
 426 private:
 427     virtual             ~MetaPolygonAction() override;
 428 public:
 429     virtual void        Execute( OutputDevice* pOut ) override;
 430     virtual rtl::Reference<MetaAction> Clone() const override;
 431
 432     explicit            MetaPolygonAction( tools::Polygon  );
 433
 434     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 435     virtual void        Scale( double fScaleX, double fScaleY ) override;
 436
 437     const tools::Polygon& GetPolygon() const { return maPoly; }
 438     void                SetPolygon(const tools::Polygon& rPoly) { maPoly = rPoly; }
 439 };
 440
 441 class VCL_DLLPUBLIC MetaPolyPolygonAction final : public MetaAction
 442 {
 443 private:
 444
 445     tools::PolyPolygon  maPolyPoly;
 446
 447 public:
 448                         MetaPolyPolygonAction();
 449     MetaPolyPolygonAction(MetaPolyPolygonAction const &) = default;
 450     MetaPolyPolygonAction(MetaPolyPolygonAction &&) = default;
 451     MetaPolyPolygonAction & operator =(MetaPolyPolygonAction const &) = delete; // due to MetaAction
 452     MetaPolyPolygonAction & operator =(MetaPolyPolygonAction &&) = delete; // due to MetaAction
 453 private:
 454     virtual             ~MetaPolyPolygonAction() override;
 455 public:
 456     virtual void        Execute( OutputDevice* pOut ) override;
 457     virtual rtl::Reference<MetaAction> Clone() const override;
 458
 459     explicit            MetaPolyPolygonAction( tools::PolyPolygon  );
 460
 461     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 462     virtual void        Scale( double fScaleX, double fScaleY ) override;
 463
 464     const tools::PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }
 465     void                SetPolyPolygon(const tools::PolyPolygon& rPolyPoly) { maPolyPoly = rPolyPoly; }
 466 };
 467
 468 class SAL_DLLPUBLIC_RTTI MetaTextAction final : public MetaAction
 469 {
 470 private:
 471
 472     Point           maPt;
 473     OUString        maStr;
 474     sal_Int32       mnIndex;
 475     sal_Int32       mnLen;
 476
 477 public:
 478                         MetaTextAction();
 479     MetaTextAction(MetaTextAction const &) = default;
 480     MetaTextAction(MetaTextAction &&) = default;
 481     MetaTextAction & operator =(MetaTextAction const &) = delete; // due to MetaAction
 482     MetaTextAction & operator =(MetaTextAction &&) = delete; // due to MetaAction
 483 private:
 484     virtual             ~MetaTextAction() override;
 485 public:
 486     virtual void        Execute( OutputDevice* pOut ) override;
 487     virtual rtl::Reference<MetaAction> Clone() const override;
 488
 489     MetaTextAction( const Point& rPt, OUString aStr,
 490                     sal_Int32 nIndex, sal_Int32 nLen );
 491
 492     virtual void    Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 493     virtual void    Scale( double fScaleX, double fScaleY ) override;
 494
 495     const Point&    GetPoint() const { return maPt; }
 496     const OUString& GetText() const { return maStr; }
 497     sal_Int32       GetIndex() const { return mnIndex; }
 498     sal_Int32       GetLen() const { return mnLen; }
 499     void            SetPoint(const Point& rPt) { maPt = rPt; }
 500     void            SetText(const OUString& rStr) { maStr = rStr; }
 501     void            SetIndex(sal_Int32 rIndex) { mnIndex = rIndex; }
 502     void            SetLen(sal_Int32 rLen) { mnLen = rLen; }
 503 };
 504
 505 class VCL_DLLPUBLIC MetaTextArrayAction final : public MetaAction
 506 {
 507 private:
 508
 509     Point       maStartPt;
 510     OUString    maStr;
 511     KernArray   maDXAry;
 512     std::vector<sal_Bool> maKashidaAry;
 513     sal_Int32   mnIndex;
 514     sal_Int32   mnLen;
 515
 516     virtual             ~MetaTextArrayAction() override;
 517
 518 public:
 519                         MetaTextArrayAction();
 520                         MetaTextArrayAction( const MetaTextArrayAction& rAction );
 521     MetaTextArrayAction( const Point& rStartPt, OUString aStr,
 522                          KernArray rDXAry,
 523                          std::vector<sal_Bool> pKashidaAry,
 524                          sal_Int32 nIndex,
 525                          sal_Int32 nLen );
 526     MetaTextArrayAction( const Point& rStartPt, OUString aStr,
 527                          KernArraySpan pDXAry,
 528                          o3tl::span<const sal_Bool> pKashidaAry,
 529                          sal_Int32 nIndex,
 530                          sal_Int32 nLen );
 531
 532     virtual void        Execute( OutputDevice* pOut ) override;
 533
 534     virtual rtl::Reference<MetaAction> Clone() const override;
 535
 536     virtual void    Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 537     virtual void    Scale( double fScaleX, double fScaleY ) override;
 538
 539     const Point&    GetPoint() const { return maStartPt; }
 540     const OUString& GetText() const { return maStr; }
 541     sal_Int32       GetIndex() const { return mnIndex; }
 542     sal_Int32       GetLen() const { return mnLen; }
 543     const KernArray& GetDXArray() const { return maDXAry; }
 544     const std::vector<sal_Bool> & GetKashidaArray() const { return maKashidaAry; }
 545     void            SetPoint(const Point& rPt) { maStartPt = rPt; }
 546     void            SetText(const OUString& rStr) { maStr = rStr; }
 547     void            SetIndex(sal_Int32 rIndex) { mnIndex = rIndex; }
 548     void            SetLen(sal_Int32 rLen) { mnLen = rLen; }
 549     void            SetDXArray(KernArray aArray);
 550     void            SetKashidaArray(std::vector<sal_Bool> aArray);
 551 };
 552
 553 class SAL_DLLPUBLIC_RTTI MetaStretchTextAction final : public MetaAction
 554 {
 555 private:
 556
 557     Point       maPt;
 558     OUString    maStr;
 559     sal_uInt32  mnWidth;
 560     sal_Int32   mnIndex;
 561     sal_Int32   mnLen;
 562
 563 public:
 564                         MetaStretchTextAction();
 565     MetaStretchTextAction(MetaStretchTextAction const &) = default;
 566     MetaStretchTextAction(MetaStretchTextAction &&) = default;
 567     MetaStretchTextAction & operator =(MetaStretchTextAction const &) = delete; // due to MetaAction
 568     MetaStretchTextAction & operator =(MetaStretchTextAction &&) = delete; // due to MetaAction
 569 private:
 570     virtual             ~MetaStretchTextAction() override;
 571 public:
 572     virtual void        Execute( OutputDevice* pOut ) override;
 573     virtual rtl::Reference<MetaAction> Clone() const override;
 574
 575     MetaStretchTextAction( const Point& rPt, sal_uInt32 nWidth,
 576                            OUString aStr,
 577                            sal_Int32 nIndex, sal_Int32 nLen );
 578
 579     virtual void    Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 580     virtual void    Scale( double fScaleX, double fScaleY ) override;
 581
 582     const Point&    GetPoint() const { return maPt; }
 583     const OUString& GetText() const { return maStr; }
 584     sal_uInt32      GetWidth() const { return mnWidth; }
 585     sal_Int32       GetIndex() const { return mnIndex; }
 586     sal_Int32       GetLen() const { return mnLen; }
 587     void            SetPoint(const Point& rPt) { maPt = rPt; }
 588     void            SetText(const OUString& rStr) { maStr = rStr; }
 589     void            SetWidth(sal_uInt32 rWidth) { mnWidth = rWidth; }
 590     void            SetIndex(sal_uInt32 rIndex) { mnIndex = rIndex; }
 591     void            SetLen(sal_uInt32 rLen) { mnLen = rLen; }
 592 };
 593
 594 class SAL_DLLPUBLIC_RTTI MetaTextRectAction final : public MetaAction
 595 {
 596 private:
 597
 598     tools::Rectangle           maRect;
 599     OUString            maStr;
 600     DrawTextFlags       mnStyle;
 601
 602 public:
 603                         MetaTextRectAction();
 604     MetaTextRectAction(MetaTextRectAction const &) = default;
 605     MetaTextRectAction(MetaTextRectAction &&) = default;
 606     MetaTextRectAction & operator =(MetaTextRectAction const &) = delete; // due to MetaAction
 607     MetaTextRectAction & operator =(MetaTextRectAction &&) = delete; // due to MetaAction
 608 private:
 609     virtual             ~MetaTextRectAction() override;
 610 public:
 611     virtual void        Execute( OutputDevice* pOut ) override;
 612     virtual rtl::Reference<MetaAction> Clone() const override;
 613
 614     MetaTextRectAction( const tools::Rectangle& rRect,
 615                         OUString aStr, DrawTextFlags nStyle );
 616
 617     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 618     virtual void        Scale( double fScaleX, double fScaleY ) override;
 619
 620     const tools::Rectangle&    GetRect() const { return maRect; }
 621     const OUString&     GetText() const { return maStr; }
 622     DrawTextFlags       GetStyle() const { return mnStyle; }
 623     void                SetRect(const tools::Rectangle& rRect) { maRect = rRect; }
 624     void                SetText(const OUString& rStr) { maStr = rStr; }
 625     void                SetStyle(DrawTextFlags rStyle) { mnStyle = rStyle; }
 626 };
 627
 628 class SAL_DLLPUBLIC_RTTI MetaTextLineAction final : public MetaAction
 629 {
 630 private:
 631
 632     Point               maPos;
 633     tools::Long                mnWidth;
 634     FontStrikeout       meStrikeout;
 635     FontLineStyle       meUnderline;
 636     FontLineStyle       meOverline;
 637
 638 public:
 639                         MetaTextLineAction();
 640     MetaTextLineAction(MetaTextLineAction const &) = default;
 641     MetaTextLineAction(MetaTextLineAction &&) = default;
 642     MetaTextLineAction & operator =(MetaTextLineAction const &) = delete; // due to MetaAction
 643     MetaTextLineAction & operator =(MetaTextLineAction &&) = delete; // due to MetaAction
 644 private:
 645     virtual             ~MetaTextLineAction() override;
 646 public:
 647     virtual void        Execute( OutputDevice* pOut ) override;
 648     virtual rtl::Reference<MetaAction> Clone() const override;
 649
 650                         MetaTextLineAction( const Point& rPos, tools::Long nWidth,
 651                                             FontStrikeout eStrikeout,
 652                                             FontLineStyle eUnderline,
 653                                             FontLineStyle eOverline );
 654     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 655     virtual void        Scale( double fScaleX, double fScaleY ) override;
 656
 657     const Point&        GetStartPoint() const { return maPos; }
 658     tools::Long                GetWidth() const { return mnWidth; }
 659     FontStrikeout       GetStrikeout() const { return meStrikeout; }
 660     FontLineStyle       GetUnderline() const { return meUnderline; }
 661     FontLineStyle       GetOverline()  const { return meOverline; }
 662     void                SetStartPoint(const Point& rPos) { maPos = rPos; }
 663     void                SetWidth(tools::Long rWidth) { mnWidth = rWidth; }
 664     void                SetStrikeout(FontStrikeout eStrikeout) { meStrikeout = eStrikeout; }
 665     void                SetUnderline(FontLineStyle eUnderline) { meUnderline = eUnderline; }
 666     void                SetOverline(FontLineStyle eOverline) { meOverline = eOverline; }
 667 };
 668
 669 class VCL_DLLPUBLIC MetaBmpAction final : public MetaAction
 670 {
 671 private:
 672
 673     Bitmap              maBmp;
 674     Point               maPt;
 675
 676 public:
 677                         MetaBmpAction();
 678     MetaBmpAction(MetaBmpAction const &) = default;
 679     MetaBmpAction(MetaBmpAction &&) = default;
 680     MetaBmpAction & operator =(MetaBmpAction const &) = delete; // due to MetaAction
 681     MetaBmpAction & operator =(MetaBmpAction &&) = delete; // due to MetaAction
 682 private:
 683     virtual             ~MetaBmpAction() override;
 684 public:
 685     virtual void        Execute( OutputDevice* pOut ) override;
 686     virtual rtl::Reference<MetaAction> Clone() const override;
 687
 688                         MetaBmpAction( const Point& rPt, const Bitmap& rBmp );
 689
 690     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 691     virtual void        Scale( double fScaleX, double fScaleY ) override;
 692
 693     const Bitmap&       GetBitmap() const { return maBmp; }
 694     const Point&        GetPoint() const { return maPt; }
 695     void                SetBitmap(const Bitmap& rBmp) { maBmp = rBmp; }
 696     void                SetPoint(const Point& rPt) { maPt = rPt; }
 697 };
 698
 699 class VCL_DLLPUBLIC MetaBmpScaleAction final : public MetaAction
 700 {
 701 private:
 702
 703     Bitmap              maBmp;
 704     Point               maPt;
 705     Size                maSz;
 706
 707 public:
 708                         MetaBmpScaleAction();
 709     MetaBmpScaleAction(MetaBmpScaleAction const &) = default;
 710     MetaBmpScaleAction(MetaBmpScaleAction &&) = default;
 711     MetaBmpScaleAction & operator =(MetaBmpScaleAction const &) = delete; // due to MetaAction
 712     MetaBmpScaleAction & operator =(MetaBmpScaleAction &&) = delete; // due to MetaAction
 713 private:
 714     virtual             ~MetaBmpScaleAction() override;
 715 public:
 716     virtual void        Execute( OutputDevice* pOut ) override;
 717     virtual rtl::Reference<MetaAction> Clone() const override;
 718
 719                         MetaBmpScaleAction( const Point& rPt, const Size& rSz,
 720                                             const Bitmap& rBmp );
 721
 722     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 723     virtual void        Scale( double fScaleX, double fScaleY ) override;
 724
 725     const Bitmap&       GetBitmap() const { return maBmp; }
 726     const Point&        GetPoint() const { return maPt; }
 727     const Size&         GetSize() const { return maSz; }
 728     void                SetBitmap(const Bitmap& rBmp) { maBmp = rBmp; }
 729     void                SetPoint(const Point& rPt) { maPt = rPt; }
 730     void                SetSize(const Size& rSz) { maSz = rSz; }
 731 };
 732
 733 class VCL_DLLPUBLIC MetaBmpScalePartAction final : public MetaAction
 734 {
 735 private:
 736
 737     Bitmap              maBmp;
 738     Point               maDstPt;
 739     Size                maDstSz;
 740     Point               maSrcPt;
 741     Size                maSrcSz;
 742
 743 public:
 744                         MetaBmpScalePartAction();
 745     MetaBmpScalePartAction(MetaBmpScalePartAction const &) = default;
 746     MetaBmpScalePartAction(MetaBmpScalePartAction &&) = default;
 747     MetaBmpScalePartAction & operator =(MetaBmpScalePartAction const &) = delete; // due to MetaAction
 748     MetaBmpScalePartAction & operator =(MetaBmpScalePartAction &&) = delete; // due to MetaAction
 749 private:
 750     virtual             ~MetaBmpScalePartAction() override;
 751 public:
 752     virtual void        Execute( OutputDevice* pOut ) override;
 753     virtual rtl::Reference<MetaAction> Clone() const override;
 754
 755                         MetaBmpScalePartAction( const Point& rDstPt, const Size& rDstSz,
 756                                                 const Point& rSrcPt, const Size& rSrcSz,
 757                                                 const Bitmap& rBmp );
 758
 759     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 760     virtual void        Scale( double fScaleX, double fScaleY ) override;
 761
 762     const Bitmap&       GetBitmap() const { return maBmp; }
 763     const Point&        GetDestPoint() const { return maDstPt; }
 764     const Size&         GetDestSize() const { return maDstSz; }
 765     const Point&        GetSrcPoint() const { return maSrcPt; }
 766     const Size&         GetSrcSize() const { return maSrcSz; }
 767     void                SetBitmap(const Bitmap& rBmp) { maBmp = rBmp; }
 768     void                SetDestPoint(const Point& rPt) { maDstPt = rPt; }
 769     void                SetDestSize(const Size& rSz) { maDstSz = rSz; }
 770     void                SetSrcPoint(const Point& rPt) { maSrcPt = rPt; }
 771     void                SetSrcSize(const Size& rSz) { maSrcSz = rSz; }
 772 };
 773
 774 class VCL_DLLPUBLIC MetaBmpExAction final : public MetaAction
 775 {
 776 private:
 777
 778     BitmapEx            maBmpEx;
 779     Point               maPt;
 780
 781 public:
 782                         MetaBmpExAction();
 783     MetaBmpExAction(MetaBmpExAction const &) = default;
 784     MetaBmpExAction(MetaBmpExAction &&) = default;
 785     MetaBmpExAction & operator =(MetaBmpExAction const &) = delete; // due to MetaAction
 786     MetaBmpExAction & operator =(MetaBmpExAction &&) = delete; // due to MetaAction
 787 private:
 788     virtual             ~MetaBmpExAction() override;
 789 public:
 790     virtual void        Execute( OutputDevice* pOut ) override;
 791     virtual rtl::Reference<MetaAction> Clone() const override;
 792
 793                         MetaBmpExAction( const Point& rPt, const BitmapEx& rBmpEx );
 794
 795     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 796     virtual void        Scale( double fScaleX, double fScaleY ) override;
 797
 798     const BitmapEx&     GetBitmapEx() const { return maBmpEx; }
 799     const Point&        GetPoint() const { return maPt; }
 800     void                SetBitmapEx(BitmapEx rBmpEx) { maBmpEx = rBmpEx; }
 801     void                SetPoint(const Point& rPt) { maPt = rPt; }
 802     bool                IsTransparent() const override { return GetBitmapEx().IsAlpha(); }
 803 };
 804
 805 class VCL_DLLPUBLIC MetaBmpExScaleAction final : public MetaAction
 806 {
 807 private:
 808
 809     BitmapEx            maBmpEx;
 810     Point               maPt;
 811     Size                maSz;
 812
 813 public:
 814                         MetaBmpExScaleAction();
 815     MetaBmpExScaleAction(MetaBmpExScaleAction const &) = default;
 816     MetaBmpExScaleAction(MetaBmpExScaleAction &&) = default;
 817     MetaBmpExScaleAction & operator =(MetaBmpExScaleAction const &) = delete; // due to MetaAction
 818     MetaBmpExScaleAction & operator =(MetaBmpExScaleAction &&) = delete; // due to MetaAction
 819 private:
 820     virtual             ~MetaBmpExScaleAction() override;
 821 public:
 822     virtual void        Execute( OutputDevice* pOut ) override;
 823     virtual rtl::Reference<MetaAction> Clone() const override;
 824
 825                         MetaBmpExScaleAction( const Point& rPt, const Size& rSz,
 826                                               const BitmapEx& rBmpEx ) ;
 827
 828     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 829     virtual void        Scale( double fScaleX, double fScaleY ) override;
 830
 831     const BitmapEx&     GetBitmapEx() const { return maBmpEx; }
 832     const Point&        GetPoint() const { return maPt; }
 833     const Size&         GetSize() const { return maSz; }
 834     void                SetBitmapEx(const BitmapEx& rBmpEx) { maBmpEx = rBmpEx; }
 835     void                SetPoint(const Point& rPt) { maPt = rPt; }
 836     void                SetSize(const Size& rSz) { maSz = rSz; }
 837     bool                IsTransparent() const override { return GetBitmapEx().IsAlpha(); }
 838 };
 839
 840 class VCL_DLLPUBLIC MetaBmpExScalePartAction final : public MetaAction
 841 {
 842 private:
 843
 844     BitmapEx            maBmpEx;
 845     Point               maDstPt;
 846     Size                maDstSz;
 847     Point               maSrcPt;
 848     Size                maSrcSz;
 849
 850 public:
 851                         MetaBmpExScalePartAction();
 852     MetaBmpExScalePartAction(MetaBmpExScalePartAction const &) = default;
 853     MetaBmpExScalePartAction(MetaBmpExScalePartAction &&) = default;
 854     MetaBmpExScalePartAction & operator =(MetaBmpExScalePartAction const &) = delete; // due to MetaAction
 855     MetaBmpExScalePartAction & operator =(MetaBmpExScalePartAction &&) = delete; // due to MetaAction
 856 private:
 857     virtual             ~MetaBmpExScalePartAction() override;
 858 public:
 859     virtual void        Execute( OutputDevice* pOut ) override;
 860     virtual rtl::Reference<MetaAction> Clone() const override;
 861
 862                         MetaBmpExScalePartAction( const Point& rDstPt, const Size& rDstSz,
 863                                                   const Point& rSrcPt, const Size& rSrcSz,
 864                                                   const BitmapEx& rBmpEx );
 865
 866     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 867     virtual void        Scale( double fScaleX, double fScaleY ) override;
 868
 869     const BitmapEx&     GetBitmapEx() const { return maBmpEx; }
 870     const Point&        GetDestPoint() const { return maDstPt; }
 871     const Size&         GetDestSize() const { return maDstSz; }
 872     const Point&        GetSrcPoint() const { return maSrcPt; }
 873     const Size&         GetSrcSize() const { return maSrcSz; }
 874     void                SetBitmapEx(const BitmapEx& rBmpEx) { maBmpEx = rBmpEx; }
 875     void                SetDestPoint(const Point& rDstPt) { maDstPt = rDstPt; }
 876     void                SetDestSize(const Size& rDstSz) { maDstSz = rDstSz; }
 877     void                SetSrcPoint(const Point& rSrcPt) { maSrcPt = rSrcPt; }
 878     void                SetSrcSize(const Size& rSrcSz) { maSrcSz = rSrcSz; }
 879     bool                IsTransparent() const override { return GetBitmapEx().IsAlpha(); }
 880 };
 881
 882 class SAL_DLLPUBLIC_RTTI MetaMaskAction final : public MetaAction
 883 {
 884 private:
 885
 886     Bitmap              maBmp;
 887     Color               maColor;
 888     Point               maPt;
 889
 890 public:
 891                         MetaMaskAction();
 892     MetaMaskAction(MetaMaskAction const &) = default;
 893     MetaMaskAction(MetaMaskAction &&) = default;
 894     MetaMaskAction & operator =(MetaMaskAction const &) = delete; // due to MetaAction
 895     MetaMaskAction & operator =(MetaMaskAction &&) = delete; // due to MetaAction
 896 private:
 897     virtual             ~MetaMaskAction() override;
 898 public:
 899     virtual void        Execute( OutputDevice* pOut ) override;
 900     virtual rtl::Reference<MetaAction> Clone() const override;
 901
 902                         MetaMaskAction( const Point& rPt,
 903                                         const Bitmap& rBmp,
 904                                         const Color& rColor );
 905
 906     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 907     virtual void        Scale( double fScaleX, double fScaleY ) override;
 908
 909     const Bitmap&       GetBitmap() const { return maBmp; }
 910     const Color&        GetColor() const { return maColor; }
 911     const Point&        GetPoint() const { return maPt; }
 912     void                SetBitmap(const Bitmap& rBmp) { maBmp = rBmp; }
 913     void                SetPoint(const Point& rPt) { maPt = rPt; }
 914 };
 915
 916 class SAL_DLLPUBLIC_RTTI MetaMaskScaleAction final : public MetaAction
 917 {
 918 private:
 919
 920     Bitmap              maBmp;
 921     Color               maColor;
 922     Point               maPt;
 923     Size                maSz;
 924
 925 public:
 926                         MetaMaskScaleAction();
 927     MetaMaskScaleAction(MetaMaskScaleAction const &) = default;
 928     MetaMaskScaleAction(MetaMaskScaleAction &&) = default;
 929     MetaMaskScaleAction & operator =(MetaMaskScaleAction const &) = delete; // due to MetaAction
 930     MetaMaskScaleAction & operator =(MetaMaskScaleAction &&) = delete; // due to MetaAction
 931 private:
 932     virtual             ~MetaMaskScaleAction() override;
 933 public:
 934     virtual void        Execute( OutputDevice* pOut ) override;
 935     virtual rtl::Reference<MetaAction> Clone() const override;
 936
 937                         MetaMaskScaleAction( const Point& rPt, const Size& rSz,
 938                                              const Bitmap& rBmp,
 939                                              const Color& rColor );
 940
 941     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 942     virtual void        Scale( double fScaleX, double fScaleY ) override;
 943
 944     const Bitmap&       GetBitmap() const { return maBmp; }
 945     const Color&        GetColor() const { return maColor; }
 946     const Point&        GetPoint() const { return maPt; }
 947     const Size&         GetSize() const { return maSz; }
 948     void                SetBitmap(const Bitmap& rBmp) { maBmp = rBmp; }
 949     void                SetPoint(const Point& rPt) { maPt = rPt; }
 950     void                SetSize(const Size& rSz) { maSz = rSz; }
 951 };
 952
 953 class SAL_DLLPUBLIC_RTTI MetaMaskScalePartAction final : public MetaAction
 954 {
 955 private:
 956
 957     Bitmap              maBmp;
 958     Color               maColor;
 959     Point               maDstPt;
 960     Size                maDstSz;
 961     Point               maSrcPt;
 962     Size                maSrcSz;
 963
 964 public:
 965                         MetaMaskScalePartAction();
 966     MetaMaskScalePartAction(MetaMaskScalePartAction const &) = default;
 967     MetaMaskScalePartAction(MetaMaskScalePartAction &&) = default;
 968     MetaMaskScalePartAction & operator =(MetaMaskScalePartAction const &) = delete; // due to MetaAction
 969     MetaMaskScalePartAction & operator =(MetaMaskScalePartAction &&) = delete; // due to MetaAction
 970 private:
 971     virtual             ~MetaMaskScalePartAction() override;
 972 public:
 973     virtual void        Execute( OutputDevice* pOut ) override;
 974     virtual rtl::Reference<MetaAction> Clone() const override;
 975
 976                         MetaMaskScalePartAction( const Point& rDstPt, const Size& rDstSz,
 977                                                  const Point& rSrcPt, const Size& rSrcSz,
 978                                                  const Bitmap& rBmp,
 979                                                  const Color& rColor );
 980
 981     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
 982     virtual void        Scale( double fScaleX, double fScaleY ) override;
 983
 984     const Bitmap&       GetBitmap() const { return maBmp; }
 985     const Color&        GetColor() const { return maColor; }
 986     const Point&        GetDestPoint() const { return maDstPt; }
 987     const Size&         GetDestSize() const { return maDstSz; }
 988     const Point&        GetSrcPoint() const { return maSrcPt; }
 989     const Size&         GetSrcSize() const { return maSrcSz; }
 990     void                SetBitmap(const Bitmap& rBmp) { maBmp = rBmp; }
 991     void                SetColor(Color rColor) { maColor = rColor; }
 992     void                SetDestPoint(const Point& rPt) { maDstPt = rPt; }
 993     void                SetDestSize(const Size& rSz) { maDstSz = rSz; }
 994     void                SetSrcPoint(const Point& rPt) { maSrcPt = rPt; }
 995     void                SetSrcSize(const Size& rSz) { maSrcSz = rSz; }
 996 };
 997
 998 class SAL_DLLPUBLIC_RTTI MetaGradientAction final : public MetaAction
 999 {
1000 private:
1001
1002     tools::Rectangle           maRect;
1003     Gradient            maGradient;
1004
1005 public:
1006                         MetaGradientAction();
1007     MetaGradientAction(MetaGradientAction const &) = default;
1008     MetaGradientAction(MetaGradientAction &&) = default;
1009     MetaGradientAction & operator =(MetaGradientAction const &) = delete; // due to MetaAction
1010     MetaGradientAction & operator =(MetaGradientAction &&) = delete; // due to MetaAction
1011 private:
1012     virtual             ~MetaGradientAction() override;
1013 public:
1014     virtual void        Execute( OutputDevice* pOut ) override;
1015     virtual rtl::Reference<MetaAction> Clone() const override;
1016
1017                         MetaGradientAction( const tools::Rectangle& rRect, Gradient aGradient );
1018
1019     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
1020     virtual void        Scale( double fScaleX, double fScaleY ) override;
1021
1022     const tools::Rectangle&    GetRect() const { return maRect; }
1023     const Gradient&     GetGradient() const { return maGradient; }
1024     void                SetGradient(const Gradient& rGradient) { maGradient = rGradient; }
1025     void                SetRect(const tools::Rectangle& rRect) { maRect = rRect; }
1026 };
1027
1028 class VCL_DLLPUBLIC MetaGradientExAction final : public MetaAction
1029 {
1030 private:
1031
1032     tools::PolyPolygon  maPolyPoly;
1033     Gradient            maGradient;
1034
1035 public:
1036                         MetaGradientExAction();
1037     MetaGradientExAction(MetaGradientExAction const &) = default;
1038     MetaGradientExAction(MetaGradientExAction &&) = default;
1039     MetaGradientExAction & operator =(MetaGradientExAction const &) = delete; // due to MetaAction
1040     MetaGradientExAction & operator =(MetaGradientExAction &&) = delete; // due to MetaAction
1041 private:
1042     virtual             ~MetaGradientExAction() override;
1043 public:
1044     virtual void        Execute( OutputDevice* pOut ) override;
1045     virtual rtl::Reference<MetaAction> Clone() const override;
1046
1047                         MetaGradientExAction( tools::PolyPolygon  rPolyPoly, Gradient aGradient );
1048
1049     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
1050     virtual void        Scale( double fScaleX, double fScaleY ) override;
1051
1052     const tools::PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }
1053     const Gradient&     GetGradient() const { return maGradient; }
1054     void                SetPolyPolygon(const tools::PolyPolygon& rPolyPoly) { maPolyPoly = rPolyPoly; }
1055     void                SetGradient(const Gradient& rGradient) { maGradient = rGradient; }
1056 };
1057
1058 class SAL_DLLPUBLIC_RTTI MetaHatchAction final : public MetaAction
1059 {
1060 private:
1061
1062     tools::PolyPolygon  maPolyPoly;
1063     Hatch               maHatch;
1064
1065 public:
1066                         MetaHatchAction();
1067     MetaHatchAction(MetaHatchAction const &) = default;
1068     MetaHatchAction(MetaHatchAction &&) = default;
1069     MetaHatchAction & operator =(MetaHatchAction const &) = delete; // due to MetaAction
1070     MetaHatchAction & operator =(MetaHatchAction &&) = delete; // due to MetaAction
1071 private:
1072     virtual             ~MetaHatchAction() override;
1073 public:
1074     virtual void        Execute( OutputDevice* pOut ) override;
1075     virtual rtl::Reference<MetaAction> Clone() const override;
1076
1077                         MetaHatchAction( tools::PolyPolygon aPolyPoly, const Hatch& rHatch );
1078
1079     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
1080     virtual void        Scale( double fScaleX, double fScaleY ) override;
1081
1082     const tools::PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }
1083     const Hatch&        GetHatch() const { return maHatch; }
1084     void                SetPolyPolygon(const tools::PolyPolygon& rPolyPoly) { maPolyPoly = rPolyPoly; }
1085     void                SetHatch(const Hatch& rHatch) { maHatch = rHatch; }
1086 };
1087
1088 class VCL_DLLPUBLIC MetaWallpaperAction final : public MetaAction
1089 {
1090 private:
1091
1092     tools::Rectangle           maRect;
1093     Wallpaper           maWallpaper;
1094
1095 public:
1096                         MetaWallpaperAction();
1097     MetaWallpaperAction(MetaWallpaperAction const &) = default;
1098     MetaWallpaperAction(MetaWallpaperAction &&) = default;
1099     MetaWallpaperAction & operator =(MetaWallpaperAction const &) = delete; // due to MetaAction
1100     MetaWallpaperAction & operator =(MetaWallpaperAction &&) = delete; // due to MetaAction
1101 private:
1102     virtual             ~MetaWallpaperAction() override;
1103 public:
1104     virtual void        Execute( OutputDevice* pOut ) override;
1105     virtual rtl::Reference<MetaAction> Clone() const override;
1106
1107                         MetaWallpaperAction( const tools::Rectangle& rRect,
1108                                              const Wallpaper& rPaper );
1109
1110     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
1111     virtual void        Scale( double fScaleX, double fScaleY ) override;
1112
1113     const tools::Rectangle&    GetRect() const { return maRect; }
1114     const Wallpaper&    GetWallpaper() const { return maWallpaper; }
1115     void                SetWallpaper(const Wallpaper& rWallpaper) { maWallpaper = rWallpaper; }
1116 };
1117
1118 class VCL_DLLPUBLIC MetaClipRegionAction final : public MetaAction
1119 {
1120 private:
1121
1122     vcl::Region         maRegion;
1123     bool                mbClip;
1124
1125 public:
1126                         MetaClipRegionAction();
1127     MetaClipRegionAction(MetaClipRegionAction const &) = default;
1128     MetaClipRegionAction(MetaClipRegionAction &&) = default;
1129     MetaClipRegionAction & operator =(MetaClipRegionAction const &) = delete; // due to MetaAction
1130     MetaClipRegionAction & operator =(MetaClipRegionAction &&) = delete; // due to MetaAction
1131 private:
1132     virtual             ~MetaClipRegionAction() override;
1133 public:
1134     virtual void        Execute( OutputDevice* pOut ) override;
1135     virtual rtl::Reference<MetaAction> Clone() const override;
1136
1137                         MetaClipRegionAction( vcl::Region aRegion, bool bClip );
1138
1139     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
1140     virtual void        Scale( double fScaleX, double fScaleY ) override;
1141
1142     const vcl::Region&  GetRegion() const { return maRegion; }
1143     bool                IsClipping() const { return mbClip; }
1144     void                SetRegion(const vcl::Region& rRegion) { maRegion = rRegion; }
1145     void                SetClipping(bool bClip) { mbClip = bClip; }
1146 };
1147
1148 class VCL_DLLPUBLIC MetaISectRectClipRegionAction final : public MetaAction
1149 {
1150 private:
1151
1152     tools::Rectangle           maRect;
1153
1154 public:
1155                         MetaISectRectClipRegionAction();
1156     MetaISectRectClipRegionAction(MetaISectRectClipRegionAction const &) = default;
1157     MetaISectRectClipRegionAction(MetaISectRectClipRegionAction &&) = default;
1158     MetaISectRectClipRegionAction & operator =(MetaISectRectClipRegionAction const &) = delete; // due to MetaAction
1159     MetaISectRectClipRegionAction & operator =(MetaISectRectClipRegionAction &&) = delete; // due to MetaAction
1160 private:
1161     virtual             ~MetaISectRectClipRegionAction() override;
1162 public:
1163     virtual void        Execute( OutputDevice* pOut ) override;
1164     virtual rtl::Reference<MetaAction> Clone() const override;
1165
1166     explicit            MetaISectRectClipRegionAction( const tools::Rectangle& );
1167
1168     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
1169     virtual void        Scale( double fScaleX, double fScaleY ) override;
1170
1171     const tools::Rectangle&    GetRect() const { return maRect; }
1172     void                SetRect(const tools::Rectangle& rRect) { maRect = rRect; }
1173 };
1174
1175 class VCL_DLLPUBLIC MetaISectRegionClipRegionAction final : public MetaAction
1176 {
1177 private:
1178
1179     vcl::Region          maRegion;
1180
1181 public:
1182                         MetaISectRegionClipRegionAction();
1183     MetaISectRegionClipRegionAction(MetaISectRegionClipRegionAction const &) = default;
1184     MetaISectRegionClipRegionAction(MetaISectRegionClipRegionAction &&) = default;
1185     MetaISectRegionClipRegionAction & operator =(MetaISectRegionClipRegionAction const &) = delete; // due to MetaAction
1186     MetaISectRegionClipRegionAction & operator =(MetaISectRegionClipRegionAction &&) = delete; // due to MetaAction
1187 private:
1188     virtual             ~MetaISectRegionClipRegionAction() override;
1189 public:
1190     virtual void        Execute( OutputDevice* pOut ) override;
1191     virtual rtl::Reference<MetaAction> Clone() const override;
1192
1193     explicit            MetaISectRegionClipRegionAction( vcl::Region  );
1194
1195     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
1196     virtual void        Scale( double fScaleX, double fScaleY ) override;
1197
1198     const vcl::Region&  GetRegion() const { return maRegion; }
1199     void                SetRegion(const vcl::Region& rRegion) { maRegion = rRegion; }
1200 };
1201
1202 class VCL_DLLPUBLIC MetaMoveClipRegionAction final : public MetaAction
1203 {
1204 private:
1205
1206     tools::Long                mnHorzMove;
1207     tools::Long                mnVertMove;
1208
1209 public:
1210                         MetaMoveClipRegionAction();
1211     MetaMoveClipRegionAction(MetaMoveClipRegionAction const &) = default;
1212     MetaMoveClipRegionAction(MetaMoveClipRegionAction &&) = default;
1213     MetaMoveClipRegionAction & operator =(MetaMoveClipRegionAction const &) = delete; // due to MetaAction
1214     MetaMoveClipRegionAction & operator =(MetaMoveClipRegionAction &&) = delete; // due to MetaAction
1215 private:
1216     virtual             ~MetaMoveClipRegionAction() override;
1217 public:
1218     virtual void        Execute( OutputDevice* pOut ) override;
1219     virtual rtl::Reference<MetaAction> Clone() const override;
1220
1221                         MetaMoveClipRegionAction( tools::Long nHorzMove, tools::Long nVertMove );
1222
1223     virtual void        Scale( double fScaleX, double fScaleY ) override;
1224
1225     tools::Long                GetHorzMove() const { return mnHorzMove; }
1226     tools::Long                GetVertMove() const { return mnVertMove; }
1227     void                SetHorzMove(tools::Long nHorzMove) { mnHorzMove = nHorzMove; }
1228     void                SetVertMove(tools::Long nVertMove) { mnVertMove = nVertMove; }
1229 };
1230
1231 class VCL_DLLPUBLIC MetaLineColorAction final : public MetaAction
1232 {
1233 private:
1234
1235     Color               maColor;
1236     bool                mbSet;
1237
1238 public:
1239                         MetaLineColorAction();
1240     MetaLineColorAction(MetaLineColorAction const &) = default;
1241     MetaLineColorAction(MetaLineColorAction &&) = default;
1242     MetaLineColorAction & operator =(MetaLineColorAction const &) = delete; // due to MetaAction
1243     MetaLineColorAction & operator =(MetaLineColorAction &&) = delete; // due to MetaAction
1244 private:
1245     virtual             ~MetaLineColorAction() override;
1246 public:
1247     virtual void        Execute( OutputDevice* pOut ) override;
1248     virtual rtl::Reference<MetaAction> Clone() const override;
1249
1250                         MetaLineColorAction( const Color& rColor, bool bSet );
1251
1252     const Color&        GetColor() const { return maColor; }
1253     bool                IsSetting() const { return mbSet; }
1254     void                SetColor(const Color& rColor) { maColor = rColor; }
1255     void                SetSetting(bool rSet) { mbSet = rSet; }
1256 };
1257
1258 class VCL_DLLPUBLIC MetaFillColorAction final : public MetaAction
1259 {
1260 private:
1261
1262     Color               maColor;
1263     bool                mbSet;
1264
1265 public:
1266                         MetaFillColorAction();
1267     MetaFillColorAction(MetaFillColorAction const &) = default;
1268     MetaFillColorAction(MetaFillColorAction &&) = default;
1269     MetaFillColorAction & operator =(MetaFillColorAction const &) = delete; // due to MetaAction
1270     MetaFillColorAction & operator =(MetaFillColorAction &&) = delete; // due to MetaAction
1271 private:
1272     virtual             ~MetaFillColorAction() override;
1273 public:
1274     virtual void        Execute( OutputDevice* pOut ) override;
1275     virtual rtl::Reference<MetaAction> Clone() const override;
1276
1277                         MetaFillColorAction( const Color& rColor, bool bSet );
1278
1279     const Color&        GetColor() const { return maColor; }
1280     bool                IsSetting() const { return mbSet; }
1281     void                SetSetting(bool rSet) { mbSet = rSet; }
1282     void                SetColor(Color rColor) { maColor = rColor; }
1283
1284 };
1285
1286 class VCL_DLLPUBLIC MetaTextColorAction final : public MetaAction
1287 {
1288 private:
1289
1290     Color               maColor;
1291
1292 public:
1293                         MetaTextColorAction();
1294     MetaTextColorAction(MetaTextColorAction const &) = default;
1295     MetaTextColorAction(MetaTextColorAction &&) = default;
1296     MetaTextColorAction & operator =(MetaTextColorAction const &) = delete; // due to MetaAction
1297     MetaTextColorAction & operator =(MetaTextColorAction &&) = delete; // due to MetaAction
1298 private:
1299     virtual             ~MetaTextColorAction() override;
1300 public:
1301     virtual void        Execute( OutputDevice* pOut ) override;
1302     virtual rtl::Reference<MetaAction> Clone() const override;
1303
1304     explicit            MetaTextColorAction( const Color& );
1305
1306     const Color&        GetColor() const { return maColor; }
1307     void                SetColor(Color rColor) { maColor = rColor; }
1308 };
1309
1310 class VCL_DLLPUBLIC MetaTextFillColorAction final : public MetaAction
1311 {
1312 private:
1313
1314     Color               maColor;
1315     bool                mbSet;
1316
1317 public:
1318                         MetaTextFillColorAction();
1319     MetaTextFillColorAction(MetaTextFillColorAction const &) = default;
1320     MetaTextFillColorAction(MetaTextFillColorAction &&) = default;
1321     MetaTextFillColorAction & operator =(MetaTextFillColorAction const &) = delete; // due to MetaAction
1322     MetaTextFillColorAction & operator =(MetaTextFillColorAction &&) = delete; // due to MetaAction
1323 private:
1324     virtual             ~MetaTextFillColorAction() override;
1325 public:
1326     virtual void        Execute( OutputDevice* pOut ) override;
1327     virtual rtl::Reference<MetaAction> Clone() const override;
1328
1329                         MetaTextFillColorAction( const Color& rColor, bool bSet );
1330
1331     const Color&        GetColor() const { return maColor; }
1332     void                SetColor(Color rColor) { maColor = rColor; }
1333     void                SetSetting(bool bSet) { mbSet = bSet; }
1334     bool                IsSetting() const { return mbSet; }
1335
1336 };
1337
1338 class VCL_DLLPUBLIC MetaTextLineColorAction final : public MetaAction
1339 {
1340 private:
1341
1342     Color               maColor;
1343     bool                mbSet;
1344
1345 public:
1346                         MetaTextLineColorAction();
1347     MetaTextLineColorAction(MetaTextLineColorAction const &) = default;
1348     MetaTextLineColorAction(MetaTextLineColorAction &&) = default;
1349     MetaTextLineColorAction & operator =(MetaTextLineColorAction const &) = delete; // due to MetaAction
1350     MetaTextLineColorAction & operator =(MetaTextLineColorAction &&) = delete; // due to MetaAction
1351 private:
1352     virtual             ~MetaTextLineColorAction() override;
1353 public:
1354     virtual void        Execute( OutputDevice* pOut ) override;
1355     virtual rtl::Reference<MetaAction> Clone() const override;
1356
1357                         MetaTextLineColorAction( const Color& rColor, bool bSet );
1358
1359     const Color&        GetColor() const { return maColor; }
1360     void                SetColor(const Color& rColor) { maColor = rColor; }
1361     void                SetSetting(bool bSet) { mbSet = bSet; }
1362     bool                IsSetting() const { return mbSet; }
1363 };
1364
1365 class VCL_DLLPUBLIC MetaOverlineColorAction final : public MetaAction
1366 {
1367 private:
1368
1369     Color               maColor;
1370     bool                mbSet;
1371
1372 public:
1373                         MetaOverlineColorAction();
1374     MetaOverlineColorAction(MetaOverlineColorAction const &) = default;
1375     MetaOverlineColorAction(MetaOverlineColorAction &&) = default;
1376     MetaOverlineColorAction & operator =(MetaOverlineColorAction const &) = delete; // due to MetaAction
1377     MetaOverlineColorAction & operator =(MetaOverlineColorAction &&) = delete; // due to MetaAction
1378 private:
1379     virtual             ~MetaOverlineColorAction() override;
1380 public:
1381     virtual void        Execute( OutputDevice* pOut ) override;
1382     virtual rtl::Reference<MetaAction> Clone() const override;
1383
1384                         MetaOverlineColorAction( const Color& rColor, bool bSet );
1385
1386     const Color&        GetColor() const { return maColor; }
1387     void                SetColor(const Color& rColor) { maColor = rColor; }
1388     void                SetSetting(bool bSet) { mbSet = bSet; }
1389     bool                IsSetting() const { return mbSet; }
1390 };
1391
1392 class VCL_DLLPUBLIC MetaTextAlignAction final : public MetaAction
1393 {
1394 private:
1395
1396     TextAlign           maAlign;
1397
1398 public:
1399                         MetaTextAlignAction();
1400     MetaTextAlignAction(MetaTextAlignAction const &) = default;
1401     MetaTextAlignAction(MetaTextAlignAction &&) = default;
1402     MetaTextAlignAction & operator =(MetaTextAlignAction const &) = delete; // due to MetaAction
1403     MetaTextAlignAction & operator =(MetaTextAlignAction &&) = delete; // due to MetaAction
1404 private:
1405     virtual             ~MetaTextAlignAction() override;
1406 public:
1407     virtual void        Execute( OutputDevice* pOut ) override;
1408     virtual rtl::Reference<MetaAction> Clone() const override;
1409
1410     explicit            MetaTextAlignAction( TextAlign eAlign );
1411
1412     TextAlign           GetTextAlign() const { return maAlign; }
1413     void                SetTextAlign(TextAlign eAlign) { maAlign = eAlign; }
1414 };
1415
1416 class VCL_DLLPUBLIC MetaMapModeAction final : public MetaAction
1417 {
1418 private:
1419
1420     MapMode             maMapMode;
1421
1422 public:
1423                         MetaMapModeAction();
1424     MetaMapModeAction(MetaMapModeAction const &) = default;
1425     MetaMapModeAction(MetaMapModeAction &&) = default;
1426     MetaMapModeAction & operator =(MetaMapModeAction const &) = delete; // due to MetaAction
1427     MetaMapModeAction & operator =(MetaMapModeAction &&) = delete; // due to MetaAction
1428 private:
1429     virtual             ~MetaMapModeAction() override;
1430 public:
1431     virtual void        Execute( OutputDevice* pOut ) override;
1432     virtual rtl::Reference<MetaAction> Clone() const override;
1433
1434     explicit            MetaMapModeAction( const MapMode& );
1435
1436     virtual void        Scale( double fScaleX, double fScaleY ) override;
1437
1438     const MapMode&      GetMapMode() const { return maMapMode; }
1439     void                SetMapMode(const MapMode& rMapMode) { maMapMode = rMapMode; }
1440 };
1441
1442 // tdf#127471 decl for friend below
1443 namespace emfio { class ScaledFontDetectCorrectHelper; }
1444
1445 class VCL_DLLPUBLIC MetaFontAction final : public MetaAction
1446 {
1447 private:
1448
1449     vcl::Font           maFont;
1450
1451     // tdf#127471 for import correction of own wrong written EMF/WMF files allow correction
1452     // of FontScale after import. Only from there, so use a friend here and keep the method private
1453     friend class emfio::ScaledFontDetectCorrectHelper;
1454     void correctFontScale(tools::Long nNewFontScale) { maFont.SetAverageFontWidth(nNewFontScale); }
1455
1456 public:
1457                         MetaFontAction();
1458     MetaFontAction(MetaFontAction const &) = default;
1459     MetaFontAction(MetaFontAction &&) = default;
1460     MetaFontAction & operator =(MetaFontAction const &) = delete; // due to MetaAction
1461     MetaFontAction & operator =(MetaFontAction &&) = delete; // due to MetaAction
1462 private:
1463     virtual             ~MetaFontAction() override;
1464 public:
1465     virtual void        Execute( OutputDevice* pOut ) override;
1466     virtual rtl::Reference<MetaAction> Clone() const override;
1467
1468     explicit            MetaFontAction( vcl::Font  );
1469
1470     virtual void        Scale( double fScaleX, double fScaleY ) override;
1471
1472     const vcl::Font&    GetFont() const { return maFont; }
1473     void                SetFont(const vcl::Font& rFont) { maFont = rFont; }
1474
1475 };
1476
1477 class VCL_DLLPUBLIC MetaPushAction final : public MetaAction
1478 {
1479 private:
1480
1481     vcl::PushFlags           mnFlags;
1482
1483 public:
1484                         MetaPushAction();
1485     MetaPushAction(MetaPushAction const &) = default;
1486     MetaPushAction(MetaPushAction &&) = default;
1487     MetaPushAction & operator =(MetaPushAction const &) = delete; // due to MetaAction
1488     MetaPushAction & operator =(MetaPushAction &&) = delete; // due to MetaAction
1489 private:
1490     virtual             ~MetaPushAction() override;
1491 public:
1492     virtual void        Execute( OutputDevice* pOut ) override;
1493     virtual rtl::Reference<MetaAction> Clone() const override;
1494
1495     explicit            MetaPushAction( vcl::PushFlags nFlags );
1496
1497     vcl::PushFlags           GetFlags() const { return mnFlags; }
1498     void                SetPushFlags(const vcl::PushFlags nFlags) { mnFlags = nFlags; }
1499 };
1500
1501 class VCL_DLLPUBLIC MetaPopAction final : public MetaAction
1502 {
1503 public:
1504
1505                         MetaPopAction();
1506     MetaPopAction(MetaPopAction const &) = default;
1507     MetaPopAction(MetaPopAction &&) = default;
1508     MetaPopAction & operator =(MetaPopAction const &) = delete; // due to MetaAction
1509     MetaPopAction & operator =(MetaPopAction &&) = delete; // due to MetaAction
1510 private:
1511     virtual             ~MetaPopAction() override;
1512 public:
1513     virtual void        Execute( OutputDevice* pOut ) override;
1514     virtual rtl::Reference<MetaAction> Clone() const override;
1515 };
1516
1517 class VCL_DLLPUBLIC MetaRasterOpAction final : public MetaAction
1518 {
1519 private:
1520
1521     RasterOp            meRasterOp;
1522
1523 public:
1524                         MetaRasterOpAction();
1525     MetaRasterOpAction(MetaRasterOpAction const &) = default;
1526     MetaRasterOpAction(MetaRasterOpAction &&) = default;
1527     MetaRasterOpAction & operator =(MetaRasterOpAction const &) = delete; // due to MetaAction
1528     MetaRasterOpAction & operator =(MetaRasterOpAction &&) = delete; // due to MetaAction
1529 private:
1530     virtual             ~MetaRasterOpAction() override;
1531 public:
1532     virtual void        Execute( OutputDevice* pOut ) override;
1533     virtual rtl::Reference<MetaAction> Clone() const override;
1534
1535     explicit            MetaRasterOpAction( RasterOp eRasterOp );
1536
1537     RasterOp            GetRasterOp() const { return meRasterOp; }
1538     void                SetRasterOp(const RasterOp eRasterOp) { meRasterOp = eRasterOp; }
1539 };
1540
1541 class SAL_DLLPUBLIC_RTTI MetaTransparentAction final : public MetaAction
1542 {
1543 private:
1544
1545     tools::PolyPolygon  maPolyPoly;
1546     sal_uInt16          mnTransPercent;
1547
1548 public:
1549                         MetaTransparentAction();
1550     MetaTransparentAction(MetaTransparentAction const &) = default;
1551     MetaTransparentAction(MetaTransparentAction &&) = default;
1552     MetaTransparentAction & operator =(MetaTransparentAction const &) = delete; // due to MetaAction
1553     MetaTransparentAction & operator =(MetaTransparentAction &&) = delete; // due to MetaAction
1554 private:
1555     virtual             ~MetaTransparentAction() override;
1556 public:
1557     virtual void        Execute( OutputDevice* pOut ) override;
1558     virtual rtl::Reference<MetaAction> Clone() const override;
1559
1560                         MetaTransparentAction( tools::PolyPolygon aPolyPoly, sal_uInt16 nTransPercent );
1561
1562     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
1563     virtual void        Scale( double fScaleX, double fScaleY ) override;
1564
1565     const tools::PolyPolygon&  GetPolyPolygon() const { return maPolyPoly; }
1566     sal_uInt16              GetTransparence() const { return mnTransPercent; }
1567     void                SetPolyPolygon(const tools::PolyPolygon& rPolyPoly) { maPolyPoly = rPolyPoly; }
1568     void                SetTransparence(const sal_uInt16 nTransPercent) { mnTransPercent = nTransPercent; }
1569
1570     bool                IsTransparent() const override { return true; }
1571 };
1572
1573 class VCL_DLLPUBLIC MetaFloatTransparentAction final : public MetaAction
1574 {
1575 private:
1576
1577     GDIMetaFile         maMtf;
1578     Point               maPoint;
1579     Size                maSize;
1580     Gradient            maGradient;
1581
1582     // tdf#155479 allow holding MCGR infos
1583     std::optional<basegfx::BColorStops> maSVGTransparencyColorStops;
1584
1585 public:
1586                         MetaFloatTransparentAction();
1587     MetaFloatTransparentAction(MetaFloatTransparentAction const &) = default;
1588     MetaFloatTransparentAction(MetaFloatTransparentAction &&) = default;
1589     MetaFloatTransparentAction & operator =(MetaFloatTransparentAction const &) = delete; // due to MetaAction
1590     MetaFloatTransparentAction & operator =(MetaFloatTransparentAction &&) = delete; // due to MetaAction
1591 private:
1592     virtual             ~MetaFloatTransparentAction() override;
1593 public:
1594     virtual void        Execute( OutputDevice* pOut ) override;
1595     virtual rtl::Reference<MetaAction> Clone() const override;
1596
1597                         MetaFloatTransparentAction( const GDIMetaFile& rMtf, const Point& rPos,
1598                                                     const Size& rSize, Gradient aGradient );
1599
1600     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
1601     virtual void        Scale( double fScaleX, double fScaleY ) override;
1602
1603     const GDIMetaFile&  GetGDIMetaFile() const { return maMtf; }
1604     const Point&        GetPoint() const { return maPoint; }
1605     const Size&         GetSize() const { return maSize; }
1606     const Gradient&     GetGradient() const { return maGradient; }
1607     void                SetGDIMetaFile(const GDIMetaFile &rMtf) { maMtf  = rMtf; }
1608     void                SetPoint(const Point& rPoint) { maPoint = rPoint; }
1609     void                SetSize(const Size& rSize) { maSize = rSize; }
1610     void                SetGradient(const Gradient& rGradient) { maGradient = rGradient; }
1611     bool                IsTransparent() const override { return true; }
1612
1613     // tdf#155479 allow holding MCGR infos
1614     const basegfx::BColorStops* getSVGTransparencyColorStops() const
1615     { return !maSVGTransparencyColorStops ? nullptr : &(*maSVGTransparencyColorStops); }
1616     void addSVGTransparencyColorStops(const basegfx::BColorStops& rSVGTransparencyColorStops);
1617 };
1618
1619 class VCL_DLLPUBLIC MetaEPSAction final : public MetaAction
1620 {
1621 private:
1622
1623     GfxLink             maGfxLink;
1624     GDIMetaFile         maSubst;
1625     Point               maPoint;
1626     Size                maSize;
1627
1628 public:
1629                         MetaEPSAction();
1630     MetaEPSAction(MetaEPSAction const &) = default;
1631     MetaEPSAction(MetaEPSAction &&) = default;
1632     MetaEPSAction & operator =(MetaEPSAction const &) = delete; // due to MetaAction
1633     MetaEPSAction & operator =(MetaEPSAction &&) = delete; // due to MetaAction
1634 private:
1635     virtual             ~MetaEPSAction() override;
1636 public:
1637     virtual void        Execute( OutputDevice* pOut ) override;
1638     virtual rtl::Reference<MetaAction> Clone() const override;
1639
1640                         MetaEPSAction( const Point& rPoint, const Size& rSize,
1641                                        GfxLink aGfxLink, const GDIMetaFile& rSubst );
1642
1643     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
1644     virtual void        Scale( double fScaleX, double fScaleY ) override;
1645
1646     const GfxLink&      GetLink() const { return maGfxLink; }
1647     const GDIMetaFile&  GetSubstitute() const { return maSubst; }
1648     const Point&        GetPoint() const { return maPoint; }
1649     const Size&         GetSize() const { return maSize; }
1650     void                SetLink(const GfxLink& rGfxLink) { maGfxLink = rGfxLink; }
1651     void                SetSubstitute(const GDIMetaFile& rSubst) { maSubst = rSubst; }
1652     void                SetPoint(const Point& rPoint) { maPoint = rPoint; }
1653     void                SetSize(const Size& rSize) { maSize = rSize; }
1654 };
1655
1656 class VCL_DLLPUBLIC MetaRefPointAction final : public MetaAction
1657 {
1658 private:
1659
1660     Point               maRefPoint;
1661     bool                mbSet;
1662
1663 public:
1664                         MetaRefPointAction();
1665     MetaRefPointAction(MetaRefPointAction const &) = default;
1666     MetaRefPointAction(MetaRefPointAction &&) = default;
1667     MetaRefPointAction & operator =(MetaRefPointAction const &) = delete; // due to MetaAction
1668     MetaRefPointAction & operator =(MetaRefPointAction &&) = delete; // due to MetaAction
1669 private:
1670     virtual             ~MetaRefPointAction() override;
1671 public:
1672     virtual void        Execute( OutputDevice* pOut ) override;
1673     virtual rtl::Reference<MetaAction> Clone() const override;
1674
1675                         MetaRefPointAction( const Point& rRefPoint, bool bSet );
1676
1677     const Point&        GetRefPoint() const { return maRefPoint; }
1678     void                SetRefPoint(const Point& rRefPoint) { maRefPoint = rRefPoint; }
1679     void                SetSetting(const bool bSet) { mbSet = bSet; }
1680     bool                IsSetting() const { return mbSet; }
1681 };
1682
1683 class VCL_DLLPUBLIC MetaCommentAction final : public MetaAction
1684 {
1685 private:
1686
1687     OString             maComment;
1688     sal_Int32           mnValue;
1689     sal_uInt32          mnDataSize;
1690     std::unique_ptr<sal_uInt8[]>
1691                         mpData;
1692
1693     SAL_DLLPRIVATE void ImplInitDynamicData( const sal_uInt8* pData, sal_uInt32 nDataSize );
1694
1695 private:
1696     virtual             ~MetaCommentAction() override;
1697
1698 public:
1699     explicit            MetaCommentAction();
1700     explicit            MetaCommentAction( const MetaCommentAction& rAct );
1701     explicit            MetaCommentAction( OString aComment, sal_Int32 nValue = 0, const sal_uInt8* pData = nullptr, sal_uInt32 nDataSize = 0 );
1702
1703     virtual void        Move( tools::Long nHorzMove, tools::Long nVertMove ) override;
1704     virtual void        Scale( double fScaleX, double fScaleY ) override;
1705
1706     virtual void        Execute( OutputDevice* pOut ) override;
1707     virtual rtl::Reference<MetaAction> Clone() const override;
1708
1709     const OString&      GetComment() const { return maComment; }
1710     sal_Int32           GetValue() const { return mnValue; }
1711     sal_uInt32          GetDataSize() const { return mnDataSize; }
1712     const sal_uInt8*    GetData() const { return mpData.get(); }
1713     void                SetComment(const OString& rComment) { maComment = rComment; }
1714     void                SetValue(const sal_Int32 nValue) { mnValue = nValue; }
1715     void                SetDataSize(const sal_Int32 nDataSize) { mnDataSize = nDataSize; }
1716     void                SetData(const sal_uInt8* pData, const sal_uInt32 nDataSize) { ImplInitDynamicData(pData, nDataSize); }
1717 };
1718
1719 class VCL_DLLPUBLIC MetaLayoutModeAction final : public MetaAction
1720 {
1721 private:
1722
1723     vcl::text::ComplexTextLayoutFlags  mnLayoutMode;
1724
1725 public:
1726                         MetaLayoutModeAction();
1727     MetaLayoutModeAction(MetaLayoutModeAction const &) = default;
1728     MetaLayoutModeAction(MetaLayoutModeAction &&) = default;
1729     MetaLayoutModeAction & operator =(MetaLayoutModeAction const &) = delete; // due to MetaAction
1730     MetaLayoutModeAction & operator =(MetaLayoutModeAction &&) = delete; // due to MetaAction
1731 private:
1732     virtual             ~MetaLayoutModeAction() override;
1733 public:
1734     virtual void        Execute( OutputDevice* pOut ) override;
1735     virtual rtl::Reference<MetaAction> Clone() const override;
1736
1737     explicit            MetaLayoutModeAction( vcl::text::ComplexTextLayoutFlags nLayoutMode );
1738
1739     vcl::text::ComplexTextLayoutFlags  GetLayoutMode() const { return mnLayoutMode; }
1740     void                SetLayoutMode(const vcl::text::ComplexTextLayoutFlags nLayoutMode) { mnLayoutMode = nLayoutMode; }
1741 };
1742
1743 class VCL_DLLPUBLIC MetaTextLanguageAction final : public MetaAction
1744 {
1745 private:
1746
1747     LanguageType        meTextLanguage;
1748
1749 public:
1750                         MetaTextLanguageAction();
1751     MetaTextLanguageAction(MetaTextLanguageAction const &) = default;
1752     MetaTextLanguageAction(MetaTextLanguageAction &&) = default;
1753     MetaTextLanguageAction & operator =(MetaTextLanguageAction const &) = delete; // due to MetaAction
1754     MetaTextLanguageAction & operator =(MetaTextLanguageAction &&) = delete; // due to MetaAction
1755 private:
1756     virtual             ~MetaTextLanguageAction() override;
1757 public:
1758     virtual void        Execute( OutputDevice* pOut ) override;
1759     virtual rtl::Reference<MetaAction> Clone() const override;
1760
1761     explicit            MetaTextLanguageAction( LanguageType );
1762
1763     LanguageType        GetTextLanguage() const { return meTextLanguage; }
1764     void                SetTextLanguage(const LanguageType eTextLanguage) { meTextLanguage = eTextLanguage; }
1765 };
1766
1767 #endif // INCLUDED_VCL_METAACT_HXX
1768
1769 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */