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