Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1882 insertions, 0 deletions

diff --git a/vcl/source/gdi/impgraph.cxx b/vcl/source/gdi/impgraph.cxx
new file mode 100644
index 000000000..e06663706
--- /dev/null
+++ b/vcl/source/gdi/impgraph.cxx
@@ -0,0 +1,1882 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+#include <sal/log.hxx>
+
+#include <comphelper/fileformat.h>
+#include <o3tl/deleter.hxx>
+#include <tools/fract.hxx>
+#include <tools/vcompat.hxx>
+#include <tools/urlobj.hxx>
+#include <tools/stream.hxx>
+#include <unotools/ucbhelper.hxx>
+#include <unotools/ucbstreamhelper.hxx>
+#include <unotools/tempfile.hxx>
+#include <vcl/outdev.hxx>
+#include <vcl/graphicfilter.hxx>
+#include <vcl/virdev.hxx>
+#include <vcl/gfxlink.hxx>
+#include <vcl/cvtgrf.hxx>
+#include <vcl/graph.hxx>
+#include <vcl/metaact.hxx>
+#include <impgraph.hxx>
+#include <com/sun/star/graphic/XPrimitive2D.hpp>
+#include <vcl/dibtools.hxx>
+#include <map>
+#include <memory>
+#include <vcl/gdimetafiletools.hxx>
+#include <TypeSerializer.hxx>
+#include <vcl/pdfread.hxx>
+
+#define GRAPHIC_MTFTOBMP_MAXEXT     2048
+#define GRAPHIC_STREAMBUFSIZE       8192UL
+
+#define SYS_WINMETAFILE             0x00000003L
+#define SYS_WNTMETAFILE             0x00000004L
+#define SYS_OS2METAFILE             0x00000005L
+#define SYS_MACMETAFILE             0x00000006L
+
+#define GRAPHIC_FORMAT_50           COMPAT_FORMAT( 'G', 'R', 'F', '5' )
+#define NATIVE_FORMAT_50            COMPAT_FORMAT( 'N', 'A', 'T', '5' )
+
+namespace {
+
+constexpr sal_uInt32 constSvgMagic((sal_uInt32('s') << 24) | (sal_uInt32('v') << 16) | (sal_uInt32('g') << 8) | sal_uInt32('0'));
+constexpr sal_uInt32 constWmfMagic((sal_uInt32('w') << 24) | (sal_uInt32('m') << 16) | (sal_uInt32('f') << 8) | sal_uInt32('0'));
+constexpr sal_uInt32 constEmfMagic((sal_uInt32('e') << 24) | (sal_uInt32('m') << 16) | (sal_uInt32('f') << 8) | sal_uInt32('0'));
+constexpr sal_uInt32 constPdfMagic((sal_uInt32('s') << 24) | (sal_uInt32('v') << 16) | (sal_uInt32('g') << 8) | sal_uInt32('0'));
+
+}
+
+using namespace com::sun::star;
+
+class ImpSwapFile
+{
+private:
+    INetURLObject maSwapURL;
+    OUString maOriginURL;
+
+public:
+    ImpSwapFile(INetURLObject const & rSwapURL, OUString const & rOriginURL)
+        : maSwapURL(rSwapURL)
+        , maOriginURL(rOriginURL)
+    {
+    }
+
+    ~ImpSwapFile() COVERITY_NOEXCEPT_FALSE
+    {
+        utl::UCBContentHelper::Kill(maSwapURL.GetMainURL(INetURLObject::DecodeMechanism::NONE));
+    }
+
+    INetURLObject getSwapURL()
+    {
+        return maSwapURL;
+    }
+
+    OUString getSwapURLString()
+    {
+        return maSwapURL.GetMainURL(INetURLObject::DecodeMechanism::NONE);
+    }
+
+    OUString const & getOriginURL() { return maOriginURL; }
+
+    std::unique_ptr<SvStream> openOutputStream()
+    {
+        OUString sSwapURL = getSwapURLString();
+        if (!sSwapURL.isEmpty())
+        {
+            try
+            {
+                return utl::UcbStreamHelper::CreateStream(sSwapURL, StreamMode::READWRITE | StreamMode::SHARE_DENYWRITE);
+            }
+            catch (const css::uno::Exception&)
+            {
+            }
+        }
+        return std::unique_ptr<SvStream>();
+    }
+};
+
+OUString ImpGraphic::getSwapFileURL()
+{
+    if (mpSwapFile)
+        return mpSwapFile->getSwapURL().GetMainURL(INetURLObject::DecodeMechanism::NONE);
+    return OUString();
+}
+
+ImpGraphic::ImpGraphic() :
+        meType          ( GraphicType::NONE ),
+        mnSizeBytes     ( 0 ),
+        mbSwapOut       ( false ),
+        mbDummyContext  ( false ),
+        maLastUsed (std::chrono::high_resolution_clock::now()),
+        mbPrepared      ( false )
+{
+}
+
+ImpGraphic::ImpGraphic(const ImpGraphic& rImpGraphic)
+    : maMetaFile(rImpGraphic.maMetaFile)
+    , maBitmapEx(rImpGraphic.maBitmapEx)
+    , maSwapInfo(rImpGraphic.maSwapInfo)
+    , mpContext(rImpGraphic.mpContext)
+    , mpSwapFile(rImpGraphic.mpSwapFile)
+    , mpGfxLink(rImpGraphic.mpGfxLink)
+    , meType(rImpGraphic.meType)
+    , mnSizeBytes(rImpGraphic.mnSizeBytes)
+    , mbSwapOut(rImpGraphic.mbSwapOut)
+    , mbDummyContext(rImpGraphic.mbDummyContext)
+    , maVectorGraphicData(rImpGraphic.maVectorGraphicData)
+    , maGraphicExternalLink(rImpGraphic.maGraphicExternalLink)
+    , maLastUsed (std::chrono::high_resolution_clock::now())
+    , mbPrepared (rImpGraphic.mbPrepared)
+{
+    if( rImpGraphic.mpAnimation )
+    {
+        mpAnimation = std::make_unique<Animation>( *rImpGraphic.mpAnimation );
+        maBitmapEx = mpAnimation->GetBitmapEx();
+    }
+}
+
+ImpGraphic::ImpGraphic(ImpGraphic&& rImpGraphic) noexcept
+    : maMetaFile(std::move(rImpGraphic.maMetaFile))
+    , maBitmapEx(std::move(rImpGraphic.maBitmapEx))
+    , maSwapInfo(std::move(rImpGraphic.maSwapInfo))
+    , mpAnimation(std::move(rImpGraphic.mpAnimation))
+    , mpContext(std::move(rImpGraphic.mpContext))
+    , mpSwapFile(std::move(rImpGraphic.mpSwapFile))
+    , mpGfxLink(std::move(rImpGraphic.mpGfxLink))
+    , meType(rImpGraphic.meType)
+    , mnSizeBytes(rImpGraphic.mnSizeBytes)
+    , mbSwapOut(rImpGraphic.mbSwapOut)
+    , mbDummyContext(rImpGraphic.mbDummyContext)
+    , maVectorGraphicData(std::move(rImpGraphic.maVectorGraphicData))
+    , maGraphicExternalLink(rImpGraphic.maGraphicExternalLink)
+    , maLastUsed (std::chrono::high_resolution_clock::now())
+    , mbPrepared (rImpGraphic.mbPrepared)
+{
+    rImpGraphic.ImplClear();
+    rImpGraphic.mbDummyContext = false;
+}
+
+ImpGraphic::ImpGraphic(GraphicExternalLink const & rGraphicExternalLink) :
+        meType          ( GraphicType::Default ),
+        mnSizeBytes     ( 0 ),
+        mbSwapOut       ( false ),
+        mbDummyContext  ( false ),
+        maGraphicExternalLink(rGraphicExternalLink),
+        maLastUsed (std::chrono::high_resolution_clock::now()),
+        mbPrepared (false)
+{
+}
+
+ImpGraphic::ImpGraphic( const Bitmap& rBitmap ) :
+        maBitmapEx            ( rBitmap ),
+        meType          ( !rBitmap.IsEmpty() ? GraphicType::Bitmap : GraphicType::NONE ),
+        mnSizeBytes     ( 0 ),
+        mbSwapOut       ( false ),
+        mbDummyContext  ( false ),
+        maLastUsed (std::chrono::high_resolution_clock::now()),
+        mbPrepared (false)
+{
+}
+
+ImpGraphic::ImpGraphic( const BitmapEx& rBitmapEx ) :
+        maBitmapEx            ( rBitmapEx ),
+        meType          ( !rBitmapEx.IsEmpty() ? GraphicType::Bitmap : GraphicType::NONE ),
+        mnSizeBytes     ( 0 ),
+        mbSwapOut       ( false ),
+        mbDummyContext  ( false ),
+        maLastUsed (std::chrono::high_resolution_clock::now()),
+        mbPrepared (false)
+{
+}
+
+ImpGraphic::ImpGraphic(const std::shared_ptr<VectorGraphicData>& rVectorGraphicDataPtr)
+:   meType( rVectorGraphicDataPtr ? GraphicType::Bitmap : GraphicType::NONE ),
+    mnSizeBytes( 0 ),
+    mbSwapOut( false ),
+    mbDummyContext  ( false ),
+    maVectorGraphicData(rVectorGraphicDataPtr),
+    maLastUsed (std::chrono::high_resolution_clock::now()),
+    mbPrepared (false)
+{
+}
+
+ImpGraphic::ImpGraphic( const Animation& rAnimation ) :
+        maBitmapEx      ( rAnimation.GetBitmapEx() ),
+        mpAnimation     ( std::make_unique<Animation>( rAnimation ) ),
+        meType          ( GraphicType::Bitmap ),
+        mnSizeBytes     ( 0 ),
+        mbSwapOut       ( false ),
+        mbDummyContext  ( false ),
+        maLastUsed (std::chrono::high_resolution_clock::now()),
+        mbPrepared (false)
+{
+}
+
+ImpGraphic::ImpGraphic( const GDIMetaFile& rMtf ) :
+        maMetaFile      ( rMtf ),
+        meType          ( GraphicType::GdiMetafile ),
+        mnSizeBytes     ( 0 ),
+        mbSwapOut       ( false ),
+        mbDummyContext  ( false ),
+        maLastUsed (std::chrono::high_resolution_clock::now()),
+        mbPrepared (false)
+{
+}
+
+ImpGraphic::~ImpGraphic()
+{
+    vcl::graphic::Manager::get().unregisterGraphic(this);
+}
+
+ImpGraphic& ImpGraphic::operator=( const ImpGraphic& rImpGraphic )
+{
+    if( &rImpGraphic != this )
+    {
+        sal_Int64 aOldSizeBytes = mnSizeBytes;
+
+        maMetaFile = rImpGraphic.maMetaFile;
+        meType = rImpGraphic.meType;
+        mnSizeBytes = rImpGraphic.mnSizeBytes;
+
+        maSwapInfo = rImpGraphic.maSwapInfo;
+        mpContext = rImpGraphic.mpContext;
+        mbDummyContext = rImpGraphic.mbDummyContext;
+        maGraphicExternalLink = rImpGraphic.maGraphicExternalLink;
+
+        mpAnimation.reset();
+
+        if ( rImpGraphic.mpAnimation )
+        {
+            mpAnimation = std::make_unique<Animation>( *rImpGraphic.mpAnimation );
+            maBitmapEx = mpAnimation->GetBitmapEx();
+        }
+        else
+        {
+            maBitmapEx = rImpGraphic.maBitmapEx;
+        }
+
+        mbSwapOut = rImpGraphic.mbSwapOut;
+        mpSwapFile = rImpGraphic.mpSwapFile;
+        mbPrepared = rImpGraphic.mbPrepared;
+
+        mpGfxLink = rImpGraphic.mpGfxLink;
+
+        maVectorGraphicData = rImpGraphic.maVectorGraphicData;
+        maLastUsed = std::chrono::high_resolution_clock::now();
+
+        vcl::graphic::Manager::get().changeExisting(this, aOldSizeBytes);
+    }
+
+    return *this;
+}
+
+ImpGraphic& ImpGraphic::operator=(ImpGraphic&& rImpGraphic)
+{
+    sal_Int64 aOldSizeBytes = mnSizeBytes;
+
+    maMetaFile = std::move(rImpGraphic.maMetaFile);
+    meType = rImpGraphic.meType;
+    mnSizeBytes = rImpGraphic.mnSizeBytes;
+    maSwapInfo = std::move(rImpGraphic.maSwapInfo);
+    mpContext = std::move(rImpGraphic.mpContext);
+    mbDummyContext = rImpGraphic.mbDummyContext;
+    mpAnimation = std::move(rImpGraphic.mpAnimation);
+    maBitmapEx = std::move(rImpGraphic.maBitmapEx);
+    mbSwapOut = rImpGraphic.mbSwapOut;
+    mpSwapFile = std::move(rImpGraphic.mpSwapFile);
+    mpGfxLink = std::move(rImpGraphic.mpGfxLink);
+    maVectorGraphicData = std::move(rImpGraphic.maVectorGraphicData);
+    maGraphicExternalLink = rImpGraphic.maGraphicExternalLink;
+    mbPrepared = rImpGraphic.mbPrepared;
+
+    rImpGraphic.ImplClear();
+    rImpGraphic.mbDummyContext = false;
+    maLastUsed = std::chrono::high_resolution_clock::now();
+
+    vcl::graphic::Manager::get().changeExisting(this, aOldSizeBytes);
+
+    return *this;
+}
+
+bool ImpGraphic::operator==( const ImpGraphic& rImpGraphic ) const
+{
+    bool bRet = false;
+
+    if( this == &rImpGraphic )
+        bRet = true;
+    else if (mbPrepared && rImpGraphic.mbPrepared)
+    {
+        bRet = (*mpGfxLink == *rImpGraphic.mpGfxLink);
+    }
+    else if (isAvailable() && rImpGraphic.isAvailable())
+    {
+        switch( meType )
+        {
+            case GraphicType::NONE:
+                bRet = true;
+            break;
+
+            case GraphicType::GdiMetafile:
+            {
+                if( rImpGraphic.maMetaFile == maMetaFile )
+                    bRet = true;
+            }
+            break;
+
+            case GraphicType::Bitmap:
+            {
+                if(maVectorGraphicData)
+                {
+                    if(maVectorGraphicData == rImpGraphic.maVectorGraphicData)
+                    {
+                        // equal instances
+                        bRet = true;
+                    }
+                    else if(rImpGraphic.maVectorGraphicData)
+                    {
+                        // equal content
+                        bRet = (*maVectorGraphicData) == (*rImpGraphic.maVectorGraphicData);
+                    }
+                }
+                else if( mpAnimation )
+                {
+                    if( rImpGraphic.mpAnimation && ( *rImpGraphic.mpAnimation == *mpAnimation ) )
+                        bRet = true;
+                }
+                else if( !rImpGraphic.mpAnimation && ( rImpGraphic.maBitmapEx == maBitmapEx ) )
+                {
+                    bRet = true;
+                }
+            }
+            break;
+
+            default:
+            break;
+        }
+    }
+
+    return bRet;
+}
+
+const std::shared_ptr<VectorGraphicData>& ImpGraphic::getVectorGraphicData() const
+{
+    ensureAvailable();
+
+    return maVectorGraphicData;
+}
+
+void ImpGraphic::createSwapInfo()
+{
+    if (isSwappedOut())
+        return;
+
+    maSwapInfo.maPrefMapMode = ImplGetPrefMapMode();
+    maSwapInfo.maPrefSize = ImplGetPrefSize();
+    maSwapInfo.mbIsAnimated = ImplIsAnimated();
+    maSwapInfo.mbIsEPS = ImplIsEPS();
+    maSwapInfo.mbIsTransparent = ImplIsTransparent();
+    maSwapInfo.mbIsAlpha = ImplIsAlpha();
+    maSwapInfo.mnAnimationLoopCount = ImplGetAnimationLoopCount();
+}
+
+void ImpGraphic::ImplClearGraphics()
+{
+    maBitmapEx.Clear();
+    maMetaFile.Clear();
+    mpAnimation.reset();
+    mpGfxLink.reset();
+    maVectorGraphicData.reset();
+}
+
+void ImpGraphic::ImplSetPrepared(bool bAnimated, const Size* pSizeHint)
+{
+    mbPrepared = true;
+    mbSwapOut = true;
+    meType = GraphicType::Bitmap;
+
+    SvMemoryStream aMemoryStream(const_cast<sal_uInt8*>(mpGfxLink->GetData()), mpGfxLink->GetDataSize(), StreamMode::READ | StreamMode::WRITE);
+
+    if (pSizeHint)
+    {
+        maSwapInfo.maPrefSize = *pSizeHint;
+        maSwapInfo.maPrefMapMode = MapMode(MapUnit::Map100thMM);
+    }
+
+    GraphicDescriptor aDescriptor(aMemoryStream, nullptr);
+    if (aDescriptor.Detect(true))
+    {
+        if (!pSizeHint)
+        {
+            // If we have logic size, work with that, as later pixel -> logic
+            // conversion will work with the output device DPI, not the graphic
+            // DPI.
+            Size aLogSize = aDescriptor.GetSize_100TH_MM();
+            if (aLogSize.getWidth() && aLogSize.getHeight())
+            {
+                maSwapInfo.maPrefSize = aLogSize;
+                maSwapInfo.maPrefMapMode = MapMode(MapUnit::Map100thMM);
+            }
+            else
+            {
+                maSwapInfo.maPrefSize = aDescriptor.GetSizePixel();
+                maSwapInfo.maPrefMapMode = MapMode(MapUnit::MapPixel);
+            }
+        }
+
+        maSwapInfo.maSizePixel = aDescriptor.GetSizePixel();
+        maSwapInfo.mbIsTransparent = aDescriptor.IsTransparent();
+        maSwapInfo.mbIsAlpha = aDescriptor.IsAlpha();
+    } else {
+        maSwapInfo.mbIsTransparent = false;
+        maSwapInfo.mbIsAlpha = false;
+    }
+
+    maSwapInfo.mnAnimationLoopCount = 0;
+    maSwapInfo.mbIsEPS = false;
+    maSwapInfo.mbIsAnimated = bAnimated;
+}
+
+void ImpGraphic::ImplClear()
+{
+    mpSwapFile.reset();
+    mbSwapOut = false;
+    mbPrepared = false;
+
+    // cleanup
+    ImplClearGraphics();
+    meType = GraphicType::NONE;
+    sal_Int64 nOldSize = mnSizeBytes;
+    mnSizeBytes = 0;
+    vcl::graphic::Manager::get().changeExisting(this, nOldSize);
+    maGraphicExternalLink.msURL.clear();
+}
+
+void ImpGraphic::ImplSetDefaultType()
+{
+    ImplClear();
+    meType = GraphicType::Default;
+}
+
+bool ImpGraphic::ImplIsSupportedGraphic() const
+{
+    return( meType != GraphicType::NONE );
+}
+
+bool ImpGraphic::ImplIsTransparent() const
+{
+    bool bRet(true);
+
+    if (mbSwapOut)
+    {
+        bRet = maSwapInfo.mbIsTransparent;
+    }
+    else if (meType == GraphicType::Bitmap && !maVectorGraphicData)
+    {
+        bRet = mpAnimation ? mpAnimation->IsTransparent() : maBitmapEx.IsTransparent();
+    }
+
+    return bRet;
+}
+
+bool ImpGraphic::ImplIsAlpha() const
+{
+    bool bRet(false);
+
+    if (mbSwapOut)
+    {
+        bRet = maSwapInfo.mbIsAlpha;
+    }
+    else if (maVectorGraphicData)
+    {
+        bRet = true;
+    }
+    else if (meType == GraphicType::Bitmap)
+    {
+        bRet = (nullptr == mpAnimation && maBitmapEx.IsAlpha());
+    }
+
+    return bRet;
+}
+
+bool ImpGraphic::ImplIsAnimated() const
+{
+    return mbSwapOut ? maSwapInfo.mbIsAnimated : mpAnimation != nullptr;
+}
+
+bool ImpGraphic::ImplIsEPS() const
+{
+    if (mbSwapOut)
+        return maSwapInfo.mbIsEPS;
+
+    return( ( meType == GraphicType::GdiMetafile ) &&
+            ( maMetaFile.GetActionSize() > 0 ) &&
+            ( maMetaFile.GetAction( 0 )->GetType() == MetaActionType::EPS ) );
+}
+
+bool ImpGraphic::isAvailable() const
+{
+    return !mbPrepared && !mbSwapOut;
+}
+
+bool ImpGraphic::makeAvailable()
+{
+    return ensureAvailable();
+}
+
+BitmapEx ImpGraphic::getVectorGraphicReplacement() const
+{
+    BitmapEx aRet = maVectorGraphicData->getReplacement();
+
+    if (maExPrefSize.getWidth() && maExPrefSize.getHeight())
+    {
+        aRet.SetPrefSize(maExPrefSize);
+    }
+
+    return aRet;
+}
+
+Bitmap ImpGraphic::ImplGetBitmap(const GraphicConversionParameters& rParameters) const
+{
+    Bitmap aRetBmp;
+
+    ensureAvailable();
+
+    if( meType == GraphicType::Bitmap )
+    {
+        if(maVectorGraphicData && maBitmapEx.IsEmpty())
+        {
+            // use maBitmapEx as local buffer for rendered svg
+            const_cast< ImpGraphic* >(this)->maBitmapEx = getVectorGraphicReplacement();
+        }
+
+        const BitmapEx& rRetBmpEx = ( mpAnimation ? mpAnimation->GetBitmapEx() : maBitmapEx );
+
+        aRetBmp = rRetBmpEx.GetBitmap( COL_WHITE );
+
+        if(rParameters.getSizePixel().Width() || rParameters.getSizePixel().Height())
+            aRetBmp.Scale(rParameters.getSizePixel());
+    }
+    else if( ( meType != GraphicType::Default ) && ImplIsSupportedGraphic() )
+    {
+        if(maBitmapEx.IsEmpty())
+        {
+            // calculate size
+            ScopedVclPtrInstance< VirtualDevice > aVDev;
+            Size aDrawSize(aVDev->LogicToPixel(maMetaFile.GetPrefSize(), maMetaFile.GetPrefMapMode()));
+
+            if(rParameters.getSizePixel().Width() && rParameters.getSizePixel().Height())
+            {
+                // apply given size if exists
+                aDrawSize = rParameters.getSizePixel();
+            }
+
+            if(aDrawSize.Width() && aDrawSize.Height() && !rParameters.getUnlimitedSize()
+                && (aDrawSize.Width() > GRAPHIC_MTFTOBMP_MAXEXT || aDrawSize.Height() > GRAPHIC_MTFTOBMP_MAXEXT))
+            {
+                // limit bitmap size to a maximum of GRAPHIC_MTFTOBMP_MAXEXT x GRAPHIC_MTFTOBMP_MAXEXT
+                double fWH(static_cast<double>(aDrawSize.Width()) / static_cast<double>(aDrawSize.Height()));
+
+                if(fWH <= 1.0)
+                {
+                    aDrawSize.setWidth(basegfx::fround(GRAPHIC_MTFTOBMP_MAXEXT * fWH));
+                    aDrawSize.setHeight(GRAPHIC_MTFTOBMP_MAXEXT);
+                }
+                else
+                {
+                    aDrawSize.setWidth(GRAPHIC_MTFTOBMP_MAXEXT);
+                    aDrawSize.setHeight(basegfx::fround(GRAPHIC_MTFTOBMP_MAXEXT / fWH));
+                }
+            }
+
+            // calculate pixel size. Normally, it's the same as aDrawSize, but may
+            // need to be extended when hairlines are on the right or bottom edge
+            Size aPixelSize(aDrawSize);
+
+            if(GraphicType::GdiMetafile == ImplGetType())
+            {
+                // get hairline and full bound rect
+                tools::Rectangle aHairlineRect;
+                const tools::Rectangle aRect(maMetaFile.GetBoundRect(*aVDev, &aHairlineRect));
+
+                if(!aRect.IsEmpty() && !aHairlineRect.IsEmpty())
+                {
+                    // expand if needed to allow bottom and right hairlines to be added
+                    if(aRect.Right() == aHairlineRect.Right())
+                    {
+                        aPixelSize.setWidth(aPixelSize.getWidth() + 1);
+                    }
+
+                    if(aRect.Bottom() == aHairlineRect.Bottom())
+                    {
+                        aPixelSize.setHeight(aPixelSize.getHeight() + 1);
+                    }
+                }
+            }
+
+            if(aVDev->SetOutputSizePixel(aPixelSize))
+            {
+                if(rParameters.getAntiAliase())
+                {
+                    aVDev->SetAntialiasing(aVDev->GetAntialiasing() | AntialiasingFlags::EnableB2dDraw);
+                }
+
+                if(rParameters.getSnapHorVerLines())
+                {
+                    aVDev->SetAntialiasing(aVDev->GetAntialiasing() | AntialiasingFlags::PixelSnapHairline);
+                }
+
+                ImplDraw( aVDev.get(), Point(), aDrawSize );
+
+                // use maBitmapEx as local buffer for rendered metafile
+                const_cast< ImpGraphic* >(this)->maBitmapEx = aVDev->GetBitmapEx( Point(), aVDev->GetOutputSizePixel() );
+            }
+        }
+
+        aRetBmp = maBitmapEx.GetBitmap();
+    }
+
+    if( !!aRetBmp )
+    {
+        aRetBmp.SetPrefMapMode( ImplGetPrefMapMode() );
+        aRetBmp.SetPrefSize( ImplGetPrefSize() );
+    }
+
+    return aRetBmp;
+}
+
+BitmapEx ImpGraphic::ImplGetBitmapEx(const GraphicConversionParameters& rParameters) const
+{
+    BitmapEx aRetBmpEx;
+
+    ensureAvailable();
+
+    if( meType == GraphicType::Bitmap )
+    {
+        if(maVectorGraphicData && maBitmapEx.IsEmpty())
+        {
+            // use maBitmapEx as local buffer for rendered svg
+            const_cast< ImpGraphic* >(this)->maBitmapEx = getVectorGraphicReplacement();
+        }
+
+        aRetBmpEx = ( mpAnimation ? mpAnimation->GetBitmapEx() : maBitmapEx );
+
+        if(rParameters.getSizePixel().Width() || rParameters.getSizePixel().Height())
+        {
+            aRetBmpEx.Scale(
+                rParameters.getSizePixel(),
+                BmpScaleFlag::Fast);
+        }
+    }
+    else if( ( meType != GraphicType::Default ) && ImplIsSupportedGraphic() )
+    {
+        if(maBitmapEx.IsEmpty())
+        {
+            const ImpGraphic aMonoMask( maMetaFile.GetMonochromeMtf( COL_BLACK ) );
+
+            // use maBitmapEx as local buffer for rendered metafile
+            const_cast< ImpGraphic* >(this)->maBitmapEx = BitmapEx(ImplGetBitmap(rParameters), aMonoMask.ImplGetBitmap(rParameters));
+        }
+
+        aRetBmpEx = maBitmapEx;
+    }
+
+    return aRetBmpEx;
+}
+
+Animation ImpGraphic::ImplGetAnimation() const
+{
+    Animation aAnimation;
+
+    ensureAvailable();
+    if( mpAnimation )
+        aAnimation = *mpAnimation;
+
+    return aAnimation;
+}
+
+const BitmapEx& ImpGraphic::ImplGetBitmapExRef() const
+{
+    ensureAvailable();
+    return maBitmapEx;
+}
+
+const GDIMetaFile& ImpGraphic::ImplGetGDIMetaFile() const
+{
+    ensureAvailable();
+    if (!maMetaFile.GetActionSize()
+        && maVectorGraphicData
+        && (VectorGraphicDataType::Emf == maVectorGraphicData->getVectorGraphicDataType()
+            || VectorGraphicDataType::Wmf == maVectorGraphicData->getVectorGraphicDataType()))
+    {
+        // If we have a Emf/Wmf VectorGraphic object, we
+        // need a way to get the Metafile data out of the primitive
+        // representation. Use a strict virtual hook (MetafileAccessor)
+        // to access the MetafilePrimitive2D directly. Also see comments in
+        // XEmfParser about this.
+        const std::deque< css::uno::Reference< css::graphic::XPrimitive2D > > aSequence(maVectorGraphicData->getPrimitive2DSequence());
+
+        if (1 == aSequence.size())
+        {
+            // try to cast to MetafileAccessor implementation
+            const css::uno::Reference< css::graphic::XPrimitive2D > xReference(aSequence[0]);
+            const MetafileAccessor* pMetafileAccessor = dynamic_cast< const MetafileAccessor* >(xReference.get());
+
+            if (pMetafileAccessor)
+            {
+                // it is a MetafileAccessor implementation, get Metafile
+                pMetafileAccessor->accessMetafile(const_cast< ImpGraphic* >(this)->maMetaFile);
+            }
+        }
+    }
+
+    if (GraphicType::Bitmap == meType && !maMetaFile.GetActionSize())
+    {
+        // #i119735#
+        // Use the local maMetaFile as container for a metafile-representation
+        // of the bitmap graphic. This will be done only once, thus be buffered.
+        // I checked all usages of maMetaFile, it is only used when type is not
+        // GraphicType::Bitmap. In operator= it will get copied, thus buffering will
+        // survive copying (change this if not wanted)
+        ImpGraphic* pThat = const_cast< ImpGraphic* >(this);
+
+        if(maVectorGraphicData && !maBitmapEx)
+        {
+            // use maBitmapEx as local buffer for rendered svg
+            pThat->maBitmapEx = getVectorGraphicReplacement();
+        }
+
+        // #123983# directly create a metafile with the same PrefSize and PrefMapMode
+        // the bitmap has, this will be an always correct metafile
+        if(maBitmapEx.IsTransparent())
+        {
+            pThat->maMetaFile.AddAction(new MetaBmpExScaleAction(Point(), maBitmapEx.GetPrefSize(), maBitmapEx));
+        }
+        else
+        {
+            pThat->maMetaFile.AddAction(new MetaBmpScaleAction(Point(), maBitmapEx.GetPrefSize(), maBitmapEx.GetBitmap()));
+        }
+
+        pThat->maMetaFile.Stop();
+        pThat->maMetaFile.WindStart();
+        pThat->maMetaFile.SetPrefSize(maBitmapEx.GetPrefSize());
+        pThat->maMetaFile.SetPrefMapMode(maBitmapEx.GetPrefMapMode());
+    }
+
+    return maMetaFile;
+}
+
+Size ImpGraphic::ImplGetSizePixel() const
+{
+    Size aSize;
+
+    if (isSwappedOut())
+        aSize = maSwapInfo.maSizePixel;
+    else
+        aSize = ImplGetBitmapEx(GraphicConversionParameters()).GetSizePixel();
+
+    return aSize;
+}
+
+Size ImpGraphic::ImplGetPrefSize() const
+{
+    Size aSize;
+
+    if (isSwappedOut())
+    {
+        aSize = maSwapInfo.maPrefSize;
+    }
+    else
+    {
+        switch( meType )
+        {
+            case GraphicType::NONE:
+            case GraphicType::Default:
+            break;
+
+            case GraphicType::Bitmap:
+            {
+                if(maVectorGraphicData && maBitmapEx.IsEmpty())
+                {
+                    if (!maExPrefSize.getWidth() || !maExPrefSize.getHeight())
+                    {
+                        // svg not yet buffered in maBitmapEx, return size derived from range
+                        const basegfx::B2DRange& rRange = maVectorGraphicData->getRange();
+
+                        aSize = Size(basegfx::fround(rRange.getWidth()), basegfx::fround(rRange.getHeight()));
+                    }
+                    else
+                    {
+                        aSize = maExPrefSize;
+                    }
+                }
+                else
+                {
+                    aSize = maBitmapEx.GetPrefSize();
+
+                    if( !aSize.Width() || !aSize.Height() )
+                    {
+                        aSize = maBitmapEx.GetSizePixel();
+                    }
+                }
+            }
+            break;
+
+            default:
+            {
+                if( ImplIsSupportedGraphic() )
+                  aSize = maMetaFile.GetPrefSize();
+            }
+            break;
+        }
+    }
+
+    return aSize;
+}
+
+void ImpGraphic::ImplSetPrefSize( const Size& rPrefSize )
+{
+    ensureAvailable();
+
+    switch( meType )
+    {
+        case GraphicType::NONE:
+        case GraphicType::Default:
+        break;
+
+        case GraphicType::Bitmap:
+        {
+            // used when importing a writer FlyFrame with SVG as graphic, added conversion
+            // to allow setting the PrefSize at the BitmapEx to hold it
+            if(maVectorGraphicData && maBitmapEx.IsEmpty())
+            {
+                maExPrefSize = rPrefSize;
+            }
+
+            // #108077# Push through pref size to animation object,
+            // will be lost on copy otherwise
+            if( ImplIsAnimated() )
+            {
+                const_cast< BitmapEx& >(mpAnimation->GetBitmapEx()).SetPrefSize( rPrefSize );
+            }
+
+            if (!maExPrefSize.getWidth() || !maExPrefSize.getHeight())
+            {
+                maBitmapEx.SetPrefSize( rPrefSize );
+            }
+        }
+        break;
+
+        default:
+        {
+            if( ImplIsSupportedGraphic() )
+                maMetaFile.SetPrefSize( rPrefSize );
+        }
+        break;
+    }
+}
+
+MapMode ImpGraphic::ImplGetPrefMapMode() const
+{
+    MapMode aMapMode;
+
+    if (isSwappedOut())
+    {
+        aMapMode = maSwapInfo.maPrefMapMode;
+    }
+    else
+    {
+        switch( meType )
+        {
+            case GraphicType::NONE:
+            case GraphicType::Default:
+            break;
+
+            case GraphicType::Bitmap:
+            {
+                if(maVectorGraphicData && maBitmapEx.IsEmpty())
+                {
+                    // svg not yet buffered in maBitmapEx, return default PrefMapMode
+                    aMapMode = MapMode(MapUnit::Map100thMM);
+                }
+                else
+                {
+                    const Size aSize( maBitmapEx.GetPrefSize() );
+
+                    if ( aSize.Width() && aSize.Height() )
+                        aMapMode = maBitmapEx.GetPrefMapMode();
+                }
+            }
+            break;
+
+            default:
+            {
+                if( ImplIsSupportedGraphic() )
+                    return maMetaFile.GetPrefMapMode();
+            }
+            break;
+        }
+    }
+
+    return aMapMode;
+}
+
+void ImpGraphic::ImplSetPrefMapMode( const MapMode& rPrefMapMode )
+{
+    ensureAvailable();
+
+    switch( meType )
+    {
+        case GraphicType::NONE:
+        case GraphicType::Default:
+        break;
+
+        case GraphicType::Bitmap:
+        {
+            if(maVectorGraphicData)
+            {
+                // ignore for Vector Graphic Data. If this is really used (except the grfcache)
+                // it can be extended by using maBitmapEx as buffer for getVectorGraphicReplacement()
+            }
+            else
+            {
+                // #108077# Push through pref mapmode to animation object,
+                // will be lost on copy otherwise
+                if( ImplIsAnimated() )
+                {
+                    const_cast< BitmapEx& >(mpAnimation->GetBitmapEx()).SetPrefMapMode( rPrefMapMode );
+                }
+
+                maBitmapEx.SetPrefMapMode( rPrefMapMode );
+            }
+        }
+        break;
+
+        default:
+        {
+            if( ImplIsSupportedGraphic() )
+                maMetaFile.SetPrefMapMode( rPrefMapMode );
+        }
+        break;
+    }
+}
+
+sal_uLong ImpGraphic::ImplGetSizeBytes() const
+{
+    if( mnSizeBytes )
+        return mnSizeBytes;
+
+    if (mbPrepared)
+        ensureAvailable();
+
+    if( meType == GraphicType::Bitmap )
+    {
+        if(maVectorGraphicData)
+        {
+            std::pair<VectorGraphicData::State, size_t> tmp(maVectorGraphicData->getSizeBytes());
+            if (VectorGraphicData::State::UNPARSED == tmp.first)
+            {
+                return tmp.second; // don't cache it until Vector Graphic Data is parsed
+            }
+            mnSizeBytes = tmp.second;
+        }
+        else
+        {
+            mnSizeBytes = mpAnimation ? mpAnimation->GetSizeBytes() : maBitmapEx.GetSizeBytes();
+        }
+    }
+    else if( meType == GraphicType::GdiMetafile )
+    {
+        mnSizeBytes = maMetaFile.GetSizeBytes();
+    }
+
+    return mnSizeBytes;
+}
+
+void ImpGraphic::ImplDraw( OutputDevice* pOutDev, const Point& rDestPt ) const
+{
+    ensureAvailable();
+    if( !ImplIsSupportedGraphic() || isSwappedOut() )
+        return;
+
+    switch( meType )
+    {
+        case GraphicType::Default:
+        break;
+
+        case GraphicType::Bitmap:
+        {
+            if(maVectorGraphicData && !maBitmapEx)
+            {
+                // use maEx as local buffer for rendered svg
+                const_cast< ImpGraphic* >(this)->maBitmapEx = getVectorGraphicReplacement();
+            }
+
+            if ( mpAnimation )
+            {
+                mpAnimation->Draw( pOutDev, rDestPt );
+            }
+            else
+            {
+                maBitmapEx.Draw( pOutDev, rDestPt );
+            }
+        }
+        break;
+
+        default:
+            ImplDraw( pOutDev, rDestPt, maMetaFile.GetPrefSize() );
+        break;
+    }
+}
+
+void ImpGraphic::ImplDraw( OutputDevice* pOutDev,
+                           const Point& rDestPt, const Size& rDestSize ) const
+{
+    ensureAvailable();
+    if( !ImplIsSupportedGraphic() || isSwappedOut() )
+        return;
+
+    switch( meType )
+    {
+        case GraphicType::Default:
+        break;
+
+        case GraphicType::Bitmap:
+        {
+            if(maVectorGraphicData && maBitmapEx.IsEmpty())
+            {
+                // use maEx as local buffer for rendered svg
+                const_cast< ImpGraphic* >(this)->maBitmapEx = getVectorGraphicReplacement();
+            }
+
+            if( mpAnimation )
+            {
+                mpAnimation->Draw( pOutDev, rDestPt, rDestSize );
+            }
+            else
+            {
+                maBitmapEx.Draw( pOutDev, rDestPt, rDestSize );
+            }
+        }
+        break;
+
+        default:
+        {
+            const_cast<ImpGraphic*>(this)->maMetaFile.WindStart();
+            const_cast<ImpGraphic*>(this)->maMetaFile.Play( pOutDev, rDestPt, rDestSize );
+            const_cast<ImpGraphic*>(this)->maMetaFile.WindStart();
+        }
+        break;
+    }
+}
+
+void ImpGraphic::ImplStartAnimation( OutputDevice* pOutDev, const Point& rDestPt,
+                                     const Size& rDestSize, long nExtraData,
+                                     OutputDevice* pFirstFrameOutDev )
+{
+    ensureAvailable();
+
+    if( ImplIsSupportedGraphic() && !isSwappedOut() && mpAnimation )
+        mpAnimation->Start( pOutDev, rDestPt, rDestSize, nExtraData, pFirstFrameOutDev );
+}
+
+void ImpGraphic::ImplStopAnimation( OutputDevice* pOutDev, long nExtraData )
+{
+    ensureAvailable();
+
+    if( ImplIsSupportedGraphic() && !isSwappedOut() && mpAnimation )
+        mpAnimation->Stop( pOutDev, nExtraData );
+}
+
+void ImpGraphic::ImplSetAnimationNotifyHdl( const Link<Animation*,void>& rLink )
+{
+    ensureAvailable();
+
+    if( mpAnimation )
+        mpAnimation->SetNotifyHdl( rLink );
+}
+
+Link<Animation*,void> ImpGraphic::ImplGetAnimationNotifyHdl() const
+{
+    Link<Animation*,void> aLink;
+
+    ensureAvailable();
+
+    if( mpAnimation )
+        aLink = mpAnimation->GetNotifyHdl();
+
+    return aLink;
+}
+
+sal_uInt32 ImpGraphic::ImplGetAnimationLoopCount() const
+{
+    if (mbSwapOut)
+        return maSwapInfo.mnAnimationLoopCount;
+
+    return mpAnimation ? mpAnimation->GetLoopCount() : 0;
+}
+
+void ImpGraphic::ImplSetContext( const std::shared_ptr<GraphicReader>& pReader )
+{
+    mpContext = pReader;
+    mbDummyContext = false;
+}
+
+bool ImpGraphic::ImplReadEmbedded( SvStream& rIStm )
+{
+    ensureAvailable();
+
+    MapMode         aMapMode;
+    Size            aSize;
+    sal_uInt32      nId;
+    sal_Int32       nType;
+    const SvStreamEndian nOldFormat = rIStm.GetEndian();
+    bool            bRet = false;
+
+    rIStm.SetEndian( SvStreamEndian::LITTLE );
+    rIStm.ReadUInt32( nId );
+
+    // check version
+    if( GRAPHIC_FORMAT_50 == nId )
+    {
+        // read new style header
+        VersionCompat aCompat( rIStm, StreamMode::READ );
+
+        rIStm.ReadInt32( nType );
+        sal_Int32 nLen;
+        rIStm.ReadInt32( nLen );
+        TypeSerializer aSerializer(rIStm);
+        aSerializer.readSize(aSize);
+        ReadMapMode( rIStm, aMapMode );
+    }
+    else
+    {
+        // read old style header
+        sal_Int32 nWidth, nHeight;
+        sal_Int32 nMapMode, nScaleNumX, nScaleDenomX;
+        sal_Int32 nScaleNumY, nScaleDenomY, nOffsX, nOffsY;
+
+        rIStm.SeekRel( -4 );
+
+        sal_Int32 nLen;
+        rIStm.ReadInt32( nType ).ReadInt32( nLen ).ReadInt32( nWidth ).ReadInt32( nHeight );
+        rIStm.ReadInt32( nMapMode ).ReadInt32( nScaleNumX ).ReadInt32( nScaleDenomX ).ReadInt32( nScaleNumY );
+        rIStm.ReadInt32( nScaleDenomY ).ReadInt32( nOffsX ).ReadInt32( nOffsY );
+
+        // swapped
+        if( nType > 100 )
+        {
+            nType = OSL_SWAPDWORD( nType );
+            nWidth = OSL_SWAPDWORD( nWidth );
+            nHeight = OSL_SWAPDWORD( nHeight );
+            nMapMode = OSL_SWAPDWORD( nMapMode );
+            nScaleNumX = OSL_SWAPDWORD( nScaleNumX );
+            nScaleDenomX = OSL_SWAPDWORD( nScaleDenomX );
+            nScaleNumY = OSL_SWAPDWORD( nScaleNumY );
+            nScaleDenomY = OSL_SWAPDWORD( nScaleDenomY );
+            nOffsX = OSL_SWAPDWORD( nOffsX );
+            nOffsY = OSL_SWAPDWORD( nOffsY );
+        }
+
+        aSize = Size( nWidth, nHeight );
+        aMapMode = MapMode( static_cast<MapUnit>(nMapMode), Point( nOffsX, nOffsY ),
+                            Fraction( nScaleNumX, nScaleDenomX ),
+                            Fraction( nScaleNumY, nScaleDenomY ) );
+    }
+
+    meType = static_cast<GraphicType>(nType);
+
+    if( meType != GraphicType::NONE )
+    {
+        if( meType == GraphicType::Bitmap )
+        {
+            if(maVectorGraphicData && maBitmapEx.IsEmpty())
+            {
+                // use maBitmapEx as local buffer for rendered svg
+                maBitmapEx = getVectorGraphicReplacement();
+            }
+
+            maBitmapEx.SetSizePixel(aSize);
+
+            if( aMapMode != MapMode() )
+            {
+                maBitmapEx.SetPrefMapMode( aMapMode );
+                maBitmapEx.SetPrefSize( aSize );
+            }
+        }
+        else
+        {
+            maMetaFile.SetPrefMapMode( aMapMode );
+            maMetaFile.SetPrefSize( aSize );
+        }
+
+        if( meType == GraphicType::Bitmap || meType == GraphicType::GdiMetafile )
+        {
+            ReadImpGraphic( rIStm, *this );
+            bRet = rIStm.GetError() == ERRCODE_NONE;
+        }
+        else if( sal::static_int_cast<sal_uLong>(meType) >= SYS_WINMETAFILE
+                 && sal::static_int_cast<sal_uLong>(meType) <= SYS_MACMETAFILE )
+        {
+            Graphic           aSysGraphic;
+            ConvertDataFormat nCvtType;
+
+            switch( sal::static_int_cast<sal_uLong>(meType) )
+            {
+                case SYS_WINMETAFILE:
+                case SYS_WNTMETAFILE: nCvtType = ConvertDataFormat::WMF; break;
+                case SYS_OS2METAFILE: nCvtType = ConvertDataFormat::MET; break;
+                case SYS_MACMETAFILE: nCvtType = ConvertDataFormat::PCT; break;
+
+                default:
+                    nCvtType = ConvertDataFormat::Unknown;
+                break;
+            }
+
+            if( nType && GraphicConverter::Import( rIStm, aSysGraphic, nCvtType ) == ERRCODE_NONE )
+            {
+                *this = ImpGraphic( aSysGraphic.GetGDIMetaFile() );
+                bRet = rIStm.GetError() == ERRCODE_NONE;
+            }
+            else
+                meType = GraphicType::Default;
+        }
+
+        if( bRet )
+        {
+            ImplSetPrefMapMode( aMapMode );
+            ImplSetPrefSize( aSize );
+        }
+    }
+    else
+        bRet = true;
+
+    rIStm.SetEndian( nOldFormat );
+
+    return bRet;
+}
+
+bool ImpGraphic::ImplWriteEmbedded( SvStream& rOStm )
+{
+    ensureAvailable();
+
+    if( ( meType == GraphicType::NONE ) || ( meType == GraphicType::Default ) || isSwappedOut() )
+        return false;
+
+    const MapMode   aMapMode( ImplGetPrefMapMode() );
+    const Size      aSize( ImplGetPrefSize() );
+    const SvStreamEndian nOldFormat = rOStm.GetEndian();
+    sal_uLong           nDataFieldPos;
+
+    rOStm.SetEndian( SvStreamEndian::LITTLE );
+
+    // write correct version ( old style/new style header )
+    if( rOStm.GetVersion() >= SOFFICE_FILEFORMAT_50 )
+    {
+        // write ID for new format (5.0)
+        rOStm.WriteUInt32( GRAPHIC_FORMAT_50 );
+
+        // write new style header
+        VersionCompat aCompat( rOStm, StreamMode::WRITE, 1 );
+
+        rOStm.WriteInt32( static_cast<sal_Int32>(meType) );
+
+        // data size is updated later
+        nDataFieldPos = rOStm.Tell();
+        rOStm.WriteInt32( 0 );
+
+        TypeSerializer aSerializer(rOStm);
+        aSerializer.writeSize(aSize);
+
+        WriteMapMode( rOStm, aMapMode );
+    }
+    else
+    {
+        // write old style (<=4.0) header
+        rOStm.WriteInt32( static_cast<sal_Int32>(meType) );
+
+        // data size is updated later
+        nDataFieldPos = rOStm.Tell();
+        rOStm.WriteInt32( 0 );
+        rOStm.WriteInt32( aSize.Width() );
+        rOStm.WriteInt32( aSize.Height() );
+        rOStm.WriteInt32( static_cast<sal_uInt16>(aMapMode.GetMapUnit()) );
+        rOStm.WriteInt32( aMapMode.GetScaleX().GetNumerator() );
+        rOStm.WriteInt32( aMapMode.GetScaleX().GetDenominator() );
+        rOStm.WriteInt32( aMapMode.GetScaleY().GetNumerator() );
+        rOStm.WriteInt32( aMapMode.GetScaleY().GetDenominator() );
+        rOStm.WriteInt32( aMapMode.GetOrigin().X() );
+        rOStm.WriteInt32( aMapMode.GetOrigin().Y() );
+    }
+
+    bool bRet = false;
+    // write data block
+    if( !rOStm.GetError() )
+    {
+        const sal_uLong nDataStart = rOStm.Tell();
+
+        if( ImplIsSupportedGraphic() )
+            WriteImpGraphic( rOStm, *this );
+
+        if( !rOStm.GetError() )
+        {
+            const sal_uLong nStmPos2 = rOStm.Tell();
+            rOStm.Seek( nDataFieldPos );
+            rOStm.WriteInt32( nStmPos2 - nDataStart );
+            rOStm.Seek( nStmPos2 );
+            bRet = true;
+        }
+    }
+
+    rOStm.SetEndian( nOldFormat );
+
+    return bRet;
+}
+
+bool ImpGraphic::swapOut()
+{
+    if (isSwappedOut())
+        return false;
+
+    // Create a temp filename for the swap file
+    utl::TempFile aTempFile;
+    const INetURLObject aTempFileURL(aTempFile.GetURL());
+
+    // Create a swap file
+    std::shared_ptr<ImpSwapFile> pSwapFile(new ImpSwapFile(aTempFileURL, getOriginURL()), o3tl::default_delete<ImpSwapFile>());
+
+    bool bResult = false;
+
+    // Open a stream to write the swap file to
+    {
+        std::unique_ptr<SvStream> xOutputStream = pSwapFile->openOutputStream();
+
+        if (!xOutputStream)
+            return false;
+
+        // Write to stream
+        xOutputStream->SetVersion(SOFFICE_FILEFORMAT_50);
+        xOutputStream->SetCompressMode(SvStreamCompressFlags::NATIVE);
+        xOutputStream->SetBufferSize(GRAPHIC_STREAMBUFSIZE);
+
+        if (!xOutputStream->GetError() && ImplWriteEmbedded(*xOutputStream))
+        {
+            xOutputStream->Flush();
+            bResult = !xOutputStream->GetError();
+        }
+    }
+
+    // Check if writing was successful
+    if (bResult)
+    {
+        // We have swapped out, so can clean memory and prepare swap info
+        createSwapInfo();
+        ImplClearGraphics();
+
+        mpSwapFile = std::move(pSwapFile);
+        mbSwapOut = true;
+
+        // Signal to manager that we have swapped out
+        vcl::graphic::Manager::get().swappedOut(this);
+    }
+
+    return bResult;
+}
+
+bool ImpGraphic::ensureAvailable() const
+{
+    auto pThis = const_cast<ImpGraphic*>(this);
+
+    if (isSwappedOut())
+        return pThis->swapIn();
+
+    pThis->maLastUsed = std::chrono::high_resolution_clock::now();
+    return true;
+}
+
+bool ImpGraphic::loadPrepared()
+{
+    Graphic aGraphic;
+    if (!mpGfxLink->LoadNative(aGraphic))
+        return false;
+
+    GraphicExternalLink aLink = maGraphicExternalLink;
+
+    Size aPrefSize = maSwapInfo.maPrefSize;
+    MapMode aPrefMapMode = maSwapInfo.maPrefMapMode;
+    *this = *aGraphic.ImplGetImpGraphic();
+    if (aPrefSize.getWidth() && aPrefSize.getHeight() && aPrefMapMode == ImplGetPrefMapMode())
+    {
+        // Use custom preferred size if it was set when the graphic was still unloaded.
+        // Only set the size in case the unloaded and loaded unit matches.
+        ImplSetPrefSize(aPrefSize);
+    }
+
+    maGraphicExternalLink = aLink;
+
+    return true;
+}
+
+bool ImpGraphic::swapIn()
+{
+    bool bRet = false;
+
+    if (!isSwappedOut())
+        return bRet;
+
+    if (mbPrepared)
+    {
+        bRet = loadPrepared();
+    }
+    else
+    {
+        OUString aSwapURL;
+
+        if( mpSwapFile )
+            aSwapURL = mpSwapFile->getSwapURL().GetMainURL( INetURLObject::DecodeMechanism::NONE );
+
+        if( !aSwapURL.isEmpty() )
+        {
+            std::unique_ptr<SvStream> xIStm;
+            try
+            {
+                xIStm = ::utl::UcbStreamHelper::CreateStream( aSwapURL, StreamMode::READWRITE | StreamMode::SHARE_DENYWRITE );
+            }
+            catch( const css::uno::Exception& )
+            {
+            }
+
+            if( xIStm )
+            {
+                xIStm->SetVersion( SOFFICE_FILEFORMAT_50 );
+                xIStm->SetCompressMode( SvStreamCompressFlags::NATIVE );
+
+                bRet = swapInFromStream(xIStm.get());
+                xIStm.reset();
+                if (mpSwapFile)
+                    setOriginURL(mpSwapFile->getOriginURL());
+                mpSwapFile.reset();
+            }
+        }
+    }
+
+    if (bRet)
+        vcl::graphic::Manager::get().swappedIn(this);
+
+    return bRet;
+}
+
+bool ImpGraphic::swapInFromStream(SvStream* xIStm)
+{
+    bool bRet = false;
+
+    if( !xIStm )
+        return false;
+
+    xIStm->SetBufferSize( GRAPHIC_STREAMBUFSIZE );
+
+    if( xIStm->GetError() )
+        return false;
+
+    //keep the swap file alive, because its quite possibly the backing storage
+    //for xIStm
+    std::shared_ptr<ImpSwapFile> xSwapFile(std::move(mpSwapFile));
+    assert(!mpSwapFile);
+
+    std::shared_ptr<GraphicReader> xContext(std::move(mpContext));
+    assert(!mpContext);
+
+    bool bDummyContext = mbDummyContext;
+    mbDummyContext = false;
+
+    bRet = ImplReadEmbedded( *xIStm );
+
+    //restore ownership of the swap file and context
+    mpSwapFile = std::move(xSwapFile);
+    mpContext = std::move(xContext);
+    mbDummyContext = bDummyContext;
+
+    if (!bRet)
+    {
+        //throw away swapfile, etc.
+        ImplClear();
+    }
+
+    mbSwapOut = false;
+
+    return bRet;
+}
+
+void ImpGraphic::ImplSetLink(const std::shared_ptr<GfxLink>& rGfxLink)
+{
+    ensureAvailable();
+
+    mpGfxLink = rGfxLink;
+}
+
+std::shared_ptr<GfxLink> ImpGraphic::ImplGetSharedGfxLink() const
+{
+    return mpGfxLink;
+}
+
+GfxLink ImpGraphic::ImplGetLink()
+{
+    ensureAvailable();
+
+    return( mpGfxLink ? *mpGfxLink : GfxLink() );
+}
+
+bool ImpGraphic::ImplIsLink() const
+{
+    return ( bool(mpGfxLink) );
+}
+
+BitmapChecksum ImpGraphic::ImplGetChecksum() const
+{
+    if (mnChecksum != 0)
+        return mnChecksum;
+
+    BitmapChecksum nRet = 0;
+
+    ensureAvailable();
+
+    if( ImplIsSupportedGraphic() && !isSwappedOut() )
+    {
+        switch( meType )
+        {
+            case GraphicType::Default:
+            break;
+
+            case GraphicType::Bitmap:
+            {
+                if(maVectorGraphicData)
+                    nRet = maVectorGraphicData->GetChecksum();
+                else if( mpAnimation )
+                    nRet = mpAnimation->GetChecksum();
+                else
+                    nRet = maBitmapEx.GetChecksum();
+            }
+            break;
+
+            default:
+                nRet = maMetaFile.GetChecksum();
+            break;
+        }
+    }
+
+    mnChecksum = nRet;
+    return nRet;
+}
+
+bool ImpGraphic::ImplExportNative( SvStream& rOStm ) const
+{
+    ensureAvailable();
+
+    if( rOStm.GetError() )
+        return false;
+
+    bool bResult = false;
+
+    if( !isSwappedOut() )
+    {
+        if( mpGfxLink && mpGfxLink->IsNative() )
+            bResult = mpGfxLink->ExportNative( rOStm );
+        else
+        {
+            WriteImpGraphic( rOStm, *this );
+            bResult = ( rOStm.GetError() == ERRCODE_NONE );
+        }
+    }
+    else
+         rOStm.SetError( SVSTREAM_GENERALERROR );
+
+    return bResult;
+}
+
+sal_Int32 ImpGraphic::getPageNumber() const
+{
+    if (maVectorGraphicData)
+        return maVectorGraphicData->getPageIndex();
+    return -1;
+}
+
+void ReadImpGraphic( SvStream& rIStm, ImpGraphic& rImpGraphic )
+{
+    if (rIStm.GetError())
+        return;
+
+    const sal_uLong nStmPos1 = rIStm.Tell();
+    sal_uInt32 nTmp;
+
+    rImpGraphic.ImplClear();
+
+    // read Id
+    rIStm.ReadUInt32( nTmp );
+
+    // if there is no more data, avoid further expensive
+    // reading which will create VDevs and other stuff, just to
+    // read nothing. CAUTION: Eof is only true AFTER reading another
+    // byte, a speciality of SvMemoryStream (!)
+    if (!rIStm.good())
+        return;
+
+    if (NATIVE_FORMAT_50 == nTmp)
+    {
+        Graphic         aGraphic;
+        GfxLink         aLink;
+
+        // read compat info, destructor writes stuff into the header
+        {
+            VersionCompat aCompat( rIStm, StreamMode::READ );
+        }
+
+        TypeSerializer aSerializer(rIStm);
+        aSerializer.readGfxLink(aLink);
+
+        // set dummy link to avoid creation of additional link after filtering;
+        // we set a default link to avoid unnecessary swapping of native data
+        aGraphic.SetGfxLink(std::make_shared<GfxLink>());
+
+        if( !rIStm.GetError() && aLink.LoadNative( aGraphic ) )
+        {
+            // set link only, if no other link was set
+            const bool bSetLink = !rImpGraphic.mpGfxLink;
+
+            // assign graphic
+            rImpGraphic = *aGraphic.ImplGetImpGraphic();
+
+            if( aLink.IsPrefMapModeValid() )
+                rImpGraphic.ImplSetPrefMapMode( aLink.GetPrefMapMode() );
+
+            if( aLink.IsPrefSizeValid() )
+                rImpGraphic.ImplSetPrefSize( aLink.GetPrefSize() );
+
+            if( bSetLink )
+                rImpGraphic.ImplSetLink(std::make_shared<GfxLink>(aLink));
+        }
+        else
+        {
+            rIStm.Seek( nStmPos1 );
+            rIStm.SetError( ERRCODE_IO_WRONGFORMAT );
+        }
+        return;
+    }
+
+    BitmapEx        aBmpEx;
+    const SvStreamEndian nOldFormat = rIStm.GetEndian();
+
+    rIStm.SeekRel( -4 );
+    rIStm.SetEndian( SvStreamEndian::LITTLE );
+    ReadDIBBitmapEx(aBmpEx, rIStm);
+
+    if( !rIStm.GetError() )
+    {
+        sal_uInt32  nMagic1(0), nMagic2(0);
+        sal_uLong   nActPos = rIStm.Tell();
+
+        rIStm.ReadUInt32( nMagic1 ).ReadUInt32( nMagic2 );
+        rIStm.Seek( nActPos );
+
+        rImpGraphic = ImpGraphic( aBmpEx );
+
+        if( !rIStm.GetError() && ( 0x5344414e == nMagic1 ) && ( 0x494d4931 == nMagic2 ) )
+        {
+            rImpGraphic.mpAnimation = std::make_unique<Animation>();
+            ReadAnimation( rIStm, *rImpGraphic.mpAnimation );
+
+            // #108077# manually set loaded BmpEx to Animation
+            // (which skips loading its BmpEx if already done)
+            rImpGraphic.mpAnimation->SetBitmapEx(aBmpEx);
+        }
+        else
+            rIStm.ResetError();
+    }
+    else
+    {
+        GDIMetaFile aMtf;
+
+        rIStm.Seek( nStmPos1 );
+        rIStm.ResetError();
+        ReadGDIMetaFile( rIStm, aMtf );
+
+        if( !rIStm.GetError() )
+        {
+            rImpGraphic = aMtf;
+        }
+        else
+        {
+            ErrCode nOrigError = rIStm.GetErrorCode();
+            // try to stream in Svg defining data (length, byte array and evtl. path)
+            // See below (operator<<) for more information
+            sal_uInt32 nMagic;
+            rIStm.Seek(nStmPos1);
+            rIStm.ResetError();
+            rIStm.ReadUInt32( nMagic );
+
+            if (constSvgMagic == nMagic || constWmfMagic == nMagic || constEmfMagic == nMagic || constPdfMagic == nMagic)
+            {
+                sal_uInt32 nVectorGraphicDataArrayLength(0);
+                rIStm.ReadUInt32(nVectorGraphicDataArrayLength);
+
+                if (nVectorGraphicDataArrayLength)
+                {
+                    VectorGraphicDataArray aNewData(nVectorGraphicDataArrayLength);
+
+                    rIStm.ReadBytes(aNewData.getArray(), nVectorGraphicDataArrayLength);
+                    OUString aPath = rIStm.ReadUniOrByteString(rIStm.GetStreamCharSet());
+
+                    if (!rIStm.GetError())
+                    {
+                        VectorGraphicDataType aDataType(VectorGraphicDataType::Svg);
+
+                        if (constWmfMagic == nMagic)
+                        {
+                            aDataType = VectorGraphicDataType::Wmf;
+                        }
+                        else if (constEmfMagic == nMagic)
+                        {
+                            aDataType = VectorGraphicDataType::Emf;
+                        }
+                        else if (constPdfMagic == nMagic)
+                        {
+                            aDataType = VectorGraphicDataType::Pdf;
+                        }
+
+                        auto aVectorGraphicDataPtr = std::make_shared<VectorGraphicData>(aNewData, aPath, aDataType);
+                        rImpGraphic = aVectorGraphicDataPtr;
+                    }
+                }
+            }
+            else
+            {
+                rIStm.SetError(nOrigError);
+            }
+
+            rIStm.Seek(nStmPos1);
+        }
+    }
+
+    rIStm.SetEndian( nOldFormat );
+}
+
+void WriteImpGraphic(SvStream& rOStm, const ImpGraphic& rImpGraphic)
+{
+    if (rOStm.GetError())
+        return;
+
+    rImpGraphic.ensureAvailable();
+
+    if (rImpGraphic.isSwappedOut())
+    {
+        rOStm.SetError( SVSTREAM_GENERALERROR );
+        return;
+    }
+
+    if( ( rOStm.GetVersion() >= SOFFICE_FILEFORMAT_50 ) &&
+        ( rOStm.GetCompressMode() & SvStreamCompressFlags::NATIVE ) &&
+        rImpGraphic.mpGfxLink && rImpGraphic.mpGfxLink->IsNative())
+    {
+        // native format
+        rOStm.WriteUInt32( NATIVE_FORMAT_50 );
+
+        // write compat info, destructor writes stuff into the header
+        {
+            VersionCompat aCompat( rOStm, StreamMode::WRITE, 1 );
+        }
+        rImpGraphic.mpGfxLink->SetPrefMapMode( rImpGraphic.ImplGetPrefMapMode() );
+        rImpGraphic.mpGfxLink->SetPrefSize( rImpGraphic.ImplGetPrefSize() );
+        TypeSerializer aSerializer(rOStm);
+        aSerializer.writeGfxLink(*rImpGraphic.mpGfxLink);
+    }
+    else
+    {
+        // own format
+        const SvStreamEndian nOldFormat = rOStm.GetEndian();
+        rOStm.SetEndian( SvStreamEndian::LITTLE );
+
+        switch( rImpGraphic.ImplGetType() )
+        {
+            case GraphicType::NONE:
+            case GraphicType::Default:
+            break;
+
+            case GraphicType::Bitmap:
+            {
+                if(rImpGraphic.getVectorGraphicData())
+                {
+                    // stream out Vector Graphic defining data (length, byte array and evtl. path)
+                    // this is used e.g. in swapping out graphic data and in transporting it over UNO API
+                    // as sequence of bytes, but AFAIK not written anywhere to any kind of file, so it should be
+                    // no problem to extend it; only used at runtime
+                    switch (rImpGraphic.getVectorGraphicData()->getVectorGraphicDataType())
+                    {
+                        case VectorGraphicDataType::Wmf:
+                        {
+                            rOStm.WriteUInt32(constWmfMagic);
+                            break;
+                        }
+                        case VectorGraphicDataType::Emf:
+                        {
+                            rOStm.WriteUInt32(constEmfMagic);
+                            break;
+                        }
+                        case VectorGraphicDataType::Svg:
+                        {
+                            rOStm.WriteUInt32(constSvgMagic);
+                            break;
+                        }
+                        case VectorGraphicDataType::Pdf:
+                        {
+                            rOStm.WriteUInt32(constPdfMagic);
+                            break;
+                        }
+                    }
+
+                    rOStm.WriteUInt32( rImpGraphic.getVectorGraphicData()->getVectorGraphicDataArrayLength() );
+                    rOStm.WriteBytes(rImpGraphic.getVectorGraphicData()->getVectorGraphicDataArray().getConstArray(),
+                        rImpGraphic.getVectorGraphicData()->getVectorGraphicDataArrayLength());
+                    rOStm.WriteUniOrByteString(rImpGraphic.getVectorGraphicData()->getPath(),
+                                               rOStm.GetStreamCharSet());
+                }
+                else if( rImpGraphic.ImplIsAnimated())
+                {
+                    WriteAnimation( rOStm, *rImpGraphic.mpAnimation );
+                }
+                else
+                {
+                    WriteDIBBitmapEx(rImpGraphic.maBitmapEx, rOStm);
+                }
+            }
+            break;
+
+            default:
+            {
+                if( rImpGraphic.ImplIsSupportedGraphic() )
+                    WriteGDIMetaFile( rOStm, rImpGraphic.maMetaFile );
+            }
+            break;
+        }
+
+        rOStm.SetEndian( nOldFormat );
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */