vcl/source/gdi/metaact.cxx

   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 #include <stdio.h>
  21 #include <string.h>
  22 #include <osl/thread.h>
  23 #include <sal/log.hxx>
  24 #include <tools/stream.hxx>
  25 #include <tools/vcompat.hxx>
  26 #include <tools/helpers.hxx>
  27 #include <utility>
  28 #include <vcl/dibtools.hxx>
  29 #include <vcl/filter/SvmReader.hxx>
  30 #include <vcl/filter/SvmWriter.hxx>
  31 #include <vcl/outdev.hxx>
  32 #include <vcl/metaact.hxx>
  33 #include <vcl/graphictools.hxx>
  34 #include <comphelper/configuration.hxx>
  35 #include <unotools/fontdefs.hxx>
  36 #include <vcl/TypeSerializer.hxx>
  37
  38 namespace
  39 {
  40
  41 void ImplScalePoint( Point& rPt, double fScaleX, double fScaleY )
  42 {
  43     rPt.setX(basegfx::fround<tools::Long>(fScaleX * rPt.X()));
  44     rPt.setY(basegfx::fround<tools::Long>(fScaleY * rPt.Y()));
  45 }
  46
  47 void ImplScaleRect( tools::Rectangle& rRect, double fScaleX, double fScaleY )
  48 {
  49     Point aTL( rRect.TopLeft() );
  50     Point aBR( rRect.BottomRight() );
  51
  52     ImplScalePoint( aTL, fScaleX, fScaleY );
  53     ImplScalePoint( aBR, fScaleX, fScaleY );
  54
  55     rRect = tools::Rectangle( aTL, aBR );
  56     rRect.Normalize();
  57 }
  58
  59 void ImplScalePoly( tools::Polygon& rPoly, double fScaleX, double fScaleY )
  60 {
  61     for( sal_uInt16 i = 0, nCount = rPoly.GetSize(); i < nCount; i++ )
  62         ImplScalePoint( rPoly[ i ], fScaleX, fScaleY );
  63 }
  64
  65 void ImplScaleLineInfo( LineInfo& rLineInfo, double fScaleX, double fScaleY )
  66 {
  67     if( !rLineInfo.IsDefault() )
  68     {
  69         const double fScale = ( fabs(fScaleX) + fabs(fScaleY) ) * 0.5;
  70
  71         rLineInfo.SetWidth(fScale * rLineInfo.GetWidth());
  72         rLineInfo.SetDashLen(fScale * rLineInfo.GetDashLen());
  73         rLineInfo.SetDotLen(fScale * rLineInfo.GetDotLen());
  74         rLineInfo.SetDistance(fScale * rLineInfo.GetDistance());
  75     }
  76 }
  77
  78 } //anonymous namespace
  79
  80 MetaAction::MetaAction() :
  81     mnType( MetaActionType::NONE )
  82 {
  83 }
  84
  85 MetaAction::MetaAction( MetaActionType nType ) :
  86     mnType( nType )
  87 {
  88 }
  89
  90 MetaAction::MetaAction( MetaAction const & rOther ) :
  91     SimpleReferenceObject(), mnType( rOther.mnType )
  92 {
  93 }
  94
  95 MetaAction::~MetaAction()
  96 {
  97 }
  98
  99 void MetaAction::Execute( OutputDevice* )
 100 {
 101 }
 102
 103 rtl::Reference<MetaAction> MetaAction::Clone() const
 104 {
 105     return new MetaAction;
 106 }
 107
 108 void MetaAction::Move( tools::Long, tools::Long )
 109 {
 110 }
 111
 112 void MetaAction::Scale( double, double )
 113 {
 114 }
 115
 116 MetaPixelAction::MetaPixelAction() :
 117     MetaAction(MetaActionType::PIXEL)
 118 {}
 119
 120 MetaPixelAction::~MetaPixelAction()
 121 {}
 122
 123 MetaPixelAction::MetaPixelAction( const Point& rPt, const Color& rColor ) :
 124     MetaAction  ( MetaActionType::PIXEL ),
 125     maPt        ( rPt ),
 126     maColor     ( rColor )
 127 {}
 128
 129 void MetaPixelAction::Execute( OutputDevice* pOut )
 130 {
 131     pOut->DrawPixel( maPt, maColor );
 132 }
 133
 134 rtl::Reference<MetaAction> MetaPixelAction::Clone() const
 135 {
 136     return new MetaPixelAction( *this );
 137 }
 138
 139 void MetaPixelAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
 140 {
 141     maPt.Move( nHorzMove, nVertMove );
 142 }
 143
 144 void MetaPixelAction::Scale( double fScaleX, double fScaleY )
 145 {
 146     ImplScalePoint( maPt, fScaleX, fScaleY );
 147 }
 148
 149 MetaPointAction::MetaPointAction() :
 150     MetaAction(MetaActionType::POINT)
 151 {}
 152
 153 MetaPointAction::~MetaPointAction()
 154 {}
 155
 156 MetaPointAction::MetaPointAction( const Point& rPt ) :
 157     MetaAction  ( MetaActionType::POINT ),
 158     maPt        ( rPt )
 159 {}
 160
 161 void MetaPointAction::Execute( OutputDevice* pOut )
 162 {
 163     pOut->DrawPixel( maPt );
 164 }
 165
 166 rtl::Reference<MetaAction> MetaPointAction::Clone() const
 167 {
 168     return new MetaPointAction( *this );
 169 }
 170
 171 void MetaPointAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
 172 {
 173     maPt.Move( nHorzMove, nVertMove );
 174 }
 175
 176 void MetaPointAction::Scale( double fScaleX, double fScaleY )
 177 {
 178     ImplScalePoint( maPt, fScaleX, fScaleY );
 179 }
 180
 181 MetaLineAction::MetaLineAction() :
 182     MetaAction(MetaActionType::LINE)
 183 {}
 184
 185 MetaLineAction::~MetaLineAction()
 186 {}
 187
 188 MetaLineAction::MetaLineAction( const Point& rStart, const Point& rEnd ) :
 189     MetaAction  ( MetaActionType::LINE ),
 190     maStartPt   ( rStart ),
 191     maEndPt     ( rEnd )
 192 {}
 193
 194 MetaLineAction::MetaLineAction( const Point& rStart, const Point& rEnd,
 195                                 LineInfo aLineInfo ) :
 196     MetaAction  ( MetaActionType::LINE ),
 197     maLineInfo  (std::move( aLineInfo )),
 198     maStartPt   ( rStart ),
 199     maEndPt     ( rEnd )
 200 {}
 201
 202 void MetaLineAction::Execute( OutputDevice* pOut )
 203 {
 204     if( maLineInfo.IsDefault() )
 205         pOut->DrawLine( maStartPt, maEndPt );
 206     else
 207         pOut->DrawLine( maStartPt, maEndPt, maLineInfo );
 208 }
 209
 210 rtl::Reference<MetaAction> MetaLineAction::Clone() const
 211 {
 212     return new MetaLineAction( *this );
 213 }
 214
 215 void MetaLineAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
 216 {
 217     maStartPt.Move( nHorzMove, nVertMove );
 218     maEndPt.Move( nHorzMove, nVertMove );
 219 }
 220
 221 void MetaLineAction::Scale( double fScaleX, double fScaleY )
 222 {
 223     ImplScalePoint( maStartPt, fScaleX, fScaleY );
 224     ImplScalePoint( maEndPt, fScaleX, fScaleY );
 225     ImplScaleLineInfo( maLineInfo, fScaleX, fScaleY );
 226 }
 227
 228 MetaRectAction::MetaRectAction() :
 229     MetaAction(MetaActionType::RECT)
 230 {}
 231
 232 MetaRectAction::~MetaRectAction()
 233 {}
 234
 235 MetaRectAction::MetaRectAction( const tools::Rectangle& rRect ) :
 236     MetaAction  ( MetaActionType::RECT ),
 237     maRect      ( rRect )
 238 {}
 239
 240 static bool AllowDim(tools::Long nDim)
 241 {
 242     static bool bFuzzing = comphelper::IsFuzzing();
 243     if (bFuzzing)
 244     {
 245         if (nDim > 0x20000000 || nDim < -0x20000000)
 246         {
 247             SAL_WARN("vcl", "skipping huge dimension: " << nDim);
 248             return false;
 249         }
 250     }
 251     return true;
 252 }
 253
 254 static bool AllowPoint(const Point& rPoint)
 255 {
 256     return AllowDim(rPoint.X()) && AllowDim(rPoint.Y());
 257 }
 258
 259 static bool AllowRect(const tools::Rectangle& rRect)
 260 {
 261     return AllowPoint(rRect.TopLeft()) && AllowPoint(rRect.BottomRight());
 262 }
 263
 264 void MetaRectAction::Execute( OutputDevice* pOut )
 265 {
 266     if (!AllowRect(pOut->LogicToPixel(maRect)))
 267         return;
 268
 269     pOut->DrawRect( maRect );
 270 }
 271
 272 rtl::Reference<MetaAction> MetaRectAction::Clone() const
 273 {
 274     return new MetaRectAction( *this );
 275 }
 276
 277 void MetaRectAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
 278 {
 279     maRect.Move( nHorzMove, nVertMove );
 280 }
 281
 282 void MetaRectAction::Scale( double fScaleX, double fScaleY )
 283 {
 284     ImplScaleRect( maRect, fScaleX, fScaleY );
 285 }
 286
 287 MetaRoundRectAction::MetaRoundRectAction() :
 288     MetaAction  ( MetaActionType::ROUNDRECT ),
 289     mnHorzRound ( 0 ),
 290     mnVertRound ( 0 )
 291 {}
 292
 293 MetaRoundRectAction::~MetaRoundRectAction()
 294 {}
 295
 296 MetaRoundRectAction::MetaRoundRectAction( const tools::Rectangle& rRect,
 297                                           sal_uInt32 nHorzRound, sal_uInt32 nVertRound ) :
 298     MetaAction  ( MetaActionType::ROUNDRECT ),
 299     maRect      ( rRect ),
 300     mnHorzRound ( nHorzRound ),
 301     mnVertRound ( nVertRound )
 302 {}
 303
 304 void MetaRoundRectAction::Execute( OutputDevice* pOut )
 305 {
 306     pOut->DrawRect( maRect, mnHorzRound, mnVertRound );
 307 }
 308
 309 rtl::Reference<MetaAction> MetaRoundRectAction::Clone() const
 310 {
 311     return new MetaRoundRectAction( *this );
 312 }
 313
 314 void MetaRoundRectAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
 315 {
 316     maRect.Move( nHorzMove, nVertMove );
 317 }
 318
 319 void MetaRoundRectAction::Scale( double fScaleX, double fScaleY )
 320 {
 321     ImplScaleRect( maRect, fScaleX, fScaleY );
 322     mnHorzRound = basegfx::fround<sal_uInt32>(mnHorzRound * fabs(fScaleX));
 323     mnVertRound = basegfx::fround<sal_uInt32>(mnVertRound * fabs(fScaleY));
 324 }
 325
 326 MetaEllipseAction::MetaEllipseAction() :
 327     MetaAction(MetaActionType::ELLIPSE)
 328 {}
 329
 330 MetaEllipseAction::~MetaEllipseAction()
 331 {}
 332
 333 MetaEllipseAction::MetaEllipseAction( const tools::Rectangle& rRect ) :
 334     MetaAction  ( MetaActionType::ELLIPSE ),
 335     maRect      ( rRect )
 336 {}
 337
 338 void MetaEllipseAction::Execute( OutputDevice* pOut )
 339 {
 340     pOut->DrawEllipse( maRect );
 341 }
 342
 343 rtl::Reference<MetaAction> MetaEllipseAction::Clone() const
 344 {
 345     return new MetaEllipseAction( *this );
 346 }
 347
 348 void MetaEllipseAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
 349 {
 350     maRect.Move( nHorzMove, nVertMove );
 351 }
 352
 353 void MetaEllipseAction::Scale( double fScaleX, double fScaleY )
 354 {
 355     ImplScaleRect( maRect, fScaleX, fScaleY );
 356 }
 357
 358 MetaArcAction::MetaArcAction() :
 359     MetaAction(MetaActionType::ARC)
 360 {}
 361
 362 MetaArcAction::~MetaArcAction()
 363 {}
 364
 365 MetaArcAction::MetaArcAction( const tools::Rectangle& rRect,
 366                               const Point& rStart, const Point& rEnd ) :
 367     MetaAction  ( MetaActionType::ARC ),
 368     maRect      ( rRect ),
 369     maStartPt   ( rStart ),
 370     maEndPt     ( rEnd )
 371 {}
 372
 373 void MetaArcAction::Execute( OutputDevice* pOut )
 374 {
 375     if (!AllowRect(pOut->LogicToPixel(maRect)))
 376         return;
 377
 378     pOut->DrawArc( maRect, maStartPt, maEndPt );
 379 }
 380
 381 rtl::Reference<MetaAction> MetaArcAction::Clone() const
 382 {
 383     return new MetaArcAction( *this );
 384 }
 385
 386 void MetaArcAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
 387 {
 388     maRect.Move(  nHorzMove, nVertMove );
 389     maStartPt.Move(  nHorzMove, nVertMove );
 390     maEndPt.Move(  nHorzMove, nVertMove );
 391 }
 392
 393 void MetaArcAction::Scale( double fScaleX, double fScaleY )
 394 {
 395     ImplScaleRect( maRect, fScaleX, fScaleY );
 396     ImplScalePoint( maStartPt, fScaleX, fScaleY );
 397     ImplScalePoint( maEndPt, fScaleX, fScaleY );
 398 }
 399
 400 MetaPieAction::MetaPieAction() :
 401     MetaAction(MetaActionType::PIE)
 402 {}
 403
 404 MetaPieAction::~MetaPieAction()
 405 {}
 406
 407 MetaPieAction::MetaPieAction( const tools::Rectangle& rRect,
 408                               const Point& rStart, const Point& rEnd ) :
 409     MetaAction  ( MetaActionType::PIE ),
 410     maRect      ( rRect ),
 411     maStartPt   ( rStart ),
 412     maEndPt     ( rEnd )
 413 {}
 414
 415 void MetaPieAction::Execute( OutputDevice* pOut )
 416 {
 417     if (!AllowRect(pOut->LogicToPixel(maRect)))
 418         return;
 419
 420     pOut->DrawPie( maRect, maStartPt, maEndPt );
 421 }
 422
 423 rtl::Reference<MetaAction> MetaPieAction::Clone() const
 424 {
 425     return new MetaPieAction( *this );
 426 }
 427
 428 void MetaPieAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
 429 {
 430     maRect.Move(  nHorzMove, nVertMove );
 431     maStartPt.Move(  nHorzMove, nVertMove );
 432     maEndPt.Move(  nHorzMove, nVertMove );
 433 }
 434
 435 void MetaPieAction::Scale( double fScaleX, double fScaleY )
 436 {
 437     ImplScaleRect( maRect, fScaleX, fScaleY );
 438     ImplScalePoint( maStartPt, fScaleX, fScaleY );
 439     ImplScalePoint( maEndPt, fScaleX, fScaleY );
 440 }
 441
 442 MetaChordAction::MetaChordAction() :
 443     MetaAction(MetaActionType::CHORD)
 444 {}
 445
 446 MetaChordAction::~MetaChordAction()
 447 {}
 448
 449 MetaChordAction::MetaChordAction( const tools::Rectangle& rRect,
 450                                   const Point& rStart, const Point& rEnd ) :
 451     MetaAction  ( MetaActionType::CHORD ),
 452     maRect      ( rRect ),
 453     maStartPt   ( rStart ),
 454     maEndPt     ( rEnd )
 455 {}
 456
 457 void MetaChordAction::Execute( OutputDevice* pOut )
 458 {
 459     pOut->DrawChord( maRect, maStartPt, maEndPt );
 460 }
 461
 462 rtl::Reference<MetaAction> MetaChordAction::Clone() const
 463 {
 464     return new MetaChordAction( *this );
 465 }
 466
 467 void MetaChordAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
 468 {
 469     maRect.Move(  nHorzMove, nVertMove );
 470     maStartPt.Move(  nHorzMove, nVertMove );
 471     maEndPt.Move(  nHorzMove, nVertMove );
 472 }
 473
 474 void MetaChordAction::Scale( double fScaleX, double fScaleY )
 475 {
 476     ImplScaleRect( maRect, fScaleX, fScaleY );
 477     ImplScalePoint( maStartPt, fScaleX, fScaleY );
 478     ImplScalePoint( maEndPt, fScaleX, fScaleY );
 479 }
 480
 481 MetaPolyLineAction::MetaPolyLineAction() :
 482     MetaAction(MetaActionType::POLYLINE)
 483 {}
 484
 485 MetaPolyLineAction::~MetaPolyLineAction()
 486 {}
 487
 488 MetaPolyLineAction::MetaPolyLineAction( tools::Polygon aPoly ) :
 489     MetaAction  ( MetaActionType::POLYLINE ),
 490     maPoly      (std::move( aPoly ))
 491 {}
 492
 493 MetaPolyLineAction::MetaPolyLineAction( tools::Polygon aPoly, LineInfo aLineInfo ) :
 494     MetaAction  ( MetaActionType::POLYLINE ),
 495     maLineInfo  (std::move( aLineInfo )),
 496     maPoly      (std::move( aPoly ))
 497 {}
 498
 499 void MetaPolyLineAction::Execute( OutputDevice* pOut )
 500 {
 501     if (!AllowRect(pOut->LogicToPixel(maPoly.GetBoundRect())))
 502         return;
 503
 504     if( maLineInfo.IsDefault() )
 505         pOut->DrawPolyLine( maPoly );
 506     else
 507         pOut->DrawPolyLine( maPoly, maLineInfo );
 508 }
 509
 510 rtl::Reference<MetaAction> MetaPolyLineAction::Clone() const
 511 {
 512     return new MetaPolyLineAction( *this );
 513 }
 514
 515 void MetaPolyLineAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
 516 {
 517     maPoly.Move( nHorzMove, nVertMove );
 518 }
 519
 520 void MetaPolyLineAction::Scale( double fScaleX, double fScaleY )
 521 {
 522     ImplScalePoly( maPoly, fScaleX, fScaleY );
 523     ImplScaleLineInfo( maLineInfo, fScaleX, fScaleY );
 524 }
 525
 526 MetaPolygonAction::MetaPolygonAction() :
 527     MetaAction(MetaActionType::POLYGON)
 528 {}
 529
 530 MetaPolygonAction::~MetaPolygonAction()
 531 {}
 532
 533 MetaPolygonAction::MetaPolygonAction( tools::Polygon aPoly ) :
 534     MetaAction  ( MetaActionType::POLYGON ),
 535     maPoly      (std::move( aPoly ))
 536 {}
 537
 538 void MetaPolygonAction::Execute( OutputDevice* pOut )
 539 {
 540     pOut->DrawPolygon( maPoly );
 541 }
 542
 543 rtl::Reference<MetaAction> MetaPolygonAction::Clone() const
 544 {
 545     return new MetaPolygonAction( *this );
 546 }
 547
 548 void MetaPolygonAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
 549 {
 550     maPoly.Move( nHorzMove, nVertMove );
 551 }
 552
 553 void MetaPolygonAction::Scale( double fScaleX, double fScaleY )
 554 {
 555     ImplScalePoly( maPoly, fScaleX, fScaleY );
 556 }
 557
 558 MetaPolyPolygonAction::MetaPolyPolygonAction() :
 559     MetaAction(MetaActionType::POLYPOLYGON)
 560 {}
 561
 562 MetaPolyPolygonAction::~MetaPolyPolygonAction()
 563 {}
 564
 565 MetaPolyPolygonAction::MetaPolyPolygonAction( tools::PolyPolygon aPolyPoly ) :
 566     MetaAction  ( MetaActionType::POLYPOLYGON ),
 567     maPolyPoly  (std::move( aPolyPoly ))
 568 {}
 569
 570 void MetaPolyPolygonAction::Execute( OutputDevice* pOut )
 571 {
 572     pOut->DrawPolyPolygon( maPolyPoly );
 573 }
 574
 575 rtl::Reference<MetaAction> MetaPolyPolygonAction::Clone() const
 576 {
 577     return new MetaPolyPolygonAction( *this );
 578 }
 579
 580 void MetaPolyPolygonAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
 581 {
 582     maPolyPoly.Move( nHorzMove, nVertMove );
 583 }
 584
 585 void MetaPolyPolygonAction::Scale( double fScaleX, double fScaleY )
 586 {
 587     for( sal_uInt16 i = 0, nCount = maPolyPoly.Count(); i < nCount; i++ )
 588         ImplScalePoly( maPolyPoly[ i ], fScaleX, fScaleY );
 589 }
 590
 591 MetaTextAction::MetaTextAction() :
 592     MetaAction  ( MetaActionType::TEXT ),
 593     mnIndex     ( 0 ),
 594     mnLen       ( 0 )
 595 {}
 596
 597 MetaTextAction::~MetaTextAction()
 598 {}
 599
 600 MetaTextAction::MetaTextAction( const Point& rPt, OUString aStr,
 601                                 sal_Int32 nIndex, sal_Int32 nLen ) :
 602     MetaAction  ( MetaActionType::TEXT ),
 603     maPt        ( rPt ),
 604     maStr       (std::move( aStr )),
 605     mnIndex     ( nIndex ),
 606     mnLen       ( nLen )
 607 {}
 608
 609 void MetaTextAction::Execute( OutputDevice* pOut )
 610 {
 611     if (!AllowDim(pOut->LogicToPixel(maPt).Y()))
 612         return;
 613
 614     pOut->DrawText( maPt, maStr, mnIndex, mnLen );
 615 }
 616
 617 rtl::Reference<MetaAction> MetaTextAction::Clone() const
 618 {
 619     return new MetaTextAction( *this );
 620 }
 621
 622 void MetaTextAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
 623 {
 624     maPt.Move( nHorzMove, nVertMove );
 625 }
 626
 627 void MetaTextAction::Scale( double fScaleX, double fScaleY )
 628 {
 629     ImplScalePoint( maPt, fScaleX, fScaleY );
 630 }
 631
 632 MetaTextArrayAction::MetaTextArrayAction() :
 633     MetaAction  ( MetaActionType::TEXTARRAY ),
 634     mnIndex     ( 0 ),
 635     mnLen       ( 0 )
 636 {}
 637
 638 MetaTextArrayAction::MetaTextArrayAction(const MetaTextArrayAction& rAction)
 639     : MetaAction(MetaActionType::TEXTARRAY)
 640     , maStartPt(rAction.maStartPt)
 641     , maStr(rAction.maStr)
 642     , maDXAry(rAction.maDXAry)
 643     , maKashidaAry(rAction.maKashidaAry)
 644     , mnIndex(rAction.mnIndex)
 645     , mnLen(rAction.mnLen)
 646     , mnLayoutContextIndex(rAction.mnLayoutContextIndex)
 647     , mnLayoutContextLen(rAction.mnLayoutContextLen)
 648 {
 649 }
 650
 651 MetaTextArrayAction::MetaTextArrayAction( const Point& rStartPt,
 652                                           OUString aStr,
 653                                           KernArray aDXAry,
 654                                           std::vector<sal_Bool> aKashidaAry,
 655                                           sal_Int32 nIndex,
 656                                           sal_Int32 nLen ) :
 657     MetaAction  ( MetaActionType::TEXTARRAY ),
 658     maStartPt   ( rStartPt ),
 659     maStr       (std::move( aStr )),
 660     maDXAry     (std::move( aDXAry )),
 661     maKashidaAry(std::move( aKashidaAry )),
 662     mnIndex     ( nIndex ),
 663     mnLen       ( nLen )
 664 {
 665 }
 666
 667 MetaTextArrayAction::MetaTextArrayAction( const Point& rStartPt,
 668                                           OUString aStr,
 669                                           KernArraySpan pDXAry,
 670                                           std::span<const sal_Bool> pKashidaAry,
 671                                           sal_Int32 nIndex,
 672                                           sal_Int32 nLen ) :
 673     MetaAction  ( MetaActionType::TEXTARRAY ),
 674     maStartPt   ( rStartPt ),
 675     maStr       (std::move( aStr )),
 676     maKashidaAry( pKashidaAry.begin(), pKashidaAry.end() ),
 677     mnIndex     ( nIndex ),
 678     mnLen       ( nLen )
 679 {
 680     maDXAry.assign(pDXAry.begin(), pDXAry.end());
 681 }
 682
 683 MetaTextArrayAction::MetaTextArrayAction(const Point& rStartPt, OUString aStr, KernArraySpan pDXAry,
 684                                          std::span<const sal_Bool> pKashidaAry, sal_Int32 nIndex,
 685                                          sal_Int32 nLen, sal_Int32 nLayoutContextIndex,
 686                                          sal_Int32 nLayoutContextLen)
 687     : MetaAction(MetaActionType::TEXTARRAY)
 688     , maStartPt(rStartPt)
 689     , maStr(std::move(aStr))
 690     , maKashidaAry(pKashidaAry.begin(), pKashidaAry.end())
 691     , mnIndex(nIndex)
 692     , mnLen(nLen)
 693     , mnLayoutContextIndex(nLayoutContextIndex)
 694     , mnLayoutContextLen(nLayoutContextLen)
 695 {
 696     maDXAry.assign(pDXAry.begin(), pDXAry.end());
 697 }
 698
 699 MetaTextArrayAction::~MetaTextArrayAction()
 700 {
 701 }
 702
 703 void MetaTextArrayAction::Execute( OutputDevice* pOut )
 704 {
 705     if (!AllowPoint(pOut->LogicToPixel(maStartPt)))
 706         return;
 707
 708     if (mnLayoutContextIndex >= 0)
 709     {
 710         pOut->DrawPartialTextArray(maStartPt, maStr, maDXAry, maKashidaAry, mnLayoutContextIndex,
 711                                    mnLayoutContextLen, mnIndex, mnLen);
 712     }
 713     else
 714     {
 715         pOut->DrawTextArray(maStartPt, maStr, maDXAry, maKashidaAry, mnIndex, mnLen);
 716     }
 717 }
 718
 719 rtl::Reference<MetaAction> MetaTextArrayAction::Clone() const
 720 {
 721     return new MetaTextArrayAction( *this );
 722 }
 723
 724 void MetaTextArrayAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
 725 {
 726     maStartPt.Move( nHorzMove, nVertMove );
 727 }
 728
 729 void MetaTextArrayAction::Scale( double fScaleX, double fScaleY )
 730 {
 731     ImplScalePoint( maStartPt, fScaleX, fScaleY );
 732
 733     if ( !maDXAry.empty() && mnLen )
 734     {
 735         for ( sal_uInt16 i = 0, nCount = mnLen; i < nCount; i++ )
 736             maDXAry[i] *= fabs(fScaleX);
 737     }
 738 }
 739
 740 void MetaTextArrayAction::SetDXArray(KernArray aArray)
 741 {
 742     maDXAry = std::move(aArray);
 743 }
 744
 745 void MetaTextArrayAction::SetKashidaArray(std::vector<sal_Bool> aArray)
 746 {
 747     maKashidaAry = std::move(aArray);
 748 }
 749
 750 MetaStretchTextAction::MetaStretchTextAction() :
 751     MetaAction  ( MetaActionType::STRETCHTEXT ),
 752     mnWidth     ( 0 ),
 753     mnIndex     ( 0 ),
 754     mnLen       ( 0 )
 755 {}
 756
 757 MetaStretchTextAction::~MetaStretchTextAction()
 758 {}
 759
 760 MetaStretchTextAction::MetaStretchTextAction( const Point& rPt, sal_uInt32 nWidth,
 761                                               OUString aStr,
 762                                               sal_Int32 nIndex, sal_Int32 nLen ) :
 763     MetaAction  ( MetaActionType::STRETCHTEXT ),
 764     maPt        ( rPt ),
 765     maStr       (std::move( aStr )),
 766     mnWidth     ( nWidth ),
 767     mnIndex     ( nIndex ),
 768     mnLen       ( nLen )
 769 {}
 770
 771 void MetaStretchTextAction::Execute( OutputDevice* pOut )
 772 {
 773     if (!AllowRect(pOut->LogicToPixel(tools::Rectangle(maPt, Size(mnWidth, pOut->GetTextHeight())))))
 774         return;
 775
 776     static bool bFuzzing = comphelper::IsFuzzing();
 777     if (bFuzzing && mnWidth > 10000)
 778     {
 779         FontLineStyle eUnderline = pOut->GetFont().GetUnderline();
 780         FontLineStyle eOverline = pOut->GetFont().GetOverline();
 781
 782         if (eUnderline == LINESTYLE_SMALLWAVE || eUnderline == LINESTYLE_WAVE ||
 783             eUnderline == LINESTYLE_DOUBLEWAVE || eUnderline == LINESTYLE_BOLDWAVE ||
 784             eOverline == LINESTYLE_SMALLWAVE || eOverline == LINESTYLE_WAVE ||
 785             eOverline == LINESTYLE_DOUBLEWAVE || eOverline == LINESTYLE_BOLDWAVE)
 786         {
 787             SAL_WARN("vcl.gdi", "MetaStretchTextAction::Execute, skipping suspicious WaveTextLine of length: "
 788                                     << mnWidth << " for fuzzing performance");
 789             return;
 790         }
 791     }
 792
 793     pOut->DrawStretchText( maPt, mnWidth, maStr, mnIndex, mnLen );
 794 }
 795
 796 rtl::Reference<MetaAction> MetaStretchTextAction::Clone() const
 797 {
 798     return new MetaStretchTextAction( *this );
 799 }
 800
 801 void MetaStretchTextAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
 802 {
 803     maPt.Move( nHorzMove, nVertMove );
 804 }
 805
 806 void MetaStretchTextAction::Scale( double fScaleX, double fScaleY )
 807 {
 808     ImplScalePoint( maPt, fScaleX, fScaleY );
 809     mnWidth = basegfx::fround<sal_uInt32>(mnWidth * fabs(fScaleX));
 810 }
 811 MetaTextRectAction::MetaTextRectAction() :
 812     MetaAction  ( MetaActionType::TEXTRECT ),
 813     mnStyle     ( DrawTextFlags::NONE )
 814 {}
 815
 816 MetaTextRectAction::~MetaTextRectAction()
 817 {}
 818
 819 MetaTextRectAction::MetaTextRectAction( const tools::Rectangle& rRect,
 820                                         OUString aStr, DrawTextFlags nStyle ) :
 821     MetaAction  ( MetaActionType::TEXTRECT ),
 822     maRect      ( rRect ),
 823     maStr       (std::move( aStr )),
 824     mnStyle     ( nStyle )
 825 {}
 826
 827 void MetaTextRectAction::Execute( OutputDevice* pOut )
 828 {
 829     if (!AllowRect(pOut->LogicToPixel(maRect)))
 830         return;
 831
 832     pOut->DrawText( maRect, maStr, mnStyle );
 833 }
 834
 835 rtl::Reference<MetaAction> MetaTextRectAction::Clone() const
 836 {
 837     return new MetaTextRectAction( *this );
 838 }
 839
 840 void MetaTextRectAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
 841 {
 842     maRect.Move( nHorzMove, nVertMove );
 843 }
 844
 845 void MetaTextRectAction::Scale( double fScaleX, double fScaleY )
 846 {
 847     ImplScaleRect( maRect, fScaleX, fScaleY );
 848 }
 849
 850 MetaTextLineAction::MetaTextLineAction() :
 851     MetaAction  ( MetaActionType::TEXTLINE ),
 852     mnWidth     ( 0 ),
 853     meStrikeout ( STRIKEOUT_NONE ),
 854     meUnderline ( LINESTYLE_NONE ),
 855     meOverline  ( LINESTYLE_NONE )
 856 {}
 857
 858 MetaTextLineAction::~MetaTextLineAction()
 859 {}
 860
 861 MetaTextLineAction::MetaTextLineAction( const Point& rPos, tools::Long nWidth,
 862                                         FontStrikeout eStrikeout,
 863                                         FontLineStyle eUnderline,
 864                                         FontLineStyle eOverline ) :
 865     MetaAction  ( MetaActionType::TEXTLINE ),
 866     maPos       ( rPos ),
 867     mnWidth     ( nWidth ),
 868     meStrikeout ( eStrikeout ),
 869     meUnderline ( eUnderline ),
 870     meOverline  ( eOverline )
 871 {}
 872
 873 void MetaTextLineAction::Execute( OutputDevice* pOut )
 874 {
 875     if (mnWidth < 0)
 876     {
 877         SAL_WARN("vcl", "skipping line with negative width: " << mnWidth);
 878         return;
 879     }
 880     if (!AllowRect(pOut->LogicToPixel(tools::Rectangle(maPos, Size(mnWidth, pOut->GetTextHeight())))))
 881         return;
 882
 883     pOut->DrawTextLine( maPos, mnWidth, meStrikeout, meUnderline, meOverline );
 884 }
 885
 886 rtl::Reference<MetaAction> MetaTextLineAction::Clone() const
 887 {
 888     return new MetaTextLineAction( *this );
 889 }
 890
 891 void MetaTextLineAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
 892 {
 893     maPos.Move( nHorzMove, nVertMove );
 894 }
 895
 896 void MetaTextLineAction::Scale( double fScaleX, double fScaleY )
 897 {
 898     ImplScalePoint( maPos, fScaleX, fScaleY );
 899     mnWidth = basegfx::fround<tools::Long>(mnWidth * fabs(fScaleX));
 900 }
 901
 902 MetaBmpAction::MetaBmpAction() :
 903     MetaAction(MetaActionType::BMP)
 904 {}
 905
 906 MetaBmpAction::~MetaBmpAction()
 907 {}
 908
 909 MetaBmpAction::MetaBmpAction( const Point& rPt, const Bitmap& rBmp ) :
 910     MetaAction  ( MetaActionType::BMP ),
 911     maBmp       ( rBmp ),
 912     maPt        ( rPt )
 913 {}
 914
 915 void MetaBmpAction::Execute( OutputDevice* pOut )
 916 {
 917     pOut->DrawBitmap( maPt, maBmp );
 918 }
 919
 920 rtl::Reference<MetaAction> MetaBmpAction::Clone() const
 921 {
 922     return new MetaBmpAction( *this );
 923 }
 924
 925 void MetaBmpAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
 926 {
 927     maPt.Move( nHorzMove, nVertMove );
 928 }
 929
 930 void MetaBmpAction::Scale( double fScaleX, double fScaleY )
 931 {
 932     ImplScalePoint( maPt, fScaleX, fScaleY );
 933 }
 934
 935 MetaBmpScaleAction::MetaBmpScaleAction() :
 936     MetaAction(MetaActionType::BMPSCALE)
 937 {}
 938
 939 MetaBmpScaleAction::~MetaBmpScaleAction()
 940 {}
 941
 942 MetaBmpScaleAction::MetaBmpScaleAction( const Point& rPt, const Size& rSz,
 943                                         const Bitmap& rBmp ) :
 944     MetaAction  ( MetaActionType::BMPSCALE ),
 945     maBmp       ( rBmp ),
 946     maPt        ( rPt ),
 947     maSz        ( rSz )
 948 {}
 949
 950 static bool AllowScale(const Size& rSource, const Size& rDest)
 951 {
 952     static bool bFuzzing = comphelper::IsFuzzing();
 953     if (bFuzzing)
 954     {
 955         constexpr int nMaxScaleWhenFuzzing = 128;
 956
 957         auto nSourceHeight = rSource.Height();
 958         auto nDestHeight = rDest.Height();
 959         if (nSourceHeight && std::abs(nDestHeight / nSourceHeight) > nMaxScaleWhenFuzzing)
 960         {
 961             SAL_WARN("vcl", "skipping large vertical scaling: " << nSourceHeight << " to " << nDestHeight);
 962             return false;
 963         }
 964
 965         if (nDestHeight && std::abs(nSourceHeight / nDestHeight) > nMaxScaleWhenFuzzing)
 966         {
 967             SAL_WARN("vcl", "skipping large vertical scaling: " << nSourceHeight << " to " << nDestHeight);
 968             return false;
 969         }
 970
 971         auto nSourceWidth = rSource.Width();
 972         auto nDestWidth = rDest.Width();
 973         if (nSourceWidth && std::abs(nDestWidth / nSourceWidth) > nMaxScaleWhenFuzzing)
 974         {
 975             SAL_WARN("vcl", "skipping large horizontal scaling: " << nSourceWidth << " to " << nDestWidth);
 976             return false;
 977         }
 978
 979         if (nDestWidth && std::abs(nSourceWidth / nDestWidth) > nMaxScaleWhenFuzzing)
 980         {
 981             SAL_WARN("vcl", "skipping large horizontal scaling: " << nSourceWidth << " to " << nDestWidth);
 982             return false;
 983         }
 984     }
 985
 986     return true;
 987 }
 988
 989 void MetaBmpScaleAction::Execute( OutputDevice* pOut )
 990 {
 991     Size aPixelSize(pOut->LogicToPixel(maSz));
 992     if (!AllowRect(tools::Rectangle(pOut->LogicToPixel(maPt), aPixelSize)) ||
 993         !AllowScale(maBmp.GetSizePixel(), aPixelSize))
 994     {
 995         return;
 996     }
 997
 998     pOut->DrawBitmap( maPt, maSz, maBmp );
 999 }
1000
1001 rtl::Reference<MetaAction> MetaBmpScaleAction::Clone() const
1002 {
1003     return new MetaBmpScaleAction( *this );
1004 }
1005
1006 void MetaBmpScaleAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
1007 {
1008     maPt.Move( nHorzMove, nVertMove );
1009 }
1010
1011 void MetaBmpScaleAction::Scale( double fScaleX, double fScaleY )
1012 {
1013     tools::Rectangle aRectangle(maPt, maSz);
1014     ImplScaleRect( aRectangle, fScaleX, fScaleY );
1015     maPt = aRectangle.TopLeft();
1016     maSz = aRectangle.GetSize();
1017 }
1018
1019 MetaBmpScalePartAction::MetaBmpScalePartAction() :
1020     MetaAction(MetaActionType::BMPSCALEPART)
1021 {}
1022
1023 MetaBmpScalePartAction::~MetaBmpScalePartAction()
1024 {}
1025
1026 MetaBmpScalePartAction::MetaBmpScalePartAction( const Point& rDstPt, const Size& rDstSz,
1027                                                 const Point& rSrcPt, const Size& rSrcSz,
1028                                                 const Bitmap& rBmp ) :
1029     MetaAction  ( MetaActionType::BMPSCALEPART ),
1030     maBmp       ( rBmp ),
1031     maDstPt     ( rDstPt ),
1032     maDstSz     ( rDstSz ),
1033     maSrcPt     ( rSrcPt ),
1034     maSrcSz     ( rSrcSz )
1035 {}
1036
1037 void MetaBmpScalePartAction::Execute( OutputDevice* pOut )
1038 {
1039     if (!AllowRect(pOut->LogicToPixel(tools::Rectangle(maDstPt, maDstSz))))
1040         return;
1041
1042     pOut->DrawBitmap( maDstPt, maDstSz, maSrcPt, maSrcSz, maBmp );
1043 }
1044
1045 rtl::Reference<MetaAction> MetaBmpScalePartAction::Clone() const
1046 {
1047     return new MetaBmpScalePartAction( *this );
1048 }
1049
1050 void MetaBmpScalePartAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
1051 {
1052     maDstPt.Move( nHorzMove, nVertMove );
1053 }
1054
1055 void MetaBmpScalePartAction::Scale( double fScaleX, double fScaleY )
1056 {
1057     tools::Rectangle aRectangle(maDstPt, maDstSz);
1058     ImplScaleRect( aRectangle, fScaleX, fScaleY );
1059     maDstPt = aRectangle.TopLeft();
1060     maDstSz = aRectangle.GetSize();
1061 }
1062
1063 MetaBmpExAction::MetaBmpExAction() :
1064     MetaAction(MetaActionType::BMPEX)
1065 {}
1066
1067 MetaBmpExAction::~MetaBmpExAction()
1068 {}
1069
1070 MetaBmpExAction::MetaBmpExAction( const Point& rPt, const BitmapEx& rBmpEx ) :
1071     MetaAction  ( MetaActionType::BMPEX ),
1072     maBmpEx     ( rBmpEx ),
1073     maPt        ( rPt )
1074 {}
1075
1076 void MetaBmpExAction::Execute( OutputDevice* pOut )
1077 {
1078     pOut->DrawBitmapEx( maPt, maBmpEx );
1079 }
1080
1081 rtl::Reference<MetaAction> MetaBmpExAction::Clone() const
1082 {
1083     return new MetaBmpExAction( *this );
1084 }
1085
1086 void MetaBmpExAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
1087 {
1088     maPt.Move( nHorzMove, nVertMove );
1089 }
1090
1091 void MetaBmpExAction::Scale( double fScaleX, double fScaleY )
1092 {
1093     ImplScalePoint( maPt, fScaleX, fScaleY );
1094 }
1095
1096 MetaBmpExScaleAction::MetaBmpExScaleAction() :
1097     MetaAction(MetaActionType::BMPEXSCALE)
1098 {}
1099
1100 MetaBmpExScaleAction::~MetaBmpExScaleAction()
1101 {}
1102
1103 MetaBmpExScaleAction::MetaBmpExScaleAction( const Point& rPt, const Size& rSz,
1104                                             const BitmapEx& rBmpEx ) :
1105     MetaAction  ( MetaActionType::BMPEXSCALE ),
1106     maBmpEx     ( rBmpEx ),
1107     maPt        ( rPt ),
1108     maSz        ( rSz )
1109 {}
1110
1111 void MetaBmpExScaleAction::Execute( OutputDevice* pOut )
1112 {
1113     if (!AllowScale(maBmpEx.GetSizePixel(), pOut->LogicToPixel(maSz)))
1114         return;
1115     if (!AllowRect(pOut->LogicToPixel(tools::Rectangle(maPt, maSz))))
1116         return;
1117
1118     pOut->DrawBitmapEx( maPt, maSz, maBmpEx );
1119 }
1120
1121 rtl::Reference<MetaAction> MetaBmpExScaleAction::Clone() const
1122 {
1123     return new MetaBmpExScaleAction( *this );
1124 }
1125
1126 void MetaBmpExScaleAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
1127 {
1128     maPt.Move( nHorzMove, nVertMove );
1129 }
1130
1131 void MetaBmpExScaleAction::Scale( double fScaleX, double fScaleY )
1132 {
1133     tools::Rectangle aRectangle(maPt, maSz);
1134     ImplScaleRect( aRectangle, fScaleX, fScaleY );
1135     maPt = aRectangle.TopLeft();
1136     maSz = aRectangle.GetSize();
1137 }
1138
1139 MetaBmpExScalePartAction::MetaBmpExScalePartAction() :
1140     MetaAction(MetaActionType::BMPEXSCALEPART)
1141 {}
1142
1143 MetaBmpExScalePartAction::~MetaBmpExScalePartAction()
1144 {}
1145
1146 MetaBmpExScalePartAction::MetaBmpExScalePartAction( const Point& rDstPt, const Size& rDstSz,
1147                                                     const Point& rSrcPt, const Size& rSrcSz,
1148                                                     const BitmapEx& rBmpEx ) :
1149     MetaAction  ( MetaActionType::BMPEXSCALEPART ),
1150     maBmpEx     ( rBmpEx ),
1151     maDstPt     ( rDstPt ),
1152     maDstSz     ( rDstSz ),
1153     maSrcPt     ( rSrcPt ),
1154     maSrcSz     ( rSrcSz )
1155 {}
1156
1157 void MetaBmpExScalePartAction::Execute( OutputDevice* pOut )
1158 {
1159     if (!AllowRect(pOut->LogicToPixel(tools::Rectangle(maDstPt, maDstSz))))
1160         return;
1161
1162     pOut->DrawBitmapEx( maDstPt, maDstSz, maSrcPt, maSrcSz, maBmpEx );
1163 }
1164
1165 rtl::Reference<MetaAction> MetaBmpExScalePartAction::Clone() const
1166 {
1167     return new MetaBmpExScalePartAction( *this );
1168 }
1169
1170 void MetaBmpExScalePartAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
1171 {
1172     maDstPt.Move( nHorzMove, nVertMove );
1173 }
1174
1175 void MetaBmpExScalePartAction::Scale( double fScaleX, double fScaleY )
1176 {
1177     tools::Rectangle aRectangle(maDstPt, maDstSz);
1178     ImplScaleRect( aRectangle, fScaleX, fScaleY );
1179     maDstPt = aRectangle.TopLeft();
1180     maDstSz = aRectangle.GetSize();
1181 }
1182
1183 MetaMaskAction::MetaMaskAction() :
1184     MetaAction(MetaActionType::MASK)
1185 {}
1186
1187 MetaMaskAction::~MetaMaskAction()
1188 {}
1189
1190 MetaMaskAction::MetaMaskAction( const Point& rPt,
1191                                 const Bitmap& rBmp,
1192                                 const Color& rColor ) :
1193     MetaAction  ( MetaActionType::MASK ),
1194     maBmp       ( rBmp ),
1195     maColor     ( rColor ),
1196     maPt        ( rPt )
1197 {}
1198
1199 void MetaMaskAction::Execute( OutputDevice* pOut )
1200 {
1201     pOut->DrawMask( maPt, maBmp, maColor );
1202 }
1203
1204 rtl::Reference<MetaAction> MetaMaskAction::Clone() const
1205 {
1206     return new MetaMaskAction( *this );
1207 }
1208
1209 void MetaMaskAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
1210 {
1211     maPt.Move( nHorzMove, nVertMove );
1212 }
1213
1214 void MetaMaskAction::Scale( double fScaleX, double fScaleY )
1215 {
1216     ImplScalePoint( maPt, fScaleX, fScaleY );
1217 }
1218
1219 MetaMaskScaleAction::MetaMaskScaleAction() :
1220     MetaAction(MetaActionType::MASKSCALE)
1221 {}
1222
1223 MetaMaskScaleAction::~MetaMaskScaleAction()
1224 {}
1225
1226 MetaMaskScaleAction::MetaMaskScaleAction( const Point& rPt, const Size& rSz,
1227                                           const Bitmap& rBmp,
1228                                           const Color& rColor ) :
1229     MetaAction  ( MetaActionType::MASKSCALE ),
1230     maBmp       ( rBmp ),
1231     maColor     ( rColor ),
1232     maPt        ( rPt ),
1233     maSz        ( rSz )
1234 {}
1235
1236 void MetaMaskScaleAction::Execute( OutputDevice* pOut )
1237 {
1238     if (!AllowRect(pOut->LogicToPixel(tools::Rectangle(maPt, maSz))))
1239         return;
1240     pOut->DrawMask( maPt, maSz, maBmp, maColor );
1241 }
1242
1243 rtl::Reference<MetaAction> MetaMaskScaleAction::Clone() const
1244 {
1245     return new MetaMaskScaleAction( *this );
1246 }
1247
1248 void MetaMaskScaleAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
1249 {
1250     maPt.Move( nHorzMove, nVertMove );
1251 }
1252
1253 void MetaMaskScaleAction::Scale( double fScaleX, double fScaleY )
1254 {
1255     tools::Rectangle aRectangle(maPt, maSz);
1256     ImplScaleRect( aRectangle, fScaleX, fScaleY );
1257     maPt = aRectangle.TopLeft();
1258     maSz = aRectangle.GetSize();
1259 }
1260
1261 MetaMaskScalePartAction::MetaMaskScalePartAction() :
1262     MetaAction(MetaActionType::MASKSCALEPART)
1263 {}
1264
1265 MetaMaskScalePartAction::~MetaMaskScalePartAction()
1266 {}
1267
1268 MetaMaskScalePartAction::MetaMaskScalePartAction( const Point& rDstPt, const Size& rDstSz,
1269                                                   const Point& rSrcPt, const Size& rSrcSz,
1270                                                   const Bitmap& rBmp,
1271                                                   const Color& rColor ) :
1272     MetaAction  ( MetaActionType::MASKSCALEPART ),
1273     maBmp       ( rBmp ),
1274     maColor     ( rColor ),
1275     maDstPt     ( rDstPt ),
1276     maDstSz     ( rDstSz ),
1277     maSrcPt     ( rSrcPt ),
1278     maSrcSz     ( rSrcSz )
1279 {}
1280
1281 void MetaMaskScalePartAction::Execute( OutputDevice* pOut )
1282 {
1283     if (!AllowRect(pOut->LogicToPixel(tools::Rectangle(maDstPt, maDstSz))))
1284         return;
1285
1286     pOut->DrawMask( maDstPt, maDstSz, maSrcPt, maSrcSz, maBmp, maColor, MetaActionType::MASKSCALE );
1287 }
1288
1289 rtl::Reference<MetaAction> MetaMaskScalePartAction::Clone() const
1290 {
1291     return new MetaMaskScalePartAction( *this );
1292 }
1293
1294 void MetaMaskScalePartAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
1295 {
1296     maDstPt.Move( nHorzMove, nVertMove );
1297 }
1298
1299 void MetaMaskScalePartAction::Scale( double fScaleX, double fScaleY )
1300 {
1301     tools::Rectangle aRectangle(maDstPt, maDstSz);
1302     ImplScaleRect( aRectangle, fScaleX, fScaleY );
1303     maDstPt = aRectangle.TopLeft();
1304     maDstSz = aRectangle.GetSize();
1305 }
1306
1307 MetaGradientAction::MetaGradientAction() :
1308     MetaAction(MetaActionType::GRADIENT)
1309 {}
1310
1311 MetaGradientAction::~MetaGradientAction()
1312 {}
1313
1314 MetaGradientAction::MetaGradientAction( const tools::Rectangle& rRect, Gradient aGradient ) :
1315     MetaAction  ( MetaActionType::GRADIENT ),
1316     maRect      ( rRect ),
1317     maGradient  (std::move( aGradient ))
1318 {}
1319
1320 void MetaGradientAction::Execute( OutputDevice* pOut )
1321 {
1322     pOut->DrawGradient( maRect, maGradient );
1323 }
1324
1325 rtl::Reference<MetaAction> MetaGradientAction::Clone() const
1326 {
1327     return new MetaGradientAction( *this );
1328 }
1329
1330 void MetaGradientAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
1331 {
1332     maRect.Move( nHorzMove, nVertMove );
1333 }
1334
1335 void MetaGradientAction::Scale( double fScaleX, double fScaleY )
1336 {
1337     ImplScaleRect( maRect, fScaleX, fScaleY );
1338 }
1339
1340 MetaGradientExAction::MetaGradientExAction() :
1341     MetaAction  ( MetaActionType::GRADIENTEX )
1342 {}
1343
1344 MetaGradientExAction::MetaGradientExAction( tools::PolyPolygon aPolyPoly, Gradient aGradient ) :
1345     MetaAction  ( MetaActionType::GRADIENTEX ),
1346     maPolyPoly  (std::move( aPolyPoly )),
1347     maGradient  (std::move( aGradient ))
1348 {}
1349
1350 MetaGradientExAction::~MetaGradientExAction()
1351 {}
1352
1353 void MetaGradientExAction::Execute( OutputDevice* pOut )
1354 {
1355     if( pOut->GetConnectMetaFile() )
1356     {
1357         pOut->GetConnectMetaFile()->AddAction( this );
1358     }
1359 }
1360
1361 rtl::Reference<MetaAction> MetaGradientExAction::Clone() const
1362 {
1363     return new MetaGradientExAction( *this );
1364 }
1365
1366 void MetaGradientExAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
1367 {
1368     maPolyPoly.Move( nHorzMove, nVertMove );
1369 }
1370
1371 void MetaGradientExAction::Scale( double fScaleX, double fScaleY )
1372 {
1373     for( sal_uInt16 i = 0, nCount = maPolyPoly.Count(); i < nCount; i++ )
1374         ImplScalePoly( maPolyPoly[ i ], fScaleX, fScaleY );
1375 }
1376
1377 MetaHatchAction::MetaHatchAction() :
1378     MetaAction(MetaActionType::HATCH)
1379 {}
1380
1381 MetaHatchAction::~MetaHatchAction()
1382 {}
1383
1384 MetaHatchAction::MetaHatchAction( tools::PolyPolygon aPolyPoly, const Hatch& rHatch ) :
1385     MetaAction  ( MetaActionType::HATCH ),
1386     maPolyPoly  (std::move( aPolyPoly )),
1387     maHatch     ( rHatch )
1388 {}
1389
1390 void MetaHatchAction::Execute( OutputDevice* pOut )
1391 {
1392     if (!AllowRect(pOut->LogicToPixel(maPolyPoly.GetBoundRect())))
1393         return;
1394     if (!AllowDim(pOut->LogicToPixel(Point(maHatch.GetDistance(), 0)).X()))
1395         return;
1396
1397     pOut->DrawHatch( maPolyPoly, maHatch );
1398 }
1399
1400 rtl::Reference<MetaAction> MetaHatchAction::Clone() const
1401 {
1402     return new MetaHatchAction( *this );
1403 }
1404
1405 void MetaHatchAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
1406 {
1407     maPolyPoly.Move( nHorzMove, nVertMove );
1408 }
1409
1410 void MetaHatchAction::Scale( double fScaleX, double fScaleY )
1411 {
1412     for( sal_uInt16 i = 0, nCount = maPolyPoly.Count(); i < nCount; i++ )
1413         ImplScalePoly( maPolyPoly[ i ], fScaleX, fScaleY );
1414 }
1415
1416 MetaWallpaperAction::MetaWallpaperAction() :
1417     MetaAction(MetaActionType::WALLPAPER)
1418 {}
1419
1420 MetaWallpaperAction::~MetaWallpaperAction()
1421 {}
1422
1423 MetaWallpaperAction::MetaWallpaperAction( const tools::Rectangle& rRect,
1424                                           const Wallpaper& rPaper ) :
1425     MetaAction  ( MetaActionType::WALLPAPER ),
1426     maRect      ( rRect ),
1427     maWallpaper ( rPaper )
1428 {}
1429
1430 void MetaWallpaperAction::Execute( OutputDevice* pOut )
1431 {
1432     pOut->DrawWallpaper( maRect, maWallpaper );
1433 }
1434
1435 rtl::Reference<MetaAction> MetaWallpaperAction::Clone() const
1436 {
1437     return new MetaWallpaperAction( *this );
1438 }
1439
1440 void MetaWallpaperAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
1441 {
1442     maRect.Move( nHorzMove, nVertMove );
1443 }
1444
1445 void MetaWallpaperAction::Scale( double fScaleX, double fScaleY )
1446 {
1447     ImplScaleRect( maRect, fScaleX, fScaleY );
1448 }
1449
1450 MetaClipRegionAction::MetaClipRegionAction() :
1451     MetaAction  ( MetaActionType::CLIPREGION ),
1452     mbClip      ( false )
1453 {}
1454
1455 MetaClipRegionAction::~MetaClipRegionAction()
1456 {}
1457
1458 MetaClipRegionAction::MetaClipRegionAction( vcl::Region aRegion, bool bClip ) :
1459     MetaAction  ( MetaActionType::CLIPREGION ),
1460     maRegion    (std::move( aRegion )),
1461     mbClip      ( bClip )
1462 {}
1463
1464 void MetaClipRegionAction::Execute( OutputDevice* pOut )
1465 {
1466     if( mbClip )
1467         pOut->SetClipRegion( maRegion );
1468     else
1469         pOut->SetClipRegion();
1470 }
1471
1472 rtl::Reference<MetaAction> MetaClipRegionAction::Clone() const
1473 {
1474     return new MetaClipRegionAction( *this );
1475 }
1476
1477 void MetaClipRegionAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
1478 {
1479     maRegion.Move( nHorzMove, nVertMove );
1480 }
1481
1482 void MetaClipRegionAction::Scale( double fScaleX, double fScaleY )
1483 {
1484     maRegion.Scale( fScaleX, fScaleY );
1485 }
1486
1487 MetaISectRectClipRegionAction::MetaISectRectClipRegionAction() :
1488     MetaAction(MetaActionType::ISECTRECTCLIPREGION)
1489 {}
1490
1491 MetaISectRectClipRegionAction::~MetaISectRectClipRegionAction()
1492 {}
1493
1494 MetaISectRectClipRegionAction::MetaISectRectClipRegionAction( const tools::Rectangle& rRect ) :
1495     MetaAction  ( MetaActionType::ISECTRECTCLIPREGION ),
1496     maRect      ( rRect )
1497 {}
1498
1499 void MetaISectRectClipRegionAction::Execute( OutputDevice* pOut )
1500 {
1501     pOut->IntersectClipRegion( maRect );
1502 }
1503
1504 rtl::Reference<MetaAction> MetaISectRectClipRegionAction::Clone() const
1505 {
1506     return new MetaISectRectClipRegionAction( *this );
1507 }
1508
1509 void MetaISectRectClipRegionAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
1510 {
1511     maRect.Move( nHorzMove, nVertMove );
1512 }
1513
1514 void MetaISectRectClipRegionAction::Scale( double fScaleX, double fScaleY )
1515 {
1516     ImplScaleRect( maRect, fScaleX, fScaleY );
1517 }
1518
1519 MetaISectRegionClipRegionAction::MetaISectRegionClipRegionAction() :
1520     MetaAction(MetaActionType::ISECTREGIONCLIPREGION)
1521 {}
1522
1523 MetaISectRegionClipRegionAction::~MetaISectRegionClipRegionAction()
1524 {}
1525
1526 MetaISectRegionClipRegionAction::MetaISectRegionClipRegionAction( vcl::Region aRegion ) :
1527     MetaAction  ( MetaActionType::ISECTREGIONCLIPREGION ),
1528     maRegion    (std::move( aRegion ))
1529 {
1530 }
1531
1532 void MetaISectRegionClipRegionAction::Execute( OutputDevice* pOut )
1533 {
1534     if (!AllowRect(pOut->LogicToPixel(maRegion.GetBoundRect())))
1535         return;
1536
1537     pOut->IntersectClipRegion( maRegion );
1538 }
1539
1540 rtl::Reference<MetaAction> MetaISectRegionClipRegionAction::Clone() const
1541 {
1542     return new MetaISectRegionClipRegionAction( *this );
1543 }
1544
1545 void MetaISectRegionClipRegionAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
1546 {
1547     maRegion.Move( nHorzMove, nVertMove );
1548 }
1549
1550 void MetaISectRegionClipRegionAction::Scale( double fScaleX, double fScaleY )
1551 {
1552     maRegion.Scale( fScaleX, fScaleY );
1553 }
1554
1555 MetaMoveClipRegionAction::MetaMoveClipRegionAction() :
1556     MetaAction  ( MetaActionType::MOVECLIPREGION ),
1557     mnHorzMove  ( 0 ),
1558     mnVertMove  ( 0 )
1559 {}
1560
1561 MetaMoveClipRegionAction::~MetaMoveClipRegionAction()
1562 {}
1563
1564 MetaMoveClipRegionAction::MetaMoveClipRegionAction( tools::Long nHorzMove, tools::Long nVertMove ) :
1565     MetaAction  ( MetaActionType::MOVECLIPREGION ),
1566     mnHorzMove  ( nHorzMove ),
1567     mnVertMove  ( nVertMove )
1568 {}
1569
1570 void MetaMoveClipRegionAction::Execute( OutputDevice* pOut )
1571 {
1572     if (!AllowPoint(pOut->LogicToPixel(Point(mnHorzMove, mnVertMove))))
1573         return;
1574     pOut->MoveClipRegion( mnHorzMove, mnVertMove );
1575 }
1576
1577 rtl::Reference<MetaAction> MetaMoveClipRegionAction::Clone() const
1578 {
1579     return new MetaMoveClipRegionAction( *this );
1580 }
1581
1582 void MetaMoveClipRegionAction::Scale( double fScaleX, double fScaleY )
1583 {
1584     mnHorzMove = basegfx::fround<tools::Long>(mnHorzMove * fScaleX);
1585     mnVertMove = basegfx::fround<tools::Long>(mnVertMove * fScaleY);
1586 }
1587
1588 MetaLineColorAction::MetaLineColorAction() :
1589     MetaAction  ( MetaActionType::LINECOLOR ),
1590     mbSet       ( false )
1591 {}
1592
1593 MetaLineColorAction::~MetaLineColorAction()
1594 {}
1595
1596 MetaLineColorAction::MetaLineColorAction( const Color& rColor, bool bSet ) :
1597     MetaAction  ( MetaActionType::LINECOLOR ),
1598     maColor     ( rColor ),
1599     mbSet       ( bSet )
1600 {}
1601
1602 void MetaLineColorAction::Execute( OutputDevice* pOut )
1603 {
1604     if( mbSet )
1605         pOut->SetLineColor( maColor );
1606     else
1607         pOut->SetLineColor();
1608 }
1609
1610 rtl::Reference<MetaAction> MetaLineColorAction::Clone() const
1611 {
1612     return new MetaLineColorAction( *this );
1613 }
1614
1615 MetaFillColorAction::MetaFillColorAction() :
1616     MetaAction  ( MetaActionType::FILLCOLOR ),
1617     mbSet       ( false )
1618 {}
1619
1620 MetaFillColorAction::~MetaFillColorAction()
1621 {}
1622
1623 MetaFillColorAction::MetaFillColorAction( const Color& rColor, bool bSet ) :
1624     MetaAction  ( MetaActionType::FILLCOLOR ),
1625     maColor     ( rColor ),
1626     mbSet       ( bSet )
1627 {}
1628
1629 void MetaFillColorAction::Execute( OutputDevice* pOut )
1630 {
1631     if( mbSet )
1632         pOut->SetFillColor( maColor );
1633     else
1634         pOut->SetFillColor();
1635 }
1636
1637 rtl::Reference<MetaAction> MetaFillColorAction::Clone() const
1638 {
1639     return new MetaFillColorAction( *this );
1640 }
1641
1642 MetaTextColorAction::MetaTextColorAction() :
1643     MetaAction(MetaActionType::TEXTCOLOR)
1644 {}
1645
1646 MetaTextColorAction::~MetaTextColorAction()
1647 {}
1648
1649 MetaTextColorAction::MetaTextColorAction( const Color& rColor ) :
1650     MetaAction  ( MetaActionType::TEXTCOLOR ),
1651     maColor     ( rColor )
1652 {}
1653
1654 void MetaTextColorAction::Execute( OutputDevice* pOut )
1655 {
1656     pOut->SetTextColor( maColor );
1657 }
1658
1659 rtl::Reference<MetaAction> MetaTextColorAction::Clone() const
1660 {
1661     return new MetaTextColorAction( *this );
1662 }
1663
1664 MetaTextFillColorAction::MetaTextFillColorAction() :
1665     MetaAction  ( MetaActionType::TEXTFILLCOLOR ),
1666     mbSet       ( false )
1667 {}
1668
1669 MetaTextFillColorAction::~MetaTextFillColorAction()
1670 {}
1671
1672 MetaTextFillColorAction::MetaTextFillColorAction( const Color& rColor, bool bSet ) :
1673     MetaAction  ( MetaActionType::TEXTFILLCOLOR ),
1674     maColor     ( rColor ),
1675     mbSet       ( bSet )
1676 {}
1677
1678 void MetaTextFillColorAction::Execute( OutputDevice* pOut )
1679 {
1680     if( mbSet )
1681         pOut->SetTextFillColor( maColor );
1682     else
1683         pOut->SetTextFillColor();
1684 }
1685
1686 rtl::Reference<MetaAction> MetaTextFillColorAction::Clone() const
1687 {
1688     return new MetaTextFillColorAction( *this );
1689 }
1690
1691 MetaTextLineColorAction::MetaTextLineColorAction() :
1692     MetaAction  ( MetaActionType::TEXTLINECOLOR ),
1693     mbSet       ( false )
1694 {}
1695
1696 MetaTextLineColorAction::~MetaTextLineColorAction()
1697 {}
1698
1699 MetaTextLineColorAction::MetaTextLineColorAction( const Color& rColor, bool bSet ) :
1700     MetaAction  ( MetaActionType::TEXTLINECOLOR ),
1701     maColor     ( rColor ),
1702     mbSet       ( bSet )
1703 {}
1704
1705 void MetaTextLineColorAction::Execute( OutputDevice* pOut )
1706 {
1707     if( mbSet )
1708         pOut->SetTextLineColor( maColor );
1709     else
1710         pOut->SetTextLineColor();
1711 }
1712
1713 rtl::Reference<MetaAction> MetaTextLineColorAction::Clone() const
1714 {
1715     return new MetaTextLineColorAction( *this );
1716 }
1717
1718 MetaOverlineColorAction::MetaOverlineColorAction() :
1719     MetaAction  ( MetaActionType::OVERLINECOLOR ),
1720     mbSet       ( false )
1721 {}
1722
1723 MetaOverlineColorAction::~MetaOverlineColorAction()
1724 {}
1725
1726 MetaOverlineColorAction::MetaOverlineColorAction( const Color& rColor, bool bSet ) :
1727     MetaAction  ( MetaActionType::OVERLINECOLOR ),
1728     maColor     ( rColor ),
1729     mbSet       ( bSet )
1730 {}
1731
1732 void MetaOverlineColorAction::Execute( OutputDevice* pOut )
1733 {
1734     if( mbSet )
1735         pOut->SetOverlineColor( maColor );
1736     else
1737         pOut->SetOverlineColor();
1738 }
1739
1740 rtl::Reference<MetaAction> MetaOverlineColorAction::Clone() const
1741 {
1742     return new MetaOverlineColorAction( *this );
1743 }
1744
1745 MetaTextAlignAction::MetaTextAlignAction() :
1746     MetaAction  ( MetaActionType::TEXTALIGN ),
1747     maAlign     ( ALIGN_TOP )
1748 {}
1749
1750 MetaTextAlignAction::~MetaTextAlignAction()
1751 {}
1752
1753 MetaTextAlignAction::MetaTextAlignAction( TextAlign aAlign ) :
1754     MetaAction  ( MetaActionType::TEXTALIGN ),
1755     maAlign     ( aAlign )
1756 {}
1757
1758 void MetaTextAlignAction::Execute( OutputDevice* pOut )
1759 {
1760     pOut->SetTextAlign( maAlign );
1761 }
1762
1763 rtl::Reference<MetaAction> MetaTextAlignAction::Clone() const
1764 {
1765     return new MetaTextAlignAction( *this );
1766 }
1767
1768 MetaMapModeAction::MetaMapModeAction() :
1769     MetaAction(MetaActionType::MAPMODE)
1770 {}
1771
1772 MetaMapModeAction::~MetaMapModeAction()
1773 {}
1774
1775 MetaMapModeAction::MetaMapModeAction( const MapMode& rMapMode ) :
1776     MetaAction  ( MetaActionType::MAPMODE ),
1777     maMapMode   ( rMapMode )
1778 {}
1779
1780 void MetaMapModeAction::Execute( OutputDevice* pOut )
1781 {
1782     pOut->SetMapMode( maMapMode );
1783 }
1784
1785 rtl::Reference<MetaAction> MetaMapModeAction::Clone() const
1786 {
1787     return new MetaMapModeAction( *this );
1788 }
1789
1790 void MetaMapModeAction::Scale( double fScaleX, double fScaleY )
1791 {
1792     Point aPoint( maMapMode.GetOrigin() );
1793
1794     ImplScalePoint( aPoint, fScaleX, fScaleY );
1795     maMapMode.SetOrigin( aPoint );
1796 }
1797
1798 MetaFontAction::MetaFontAction() :
1799     MetaAction(MetaActionType::FONT)
1800 {}
1801
1802 MetaFontAction::~MetaFontAction()
1803 {}
1804
1805 MetaFontAction::MetaFontAction( vcl::Font aFont ) :
1806     MetaAction  ( MetaActionType::FONT ),
1807     maFont      (std::move( aFont ))
1808 {
1809     // #96876: because RTL_TEXTENCODING_SYMBOL is often set at the OpenSymbol font,
1810     // we change the textencoding to RTL_TEXTENCODING_UNICODE here, which seems
1811     // to be the right way; changing the textencoding at other sources
1812     // is too dangerous at the moment
1813     if ( IsOpenSymbol( maFont.GetFamilyName() )
1814         && ( maFont.GetCharSet() != RTL_TEXTENCODING_UNICODE ) )
1815     {
1816         SAL_WARN_IF(maFont.GetCharSet() == RTL_TEXTENCODING_SYMBOL, "vcl", "OpenSymbol should not have charset of RTL_TEXTENCODING_SYMBOL in new documents");
1817         maFont.SetCharSet( RTL_TEXTENCODING_UNICODE );
1818     }
1819 }
1820
1821 void MetaFontAction::Execute( OutputDevice* pOut )
1822 {
1823     pOut->SetFont( maFont );
1824 }
1825
1826 rtl::Reference<MetaAction> MetaFontAction::Clone() const
1827 {
1828     return new MetaFontAction( *this );
1829 }
1830
1831 void MetaFontAction::Scale( double fScaleX, double fScaleY )
1832 {
1833     const Size aSize(
1834         basegfx::fround<tools::Long>(maFont.GetFontSize().Width() * fabs(fScaleX)),
1835         basegfx::fround<tools::Long>(maFont.GetFontSize().Height() * fabs(fScaleY)));
1836     maFont.SetFontSize( aSize );
1837 }
1838
1839 MetaPushAction::MetaPushAction() :
1840     MetaAction  ( MetaActionType::PUSH ),
1841     mnFlags     ( vcl::PushFlags::NONE )
1842 {}
1843
1844 MetaPushAction::~MetaPushAction()
1845 {}
1846
1847 MetaPushAction::MetaPushAction( vcl::PushFlags nFlags ) :
1848     MetaAction  ( MetaActionType::PUSH ),
1849     mnFlags     ( nFlags )
1850 {}
1851
1852 void MetaPushAction::Execute( OutputDevice* pOut )
1853 {
1854     pOut->Push( mnFlags );
1855 }
1856
1857 rtl::Reference<MetaAction> MetaPushAction::Clone() const
1858 {
1859     return new MetaPushAction( *this );
1860 }
1861
1862 MetaPopAction::MetaPopAction() :
1863     MetaAction(MetaActionType::POP)
1864 {}
1865
1866 MetaPopAction::~MetaPopAction()
1867 {}
1868
1869 void MetaPopAction::Execute( OutputDevice* pOut )
1870 {
1871     pOut->Pop();
1872 }
1873
1874 rtl::Reference<MetaAction> MetaPopAction::Clone() const
1875 {
1876     return new MetaPopAction( *this );
1877 }
1878
1879 MetaRasterOpAction::MetaRasterOpAction() :
1880     MetaAction  ( MetaActionType::RASTEROP ),
1881     meRasterOp  ( RasterOp::OverPaint )
1882 {}
1883
1884 MetaRasterOpAction::~MetaRasterOpAction()
1885 {}
1886
1887 MetaRasterOpAction::MetaRasterOpAction( RasterOp eRasterOp ) :
1888     MetaAction  ( MetaActionType::RASTEROP ),
1889     meRasterOp  ( eRasterOp )
1890 {
1891 }
1892
1893 void MetaRasterOpAction::Execute( OutputDevice* pOut )
1894 {
1895     pOut->SetRasterOp( meRasterOp );
1896 }
1897
1898 rtl::Reference<MetaAction> MetaRasterOpAction::Clone() const
1899 {
1900     return new MetaRasterOpAction( *this );
1901 }
1902
1903 MetaTransparentAction::MetaTransparentAction() :
1904     MetaAction      ( MetaActionType::Transparent ),
1905     mnTransPercent  ( 0 )
1906 {}
1907
1908 MetaTransparentAction::~MetaTransparentAction()
1909 {}
1910
1911 MetaTransparentAction::MetaTransparentAction( tools::PolyPolygon aPolyPoly, sal_uInt16 nTransPercent ) :
1912     MetaAction      ( MetaActionType::Transparent ),
1913     maPolyPoly      (std::move( aPolyPoly )),
1914     mnTransPercent  ( nTransPercent )
1915 {}
1916
1917 void MetaTransparentAction::Execute( OutputDevice* pOut )
1918 {
1919     pOut->DrawTransparent( maPolyPoly, mnTransPercent );
1920 }
1921
1922 rtl::Reference<MetaAction> MetaTransparentAction::Clone() const
1923 {
1924     return new MetaTransparentAction( *this );
1925 }
1926
1927 void MetaTransparentAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
1928 {
1929     maPolyPoly.Move( nHorzMove, nVertMove );
1930 }
1931
1932 void MetaTransparentAction::Scale( double fScaleX, double fScaleY )
1933 {
1934     for( sal_uInt16 i = 0, nCount = maPolyPoly.Count(); i < nCount; i++ )
1935         ImplScalePoly( maPolyPoly[ i ], fScaleX, fScaleY );
1936 }
1937
1938 MetaFloatTransparentAction::MetaFloatTransparentAction() :
1939     MetaAction(MetaActionType::FLOATTRANSPARENT)
1940 {}
1941
1942 MetaFloatTransparentAction::~MetaFloatTransparentAction()
1943 {}
1944
1945 MetaFloatTransparentAction::MetaFloatTransparentAction( const GDIMetaFile& rMtf, const Point& rPos,
1946                                                         const Size& rSize, Gradient aGradient ) :
1947     MetaAction      ( MetaActionType::FLOATTRANSPARENT ),
1948     maMtf           ( rMtf ),
1949     maPoint         ( rPos ),
1950     maSize          ( rSize ),
1951     maGradient      (std::move( aGradient ))
1952 {}
1953
1954 void MetaFloatTransparentAction::Execute( OutputDevice* pOut )
1955 {
1956     pOut->DrawTransparent( maMtf, maPoint, maSize, maGradient );
1957 }
1958
1959 rtl::Reference<MetaAction> MetaFloatTransparentAction::Clone() const
1960 {
1961     return new MetaFloatTransparentAction( *this );
1962 }
1963
1964 void MetaFloatTransparentAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
1965 {
1966     maPoint.Move( nHorzMove, nVertMove );
1967 }
1968
1969 void MetaFloatTransparentAction::Scale( double fScaleX, double fScaleY )
1970 {
1971     tools::Rectangle aRectangle(maPoint, maSize);
1972     ImplScaleRect( aRectangle, fScaleX, fScaleY );
1973     maPoint = aRectangle.TopLeft();
1974     maSize = aRectangle.GetSize();
1975 }
1976
1977 void MetaFloatTransparentAction::addSVGTransparencyColorStops(const basegfx::BColorStops& rSVGTransparencyColorStops)
1978 {
1979     maSVGTransparencyColorStops = rSVGTransparencyColorStops;
1980 }
1981
1982 MetaEPSAction::MetaEPSAction() :
1983     MetaAction(MetaActionType::EPS)
1984 {}
1985
1986 MetaEPSAction::~MetaEPSAction()
1987 {}
1988
1989 MetaEPSAction::MetaEPSAction( const Point& rPoint, const Size& rSize,
1990                               GfxLink aGfxLink, const GDIMetaFile& rSubst ) :
1991     MetaAction  ( MetaActionType::EPS ),
1992     maGfxLink   (std::move( aGfxLink )),
1993     maSubst     ( rSubst ),
1994     maPoint     ( rPoint ),
1995     maSize      ( rSize )
1996 {}
1997
1998 void MetaEPSAction::Execute( OutputDevice* pOut )
1999 {
2000     pOut->DrawEPS( maPoint, maSize, maGfxLink, &maSubst );
2001 }
2002
2003 rtl::Reference<MetaAction> MetaEPSAction::Clone() const
2004 {
2005     return new MetaEPSAction( *this );
2006 }
2007
2008 void MetaEPSAction::Move( tools::Long nHorzMove, tools::Long nVertMove )
2009 {
2010     maPoint.Move( nHorzMove, nVertMove );
2011 }
2012
2013 void MetaEPSAction::Scale( double fScaleX, double fScaleY )
2014 {
2015     tools::Rectangle aRectangle(maPoint, maSize);
2016     ImplScaleRect( aRectangle, fScaleX, fScaleY );
2017     maPoint = aRectangle.TopLeft();
2018     maSize = aRectangle.GetSize();
2019 }
2020
2021 MetaRefPointAction::MetaRefPointAction() :
2022     MetaAction  ( MetaActionType::REFPOINT ),
2023     mbSet       ( false )
2024 {}
2025
2026 MetaRefPointAction::~MetaRefPointAction()
2027 {}
2028
2029 MetaRefPointAction::MetaRefPointAction( const Point& rRefPoint, bool bSet ) :
2030     MetaAction  ( MetaActionType::REFPOINT ),
2031     maRefPoint  ( rRefPoint ),
2032     mbSet       ( bSet )
2033 {}
2034
2035 void MetaRefPointAction::Execute( OutputDevice* pOut )
2036 {
2037     if( mbSet )
2038         pOut->SetRefPoint( maRefPoint );
2039     else
2040         pOut->SetRefPoint();
2041 }
2042
2043 rtl::Reference<MetaAction> MetaRefPointAction::Clone() const
2044 {
2045     return new MetaRefPointAction( *this );
2046 }
2047
2048 MetaCommentAction::MetaCommentAction() :
2049     MetaAction  ( MetaActionType::COMMENT ),
2050     mnValue     ( 0 )
2051 {
2052     ImplInitDynamicData( nullptr, 0UL );
2053 }
2054
2055 MetaCommentAction::MetaCommentAction( const MetaCommentAction& rAct ) :
2056     MetaAction  ( MetaActionType::COMMENT ),
2057     maComment   ( rAct.maComment ),
2058     mnValue     ( rAct.mnValue )
2059 {
2060     ImplInitDynamicData( rAct.mpData.get(), rAct.mnDataSize );
2061 }
2062
2063 MetaCommentAction::MetaCommentAction( OString aComment, sal_Int32 nValue, const sal_uInt8* pData, sal_uInt32 nDataSize ) :
2064     MetaAction  ( MetaActionType::COMMENT ),
2065     maComment   (std::move( aComment )),
2066     mnValue     ( nValue )
2067 {
2068     ImplInitDynamicData( pData, nDataSize );
2069 }
2070
2071 MetaCommentAction::~MetaCommentAction()
2072 {
2073 }
2074
2075 void MetaCommentAction::ImplInitDynamicData( const sal_uInt8* pData, sal_uInt32 nDataSize )
2076 {
2077     if ( nDataSize && pData )
2078     {
2079         mnDataSize = nDataSize;
2080         mpData.reset( new sal_uInt8[ mnDataSize ] );
2081         memcpy( mpData.get(), pData, mnDataSize );
2082     }
2083     else
2084     {
2085         mnDataSize = 0;
2086         mpData = nullptr;
2087     }
2088 }
2089
2090 void MetaCommentAction::Execute( OutputDevice* pOut )
2091 {
2092     if ( pOut->GetConnectMetaFile() )
2093     {
2094         pOut->GetConnectMetaFile()->AddAction( this );
2095     }
2096 }
2097
2098 rtl::Reference<MetaAction> MetaCommentAction::Clone() const
2099 {
2100     return new MetaCommentAction( *this );
2101 }
2102
2103 void MetaCommentAction::Move( tools::Long nXMove, tools::Long nYMove )
2104 {
2105     if ( !(nXMove || nYMove) )
2106         return;
2107
2108     if ( !(mnDataSize && mpData) )
2109         return;
2110
2111     bool bPathStroke = (maComment == "XPATHSTROKE_SEQ_BEGIN");
2112     if ( !(bPathStroke || maComment == "XPATHFILL_SEQ_BEGIN") )
2113         return;
2114
2115     SvMemoryStream  aMemStm( static_cast<void*>(mpData.get()), mnDataSize, StreamMode::READ );
2116     SvMemoryStream  aDest;
2117     if ( bPathStroke )
2118     {
2119         SvtGraphicStroke aStroke;
2120         ReadSvtGraphicStroke( aMemStm, aStroke );
2121
2122         tools::Polygon aPath;
2123         aStroke.getPath( aPath );
2124         aPath.Move( nXMove, nYMove );
2125         aStroke.setPath( aPath );
2126
2127         tools::PolyPolygon aStartArrow;
2128         aStroke.getStartArrow(aStartArrow);
2129         aStartArrow.Move(nXMove, nYMove);
2130         aStroke.setStartArrow(aStartArrow);
2131
2132         tools::PolyPolygon aEndArrow;
2133         aStroke.getEndArrow(aEndArrow);
2134         aEndArrow.Move(nXMove, nYMove);
2135         aStroke.setEndArrow(aEndArrow);
2136
2137         WriteSvtGraphicStroke( aDest, aStroke );
2138     }
2139     else
2140     {
2141         SvtGraphicFill aFill;
2142         ReadSvtGraphicFill( aMemStm, aFill );
2143
2144         tools::PolyPolygon aPath;
2145         aFill.getPath( aPath );
2146         aPath.Move( nXMove, nYMove );
2147         aFill.setPath( aPath );
2148
2149         WriteSvtGraphicFill( aDest, aFill );
2150     }
2151     mpData.reset();
2152     ImplInitDynamicData( static_cast<const sal_uInt8*>( aDest.GetData() ), aDest.Tell() );
2153 }
2154
2155 // SJ: 25.07.06 #i56656# we are not able to mirror certain kind of
2156 // comments properly, especially the XPATHSTROKE and XPATHFILL lead to
2157 // problems, so it is better to remove these comments when mirroring
2158 // FIXME: fake comment to apply the next hunk in the right location
2159 void MetaCommentAction::Scale( double fXScale, double fYScale )
2160 {
2161     if (( fXScale == 1.0 ) && ( fYScale == 1.0 ))
2162         return;
2163
2164     if ( !(mnDataSize && mpData) )
2165         return;
2166
2167     bool bPathStroke = (maComment == "XPATHSTROKE_SEQ_BEGIN");
2168     if ( bPathStroke || maComment == "XPATHFILL_SEQ_BEGIN" )
2169     {
2170         SvMemoryStream  aMemStm( static_cast<void*>(mpData.get()), mnDataSize, StreamMode::READ );
2171         SvMemoryStream  aDest;
2172         if ( bPathStroke )
2173         {
2174             SvtGraphicStroke aStroke;
2175             ReadSvtGraphicStroke( aMemStm, aStroke );
2176             aStroke.scale( fXScale, fYScale );
2177             WriteSvtGraphicStroke( aDest, aStroke );
2178         }
2179         else
2180         {
2181             SvtGraphicFill aFill;
2182             ReadSvtGraphicFill( aMemStm, aFill );
2183             tools::PolyPolygon aPath;
2184             aFill.getPath( aPath );
2185             aPath.Scale( fXScale, fYScale );
2186             aFill.setPath( aPath );
2187             WriteSvtGraphicFill( aDest, aFill );
2188         }
2189         mpData.reset();
2190         ImplInitDynamicData( static_cast<const sal_uInt8*>( aDest.GetData() ), aDest.Tell() );
2191     } else if( maComment == "EMF_PLUS_HEADER_INFO" ){
2192         SvMemoryStream  aMemStm( static_cast<void*>(mpData.get()), mnDataSize, StreamMode::READ );
2193         SvMemoryStream  aDest;
2194
2195         sal_Int32 nLeft(0), nRight(0), nTop(0), nBottom(0);
2196         sal_Int32 nPixX(0), nPixY(0), nMillX(0), nMillY(0);
2197         float m11(0), m12(0), m21(0), m22(0), mdx(0), mdy(0);
2198
2199         // read data
2200         aMemStm.ReadInt32( nLeft ).ReadInt32( nTop ).ReadInt32( nRight ).ReadInt32( nBottom );
2201         aMemStm.ReadInt32( nPixX ).ReadInt32( nPixY ).ReadInt32( nMillX ).ReadInt32( nMillY );
2202         aMemStm.ReadFloat( m11 ).ReadFloat( m12 ).ReadFloat( m21 ).ReadFloat( m22 ).ReadFloat( mdx ).ReadFloat( mdy );
2203
2204         // add scale to the transformation
2205         m11 *= fXScale;
2206         m12 *= fXScale;
2207         m22 *= fYScale;
2208         m21 *= fYScale;
2209
2210         // prepare new data
2211         aDest.WriteInt32( nLeft ).WriteInt32( nTop ).WriteInt32( nRight ).WriteInt32( nBottom );
2212         aDest.WriteInt32( nPixX ).WriteInt32( nPixY ).WriteInt32( nMillX ).WriteInt32( nMillY );
2213         aDest.WriteFloat( m11 ).WriteFloat( m12 ).WriteFloat( m21 ).WriteFloat( m22 ).WriteFloat( mdx ).WriteFloat( mdy );
2214
2215         // save them
2216         ImplInitDynamicData( static_cast<const sal_uInt8*>( aDest.GetData() ), aDest.Tell() );
2217     }
2218 }
2219
2220 MetaLayoutModeAction::MetaLayoutModeAction() :
2221     MetaAction  ( MetaActionType::LAYOUTMODE ),
2222     mnLayoutMode( vcl::text::ComplexTextLayoutFlags::Default )
2223 {}
2224
2225 MetaLayoutModeAction::~MetaLayoutModeAction()
2226 {}
2227
2228 MetaLayoutModeAction::MetaLayoutModeAction( vcl::text::ComplexTextLayoutFlags nLayoutMode ) :
2229     MetaAction  ( MetaActionType::LAYOUTMODE ),
2230     mnLayoutMode( nLayoutMode )
2231 {}
2232
2233 void MetaLayoutModeAction::Execute( OutputDevice* pOut )
2234 {
2235     pOut->SetLayoutMode( mnLayoutMode );
2236 }
2237
2238 rtl::Reference<MetaAction> MetaLayoutModeAction::Clone() const
2239 {
2240     return new MetaLayoutModeAction( *this );
2241 }
2242
2243 MetaTextLanguageAction::MetaTextLanguageAction() :
2244     MetaAction  ( MetaActionType::TEXTLANGUAGE ),
2245     meTextLanguage( LANGUAGE_DONTKNOW )
2246 {}
2247
2248 MetaTextLanguageAction::~MetaTextLanguageAction()
2249 {}
2250
2251 MetaTextLanguageAction::MetaTextLanguageAction( LanguageType eTextLanguage ) :
2252     MetaAction  ( MetaActionType::TEXTLANGUAGE ),
2253     meTextLanguage( eTextLanguage )
2254 {}
2255
2256 void MetaTextLanguageAction::Execute( OutputDevice* pOut )
2257 {
2258     pOut->SetDigitLanguage( meTextLanguage );
2259 }
2260
2261 rtl::Reference<MetaAction> MetaTextLanguageAction::Clone() const
2262 {
2263     return new MetaTextLanguageAction( *this );
2264 }
2265
2266 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */