vcl/source/gdi/impgraph.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 <comphelper/fileformat.h>
  24 #include <o3tl/make_shared.hxx>
  25 #include <tools/fract.hxx>
  26 #include <tools/vcompat.hxx>
  27 #include <tools/urlobj.hxx>
  28 #include <tools/stream.hxx>
  29 #include <unotools/ucbhelper.hxx>
  30 #include <unotools/ucbstreamhelper.hxx>
  31 #include <unotools/tempfile.hxx>
  32 #include <utility>
  33 #include <vcl/filter/SvmReader.hxx>
  34 #include <vcl/filter/SvmWriter.hxx>
  35 #include <vcl/outdev.hxx>
  36 #include <vcl/graphicfilter.hxx>
  37 #include <vcl/virdev.hxx>
  38 #include <vcl/gfxlink.hxx>
  39 #include <vcl/cvtgrf.hxx>
  40 #include <vcl/graph.hxx>
  41 #include <vcl/metaact.hxx>
  42 #include <impgraph.hxx>
  43 #include <com/sun/star/graphic/XPrimitive2D.hpp>
  44 #include <drawinglayer/primitive2d/baseprimitive2d.hxx>
  45 #include <vcl/dibtools.hxx>
  46 #include <map>
  47 #include <memory>
  48 #include <vcl/gdimetafiletools.hxx>
  49 #include <vcl/TypeSerializer.hxx>
  50 #include <vcl/pdfread.hxx>
  51 #include <graphic/VectorGraphicLoader.hxx>
  52
  53 #define GRAPHIC_MTFTOBMP_MAXEXT     2048
  54 #define GRAPHIC_STREAMBUFSIZE       8192UL
  55
  56 #define SWAP_FORMAT_ID COMPAT_FORMAT( 'S', 'W', 'A', 'P' )
  57
  58 using namespace com::sun::star;
  59
  60
  61 class ImpSwapFile
  62 {
  63 private:
  64     utl::TempFileFast maTempFile;
  65     OUString maOriginURL;
  66
  67 public:
  68     ImpSwapFile(OUString aOriginURL)
  69         : maOriginURL(std::move(aOriginURL))
  70     {
  71     }
  72
  73     SvStream* getStream() { return maTempFile.GetStream(StreamMode::READWRITE); }
  74     OUString const & getOriginURL() const { return maOriginURL; }
  75 };
  76
  77 SvStream* ImpGraphic::getSwapFileStream() const
  78 {
  79     if (mpSwapFile)
  80         return mpSwapFile->getStream();
  81     return nullptr;
  82 }
  83
  84 ImpGraphic::ImpGraphic(bool bDefault)
  85     : MemoryManaged(false)
  86     , meType(bDefault ? GraphicType::Default : GraphicType::NONE)
  87 {
  88 }
  89
  90 ImpGraphic::ImpGraphic(const ImpGraphic& rImpGraphic)
  91     : MemoryManaged(rImpGraphic)
  92     , maMetaFile(rImpGraphic.maMetaFile)
  93     , maBitmapEx(rImpGraphic.maBitmapEx)
  94     , maSwapInfo(rImpGraphic.maSwapInfo)
  95     , mpSwapFile(rImpGraphic.mpSwapFile)
  96     , mpGfxLink(rImpGraphic.mpGfxLink)
  97     , maVectorGraphicData(rImpGraphic.maVectorGraphicData)
  98     , meType(rImpGraphic.meType)
  99     , mnSizeBytes(rImpGraphic.mnSizeBytes)
 100     , mbSwapOut(rImpGraphic.mbSwapOut)
 101     , mbDummyContext(rImpGraphic.mbDummyContext)
 102     , maGraphicExternalLink(rImpGraphic.maGraphicExternalLink)
 103     , mbPrepared(rImpGraphic.mbPrepared)
 104 {
 105     updateCurrentSizeInBytes(mnSizeBytes);
 106
 107     // Special case for animations
 108     if (rImpGraphic.mpAnimation)
 109     {
 110         mpAnimation = std::make_unique<Animation>(*rImpGraphic.mpAnimation);
 111         maBitmapEx = mpAnimation->GetBitmapEx();
 112     }
 113 }
 114
 115 ImpGraphic::ImpGraphic(ImpGraphic&& rImpGraphic) noexcept
 116     : MemoryManaged(rImpGraphic)
 117     , maMetaFile(std::move(rImpGraphic.maMetaFile))
 118     , maBitmapEx(std::move(rImpGraphic.maBitmapEx))
 119     , maSwapInfo(std::move(rImpGraphic.maSwapInfo))
 120     , mpAnimation(std::move(rImpGraphic.mpAnimation))
 121     , mpSwapFile(std::move(rImpGraphic.mpSwapFile))
 122     , mpGfxLink(std::move(rImpGraphic.mpGfxLink))
 123     , maVectorGraphicData(std::move(rImpGraphic.maVectorGraphicData))
 124     , meType(rImpGraphic.meType)
 125     , mnSizeBytes(rImpGraphic.mnSizeBytes)
 126     , mbSwapOut(rImpGraphic.mbSwapOut)
 127     , mbDummyContext(rImpGraphic.mbDummyContext)
 128     , maGraphicExternalLink(rImpGraphic.maGraphicExternalLink)
 129     , mbPrepared (rImpGraphic.mbPrepared)
 130 {
 131     updateCurrentSizeInBytes(mnSizeBytes);
 132
 133     rImpGraphic.clear();
 134     rImpGraphic.mbDummyContext = false;
 135 }
 136
 137 ImpGraphic::ImpGraphic(std::shared_ptr<GfxLink> xGfxLink, sal_Int32 nPageIndex)
 138     : MemoryManaged(true)
 139     , mpGfxLink(std::move(xGfxLink))
 140     , meType(GraphicType::Bitmap)
 141     , mbSwapOut(true)
 142 {
 143     maSwapInfo.mbIsTransparent = true;
 144     maSwapInfo.mbIsAlpha = true;
 145     maSwapInfo.mbIsEPS = false;
 146     maSwapInfo.mbIsAnimated = false;
 147     maSwapInfo.mnAnimationLoopCount = 0;
 148     maSwapInfo.mnPageIndex = nPageIndex;
 149
 150     ensureCurrentSizeInBytes();
 151 }
 152
 153 ImpGraphic::ImpGraphic(GraphicExternalLink aGraphicExternalLink)
 154     : MemoryManaged(true)
 155     , meType(GraphicType::Default)
 156     , maGraphicExternalLink(std::move(aGraphicExternalLink))
 157 {
 158     ensureCurrentSizeInBytes();
 159 }
 160
 161 ImpGraphic::ImpGraphic(const BitmapEx& rBitmapEx)
 162     : MemoryManaged(!rBitmapEx.IsEmpty())
 163     , maBitmapEx(rBitmapEx)
 164     , meType(rBitmapEx.IsEmpty() ? GraphicType::NONE : GraphicType::Bitmap)
 165 {
 166     ensureCurrentSizeInBytes();
 167 }
 168
 169 ImpGraphic::ImpGraphic(const std::shared_ptr<VectorGraphicData>& rVectorGraphicDataPtr)
 170     : MemoryManaged(bool(rVectorGraphicDataPtr))
 171     , maVectorGraphicData(rVectorGraphicDataPtr)
 172     , meType(rVectorGraphicDataPtr ? GraphicType::Bitmap : GraphicType::NONE)
 173 {
 174     ensureCurrentSizeInBytes();
 175 }
 176
 177 ImpGraphic::ImpGraphic(const Animation& rAnimation)
 178     : MemoryManaged(true)
 179     , maBitmapEx(rAnimation.GetBitmapEx())
 180     , mpAnimation(std::make_unique<Animation>(rAnimation))
 181     , meType(GraphicType::Bitmap)
 182 {
 183     ensureCurrentSizeInBytes();
 184 }
 185
 186 ImpGraphic::ImpGraphic(const GDIMetaFile& rMetafile)
 187     : MemoryManaged(true)
 188     , maMetaFile(rMetafile)
 189     , meType(GraphicType::GdiMetafile)
 190 {
 191     ensureCurrentSizeInBytes();
 192 }
 193
 194 ImpGraphic::~ImpGraphic()
 195 {
 196 }
 197
 198 ImpGraphic& ImpGraphic::operator=( const ImpGraphic& rImpGraphic )
 199 {
 200     if( &rImpGraphic != this )
 201     {
 202         maMetaFile = rImpGraphic.maMetaFile;
 203         meType = rImpGraphic.meType;
 204         mnSizeBytes = rImpGraphic.mnSizeBytes;
 205         updateCurrentSizeInBytes(mnSizeBytes);
 206
 207         maSwapInfo = rImpGraphic.maSwapInfo;
 208         mbDummyContext = rImpGraphic.mbDummyContext;
 209         maGraphicExternalLink = rImpGraphic.maGraphicExternalLink;
 210
 211         mpAnimation.reset();
 212
 213         if ( rImpGraphic.mpAnimation )
 214         {
 215             mpAnimation = std::make_unique<Animation>( *rImpGraphic.mpAnimation );
 216             maBitmapEx = mpAnimation->GetBitmapEx();
 217         }
 218         else
 219         {
 220             maBitmapEx = rImpGraphic.maBitmapEx;
 221         }
 222
 223         mbSwapOut = rImpGraphic.mbSwapOut;
 224         mpSwapFile = rImpGraphic.mpSwapFile;
 225         mbPrepared = rImpGraphic.mbPrepared;
 226
 227         mpGfxLink = rImpGraphic.mpGfxLink;
 228
 229         maVectorGraphicData = rImpGraphic.maVectorGraphicData;
 230         resetLastUsed();
 231
 232         changeExisting(mnSizeBytes);
 233     }
 234
 235     return *this;
 236 }
 237
 238 ImpGraphic& ImpGraphic::operator=(ImpGraphic&& rImpGraphic)
 239 {
 240     maMetaFile = std::move(rImpGraphic.maMetaFile);
 241     meType = rImpGraphic.meType;
 242     mnSizeBytes = rImpGraphic.mnSizeBytes;
 243     maSwapInfo = std::move(rImpGraphic.maSwapInfo);
 244     mbDummyContext = rImpGraphic.mbDummyContext;
 245     mpAnimation = std::move(rImpGraphic.mpAnimation);
 246     maBitmapEx = std::move(rImpGraphic.maBitmapEx);
 247     mbSwapOut = rImpGraphic.mbSwapOut;
 248     mpSwapFile = std::move(rImpGraphic.mpSwapFile);
 249     mpGfxLink = std::move(rImpGraphic.mpGfxLink);
 250     maVectorGraphicData = std::move(rImpGraphic.maVectorGraphicData);
 251     maGraphicExternalLink = rImpGraphic.maGraphicExternalLink;
 252     mbPrepared = rImpGraphic.mbPrepared;
 253
 254     rImpGraphic.clear();
 255     rImpGraphic.mbDummyContext = false;
 256     resetLastUsed();
 257
 258     changeExisting(mnSizeBytes);
 259
 260     return *this;
 261 }
 262
 263 bool ImpGraphic::operator==( const ImpGraphic& rOther ) const
 264 {
 265     if( this == &rOther )
 266         return true;
 267
 268     if (mbPrepared && rOther.mbPrepared)
 269         return (*mpGfxLink == *rOther.mpGfxLink);
 270
 271     if (!isAvailable() || !rOther.isAvailable())
 272         return false;
 273
 274     if ( meType != rOther.meType )
 275         return false;
 276
 277     bool bRet = false;
 278     switch( meType )
 279     {
 280         case GraphicType::NONE:
 281         case GraphicType::Default:
 282             return true;
 283
 284         case GraphicType::GdiMetafile:
 285             return ( rOther.maMetaFile == maMetaFile );
 286
 287         case GraphicType::Bitmap:
 288         {
 289             if(maVectorGraphicData)
 290             {
 291                 if(maVectorGraphicData == rOther.maVectorGraphicData)
 292                 {
 293                     // equal instances
 294                     bRet = true;
 295                 }
 296                 else if(rOther.maVectorGraphicData)
 297                 {
 298                     // equal content
 299                     bRet = (*maVectorGraphicData) == (*rOther.maVectorGraphicData);
 300                 }
 301             }
 302             else if( mpAnimation )
 303             {
 304                 if( rOther.mpAnimation && ( *rOther.mpAnimation == *mpAnimation ) )
 305                     bRet = true;
 306             }
 307             else if( !rOther.mpAnimation && ( rOther.maBitmapEx == maBitmapEx ) )
 308             {
 309                 bRet = true;
 310             }
 311         }
 312         break;
 313     }
 314
 315     return bRet;
 316 }
 317
 318 const std::shared_ptr<VectorGraphicData>& ImpGraphic::getVectorGraphicData() const
 319 {
 320     ensureAvailable();
 321
 322     return maVectorGraphicData;
 323 }
 324
 325 void ImpGraphic::createSwapInfo()
 326 {
 327     if (isSwappedOut())
 328         return;
 329
 330     if (!maBitmapEx.IsEmpty())
 331         maSwapInfo.maSizePixel = maBitmapEx.GetSizePixel();
 332     else
 333         maSwapInfo.maSizePixel = Size();
 334
 335     maSwapInfo.maPrefMapMode = getPrefMapMode();
 336     maSwapInfo.maPrefSize = getPrefSize();
 337     maSwapInfo.mbIsAnimated = isAnimated();
 338     maSwapInfo.mbIsEPS = isEPS();
 339     maSwapInfo.mbIsTransparent = isTransparent();
 340     maSwapInfo.mbIsAlpha = isAlpha();
 341     maSwapInfo.mnAnimationLoopCount = getAnimationLoopCount();
 342     maSwapInfo.mnPageIndex = getPageNumber();
 343 }
 344
 345 void ImpGraphic::clearGraphics()
 346 {
 347     maBitmapEx.Clear();
 348     maMetaFile.Clear();
 349     mpAnimation.reset();
 350     maVectorGraphicData.reset();
 351 }
 352
 353 void ImpGraphic::setPrepared(bool bAnimated, const Size* pSizeHint)
 354 {
 355     mbPrepared = true;
 356     mbSwapOut = true;
 357     meType = GraphicType::Bitmap;
 358
 359     SvMemoryStream aMemoryStream(const_cast<sal_uInt8*>(mpGfxLink->GetData()), mpGfxLink->GetDataSize(), StreamMode::READ | StreamMode::WRITE);
 360
 361     if (pSizeHint)
 362     {
 363         maSwapInfo.maPrefSize = *pSizeHint;
 364         maSwapInfo.maPrefMapMode = MapMode(MapUnit::Map100thMM);
 365     }
 366
 367     GraphicDescriptor aDescriptor(aMemoryStream, nullptr);
 368     if (aDescriptor.Detect(true))
 369     {
 370         if (!pSizeHint)
 371         {
 372             // If we have logic size, work with that, as later pixel -> logic
 373             // conversion will work with the output device DPI, not the graphic
 374             // DPI.
 375             Size aLogSize = aDescriptor.GetSize_100TH_MM();
 376             if (aDescriptor.GetPreferredLogSize() && aDescriptor.GetPreferredMapMode())
 377             {
 378                 maSwapInfo.maPrefSize = *aDescriptor.GetPreferredLogSize();
 379                 maSwapInfo.maPrefMapMode = *aDescriptor.GetPreferredMapMode();
 380             }
 381             else if (aLogSize.getWidth() && aLogSize.getHeight())
 382             {
 383                 maSwapInfo.maPrefSize = aLogSize;
 384                 maSwapInfo.maPrefMapMode = MapMode(MapUnit::Map100thMM);
 385             }
 386             else
 387             {
 388                 maSwapInfo.maPrefSize = aDescriptor.GetSizePixel();
 389                 maSwapInfo.maPrefMapMode = MapMode(MapUnit::MapPixel);
 390             }
 391         }
 392
 393         maSwapInfo.maSizePixel = aDescriptor.GetSizePixel();
 394         maSwapInfo.mbIsTransparent = aDescriptor.IsTransparent();
 395         maSwapInfo.mbIsAlpha = aDescriptor.IsAlpha();
 396     } else {
 397         maSwapInfo.mbIsTransparent = false;
 398         maSwapInfo.mbIsAlpha = false;
 399     }
 400
 401     maSwapInfo.mnAnimationLoopCount = 0;
 402     maSwapInfo.mbIsEPS = false;
 403     maSwapInfo.mbIsAnimated = bAnimated;
 404
 405     if (maVectorGraphicData)
 406         maSwapInfo.mnPageIndex = maVectorGraphicData->getPageIndex();
 407 }
 408
 409 void ImpGraphic::clear()
 410 {
 411     mpSwapFile.reset();
 412     mbSwapOut = false;
 413     mbPrepared = false;
 414
 415     // cleanup
 416     clearGraphics();
 417     meType = GraphicType::NONE;
 418     mnSizeBytes = 0;
 419
 420     changeExisting(mnSizeBytes);
 421     maGraphicExternalLink.msURL.clear();
 422 }
 423
 424 bool ImpGraphic::isSupportedGraphic() const
 425 {
 426     return meType != GraphicType::NONE;
 427 }
 428
 429 bool ImpGraphic::isTransparent() const
 430 {
 431     bool bRet(true);
 432
 433     if (mbSwapOut)
 434     {
 435         bRet = maSwapInfo.mbIsTransparent;
 436     }
 437     else if (meType == GraphicType::Bitmap && !maVectorGraphicData)
 438     {
 439         bRet = mpAnimation ? mpAnimation->IsTransparent() : maBitmapEx.IsAlpha();
 440     }
 441
 442     return bRet;
 443 }
 444
 445 bool ImpGraphic::isAlpha() const
 446 {
 447     bool bRet(false);
 448
 449     if (mbSwapOut)
 450     {
 451         bRet = maSwapInfo.mbIsAlpha;
 452     }
 453     else if (maVectorGraphicData)
 454     {
 455         bRet = true;
 456     }
 457     else if (meType == GraphicType::Bitmap)
 458     {
 459         bRet = (nullptr == mpAnimation && maBitmapEx.IsAlpha());
 460     }
 461
 462     return bRet;
 463 }
 464
 465 bool ImpGraphic::isAnimated() const
 466 {
 467     return mbSwapOut ? maSwapInfo.mbIsAnimated : mpAnimation != nullptr;
 468 }
 469
 470 bool ImpGraphic::isEPS() const
 471 {
 472     if (mbSwapOut)
 473         return maSwapInfo.mbIsEPS;
 474
 475     return( ( meType == GraphicType::GdiMetafile ) &&
 476             ( maMetaFile.GetActionSize() > 0 ) &&
 477             ( maMetaFile.GetAction( 0 )->GetType() == MetaActionType::EPS ) );
 478 }
 479
 480 bool ImpGraphic::isAvailable() const
 481 {
 482     return !mbPrepared && !mbSwapOut;
 483 }
 484
 485 bool ImpGraphic::makeAvailable()
 486 {
 487     return ensureAvailable();
 488 }
 489
 490 void ImpGraphic::updateBitmapFromVectorGraphic(const Size& pixelSize) const
 491 {
 492     assert (maVectorGraphicData);
 493
 494     // use maBitmapEx as local buffer for rendered vector image
 495     if (pixelSize.Width() && pixelSize.Height())
 496     {
 497         if (maBitmapEx.IsEmpty() || maBitmapEx.GetSizePixel() != pixelSize)
 498             const_cast<ImpGraphic*>(this)->maBitmapEx = maVectorGraphicData->getBitmap(pixelSize);
 499     }
 500     else // maVectorGraphicData caches the replacement, so updating unconditionally is cheap
 501     {
 502         const_cast<ImpGraphic*>(this)->maBitmapEx = maVectorGraphicData->getReplacement();
 503     }
 504
 505     if (maExPrefSize.getWidth() && maExPrefSize.getHeight())
 506         const_cast<ImpGraphic*>(this)->maBitmapEx.SetPrefSize(maExPrefSize);
 507 }
 508
 509 Bitmap ImpGraphic::getBitmap(const GraphicConversionParameters& rParameters) const
 510 {
 511     Bitmap aRetBmp;
 512
 513     ensureAvailable();
 514
 515     if( meType == GraphicType::Bitmap )
 516     {
 517         if (!mpAnimation && maVectorGraphicData)
 518             updateBitmapFromVectorGraphic(rParameters.getSizePixel());
 519
 520         const BitmapEx& rRetBmpEx = ( mpAnimation ? mpAnimation->GetBitmapEx() : maBitmapEx );
 521
 522         aRetBmp = rRetBmpEx.GetBitmap( COL_WHITE );
 523
 524         if(rParameters.getSizePixel().Width() || rParameters.getSizePixel().Height())
 525             aRetBmp.Scale(rParameters.getSizePixel());
 526     }
 527     else if( ( meType != GraphicType::Default ) && isSupportedGraphic() )
 528     {
 529         if(maBitmapEx.IsEmpty())
 530         {
 531             // calculate size
 532             ScopedVclPtrInstance< VirtualDevice > aVDev;
 533             Size aDrawSize(aVDev->LogicToPixel(maMetaFile.GetPrefSize(), maMetaFile.GetPrefMapMode()));
 534
 535             if(rParameters.getSizePixel().Width() && rParameters.getSizePixel().Height())
 536             {
 537                 // apply given size if exists
 538                 aDrawSize = rParameters.getSizePixel();
 539             }
 540
 541             if(aDrawSize.Width() && aDrawSize.Height() && !rParameters.getUnlimitedSize()
 542                 && (aDrawSize.Width() > GRAPHIC_MTFTOBMP_MAXEXT || aDrawSize.Height() > GRAPHIC_MTFTOBMP_MAXEXT))
 543             {
 544                 // limit bitmap size to a maximum of GRAPHIC_MTFTOBMP_MAXEXT x GRAPHIC_MTFTOBMP_MAXEXT
 545                 double fWH(static_cast<double>(aDrawSize.Width()) / static_cast<double>(aDrawSize.Height()));
 546
 547                 if(fWH <= 1.0)
 548                 {
 549                     aDrawSize.setWidth(basegfx::fround<tools::Long>(GRAPHIC_MTFTOBMP_MAXEXT * fWH));
 550                     aDrawSize.setHeight(GRAPHIC_MTFTOBMP_MAXEXT);
 551                 }
 552                 else
 553                 {
 554                     aDrawSize.setWidth(GRAPHIC_MTFTOBMP_MAXEXT);
 555                     aDrawSize.setHeight(basegfx::fround<tools::Long>(GRAPHIC_MTFTOBMP_MAXEXT / fWH));
 556                 }
 557             }
 558
 559             // calculate pixel size. Normally, it's the same as aDrawSize, but may
 560             // need to be extended when hairlines are on the right or bottom edge
 561             Size aPixelSize(aDrawSize);
 562
 563             if(GraphicType::GdiMetafile == getType())
 564             {
 565                 // tdf#126319 Removed correction based on hairline-at-the-extremes of
 566                 // the metafile. The task shows that this is no longer sufficient since
 567                 // less hairlines get used in general - what is good, but breaks that
 568                 // old fix. Anyways, hairlines are a left-over from non-AA times
 569                 // when it was not possible to paint lines taller than one pixel.
 570                 // This might need to be corrected further using primitives and
 571                 // the possibility to get better-quality ranges for correction. For
 572                 // now, always add that one pixel.
 573                 aPixelSize.setWidth(aPixelSize.getWidth() + 1);
 574                 aPixelSize.setHeight(aPixelSize.getHeight() + 1);
 575             }
 576
 577             if(aVDev->SetOutputSizePixel(aPixelSize))
 578             {
 579                 if(rParameters.getAntiAliase())
 580                 {
 581                     aVDev->SetAntialiasing(aVDev->GetAntialiasing() | AntialiasingFlags::Enable);
 582                 }
 583
 584                 if(rParameters.getSnapHorVerLines())
 585                 {
 586                     aVDev->SetAntialiasing(aVDev->GetAntialiasing() | AntialiasingFlags::PixelSnapHairline);
 587                 }
 588
 589                 draw(*aVDev, Point(), aDrawSize);
 590
 591                 // use maBitmapEx as local buffer for rendered metafile
 592                 const_cast< ImpGraphic* >(this)->maBitmapEx = aVDev->GetBitmapEx( Point(), aVDev->GetOutputSizePixel() );
 593             }
 594         }
 595
 596         aRetBmp = maBitmapEx.GetBitmap();
 597     }
 598
 599     if( !aRetBmp.IsEmpty() )
 600     {
 601         aRetBmp.SetPrefMapMode(getPrefMapMode());
 602         aRetBmp.SetPrefSize(getPrefSize());
 603     }
 604
 605     return aRetBmp;
 606 }
 607
 608 BitmapEx ImpGraphic::getBitmapEx(const GraphicConversionParameters& rParameters) const
 609 {
 610     BitmapEx aRetBmpEx;
 611
 612     ensureAvailable();
 613
 614     if( meType == GraphicType::Bitmap )
 615     {
 616         if (!mpAnimation && maVectorGraphicData)
 617             updateBitmapFromVectorGraphic(rParameters.getSizePixel());
 618
 619         aRetBmpEx = ( mpAnimation ? mpAnimation->GetBitmapEx() : maBitmapEx );
 620
 621         if(rParameters.getSizePixel().Width() || rParameters.getSizePixel().Height())
 622         {
 623             aRetBmpEx.Scale(
 624                 rParameters.getSizePixel(),
 625                 BmpScaleFlag::Fast);
 626         }
 627     }
 628     else if( ( meType != GraphicType::Default ) && isSupportedGraphic() )
 629     {
 630         if(maBitmapEx.IsEmpty())
 631         {
 632             const ImpGraphic aMonoMask( maMetaFile.GetMonochromeMtf( COL_BLACK ) );
 633
 634             // use maBitmapEx as local buffer for rendered metafile
 635             const_cast< ImpGraphic* >(this)->maBitmapEx = BitmapEx(getBitmap(rParameters), aMonoMask.getBitmap(rParameters));
 636         }
 637
 638         aRetBmpEx = maBitmapEx;
 639     }
 640
 641     return aRetBmpEx;
 642 }
 643
 644 Animation ImpGraphic::getAnimation() const
 645 {
 646     Animation aAnimation;
 647
 648     ensureAvailable();
 649     if( mpAnimation )
 650         aAnimation = *mpAnimation;
 651
 652     return aAnimation;
 653 }
 654
 655 const BitmapEx& ImpGraphic::getBitmapExRef() const
 656 {
 657     ensureAvailable();
 658     return maBitmapEx;
 659 }
 660
 661 const GDIMetaFile& ImpGraphic::getGDIMetaFile() const
 662 {
 663     ensureAvailable();
 664     if (!maMetaFile.GetActionSize()
 665         && maVectorGraphicData
 666         && (VectorGraphicDataType::Emf == maVectorGraphicData->getType()
 667             || VectorGraphicDataType::Wmf == maVectorGraphicData->getType()))
 668     {
 669         // If we have a Emf/Wmf VectorGraphic object, we
 670         // need a way to get the Metafile data out of the primitive
 671         // representation. Use a strict virtual hook (MetafileAccessor)
 672         // to access the MetafilePrimitive2D directly. Also see comments in
 673         // XEmfParser about this.
 674         const std::deque< css::uno::Reference< css::graphic::XPrimitive2D > > aSequence(maVectorGraphicData->getPrimitive2DSequence());
 675
 676         if (1 == aSequence.size())
 677         {
 678             // try to cast to MetafileAccessor implementation
 679             const css::uno::Reference< css::graphic::XPrimitive2D >& xReference(aSequence[0]);
 680             auto pUnoPrimitive = static_cast< const drawinglayer::primitive2d::UnoPrimitive2D* >(xReference.get());
 681             if (pUnoPrimitive)
 682             {
 683                 const MetafileAccessor* pMetafileAccessor = dynamic_cast< const MetafileAccessor* >(pUnoPrimitive->getBasePrimitive2D().get());
 684
 685                 if (pMetafileAccessor)
 686                 {
 687                     // it is a MetafileAccessor implementation, get Metafile
 688                     pMetafileAccessor->accessMetafile(const_cast< ImpGraphic* >(this)->maMetaFile);
 689                 }
 690             }
 691         }
 692     }
 693
 694     if (GraphicType::Bitmap == meType && !maMetaFile.GetActionSize())
 695     {
 696         if (maVectorGraphicData)
 697             updateBitmapFromVectorGraphic();
 698
 699         // #i119735#
 700         // Use the local maMetaFile as container for a metafile-representation
 701         // of the bitmap graphic. This will be done only once, thus be buffered.
 702         // I checked all usages of maMetaFile, it is only used when type is not
 703         // GraphicType::Bitmap. In operator= it will get copied, thus buffering will
 704         // survive copying (change this if not wanted)
 705         ImpGraphic* pThat = const_cast< ImpGraphic* >(this);
 706
 707         // #123983# directly create a metafile with the same PrefSize and PrefMapMode
 708         // the bitmap has, this will be an always correct metafile
 709         if(maBitmapEx.IsAlpha())
 710         {
 711             pThat->maMetaFile.AddAction(new MetaBmpExScaleAction(Point(), maBitmapEx.GetPrefSize(), maBitmapEx));
 712         }
 713         else
 714         {
 715             pThat->maMetaFile.AddAction(new MetaBmpScaleAction(Point(), maBitmapEx.GetPrefSize(), maBitmapEx.GetBitmap()));
 716         }
 717
 718         pThat->maMetaFile.Stop();
 719         pThat->maMetaFile.WindStart();
 720         pThat->maMetaFile.SetPrefSize(maBitmapEx.GetPrefSize());
 721         pThat->maMetaFile.SetPrefMapMode(maBitmapEx.GetPrefMapMode());
 722     }
 723
 724     return maMetaFile;
 725 }
 726
 727 Size ImpGraphic::getSizePixel() const
 728 {
 729     Size aSize;
 730
 731     if (isSwappedOut())
 732         aSize = maSwapInfo.maSizePixel;
 733     else
 734         aSize = getBitmapEx(GraphicConversionParameters()).GetSizePixel();
 735
 736     return aSize;
 737 }
 738
 739 Size ImpGraphic::getPrefSize() const
 740 {
 741     Size aSize;
 742
 743     if (isSwappedOut())
 744     {
 745         aSize = maSwapInfo.maPrefSize;
 746     }
 747     else
 748     {
 749         switch (meType)
 750         {
 751             case GraphicType::Bitmap:
 752             {
 753                 if (maVectorGraphicData && maBitmapEx.IsEmpty())
 754                 {
 755                     if (!maExPrefSize.getWidth() || !maExPrefSize.getHeight())
 756                     {
 757                         // svg not yet buffered in maBitmapEx, return size derived from range
 758                         const basegfx::B2DRange& rRange = maVectorGraphicData->getRange();
 759
 760 #ifdef MACOSX
 761                         // tdf#157680 scale down estimated size of embedded PDF
 762                         // For some unknown reason, the embedded PDF sizes
 763                         // are 20x larger than expected. This only occurs on
 764                         // macOS so possibly there is some special conversion
 765                         // from MapUnit::MapPoint to MapUnit::MapTwip elsewhere
 766                         // in the code.
 767                         if (maVectorGraphicData->getType() == VectorGraphicDataType::Pdf)
 768                            aSize = Size(basegfx::fround(rRange.getWidth() / 20.0f), basegfx::fround(rRange.getHeight() / 20.0f));
 769                         else
 770 #endif
 771                             aSize = Size(basegfx::fround<tools::Long>(rRange.getWidth()), basegfx::fround<tools::Long>(rRange.getHeight()));
 772                     }
 773                     else
 774                     {
 775                         aSize = maExPrefSize;
 776                     }
 777                 }
 778                 else
 779                 {
 780                     aSize = maBitmapEx.GetPrefSize();
 781
 782                     if( !aSize.Width() || !aSize.Height() )
 783                     {
 784                         aSize = maBitmapEx.GetSizePixel();
 785                     }
 786                 }
 787             }
 788             break;
 789
 790             case GraphicType::GdiMetafile:
 791             {
 792                 aSize = maMetaFile.GetPrefSize();
 793             }
 794             break;
 795
 796             case GraphicType::NONE:
 797             case GraphicType::Default:
 798                 break;
 799         }
 800     }
 801
 802     return aSize;
 803 }
 804
 805 void ImpGraphic::setValuesForPrefSize(const Size& rPrefSize)
 806 {
 807     switch (meType)
 808     {
 809         case GraphicType::Bitmap:
 810         {
 811             // used when importing a writer FlyFrame with SVG as graphic, added conversion
 812             // to allow setting the PrefSize at the BitmapEx to hold it
 813             if (maVectorGraphicData)
 814             {
 815                 maExPrefSize = rPrefSize;
 816             }
 817
 818             // #108077# Push through pref size to animation object,
 819             // will be lost on copy otherwise
 820             if (mpAnimation)
 821             {
 822                 const_cast< BitmapEx& >(mpAnimation->GetBitmapEx()).SetPrefSize(rPrefSize);
 823             }
 824
 825             maBitmapEx.SetPrefSize(rPrefSize);
 826         }
 827         break;
 828
 829         case GraphicType::GdiMetafile:
 830         {
 831             if (isSupportedGraphic())
 832                 maMetaFile.SetPrefSize(rPrefSize);
 833         }
 834         break;
 835
 836         case GraphicType::NONE:
 837         case GraphicType::Default:
 838             break;
 839     }
 840 }
 841
 842 void ImpGraphic::setPrefSize(const Size& rPrefSize)
 843 {
 844     ensureAvailable();
 845     setValuesForPrefSize(rPrefSize);
 846 }
 847
 848 MapMode ImpGraphic::getPrefMapMode() const
 849 {
 850     MapMode aMapMode;
 851
 852     if (isSwappedOut())
 853     {
 854         aMapMode = maSwapInfo.maPrefMapMode;
 855     }
 856     else
 857     {
 858         switch (meType)
 859         {
 860             case GraphicType::Bitmap:
 861             {
 862                 if (maVectorGraphicData && maBitmapEx.IsEmpty())
 863                 {
 864                     // svg not yet buffered in maBitmapEx, return default PrefMapMode
 865                     aMapMode = MapMode(MapUnit::Map100thMM);
 866                 }
 867                 else
 868                 {
 869                     const Size aSize(maBitmapEx.GetPrefSize());
 870
 871                     if (aSize.Width() && aSize.Height())
 872                         aMapMode = maBitmapEx.GetPrefMapMode();
 873                 }
 874             }
 875             break;
 876
 877             case GraphicType::GdiMetafile:
 878             {
 879                 return maMetaFile.GetPrefMapMode();
 880             }
 881             break;
 882
 883             case GraphicType::NONE:
 884             case GraphicType::Default:
 885                 break;
 886         }
 887     }
 888
 889     return aMapMode;
 890 }
 891
 892 void ImpGraphic::setValuesForPrefMapMod(const MapMode& rPrefMapMode)
 893 {
 894     switch (meType)
 895     {
 896         case GraphicType::Bitmap:
 897         {
 898             if (maVectorGraphicData)
 899             {
 900                 // ignore for Vector Graphic Data. If this is really used (except the grfcache)
 901                 // it can be extended by using maBitmapEx as buffer for updateBitmapFromVectorGraphic()
 902             }
 903             else
 904             {
 905                 // #108077# Push through pref mapmode to animation object,
 906                 // will be lost on copy otherwise
 907                 if (mpAnimation)
 908                 {
 909                     const_cast<BitmapEx&>(mpAnimation->GetBitmapEx()).SetPrefMapMode(rPrefMapMode);
 910                 }
 911
 912                 maBitmapEx.SetPrefMapMode(rPrefMapMode);
 913             }
 914         }
 915         break;
 916
 917         case GraphicType::GdiMetafile:
 918         {
 919             maMetaFile.SetPrefMapMode(rPrefMapMode);
 920         }
 921         break;
 922
 923         case GraphicType::NONE:
 924         case GraphicType::Default:
 925             break;
 926     }
 927 }
 928
 929 void ImpGraphic::setPrefMapMode(const MapMode& rPrefMapMode)
 930 {
 931     ensureAvailable();
 932     setValuesForPrefMapMod(rPrefMapMode);
 933 }
 934
 935 void ImpGraphic::ensureCurrentSizeInBytes()
 936 {
 937     if (isAvailable())
 938         changeExisting(getSizeBytes());
 939     else
 940         changeExisting(0);
 941 }
 942
 943 sal_uLong ImpGraphic::getSizeBytes() const
 944 {
 945     if (mnSizeBytes > 0)
 946         return mnSizeBytes;
 947
 948     if (mbPrepared)
 949         ensureAvailable();
 950
 951     switch (meType)
 952     {
 953         case GraphicType::Bitmap:
 954         {
 955             if (maVectorGraphicData)
 956             {
 957                 std::pair<VectorGraphicData::State, size_t> aPair(maVectorGraphicData->getSizeBytes());
 958                 if (VectorGraphicData::State::UNPARSED == aPair.first)
 959                 {
 960                     return aPair.second; // don't cache it until Vector Graphic Data is parsed
 961                 }
 962                 mnSizeBytes = aPair.second;
 963             }
 964             else
 965             {
 966                 mnSizeBytes = mpAnimation ? mpAnimation->GetSizeBytes() : maBitmapEx.GetSizeBytes();
 967             }
 968         }
 969         break;
 970
 971         case GraphicType::GdiMetafile:
 972         {
 973             mnSizeBytes = maMetaFile.GetSizeBytes();
 974         }
 975         break;
 976
 977         case GraphicType::NONE:
 978         case GraphicType::Default:
 979             break;
 980     }
 981
 982     return mnSizeBytes;
 983 }
 984
 985 void ImpGraphic::draw(OutputDevice& rOutDev, const Point& rDestPt) const
 986 {
 987     ensureAvailable();
 988
 989     if (isSwappedOut())
 990         return;
 991
 992     switch (meType)
 993     {
 994         case GraphicType::Bitmap:
 995         {
 996             if (mpAnimation)
 997             {
 998                 mpAnimation->Draw(rOutDev, rDestPt);
 999             }
1000             else
1001             {
1002                 if (maVectorGraphicData)
1003                     updateBitmapFromVectorGraphic();
1004                 maBitmapEx.Draw(&rOutDev, rDestPt);
1005             }
1006         }
1007         break;
1008
1009         case GraphicType::GdiMetafile:
1010         {
1011             draw(rOutDev, rDestPt, maMetaFile.GetPrefSize());
1012         }
1013         break;
1014
1015         case GraphicType::Default:
1016         case GraphicType::NONE:
1017             break;
1018     }
1019 }
1020
1021 void ImpGraphic::draw(OutputDevice& rOutDev,
1022                       const Point& rDestPt, const Size& rDestSize) const
1023 {
1024     ensureAvailable();
1025
1026     if (isSwappedOut())
1027         return;
1028
1029     switch (meType)
1030     {
1031         case GraphicType::Bitmap:
1032         {
1033             if (mpAnimation)
1034             {
1035                 mpAnimation->Draw(rOutDev, rDestPt, rDestSize);
1036             }
1037             else
1038             {
1039                 if (maVectorGraphicData)
1040                     updateBitmapFromVectorGraphic(rOutDev.LogicToPixel(rDestSize));
1041                 maBitmapEx.Draw(&rOutDev, rDestPt, rDestSize);
1042             }
1043         }
1044         break;
1045
1046         case GraphicType::GdiMetafile:
1047         {
1048             const_cast<ImpGraphic*>(this)->maMetaFile.WindStart();
1049             const_cast<ImpGraphic*>(this)->maMetaFile.Play(rOutDev, rDestPt, rDestSize);
1050             const_cast<ImpGraphic*>(this)->maMetaFile.WindStart();
1051         }
1052         break;
1053
1054         case GraphicType::Default:
1055         case GraphicType::NONE:
1056             break;
1057     }
1058 }
1059
1060 void ImpGraphic::startAnimation(OutputDevice& rOutDev, const Point& rDestPt,
1061                                 const Size& rDestSize, tools::Long nRendererId,
1062                                 OutputDevice* pFirstFrameOutDev )
1063 {
1064     ensureAvailable();
1065
1066     if( isSupportedGraphic() && !isSwappedOut() && mpAnimation )
1067         mpAnimation->Start(rOutDev, rDestPt, rDestSize, nRendererId, pFirstFrameOutDev);
1068 }
1069
1070 void ImpGraphic::stopAnimation( const OutputDevice* pOutDev, tools::Long nRendererId )
1071 {
1072     ensureAvailable();
1073
1074     if( isSupportedGraphic() && !isSwappedOut() && mpAnimation )
1075         mpAnimation->Stop( pOutDev, nRendererId );
1076 }
1077
1078 void ImpGraphic::setAnimationNotifyHdl( const Link<Animation*,void>& rLink )
1079 {
1080     ensureAvailable();
1081
1082     if( mpAnimation )
1083         mpAnimation->SetNotifyHdl( rLink );
1084 }
1085
1086 Link<Animation*,void> ImpGraphic::getAnimationNotifyHdl() const
1087 {
1088     Link<Animation*,void> aLink;
1089
1090     ensureAvailable();
1091
1092     if( mpAnimation )
1093         aLink = mpAnimation->GetNotifyHdl();
1094
1095     return aLink;
1096 }
1097
1098 sal_uInt32 ImpGraphic::getAnimationLoopCount() const
1099 {
1100     if (mbSwapOut)
1101         return maSwapInfo.mnAnimationLoopCount;
1102
1103     return mpAnimation ? mpAnimation->GetLoopCount() : 0;
1104 }
1105
1106 bool ImpGraphic::swapInContent(SvStream& rStream)
1107 {
1108     bool bRet = false;
1109
1110     sal_uInt32 nId;
1111     sal_Int32 nType;
1112     sal_Int32 nLength;
1113
1114     rStream.ReadUInt32(nId);
1115
1116     // check version
1117     if (SWAP_FORMAT_ID != nId)
1118     {
1119         SAL_WARN("vcl", "Incompatible swap file!");
1120         return false;
1121     }
1122
1123     rStream.ReadInt32(nType);
1124     rStream.ReadInt32(nLength);
1125
1126     meType = static_cast<GraphicType>(nType);
1127
1128     if (meType == GraphicType::NONE  || meType == GraphicType::Default)
1129     {
1130         return true;
1131     }
1132     else
1133     {
1134         bRet = swapInGraphic(rStream);
1135     }
1136
1137     return bRet;
1138 }
1139
1140 bool ImpGraphic::swapOutGraphic(SvStream& rStream)
1141 {
1142     if (rStream.GetError())
1143         return false;
1144
1145     ensureAvailable();
1146
1147     if (isSwappedOut())
1148     {
1149         rStream.SetError(SVSTREAM_GENERALERROR);
1150         return false;
1151     }
1152
1153     switch (meType)
1154     {
1155         case GraphicType::GdiMetafile:
1156         {
1157             if(!rStream.GetError())
1158             {
1159                 SvmWriter aWriter(rStream);
1160                 aWriter.Write(maMetaFile);
1161             }
1162         }
1163         break;
1164
1165         case GraphicType::Bitmap:
1166         {
1167             if (maVectorGraphicData)
1168             {
1169                 rStream.WriteInt32(sal_Int32(GraphicContentType::Vector));
1170                 // stream out Vector Graphic defining data (length, byte array and evtl. path)
1171                 // this is used e.g. in swapping out graphic data and in transporting it over UNO API
1172                 // as sequence of bytes, but AFAIK not written anywhere to any kind of file, so it should be
1173                 // no problem to extend it; only used at runtime
1174                 switch (maVectorGraphicData->getType())
1175                 {
1176                     case VectorGraphicDataType::Wmf:
1177                     {
1178                         rStream.WriteUInt32(constWmfMagic);
1179                         break;
1180                     }
1181                     case VectorGraphicDataType::Emf:
1182                     {
1183                         rStream.WriteUInt32(constEmfMagic);
1184                         break;
1185                     }
1186                     case VectorGraphicDataType::Svg:
1187                     {
1188                         rStream.WriteUInt32(constSvgMagic);
1189                         break;
1190                     }
1191                     case VectorGraphicDataType::Pdf:
1192                     {
1193                         rStream.WriteUInt32(constPdfMagic);
1194                         break;
1195                     }
1196                 }
1197
1198                 rStream.WriteUInt32(maVectorGraphicData->getBinaryDataContainer().getSize());
1199                 maVectorGraphicData->getBinaryDataContainer().writeToStream(rStream);
1200             }
1201             else if (mpAnimation)
1202             {
1203                 rStream.WriteInt32(sal_Int32(GraphicContentType::Animation));
1204                 WriteAnimation(rStream, *mpAnimation);
1205             }
1206             else
1207             {
1208                 rStream.WriteInt32(sal_Int32(GraphicContentType::Bitmap));
1209                 WriteDIBBitmapEx(maBitmapEx, rStream);
1210             }
1211         }
1212         break;
1213
1214         case GraphicType::NONE:
1215         case GraphicType::Default:
1216             break;
1217     }
1218
1219     if (mpGfxLink)
1220         mpGfxLink->getDataContainer().swapOut();
1221
1222     return true;
1223 }
1224
1225 bool ImpGraphic::swapOutContent(SvStream& rStream)
1226 {
1227     ensureAvailable();
1228
1229     bool bRet = false;
1230
1231     if (meType == GraphicType::NONE || meType == GraphicType::Default || isSwappedOut())
1232         return false;
1233
1234     sal_uLong nDataFieldPos;
1235
1236     // Write the SWAP ID
1237     rStream.WriteUInt32(SWAP_FORMAT_ID);
1238
1239     rStream.WriteInt32(static_cast<sal_Int32>(meType));
1240
1241     // data size is updated later
1242     nDataFieldPos = rStream.Tell();
1243     rStream.WriteInt32(0);
1244
1245     // write data block
1246     const sal_uInt64 nDataStart = rStream.Tell();
1247
1248     swapOutGraphic(rStream);
1249
1250     if (!rStream.GetError())
1251     {
1252         // Write the written length th the header
1253         const sal_uInt64 nCurrentPosition = rStream.Tell();
1254         rStream.Seek(nDataFieldPos);
1255         rStream.WriteInt32(nCurrentPosition - nDataStart);
1256         rStream.Seek(nCurrentPosition);
1257         bRet = true;
1258     }
1259
1260     return bRet;
1261 }
1262
1263 bool ImpGraphic::swapOut()
1264 {
1265     if (isSwappedOut())
1266         return false;
1267
1268     bool bResult = false;
1269
1270     // We have GfxLink so we have the source available
1271     if (mpGfxLink && mpGfxLink->IsNative())
1272     {
1273         createSwapInfo();
1274
1275         clearGraphics();
1276
1277         // reset the swap file
1278         mpSwapFile.reset();
1279
1280         mpGfxLink->getDataContainer().swapOut();
1281
1282         // mark as swapped out
1283         mbSwapOut = true;
1284
1285         bResult = true;
1286     }
1287     else
1288     {
1289         // Create a swap file
1290         auto pSwapFile = o3tl::make_shared<ImpSwapFile>(getOriginURL());
1291
1292         // Open a stream to write the swap file to
1293         {
1294             SvStream* pOutputStream = pSwapFile->getStream();
1295
1296             if (!pOutputStream)
1297                 return false;
1298
1299             // Write to stream
1300             pOutputStream->SetVersion(SOFFICE_FILEFORMAT_50);
1301             pOutputStream->SetCompressMode(SvStreamCompressFlags::NATIVE);
1302             pOutputStream->SetBufferSize(GRAPHIC_STREAMBUFSIZE);
1303
1304             if (!pOutputStream->GetError() && swapOutContent(*pOutputStream))
1305             {
1306                 pOutputStream->FlushBuffer();
1307                 bResult = !pOutputStream->GetError();
1308             }
1309         }
1310
1311         // Check if writing was successful
1312         if (bResult)
1313         {
1314             // We have swapped out, so can clean memory and prepare swap info
1315             createSwapInfo();
1316             clearGraphics();
1317
1318             mpSwapFile = std::move(pSwapFile);
1319             mbSwapOut = true;
1320         }
1321     }
1322
1323     if (bResult)
1324     {
1325         // Signal to manager that we have swapped out
1326         swappedOut(0);
1327     }
1328
1329     return bResult;
1330 }
1331
1332 bool ImpGraphic::ensureAvailable() const
1333 {
1334     bool bResult = true;
1335
1336     if (isSwappedOut())
1337     {
1338         auto pThis = const_cast<ImpGraphic*>(this);
1339         pThis->registerIntoManager();
1340
1341         bResult = pThis->swapIn();
1342     }
1343
1344     resetLastUsed();
1345     return bResult;
1346 }
1347
1348 void ImpGraphic::updateFromLoadedGraphic(const ImpGraphic* pGraphic)
1349 {
1350     if (mbPrepared)
1351     {
1352         GraphicExternalLink aLink = maGraphicExternalLink;
1353         Size aPrefSize = maSwapInfo.maPrefSize;
1354         MapMode aPrefMapMode = maSwapInfo.maPrefMapMode;
1355         *this = *pGraphic;
1356         if (aPrefSize.getWidth() && aPrefSize.getHeight() && aPrefMapMode == getPrefMapMode())
1357         {
1358             // Use custom preferred size if it was set when the graphic was still unloaded.
1359             // Only set the size in case the unloaded and loaded unit matches.
1360             setPrefSize(aPrefSize);
1361         }
1362         maGraphicExternalLink = std::move(aLink);
1363     }
1364     else
1365     {
1366         // Move over only graphic content
1367         mpAnimation.reset();
1368         if (pGraphic->mpAnimation)
1369         {
1370             mpAnimation = std::make_unique<Animation>(*pGraphic->mpAnimation);
1371             maBitmapEx = mpAnimation->GetBitmapEx();
1372         }
1373         else
1374         {
1375             maBitmapEx = pGraphic->maBitmapEx;
1376         }
1377
1378         maMetaFile = pGraphic->maMetaFile;
1379         maVectorGraphicData = pGraphic->maVectorGraphicData;
1380
1381         // Set to 0, to force recalculation
1382         mnSizeBytes = 0;
1383         mnChecksum = 0;
1384
1385         restoreFromSwapInfo();
1386
1387         mbSwapOut = false;
1388     }
1389 }
1390
1391 void ImpGraphic::dumpState(rtl::OStringBuffer &rState)
1392 {
1393     if (meType == GraphicType::NONE && mnSizeBytes == 0)
1394         return; // uninteresting.
1395
1396     rState.append("\n\t");
1397
1398     if (mbSwapOut)
1399         rState.append("swapped\t");
1400     else
1401         rState.append("loaded\t");
1402
1403     rState.append(static_cast<sal_Int32>(meType));
1404     rState.append("\tsize:\t");
1405     rState.append(static_cast<sal_Int64>(mnSizeBytes));
1406     rState.append("\tgfxl:\t");
1407     rState.append(static_cast<sal_Int64>(mpGfxLink ? mpGfxLink->getSizeBytes() : -1));
1408     rState.append("\t");
1409     rState.append(static_cast<sal_Int32>(maSwapInfo.maSizePixel.Width()));
1410     rState.append("x");
1411     rState.append(static_cast<sal_Int32>(maSwapInfo.maSizePixel.Height()));
1412     rState.append("\t");
1413     rState.append(static_cast<sal_Int32>(maExPrefSize.Width()));
1414     rState.append("x");
1415     rState.append(static_cast<sal_Int32>(maExPrefSize.Height()));
1416 }
1417
1418 void ImpGraphic::restoreFromSwapInfo()
1419 {
1420     setValuesForPrefMapMod(maSwapInfo.maPrefMapMode);
1421     setValuesForPrefSize(maSwapInfo.maPrefSize);
1422
1423     if (maVectorGraphicData)
1424     {
1425         maVectorGraphicData->setPageIndex(maSwapInfo.mnPageIndex);
1426     }
1427 }
1428
1429 namespace
1430 {
1431
1432 std::optional<VectorGraphicDataType> lclConvertToVectorGraphicType(GfxLink const & rLink)
1433 {
1434     switch(rLink.GetType())
1435     {
1436         case GfxLinkType::NativePdf:
1437             return VectorGraphicDataType::Pdf;
1438
1439         case GfxLinkType::NativeWmf:
1440             if (rLink.IsEMF())
1441                 return VectorGraphicDataType::Emf;
1442             else
1443                 return VectorGraphicDataType::Wmf;
1444
1445         case GfxLinkType::NativeSvg:
1446             return VectorGraphicDataType::Svg;
1447
1448         default:
1449             break;
1450     }
1451     return std::optional<VectorGraphicDataType>();
1452 }
1453
1454 } // end namespace
1455
1456 bool ImpGraphic::swapIn()
1457 {
1458     if (!isSwappedOut())
1459         return false;
1460
1461     bool bReturn = false;
1462
1463     if (mbPrepared)
1464     {
1465         Graphic aGraphic;
1466         if (!mpGfxLink->LoadNative(aGraphic))
1467             return false;
1468
1469         updateFromLoadedGraphic(aGraphic.ImplGetImpGraphic());
1470
1471         resetLastUsed();
1472         bReturn = true;
1473     }
1474     else if (mpGfxLink && mpGfxLink->IsNative())
1475     {
1476         std::optional<VectorGraphicDataType> oType = lclConvertToVectorGraphicType(*mpGfxLink);
1477         if (oType)
1478         {
1479             maVectorGraphicData = vcl::loadVectorGraphic(mpGfxLink->getDataContainer(), *oType);
1480
1481             // Set to 0, to force recalculation
1482             mnSizeBytes = 0;
1483             mnChecksum = 0;
1484
1485             restoreFromSwapInfo();
1486
1487             mbSwapOut = false;
1488         }
1489         else
1490         {
1491             Graphic aGraphic;
1492             if (!mpGfxLink->LoadNative(aGraphic))
1493                 return false;
1494
1495             ImpGraphic* pImpGraphic = aGraphic.ImplGetImpGraphic();
1496             if (meType != pImpGraphic->meType)
1497                 return false;
1498
1499             updateFromLoadedGraphic(pImpGraphic);
1500         }
1501
1502         resetLastUsed();
1503         bReturn = true;
1504     }
1505     else
1506     {
1507         SvStream* pStream = nullptr;
1508
1509         if (mpSwapFile)
1510             pStream = mpSwapFile->getStream();
1511
1512         if (pStream)
1513         {
1514             pStream->SetVersion(SOFFICE_FILEFORMAT_50);
1515             pStream->SetCompressMode(SvStreamCompressFlags::NATIVE);
1516             pStream->SetBufferSize(GRAPHIC_STREAMBUFSIZE);
1517             pStream->Seek(STREAM_SEEK_TO_BEGIN);
1518
1519             bReturn = swapInFromStream(*pStream);
1520
1521             restoreFromSwapInfo();
1522
1523             setOriginURL(mpSwapFile->getOriginURL());
1524
1525             mpSwapFile.reset();
1526         }
1527     }
1528
1529     if (bReturn)
1530     {
1531         swappedIn(getSizeBytes());
1532     }
1533
1534     return bReturn;
1535 }
1536
1537 bool ImpGraphic::swapInFromStream(SvStream& rStream)
1538 {
1539     bool bRet = false;
1540
1541     if (rStream.GetError())
1542         return false;
1543
1544     clearGraphics();
1545     mnSizeBytes = 0;
1546     mnChecksum = 0;
1547
1548     bRet = swapInContent(rStream);
1549
1550     if (!bRet)
1551     {
1552         //throw away swapfile, etc.
1553         clear();
1554     }
1555
1556     mbSwapOut = false;
1557
1558     return bRet;
1559 }
1560
1561 bool ImpGraphic::swapInGraphic(SvStream& rStream)
1562 {
1563     bool bReturn = false;
1564
1565     if (rStream.GetError())
1566         return bReturn;
1567
1568     if (meType == GraphicType::Bitmap)
1569     {
1570         sal_Int32 nContentType = -1;
1571         rStream.ReadInt32(nContentType);
1572         if (nContentType < 0)
1573             return false;
1574
1575         auto eContentType = static_cast<GraphicContentType>(nContentType);
1576
1577         switch (eContentType)
1578         {
1579             case GraphicContentType::Bitmap:
1580             {
1581                 BitmapEx aBitmapEx;
1582                 ReadDIBBitmapEx(aBitmapEx, rStream);
1583                 if (!rStream.GetError())
1584                 {
1585                     maBitmapEx = aBitmapEx;
1586                     bReturn = true;
1587                 }
1588             }
1589             break;
1590
1591             case GraphicContentType::Animation:
1592             {
1593                 auto pAnimation = std::make_unique<Animation>();
1594                 ReadAnimation(rStream, *pAnimation);
1595                 if (!rStream.GetError())
1596                 {
1597                     mpAnimation = std::move(pAnimation);
1598                     maBitmapEx = mpAnimation->GetBitmapEx();
1599                     bReturn = true;
1600                 }
1601             }
1602             break;
1603
1604             case GraphicContentType::Vector:
1605             {
1606                 // try to stream in Svg defining data (length, byte array and evtl. path)
1607                 // See below (operator<<) for more information
1608                 sal_uInt32 nMagic;
1609                 rStream.ReadUInt32(nMagic);
1610
1611                 if (constSvgMagic == nMagic || constWmfMagic == nMagic || constEmfMagic == nMagic || constPdfMagic == nMagic)
1612                 {
1613                     sal_uInt32 nVectorGraphicDataSize(0);
1614                     rStream.ReadUInt32(nVectorGraphicDataSize);
1615
1616                     if (nVectorGraphicDataSize)
1617                     {
1618                         BinaryDataContainer aDataContainer(rStream, nVectorGraphicDataSize);
1619
1620                         if (rStream.GetError())
1621                             return false;
1622
1623                         VectorGraphicDataType aDataType;
1624
1625                         switch (nMagic)
1626                         {
1627                             case constSvgMagic:
1628                                 aDataType = VectorGraphicDataType::Svg;
1629                                 break;
1630                             case constWmfMagic:
1631                                 aDataType = VectorGraphicDataType::Wmf;
1632                                 break;
1633                             case constEmfMagic:
1634                                 aDataType = VectorGraphicDataType::Emf;
1635                                 break;
1636                             case constPdfMagic:
1637                                 aDataType = VectorGraphicDataType::Pdf;
1638                                 break;
1639                             default:
1640                                 return false;
1641                         }
1642
1643                         auto aVectorGraphicDataPtr = std::make_shared<VectorGraphicData>(aDataContainer, aDataType);
1644
1645                         if (!rStream.GetError())
1646                         {
1647                             maVectorGraphicData = std::move(aVectorGraphicDataPtr);
1648                             bReturn = true;
1649                         }
1650                     }
1651                 }
1652             }
1653             break;
1654         }
1655     }
1656     else if (meType == GraphicType::GdiMetafile)
1657     {
1658         GDIMetaFile aMetaFile;
1659         SvmReader aReader(rStream);
1660         aReader.Read(aMetaFile);
1661         if (!rStream.GetError())
1662         {
1663             maMetaFile = aMetaFile;
1664             bReturn = true;
1665         }
1666     }
1667     return bReturn;
1668 }
1669
1670 void ImpGraphic::setGfxLink(const std::shared_ptr<GfxLink>& rGfxLink)
1671 {
1672     ensureAvailable();
1673
1674     mpGfxLink = rGfxLink;
1675 }
1676
1677 const std::shared_ptr<GfxLink> & ImpGraphic::getSharedGfxLink() const
1678 {
1679     return mpGfxLink;
1680 }
1681
1682 GfxLink ImpGraphic::getGfxLink() const
1683 {
1684     ensureAvailable();
1685
1686     return( mpGfxLink ? *mpGfxLink : GfxLink() );
1687 }
1688
1689 bool ImpGraphic::isGfxLink() const
1690 {
1691     return ( bool(mpGfxLink) );
1692 }
1693
1694 BitmapChecksum ImpGraphic::getChecksum() const
1695 {
1696     if (mnChecksum != 0)
1697         return mnChecksum;
1698
1699     ensureAvailable();
1700
1701     switch (meType)
1702     {
1703         case GraphicType::NONE:
1704         case GraphicType::Default:
1705             break;
1706
1707         case GraphicType::Bitmap:
1708         {
1709             if (maVectorGraphicData)
1710                 mnChecksum = maVectorGraphicData->GetChecksum();
1711             else if (mpAnimation)
1712                 mnChecksum = mpAnimation->GetChecksum();
1713             else
1714                 mnChecksum = maBitmapEx.GetChecksum();
1715         }
1716         break;
1717
1718         case GraphicType::GdiMetafile:
1719         {
1720             mnChecksum = SvmWriter::GetChecksum(maMetaFile);
1721         }
1722         break;
1723     }
1724     return mnChecksum;
1725 }
1726
1727 sal_Int32 ImpGraphic::getPageNumber() const
1728 {
1729     if (isSwappedOut())
1730         return maSwapInfo.mnPageIndex;
1731
1732     if (maVectorGraphicData)
1733         return maVectorGraphicData->getPageIndex();
1734     return -1;
1735 }
1736
1737 bool ImpGraphic::canReduceMemory() const
1738 {
1739     return !isSwappedOut();
1740 }
1741
1742 bool ImpGraphic::reduceMemory()
1743 {
1744     return swapOut();
1745 }
1746
1747 std::chrono::high_resolution_clock::time_point ImpGraphic::getLastUsed() const
1748 {
1749     return maLastUsed;
1750 }
1751
1752 void ImpGraphic::resetLastUsed() const
1753 {
1754     maLastUsed = std::chrono::high_resolution_clock::now();
1755 }
1756
1757 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */