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