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