vcl/source/outdev/outdev.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 <sal/config.h>
  21 #include <sal/log.hxx>
  22
  23 #include <tools/debug.hxx>
  24 #include <vcl/gdimtf.hxx>
  25 #include <vcl/graph.hxx>
  26 #include <vcl/metaact.hxx>
  27 #include <vcl/virdev.hxx>
  28 #include <vcl/outdev.hxx>
  29 #include <vcl/toolkit/unowrap.hxx>
  30 #include <vcl/svapp.hxx>
  31 #include <vcl/sysdata.hxx>
  32
  33 #include <salgdi.hxx>
  34 #include <window.h>
  35 #include <outdev.h>
  36
  37 #ifdef DISABLE_DYNLOADING
  38 // Linking all needed LO code into one .so/executable, these already
  39 // exist in the tools library, so put them in the anonymous namespace
  40 // here to avoid clash...
  41 namespace {
  42 #endif
  43 #ifdef DISABLE_DYNLOADING
  44 }
  45 #endif
  46
  47 // Begin initializer and accessor public functions
  48
  49 OutputDevice::OutputDevice(OutDevType eOutDevType) :
  50     meOutDevType(eOutDevType),
  51     maRegion(true),
  52     maFillColor( COL_WHITE ),
  53     maTextLineColor( COL_TRANSPARENT ),
  54     mxSettings( new AllSettings(Application::GetSettings()) )
  55 {
  56     mpGraphics                      = nullptr;
  57     mpUnoGraphicsList               = nullptr;
  58     mpPrevGraphics                  = nullptr;
  59     mpNextGraphics                  = nullptr;
  60     mpMetaFile                      = nullptr;
  61     mpFontInstance                     = nullptr;
  62     mpDeviceFontList                = nullptr;
  63     mpDeviceFontSizeList            = nullptr;
  64     mpAlphaVDev                     = nullptr;
  65     mpExtOutDevData                 = nullptr;
  66     mnOutOffX                       = 0;
  67     mnOutOffY                       = 0;
  68     mnOutWidth                      = 0;
  69     mnOutHeight                     = 0;
  70     mnDPIX                          = 0;
  71     mnDPIY                          = 0;
  72     mnDPIScalePercentage            = 100;
  73     mnTextOffX                      = 0;
  74     mnTextOffY                      = 0;
  75     mnOutOffOrigX                   = 0;
  76     mnOutOffLogicX                  = 0;
  77     mnOutOffOrigY                   = 0;
  78     mnOutOffLogicY                  = 0;
  79     mnEmphasisAscent                = 0;
  80     mnEmphasisDescent               = 0;
  81     mnDrawMode                      = DrawModeFlags::Default;
  82     mnTextLayoutMode                = ComplexTextLayoutFlags::Default;
  83
  84     if( AllSettings::GetLayoutRTL() ) //#i84553# tip BiDi preference to RTL
  85         mnTextLayoutMode            = ComplexTextLayoutFlags::BiDiRtl | ComplexTextLayoutFlags::TextOriginLeft;
  86
  87     meOutDevViewType                = OutDevViewType::DontKnow;
  88     mbMap                           = false;
  89     mbClipRegion                    = false;
  90     mbBackground                    = false;
  91     mbOutput                        = true;
  92     mbDevOutput                     = false;
  93     mbOutputClipped                 = false;
  94     maTextColor                     = COL_BLACK;
  95     maOverlineColor                 = COL_TRANSPARENT;
  96     meRasterOp                      = RasterOp::OverPaint;
  97     mnAntialiasing                  = AntialiasingFlags::NONE;
  98     meTextLanguage                  = LANGUAGE_SYSTEM;  // TODO: get default from configuration?
  99     mbLineColor                     = true;
 100     mbFillColor                     = true;
 101     mbInitLineColor                 = true;
 102     mbInitFillColor                 = true;
 103     mbInitFont                      = true;
 104     mbInitTextColor                 = true;
 105     mbInitClipRegion                = true;
 106     mbClipRegionSet                 = false;
 107     mbNewFont                       = true;
 108     mbTextLines                     = false;
 109     mbTextSpecial                   = false;
 110     mbRefPoint                      = false;
 111     mbEnableRTL                     = false;    // mirroring must be explicitly allowed (typically for windows only)
 112
 113     // struct ImplMapRes
 114     maMapRes.mnMapOfsX              = 0;
 115     maMapRes.mnMapOfsY              = 0;
 116     maMapRes.mnMapScNumX            = 1;
 117     maMapRes.mnMapScNumY            = 1;
 118     maMapRes.mnMapScDenomX          = 1;
 119     maMapRes.mnMapScDenomY          = 1;
 120
 121     // struct ImplOutDevData- see #i82615#
 122     mpOutDevData.reset(new ImplOutDevData);
 123     mpOutDevData->mpRotateDev       = nullptr;
 124     mpOutDevData->mpRecordLayout    = nullptr;
 125
 126     // #i75163#
 127     mpOutDevData->mpViewTransform   = nullptr;
 128     mpOutDevData->mpInverseViewTransform = nullptr;
 129 }
 130
 131 OutputDevice::~OutputDevice()
 132 {
 133     disposeOnce();
 134 }
 135
 136 void OutputDevice::dispose()
 137 {
 138     if ( GetUnoGraphicsList() )
 139     {
 140         UnoWrapperBase* pWrapper = UnoWrapperBase::GetUnoWrapper( false );
 141         if ( pWrapper )
 142             pWrapper->ReleaseAllGraphics( this );
 143         delete mpUnoGraphicsList;
 144         mpUnoGraphicsList = nullptr;
 145     }
 146
 147     mpOutDevData->mpRotateDev.disposeAndClear();
 148
 149     // #i75163#
 150     ImplInvalidateViewTransform();
 151
 152     mpOutDevData.reset();
 153
 154     // for some reason, we haven't removed state from the stack properly
 155     if ( !maOutDevStateStack.empty() )
 156         SAL_WARN( "vcl.gdi", "OutputDevice::~OutputDevice(): OutputDevice::Push() calls != OutputDevice::Pop() calls" );
 157     maOutDevStateStack.clear();
 158
 159     // release the active font instance
 160     mpFontInstance.clear();
 161
 162     // remove cached results of GetDevFontList/GetDevSizeList
 163     mpDeviceFontList.reset();
 164     mpDeviceFontSizeList.reset();
 165
 166     // release ImplFontCache specific to this OutputDevice
 167     mxFontCache.reset();
 168
 169     // release ImplFontList specific to this OutputDevice
 170     mxFontCollection.reset();
 171
 172     mpAlphaVDev.disposeAndClear();
 173     mpPrevGraphics.clear();
 174     mpNextGraphics.clear();
 175     VclReferenceBase::dispose();
 176 }
 177
 178 bool OutputDevice::IsVirtual() const
 179 {
 180     return false;
 181 }
 182
 183 SalGraphics* OutputDevice::GetGraphics()
 184 {
 185     DBG_TESTSOLARMUTEX();
 186
 187     if (!mpGraphics && !AcquireGraphics())
 188         SAL_WARN("vcl.gdi", "No mpGraphics set");
 189
 190     return mpGraphics;
 191 }
 192
 193 SalGraphics const *OutputDevice::GetGraphics() const
 194 {
 195     DBG_TESTSOLARMUTEX();
 196
 197     if (!mpGraphics && !AcquireGraphics())
 198         SAL_WARN("vcl.gdi", "No mpGraphics set");
 199
 200     return mpGraphics;
 201 }
 202
 203 void OutputDevice::SetConnectMetaFile( GDIMetaFile* pMtf )
 204 {
 205     mpMetaFile = pMtf;
 206 }
 207
 208 void OutputDevice::SetSettings( const AllSettings& rSettings )
 209 {
 210     *mxSettings = rSettings;
 211
 212     if( mpAlphaVDev )
 213         mpAlphaVDev->SetSettings( rSettings );
 214 }
 215
 216 SystemGraphicsData OutputDevice::GetSystemGfxData() const
 217 {
 218     if (!mpGraphics && !AcquireGraphics())
 219         return SystemGraphicsData();
 220
 221     return mpGraphics->GetGraphicsData();
 222 }
 223
 224 #if ENABLE_CAIRO_CANVAS
 225
 226 bool OutputDevice::SupportsCairo() const
 227 {
 228     if (!mpGraphics && !AcquireGraphics())
 229         return false;
 230
 231     return mpGraphics->SupportsCairo();
 232 }
 233
 234 cairo::SurfaceSharedPtr OutputDevice::CreateSurface(const cairo::CairoSurfaceSharedPtr& rSurface) const
 235 {
 236     if (!mpGraphics && !AcquireGraphics())
 237         return cairo::SurfaceSharedPtr();
 238     return mpGraphics->CreateSurface(rSurface);
 239 }
 240
 241 cairo::SurfaceSharedPtr OutputDevice::CreateSurface(int x, int y, int width, int height) const
 242 {
 243     if (!mpGraphics && !AcquireGraphics())
 244         return cairo::SurfaceSharedPtr();
 245     return mpGraphics->CreateSurface(*this, x, y, width, height);
 246 }
 247
 248 cairo::SurfaceSharedPtr OutputDevice::CreateBitmapSurface(const BitmapSystemData& rData, const Size& rSize) const
 249 {
 250     if (!mpGraphics && !AcquireGraphics())
 251         return cairo::SurfaceSharedPtr();
 252     return mpGraphics->CreateBitmapSurface(*this, rData, rSize);
 253 }
 254
 255 css::uno::Any OutputDevice::GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& rSurface, const basegfx::B2ISize& rSize) const
 256 {
 257     if (!mpGraphics && !AcquireGraphics())
 258         return css::uno::Any();
 259     return mpGraphics->GetNativeSurfaceHandle(rSurface, rSize);
 260 }
 261
 262 #endif // ENABLE_CAIRO_CANVAS
 263
 264 css::uno::Any OutputDevice::GetSystemGfxDataAny() const
 265 {
 266     const SystemGraphicsData aSysData = GetSystemGfxData();
 267     css::uno::Sequence< sal_Int8 > aSeq( reinterpret_cast<sal_Int8 const *>(&aSysData),
 268                                                       aSysData.nSize );
 269
 270     return css::uno::makeAny(aSeq);
 271 }
 272
 273 void OutputDevice::SetRefPoint()
 274 {
 275
 276     if ( mpMetaFile )
 277         mpMetaFile->AddAction( new MetaRefPointAction( Point(), false ) );
 278
 279     mbRefPoint = false;
 280     maRefPoint.setX(0);
 281     maRefPoint.setY(0);
 282
 283     if( mpAlphaVDev )
 284         mpAlphaVDev->SetRefPoint();
 285 }
 286
 287 void OutputDevice::SetRefPoint( const Point& rRefPoint )
 288 {
 289
 290     if ( mpMetaFile )
 291         mpMetaFile->AddAction( new MetaRefPointAction( rRefPoint, true ) );
 292
 293     mbRefPoint = true;
 294     maRefPoint = rRefPoint;
 295
 296     if( mpAlphaVDev )
 297         mpAlphaVDev->SetRefPoint( rRefPoint );
 298 }
 299
 300 sal_uInt16 OutputDevice::GetBitCount() const
 301 {
 302     // we need a graphics instance
 303     if ( !mpGraphics && !AcquireGraphics() )
 304         return 0;
 305
 306     return mpGraphics->GetBitCount();
 307 }
 308
 309 void OutputDevice::SetOutOffXPixel(tools::Long nOutOffX)
 310 {
 311     mnOutOffX = nOutOffX;
 312 }
 313
 314 void OutputDevice::SetOutOffYPixel(tools::Long nOutOffY)
 315 {
 316     mnOutOffY = nOutOffY;
 317 }
 318
 319 css::uno::Reference< css::awt::XGraphics > OutputDevice::CreateUnoGraphics()
 320 {
 321     UnoWrapperBase* pWrapper = UnoWrapperBase::GetUnoWrapper();
 322     return pWrapper ? pWrapper->CreateGraphics( this ) : css::uno::Reference< css::awt::XGraphics >();
 323 }
 324
 325 std::vector< VCLXGraphics* > *OutputDevice::CreateUnoGraphicsList()
 326 {
 327     mpUnoGraphicsList = new std::vector< VCLXGraphics* >;
 328     return mpUnoGraphicsList;
 329 }
 330
 331 // Helper public function
 332
 333 bool OutputDevice::SupportsOperation( OutDevSupportType eType ) const
 334 {
 335     if( !mpGraphics && !AcquireGraphics() )
 336         return false;
 337     const bool bHasSupport = mpGraphics->supportsOperation( eType );
 338     return bHasSupport;
 339 }
 340
 341 // Direct OutputDevice drawing public functions
 342
 343 void OutputDevice::DrawOutDev( const Point& rDestPt, const Size& rDestSize,
 344                                const Point& rSrcPt,  const Size& rSrcSize )
 345 {
 346     if( ImplIsRecordLayout() )
 347         return;
 348
 349     if ( RasterOp::Invert == meRasterOp )
 350     {
 351         DrawRect( tools::Rectangle( rDestPt, rDestSize ) );
 352         return;
 353     }
 354
 355     if ( mpMetaFile )
 356     {
 357         const Bitmap aBmp( GetBitmap( rSrcPt, rSrcSize ) );
 358         mpMetaFile->AddAction( new MetaBmpScaleAction( rDestPt, rDestSize, aBmp ) );
 359     }
 360
 361     if ( !IsDeviceOutputNecessary() )
 362         return;
 363
 364     if ( !mpGraphics && !AcquireGraphics() )
 365         return;
 366
 367     if ( mbInitClipRegion )
 368         InitClipRegion();
 369
 370     if ( mbOutputClipped )
 371         return;
 372
 373     tools::Long nSrcWidth   = ImplLogicWidthToDevicePixel( rSrcSize.Width() );
 374     tools::Long nSrcHeight  = ImplLogicHeightToDevicePixel( rSrcSize.Height() );
 375     tools::Long nDestWidth  = ImplLogicWidthToDevicePixel( rDestSize.Width() );
 376     tools::Long nDestHeight = ImplLogicHeightToDevicePixel( rDestSize.Height() );
 377
 378     if (nSrcWidth && nSrcHeight && nDestWidth && nDestHeight)
 379     {
 380         SalTwoRect aPosAry(ImplLogicXToDevicePixel(rSrcPt.X()), ImplLogicYToDevicePixel(rSrcPt.Y()),
 381                            nSrcWidth, nSrcHeight,
 382                            ImplLogicXToDevicePixel(rDestPt.X()), ImplLogicYToDevicePixel(rDestPt.Y()),
 383                            nDestWidth, nDestHeight);
 384
 385         const tools::Rectangle aSrcOutRect( Point( mnOutOffX, mnOutOffY ),
 386                                      Size( mnOutWidth, mnOutHeight ) );
 387
 388         AdjustTwoRect( aPosAry, aSrcOutRect );
 389
 390         if ( aPosAry.mnSrcWidth && aPosAry.mnSrcHeight && aPosAry.mnDestWidth && aPosAry.mnDestHeight )
 391             mpGraphics->CopyBits( aPosAry, nullptr, this, nullptr );
 392     }
 393
 394     if( mpAlphaVDev )
 395         mpAlphaVDev->DrawOutDev( rDestPt, rDestSize, rSrcPt, rSrcSize );
 396 }
 397
 398 void OutputDevice::DrawOutDev( const Point& rDestPt, const Size& rDestSize,
 399                                const Point& rSrcPt,  const Size& rSrcSize,
 400                                const OutputDevice& rOutDev )
 401 {
 402     if ( ImplIsRecordLayout() )
 403         return;
 404
 405     if ( RasterOp::Invert == meRasterOp )
 406     {
 407         DrawRect( tools::Rectangle( rDestPt, rDestSize ) );
 408         return;
 409     }
 410
 411     if ( mpMetaFile )
 412     {
 413         if (rOutDev.mpAlphaVDev)
 414         {
 415             const BitmapEx aBmpEx(rOutDev.GetBitmapEx(rSrcPt, rSrcSize));
 416             mpMetaFile->AddAction(new MetaBmpExScaleAction(rDestPt, rDestSize, aBmpEx));
 417         }
 418         else
 419         {
 420             const Bitmap aBmp(rOutDev.GetBitmap(rSrcPt, rSrcSize));
 421             mpMetaFile->AddAction(new MetaBmpScaleAction(rDestPt, rDestSize, aBmp));
 422         }
 423     }
 424
 425     if ( !IsDeviceOutputNecessary() )
 426         return;
 427
 428     if ( !mpGraphics && !AcquireGraphics() )
 429         return;
 430
 431     if ( mbInitClipRegion )
 432         InitClipRegion();
 433
 434     if ( mbOutputClipped )
 435         return;
 436
 437     if (rOutDev.mpAlphaVDev)
 438     {
 439         // alpha-blend source over destination
 440         DrawBitmapEx(rDestPt, rDestSize, rOutDev.GetBitmapEx(rSrcPt, rSrcSize));
 441     }
 442     else
 443     {
 444         SalTwoRect aPosAry(rOutDev.ImplLogicXToDevicePixel(rSrcPt.X()),
 445                            rOutDev.ImplLogicYToDevicePixel(rSrcPt.Y()),
 446                            rOutDev.ImplLogicWidthToDevicePixel(rSrcSize.Width()),
 447                            rOutDev.ImplLogicHeightToDevicePixel(rSrcSize.Height()),
 448                            ImplLogicXToDevicePixel(rDestPt.X()),
 449                            ImplLogicYToDevicePixel(rDestPt.Y()),
 450                            ImplLogicWidthToDevicePixel(rDestSize.Width()),
 451                            ImplLogicHeightToDevicePixel(rDestSize.Height()));
 452
 453         drawOutDevDirect(&rOutDev, aPosAry);
 454
 455         // #i32109#: make destination rectangle opaque - source has no alpha
 456         if (mpAlphaVDev)
 457             mpAlphaVDev->ImplFillOpaqueRectangle(tools::Rectangle(rDestPt, rDestSize));
 458     }
 459 }
 460
 461 void OutputDevice::CopyArea( const Point& rDestPt,
 462                              const Point& rSrcPt,  const Size& rSrcSize,
 463                              bool bWindowInvalidate )
 464 {
 465     if ( ImplIsRecordLayout() )
 466         return;
 467
 468     RasterOp eOldRop = GetRasterOp();
 469     SetRasterOp( RasterOp::OverPaint );
 470
 471     if ( !IsDeviceOutputNecessary() )
 472         return;
 473
 474     if ( !mpGraphics && !AcquireGraphics() )
 475         return;
 476
 477     if ( mbInitClipRegion )
 478         InitClipRegion();
 479
 480     if ( mbOutputClipped )
 481         return;
 482
 483     tools::Long nSrcWidth   = ImplLogicWidthToDevicePixel( rSrcSize.Width() );
 484     tools::Long nSrcHeight  = ImplLogicHeightToDevicePixel( rSrcSize.Height() );
 485     if (nSrcWidth && nSrcHeight)
 486     {
 487         SalTwoRect aPosAry(ImplLogicXToDevicePixel(rSrcPt.X()), ImplLogicYToDevicePixel(rSrcPt.Y()),
 488                            nSrcWidth, nSrcHeight,
 489                            ImplLogicXToDevicePixel(rDestPt.X()), ImplLogicYToDevicePixel(rDestPt.Y()),
 490                            nSrcWidth, nSrcHeight);
 491
 492         const tools::Rectangle aSrcOutRect( Point( mnOutOffX, mnOutOffY ),
 493                                      Size( mnOutWidth, mnOutHeight ) );
 494
 495         AdjustTwoRect( aPosAry, aSrcOutRect );
 496
 497         CopyDeviceArea( aPosAry, bWindowInvalidate );
 498     }
 499
 500     SetRasterOp( eOldRop );
 501
 502     if( mpAlphaVDev )
 503         mpAlphaVDev->CopyArea( rDestPt, rSrcPt, rSrcSize, bWindowInvalidate );
 504 }
 505
 506 // Direct OutputDevice drawing protected function
 507
 508 void OutputDevice::CopyDeviceArea( SalTwoRect& aPosAry, bool /*bWindowInvalidate*/)
 509 {
 510     if (aPosAry.mnSrcWidth == 0 || aPosAry.mnSrcHeight == 0 || aPosAry.mnDestWidth == 0 || aPosAry.mnDestHeight == 0)
 511         return;
 512
 513     aPosAry.mnDestWidth  = aPosAry.mnSrcWidth;
 514     aPosAry.mnDestHeight = aPosAry.mnSrcHeight;
 515     mpGraphics->CopyBits(aPosAry, nullptr, this, nullptr);
 516 }
 517
 518 // Direct OutputDevice drawing private function
 519
 520 void OutputDevice::drawOutDevDirect( const OutputDevice* pSrcDev, SalTwoRect& rPosAry )
 521 {
 522     SalGraphics* pSrcGraphics;
 523     if (const OutputDevice* pCheckedSrc = DrawOutDevDirectCheck(pSrcDev))
 524     {
 525         if (!pCheckedSrc->mpGraphics && !pCheckedSrc->AcquireGraphics())
 526             return;
 527         pSrcGraphics = pCheckedSrc->mpGraphics;
 528     }
 529     else
 530         pSrcGraphics = nullptr;
 531
 532     if (!mpGraphics && !AcquireGraphics())
 533         return;
 534
 535     // #102532# Offset only has to be pseudo window offset
 536     const tools::Rectangle aSrcOutRect( Point( pSrcDev->mnOutOffX, pSrcDev->mnOutOffY ),
 537                                  Size( pSrcDev->mnOutWidth, pSrcDev->mnOutHeight ) );
 538
 539     AdjustTwoRect( rPosAry, aSrcOutRect );
 540
 541     if ( rPosAry.mnSrcWidth && rPosAry.mnSrcHeight && rPosAry.mnDestWidth && rPosAry.mnDestHeight )
 542     {
 543         // if this is no window, but pSrcDev is a window
 544         // mirroring may be required
 545         // because only windows have a SalGraphicsLayout
 546         // mirroring is performed here
 547         DrawOutDevDirectProcess( pSrcDev, rPosAry, pSrcGraphics);
 548     }
 549 }
 550
 551 const OutputDevice* OutputDevice::DrawOutDevDirectCheck(const OutputDevice* pSrcDev) const
 552 {
 553     return this == pSrcDev ? nullptr : pSrcDev;
 554 }
 555
 556 void OutputDevice::DrawOutDevDirectProcess( const OutputDevice* pSrcDev, SalTwoRect& rPosAry, SalGraphics* pSrcGraphics )
 557 {
 558     if( pSrcGraphics && (pSrcGraphics->GetLayout() & SalLayoutFlags::BiDiRtl) )
 559     {
 560         SalTwoRect aPosAry2 = rPosAry;
 561         pSrcGraphics->mirror( aPosAry2.mnSrcX, aPosAry2.mnSrcWidth, pSrcDev );
 562         mpGraphics->CopyBits( aPosAry2, pSrcGraphics, this, pSrcDev );
 563     }
 564     else
 565         mpGraphics->CopyBits( rPosAry, pSrcGraphics, this, pSrcDev );
 566 }
 567
 568 tools::Rectangle OutputDevice::GetBackgroundComponentBounds() const
 569 {
 570     return tools::Rectangle( Point( 0, 0 ), GetOutputSizePixel() );
 571 }
 572
 573 // Layout public functions
 574
 575 void OutputDevice::EnableRTL( bool bEnable )
 576 {
 577     mbEnableRTL = bEnable;
 578
 579     if( mpAlphaVDev )
 580         mpAlphaVDev->EnableRTL( bEnable );
 581 }
 582
 583 bool OutputDevice::ImplIsAntiparallel() const
 584 {
 585     bool bRet = false;
 586     if( AcquireGraphics() )
 587     {
 588         if( ( (mpGraphics->GetLayout() & SalLayoutFlags::BiDiRtl) && ! IsRTLEnabled() ) ||
 589             ( ! (mpGraphics->GetLayout() & SalLayoutFlags::BiDiRtl) && IsRTLEnabled() ) )
 590         {
 591             bRet = true;
 592         }
 593     }
 594     return bRet;
 595 }
 596
 597 // note: the coordinates to be remirrored are in frame coordinates !
 598
 599 void    OutputDevice::ReMirror( Point &rPoint ) const
 600 {
 601     rPoint.setX( mnOutOffX + mnOutWidth - 1 - rPoint.X() + mnOutOffX );
 602 }
 603 void    OutputDevice::ReMirror( tools::Rectangle &rRect ) const
 604 {
 605     tools::Long nWidth = rRect.Right() - rRect.Left();
 606
 607     //long lc_x = rRect.nLeft - mnOutOffX;    // normalize
 608     //lc_x = mnOutWidth - nWidth - 1 - lc_x;  // mirror
 609     //rRect.nLeft = lc_x + mnOutOffX;         // re-normalize
 610
 611     rRect.SetLeft( mnOutOffX + mnOutWidth - nWidth - 1 - rRect.Left() + mnOutOffX );
 612     rRect.SetRight( rRect.Left() + nWidth );
 613 }
 614
 615 void OutputDevice::ReMirror( vcl::Region &rRegion ) const
 616 {
 617     RectangleVector aRectangles;
 618     rRegion.GetRegionRectangles(aRectangles);
 619     vcl::Region aMirroredRegion;
 620
 621     for (auto & rectangle : aRectangles)
 622     {
 623         ReMirror(rectangle);
 624         aMirroredRegion.Union(rectangle);
 625     }
 626
 627     rRegion = aMirroredRegion;
 628
 629 }
 630
 631 bool OutputDevice::HasMirroredGraphics() const
 632 {
 633    return ( AcquireGraphics() && (mpGraphics->GetLayout() & SalLayoutFlags::BiDiRtl) );
 634 }
 635
 636 bool OutputDevice::ImplIsRecordLayout() const
 637 {
 638     if (!mpOutDevData)
 639         return false;
 640
 641     return mpOutDevData->mpRecordLayout;
 642 }
 643
 644 // EPS public function
 645
 646 bool OutputDevice::DrawEPS( const Point& rPoint, const Size& rSize,
 647                             const GfxLink& rGfxLink, GDIMetaFile* pSubst )
 648 {
 649     bool bDrawn(true);
 650
 651     if ( mpMetaFile )
 652     {
 653         GDIMetaFile aSubst;
 654
 655         if( pSubst )
 656             aSubst = *pSubst;
 657
 658         mpMetaFile->AddAction( new MetaEPSAction( rPoint, rSize, rGfxLink, aSubst ) );
 659     }
 660
 661     if ( !IsDeviceOutputNecessary() || ImplIsRecordLayout() )
 662         return bDrawn;
 663
 664     if( mbOutputClipped )
 665         return bDrawn;
 666
 667     tools::Rectangle aRect( ImplLogicToDevicePixel( tools::Rectangle( rPoint, rSize ) ) );
 668
 669     if( !aRect.IsEmpty() )
 670     {
 671         // draw the real EPS graphics
 672         if( rGfxLink.GetData() && rGfxLink.GetDataSize() )
 673         {
 674             if( !mpGraphics && !AcquireGraphics() )
 675                 return bDrawn;
 676
 677             if( mbInitClipRegion )
 678                 InitClipRegion();
 679
 680             aRect.Justify();
 681             bDrawn = mpGraphics->DrawEPS( aRect.Left(), aRect.Top(), aRect.GetWidth(), aRect.GetHeight(),
 682                          const_cast<sal_uInt8*>(rGfxLink.GetData()), rGfxLink.GetDataSize(), this );
 683         }
 684
 685         // else draw the substitution graphics
 686         if( !bDrawn && pSubst )
 687         {
 688             GDIMetaFile* pOldMetaFile = mpMetaFile;
 689
 690             mpMetaFile = nullptr;
 691             Graphic( *pSubst ).Draw( this, rPoint, rSize );
 692             mpMetaFile = pOldMetaFile;
 693         }
 694     }
 695
 696     if( mpAlphaVDev )
 697         mpAlphaVDev->DrawEPS( rPoint, rSize, rGfxLink, pSubst );
 698
 699     return bDrawn;
 700 }
 701
 702 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */