vcl/source/gdi/virdev.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/log.hxx>
  21 #include <tools/debug.hxx>
  22
  23 #include <vcl/pdfextoutdevdata.hxx>
  24 #include <vcl/virdev.hxx>
  25
  26 #include <outdev.h>
  27 #include <PhysicalFontCollection.hxx>
  28 #include <salinst.hxx>
  29 #include <salgdi.hxx>
  30 #include <salvd.hxx>
  31 #include <svdata.hxx>
  32
  33 using namespace ::com::sun::star::uno;
  34
  35 bool VirtualDevice::CanEnableNativeWidget() const
  36 {
  37     const vcl::ExtOutDevData* pOutDevData(GetExtOutDevData());
  38     const vcl::PDFExtOutDevData* pPDFData(dynamic_cast<const vcl::PDFExtOutDevData*>(pOutDevData));
  39     return pPDFData == nullptr;
  40 }
  41
  42 bool VirtualDevice::AcquireGraphics() const
  43 {
  44     DBG_TESTSOLARMUTEX();
  45
  46     if ( mpGraphics )
  47         return true;
  48
  49     mbInitLineColor     = true;
  50     mbInitFillColor     = true;
  51     mbInitFont          = true;
  52     mbInitTextColor     = true;
  53     mbInitClipRegion    = true;
  54
  55     ImplSVData* pSVData = ImplGetSVData();
  56
  57     if ( mpVirDev )
  58     {
  59         mpGraphics = mpVirDev->AcquireGraphics();
  60         // if needed retry after releasing least recently used virtual device graphics
  61         while ( !mpGraphics )
  62         {
  63             if ( !pSVData->maGDIData.mpLastVirGraphics )
  64                 break;
  65             pSVData->maGDIData.mpLastVirGraphics->ReleaseGraphics();
  66             mpGraphics = mpVirDev->AcquireGraphics();
  67         }
  68         // update global LRU list of virtual device graphics
  69         if ( mpGraphics )
  70         {
  71             mpNextGraphics = pSVData->maGDIData.mpFirstVirGraphics;
  72             pSVData->maGDIData.mpFirstVirGraphics = const_cast<VirtualDevice*>(this);
  73             if ( mpNextGraphics )
  74                 mpNextGraphics->mpPrevGraphics = const_cast<VirtualDevice*>(this);
  75             if ( !pSVData->maGDIData.mpLastVirGraphics )
  76                 pSVData->maGDIData.mpLastVirGraphics = const_cast<VirtualDevice*>(this);
  77         }
  78     }
  79
  80     if ( mpGraphics )
  81     {
  82         mpGraphics->SetXORMode( (RasterOp::Invert == meRasterOp) || (RasterOp::Xor == meRasterOp), RasterOp::Invert == meRasterOp );
  83         mpGraphics->setAntiAlias(bool(mnAntialiasing & AntialiasingFlags::Enable));
  84     }
  85
  86     return mpGraphics != nullptr;
  87 }
  88
  89 void VirtualDevice::ReleaseGraphics( bool bRelease )
  90 {
  91     DBG_TESTSOLARMUTEX();
  92
  93     if ( !mpGraphics )
  94         return;
  95
  96     // release the fonts of the physically released graphics device
  97     if ( bRelease )
  98         ImplReleaseFonts();
  99
 100     ImplSVData* pSVData = ImplGetSVData();
 101
 102     VirtualDevice* pVirDev = this;
 103
 104     if ( bRelease )
 105         pVirDev->mpVirDev->ReleaseGraphics( mpGraphics );
 106     // remove from global LRU list of virtual device graphics
 107     if ( mpPrevGraphics )
 108         mpPrevGraphics->mpNextGraphics = mpNextGraphics;
 109     else
 110         pSVData->maGDIData.mpFirstVirGraphics = mpNextGraphics;
 111     if ( mpNextGraphics )
 112         mpNextGraphics->mpPrevGraphics = mpPrevGraphics;
 113     else
 114         pSVData->maGDIData.mpLastVirGraphics = mpPrevGraphics;
 115
 116     mpGraphics      = nullptr;
 117     mpPrevGraphics  = nullptr;
 118     mpNextGraphics  = nullptr;
 119 }
 120
 121 void VirtualDevice::ImplInitVirDev( const OutputDevice* pOutDev,
 122                                     tools::Long nDX, tools::Long nDY, const SystemGraphicsData *pData )
 123 {
 124     SAL_INFO( "vcl.virdev", "ImplInitVirDev(" << nDX << "," << nDY << ")" );
 125
 126     meRefDevMode = RefDevMode::NONE;
 127     mbForceZeroExtleadBug = false;
 128
 129     bool bErase = nDX > 0 && nDY > 0;
 130
 131     if ( nDX < 1 )
 132         nDX = 1;
 133
 134     if ( nDY < 1 )
 135         nDY = 1;
 136
 137     ImplSVData* pSVData = ImplGetSVData();
 138
 139     if ( !pOutDev )
 140         pOutDev = ImplGetDefaultWindow()->GetOutDev();
 141     if( !pOutDev )
 142         return;
 143
 144     SalGraphics* pGraphics;
 145     if ( !pOutDev->mpGraphics )
 146         (void)pOutDev->AcquireGraphics();
 147     pGraphics = pOutDev->mpGraphics;
 148     if ( pGraphics )
 149         mpVirDev = pSVData->mpDefInst->CreateVirtualDevice(*pGraphics, nDX, nDY, meFormat, pData);
 150     else
 151         mpVirDev = nullptr;
 152     if ( !mpVirDev )
 153     {
 154         // do not abort but throw an exception, may be the current thread terminates anyway (plugin-scenario)
 155         throw css::uno::RuntimeException(
 156             "Could not create system bitmap!",
 157             css::uno::Reference< css::uno::XInterface >() );
 158     }
 159
 160     mnBitCount = pOutDev->GetBitCount();
 161     mnOutWidth      = nDX;
 162     mnOutHeight     = nDY;
 163
 164     mbScreenComp    = pOutDev->IsScreenComp();
 165
 166     mbDevOutput     = true;
 167     mxFontCollection = pSVData->maGDIData.mxScreenFontList;
 168     mxFontCache     = pSVData->maGDIData.mxScreenFontCache;
 169     mnDPIX          = pOutDev->mnDPIX;
 170     mnDPIY          = pOutDev->mnDPIY;
 171     mnDPIScalePercentage = pOutDev->mnDPIScalePercentage;
 172     maFont          = pOutDev->maFont;
 173
 174     if( maTextColor != pOutDev->maTextColor )
 175     {
 176         maTextColor = pOutDev->maTextColor;
 177         mbInitTextColor = true;
 178     }
 179
 180     // virtual devices have white background by default
 181     SetBackground( Wallpaper( COL_WHITE ) );
 182
 183     // #i59283# don't erase user-provided surface
 184     if( !pData && bErase)
 185         Erase();
 186
 187     // register VirDev in the list
 188     mpNext = pSVData->maGDIData.mpFirstVirDev;
 189     mpPrev = nullptr;
 190     if ( mpNext )
 191         mpNext->mpPrev = this;
 192     pSVData->maGDIData.mpFirstVirDev = this;
 193 }
 194
 195 VirtualDevice::VirtualDevice(const OutputDevice* pCompDev, DeviceFormat eFormat,
 196                              DeviceFormat eAlphaFormat, OutDevType eOutDevType)
 197     : OutputDevice(eOutDevType)
 198     , meFormat(eFormat)
 199     , meAlphaFormat(eAlphaFormat)
 200 {
 201     SAL_INFO( "vcl.virdev", "VirtualDevice::VirtualDevice( " << static_cast<int>(eFormat)
 202                             << ", " << static_cast<int>(eAlphaFormat)
 203                             << ", " << static_cast<int>(eOutDevType) << " )" );
 204
 205     ImplInitVirDev(pCompDev ? pCompDev : Application::GetDefaultDevice(), 0, 0);
 206 }
 207
 208 VirtualDevice::VirtualDevice(const SystemGraphicsData& rData, const Size &rSize,
 209                              DeviceFormat eFormat)
 210     : OutputDevice(OUTDEV_VIRDEV)
 211     , meFormat(eFormat)
 212     , meAlphaFormat(DeviceFormat::NONE)
 213 {
 214     SAL_INFO( "vcl.virdev", "VirtualDevice::VirtualDevice( " << static_cast<int>(eFormat) << " )" );
 215
 216     ImplInitVirDev(Application::GetDefaultDevice(), rSize.Width(), rSize.Height(), &rData);
 217 }
 218
 219 VirtualDevice::~VirtualDevice()
 220 {
 221     SAL_INFO( "vcl.virdev", "VirtualDevice::~VirtualDevice()" );
 222     disposeOnce();
 223 }
 224
 225 void VirtualDevice::dispose()
 226 {
 227     SAL_INFO( "vcl.virdev", "VirtualDevice::dispose()" );
 228
 229     ImplSVData* pSVData = ImplGetSVData();
 230
 231     ReleaseGraphics();
 232
 233     mpVirDev.reset();
 234
 235     // remove this VirtualDevice from the double-linked global list
 236     if( mpPrev )
 237         mpPrev->mpNext = mpNext;
 238     else
 239         pSVData->maGDIData.mpFirstVirDev = mpNext;
 240
 241     if( mpNext )
 242         mpNext->mpPrev = mpPrev;
 243
 244     OutputDevice::dispose();
 245 }
 246
 247 bool VirtualDevice::InnerImplSetOutputSizePixel( const Size& rNewSize, bool bErase,
 248                                                  sal_uInt8 *const pBuffer)
 249 {
 250     SAL_INFO( "vcl.virdev",
 251               "VirtualDevice::InnerImplSetOutputSizePixel( " << rNewSize.Width() << ", "
 252               << rNewSize.Height() << ", " << int(bErase) << " )" );
 253
 254     if ( !mpVirDev )
 255         return false;
 256     else if ( rNewSize == GetOutputSizePixel() )
 257     {
 258         if ( bErase )
 259             Erase();
 260         SAL_INFO( "vcl.virdev", "Trying to re-use a VirtualDevice but this time using a pre-allocated buffer");
 261         return true;
 262     }
 263
 264     bool bRet;
 265     tools::Long nNewWidth = rNewSize.Width(), nNewHeight = rNewSize.Height();
 266
 267     if ( nNewWidth < 1 )
 268         nNewWidth = 1;
 269
 270     if ( nNewHeight < 1 )
 271         nNewHeight = 1;
 272
 273     if ( bErase )
 274     {
 275         if ( pBuffer )
 276             bRet = mpVirDev->SetSizeUsingBuffer( nNewWidth, nNewHeight, pBuffer );
 277         else
 278             bRet = mpVirDev->SetSize( nNewWidth, nNewHeight );
 279
 280         if ( bRet )
 281         {
 282             mnOutWidth  = rNewSize.Width();
 283             mnOutHeight = rNewSize.Height();
 284             Erase();
 285         }
 286     }
 287     else
 288     {
 289         std::unique_ptr<SalVirtualDevice> pNewVirDev;
 290         ImplSVData*         pSVData = ImplGetSVData();
 291
 292         // we need a graphics
 293         if ( !mpGraphics && !AcquireGraphics() )
 294             return false;
 295
 296         assert(mpGraphics);
 297
 298         pNewVirDev = pSVData->mpDefInst->CreateVirtualDevice(*mpGraphics, nNewWidth, nNewHeight, meFormat);
 299         if ( pNewVirDev )
 300         {
 301             SalGraphics* pGraphics = pNewVirDev->AcquireGraphics();
 302             if ( pGraphics )
 303             {
 304                 tools::Long nWidth;
 305                 tools::Long nHeight;
 306                 if ( mnOutWidth < nNewWidth )
 307                     nWidth = mnOutWidth;
 308                 else
 309                     nWidth = nNewWidth;
 310                 if ( mnOutHeight < nNewHeight )
 311                     nHeight = mnOutHeight;
 312                 else
 313                     nHeight = nNewHeight;
 314                 SalTwoRect aPosAry(0, 0, nWidth, nHeight, 0, 0, nWidth, nHeight);
 315                 pGraphics->CopyBits( aPosAry, *mpGraphics, *this, *this );
 316                 pNewVirDev->ReleaseGraphics( pGraphics );
 317                 ReleaseGraphics();
 318                 mpVirDev = std::move(pNewVirDev);
 319                 mnOutWidth  = rNewSize.Width();
 320                 mnOutHeight = rNewSize.Height();
 321                 bRet = true;
 322             }
 323             else
 324             {
 325                 bRet = false;
 326             }
 327         }
 328         else
 329             bRet = false;
 330     }
 331
 332     return bRet;
 333 }
 334
 335 // #i32109#: Fill opaque areas correctly (without relying on
 336 // fill/linecolor state)
 337 void VirtualDevice::ImplFillOpaqueRectangle( const tools::Rectangle& rRect )
 338 {
 339     // Set line and fill color to black (->opaque),
 340     // fill rect with that (linecolor, too, because of
 341     // those pesky missing pixel problems)
 342     Push( PushFlags::LINECOLOR | PushFlags::FILLCOLOR );
 343     SetLineColor( COL_BLACK );
 344     SetFillColor( COL_BLACK );
 345     DrawRect( rRect );
 346     Pop();
 347 }
 348
 349 bool VirtualDevice::ImplSetOutputSizePixel( const Size& rNewSize, bool bErase,
 350                                             sal_uInt8 *const pBuffer)
 351 {
 352     if( InnerImplSetOutputSizePixel(rNewSize, bErase, pBuffer) )
 353     {
 354         if (meAlphaFormat != DeviceFormat::NONE)
 355         {
 356             // #110958# Setup alpha bitmap
 357             if(mpAlphaVDev && mpAlphaVDev->GetOutputSizePixel() != rNewSize)
 358             {
 359                 mpAlphaVDev.disposeAndClear();
 360             }
 361
 362             if( !mpAlphaVDev )
 363             {
 364                 mpAlphaVDev = VclPtr<VirtualDevice>::Create(*this, meAlphaFormat);
 365                 mpAlphaVDev->InnerImplSetOutputSizePixel(rNewSize, bErase, nullptr);
 366             }
 367
 368             // TODO: copy full outdev state to new one, here. Also needed in outdev2.cxx:DrawOutDev
 369             if( GetLineColor() != COL_TRANSPARENT )
 370                 mpAlphaVDev->SetLineColor( COL_BLACK );
 371
 372             if( GetFillColor() != COL_TRANSPARENT )
 373                 mpAlphaVDev->SetFillColor( COL_BLACK );
 374
 375             mpAlphaVDev->SetMapMode( GetMapMode() );
 376         }
 377
 378         return true;
 379     }
 380
 381     return false;
 382 }
 383
 384 void VirtualDevice::EnableRTL( bool bEnable )
 385 {
 386     // virdevs default to not mirroring, they will only be set to mirroring
 387     // under rare circumstances in the UI, eg the valueset control
 388     // because each virdev has its own SalGraphics we can safely switch the SalGraphics here
 389     // ...hopefully
 390     if( AcquireGraphics() )
 391         mpGraphics->SetLayout( bEnable ? SalLayoutFlags::BiDiRtl : SalLayoutFlags::NONE );
 392
 393     OutputDevice::EnableRTL(bEnable);
 394 }
 395
 396 bool VirtualDevice::SetOutputSizePixel( const Size& rNewSize, bool bErase )
 397 {
 398     return ImplSetOutputSizePixel(rNewSize, bErase, nullptr);
 399 }
 400
 401 bool VirtualDevice::SetOutputSizePixelScaleOffsetAndBuffer(
 402     const Size& rNewSize, const Fraction& rScale, const Point& rNewOffset,
 403     sal_uInt8 *const pBuffer)
 404 {
 405     if (pBuffer) {
 406         MapMode mm = GetMapMode();
 407         mm.SetOrigin( rNewOffset );
 408         mm.SetScaleX( rScale );
 409         mm.SetScaleY( rScale );
 410         SetMapMode( mm );
 411     }
 412     return ImplSetOutputSizePixel(rNewSize, true, pBuffer);
 413 }
 414
 415 void VirtualDevice::SetReferenceDevice( RefDevMode i_eRefDevMode )
 416 {
 417     sal_Int32 nDPIX = 600, nDPIY = 600;
 418     switch( i_eRefDevMode )
 419     {
 420     case RefDevMode::NONE:
 421     default:
 422         SAL_WARN( "vcl.virdev", "VDev::SetRefDev illegal argument!" );
 423         break;
 424     case RefDevMode::Dpi600:
 425         nDPIX = nDPIY = 600;
 426         break;
 427     case RefDevMode::MSO1:
 428         nDPIX = nDPIY = 6*1440;
 429         break;
 430     case RefDevMode::PDF1:
 431         nDPIX = nDPIY = 720;
 432         break;
 433     }
 434     ImplSetReferenceDevice( i_eRefDevMode, nDPIX, nDPIY );
 435 }
 436
 437 void VirtualDevice::SetReferenceDevice( sal_Int32 i_nDPIX, sal_Int32 i_nDPIY )
 438 {
 439     ImplSetReferenceDevice( RefDevMode::Custom, i_nDPIX, i_nDPIY );
 440 }
 441
 442 bool VirtualDevice::IsVirtual() const
 443 {
 444     return true;
 445 }
 446
 447 void VirtualDevice::ImplSetReferenceDevice( RefDevMode i_eRefDevMode, sal_Int32 i_nDPIX, sal_Int32 i_nDPIY )
 448 {
 449     mnDPIX = i_nDPIX;
 450     mnDPIY = i_nDPIY;
 451     mnDPIScalePercentage = 100;
 452
 453     EnableOutput( false );  // prevent output on reference device
 454     mbScreenComp = false;
 455
 456     // invalidate currently selected fonts
 457     mbInitFont = true;
 458     mbNewFont = true;
 459
 460     // avoid adjusting font lists when already in refdev mode
 461     RefDevMode nOldRefDevMode = meRefDevMode;
 462     meRefDevMode = i_eRefDevMode;
 463     if( nOldRefDevMode != RefDevMode::NONE )
 464         return;
 465
 466     // the reference device should have only scalable fonts
 467     // => clean up the original font lists before getting new ones
 468     mpFontInstance.clear();
 469     mpDeviceFontList.reset();
 470     mpDeviceFontSizeList.reset();
 471
 472     // preserve global font lists
 473     ImplSVData* pSVData = ImplGetSVData();
 474     mxFontCollection.reset();
 475     mxFontCache.reset();
 476
 477     // get font list with scalable fonts only
 478     (void)AcquireGraphics();
 479     mxFontCollection = pSVData->maGDIData.mxScreenFontList->Clone();
 480
 481     // prepare to use new font lists
 482     mxFontCache = std::make_shared<ImplFontCache>();
 483 }
 484
 485 sal_uInt16 VirtualDevice::GetBitCount() const
 486 {
 487     return mnBitCount;
 488 }
 489
 490 bool VirtualDevice::UsePolyPolygonForComplexGradient()
 491 {
 492     return true;
 493 }
 494
 495 void VirtualDevice::Compat_ZeroExtleadBug()
 496 {
 497     mbForceZeroExtleadBug = true;
 498 }
 499
 500 tools::Long VirtualDevice::GetFontExtLeading() const
 501 {
 502 #ifdef UNX
 503     // backwards compatible line metrics after fixing #i60945#
 504     if ( mbForceZeroExtleadBug )
 505         return 0;
 506 #endif
 507
 508     return mpFontInstance->mxFontMetric->GetExternalLeading();
 509 }
 510
 511 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */