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