Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

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

1 files changed, 780 insertions, 0 deletions

diff --git a/svx/source/gallery2/galtheme.cxx b/svx/source/gallery2/galtheme.cxx
new file mode 100644
index 000000000..4a9d10e60
--- /dev/null
+++ b/svx/source/gallery2/galtheme.cxx
@@ -0,0 +1,780 @@
+/* -*- 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 <config_features.h>
+
+#include <sal/config.h>
+
+#include <algorithm>
+
+#include <osl/file.hxx>
+#include <osl/thread.hxx>
+#include <tools/urlobj.hxx>
+#include <tools/vcompat.hxx>
+#include <tools/datetime.hxx>
+#include <sot/storage.hxx>
+#include <sot/formats.hxx>
+#include <sot/filelist.hxx>
+#include <vcl/virdev.hxx>
+#include <vcl/weld.hxx>
+#include <avmedia/mediawindow.hxx>
+#include <svx/svdograf.hxx>
+#include <svx/fmmodel.hxx>
+#include <svx/fmview.hxx>
+#include <svx/galmisc.hxx>
+#include <svx/galtheme.hxx>
+#include <svx/svdpage.hxx>
+#include <svx/galleryobjectcollection.hxx>
+#include <galleryobjectbinarystorage.hxx>
+#include <galobj.hxx>
+#include <svx/gallery1.hxx>
+#include "gallerydrawmodel.hxx"
+#include <memory>
+
+using namespace ::com::sun::star;
+
+GalleryTheme::GalleryTheme( Gallery* pGallery, GalleryThemeEntry* pThemeEntry )
+    : pParent(pGallery)
+    , pThm(pThemeEntry)
+    , mnThemeLockCount(0)
+    , mnBroadcasterLockCount(0)
+    , nDragPos(0)
+    , bDragging(false)
+    , bAbortActualize(false)
+{
+    mpGalleryStorageEngine = pThm->createGalleryStorageEngine(maGalleryObjectCollection);
+}
+
+GalleryTheme::~GalleryTheme()
+{
+    if(pThm->IsModified())
+        if(!mpGalleryStorageEngine->implWrite(*this, pThm))
+            ImplSetModified(false);
+
+    for (auto & pEntry : maGalleryObjectCollection.getObjectList())
+    {
+        Broadcast( GalleryHint( GalleryHintType::CLOSE_OBJECT, GetName(), pEntry.get() ) );
+        pEntry.reset();
+    }
+    maGalleryObjectCollection.clear();
+    mpGalleryStorageEngine->clearSotStorage();
+}
+
+void GalleryTheme::SetDestDir(const OUString& rDestDir, bool bRelative)
+{
+    mpGalleryStorageEngine->setDestDir(rDestDir, bRelative);
+}
+
+void GalleryTheme::ImplBroadcast(sal_uInt32 nUpdatePos)
+{
+    if( !IsBroadcasterLocked() )
+    {
+        if( GetObjectCount() && ( nUpdatePos >= GetObjectCount() ) )
+            nUpdatePos = GetObjectCount() - 1;
+
+        Broadcast( GalleryHint( GalleryHintType::THEME_UPDATEVIEW, GetName(), reinterpret_cast<void*>(nUpdatePos) ) );
+    }
+}
+
+bool GalleryTheme::UnlockTheme()
+{
+    DBG_ASSERT( mnThemeLockCount, "Theme is not locked" );
+
+    bool bRet = false;
+
+    if( mnThemeLockCount )
+    {
+        --mnThemeLockCount;
+        bRet = true;
+    }
+
+    return bRet;
+}
+
+void GalleryTheme::UnlockBroadcaster()
+{
+    DBG_ASSERT( mnBroadcasterLockCount, "Broadcaster is not locked" );
+
+    if( mnBroadcasterLockCount && !--mnBroadcasterLockCount )
+        ImplBroadcast( 0 );
+}
+
+bool GalleryTheme::InsertObject(const SgaObject& rObj, sal_uInt32 nInsertPos)
+{
+    if (!rObj.IsValid())
+        return false;
+
+    GalleryObject* pFoundEntry = nullptr;
+    sal_uInt32 iFoundPos = 0;
+    for (sal_uInt32 n = maGalleryObjectCollection.size(); iFoundPos < n; ++iFoundPos)
+    {
+        if (maGalleryObjectCollection.get(iFoundPos)->getURL() == rObj.GetURL())
+        {
+            pFoundEntry = maGalleryObjectCollection.get(iFoundPos).get();
+            break;
+        }
+    }
+
+    mpGalleryStorageEngine->insertObject(rObj, pFoundEntry, nInsertPos);
+
+    ImplSetModified(true);
+    ImplBroadcast(pFoundEntry? iFoundPos: nInsertPos);
+
+    return true;
+}
+
+std::unique_ptr<SgaObject> GalleryTheme::AcquireObject(sal_uInt32 nPos)
+{
+    return mpGalleryStorageEngine->implReadSgaObject(maGalleryObjectCollection.getForPosition(nPos));
+}
+
+void GalleryTheme::GetPreviewBitmapExAndStrings(sal_uInt32 nPos, BitmapEx& rBitmapEx, Size& rSize, OUString& rTitle, OUString& rPath)
+{
+    const GalleryObject* pGalleryObject = maGalleryObjectCollection.get(nPos).get();
+
+    rBitmapEx = pGalleryObject->maPreviewBitmapEx;
+    rSize = pGalleryObject->maPreparedSize;
+    rTitle = pGalleryObject->maTitle;
+    rPath = pGalleryObject->maPath;
+}
+
+void GalleryTheme::SetPreviewBitmapExAndStrings(sal_uInt32 nPos, const BitmapEx& rBitmapEx, const Size& rSize, const OUString& rTitle, const OUString& rPath)
+{
+    GalleryObject* pGalleryObject = maGalleryObjectCollection.get(nPos).get();
+
+    pGalleryObject->maPreviewBitmapEx = rBitmapEx;
+    pGalleryObject->maPreparedSize = rSize;
+    pGalleryObject->maTitle = rTitle;
+    pGalleryObject->maPath = rPath;
+}
+
+void GalleryTheme::RemoveObject(sal_uInt32 nPos)
+{
+    auto it = maGalleryObjectCollection.getObjectList().begin() + nPos;
+    std::unique_ptr<GalleryObject> pEntry = std::move(*it);
+    maGalleryObjectCollection.getObjectList().erase( it );
+
+    mpGalleryStorageEngine->removeObject(pEntry);
+
+    Broadcast( GalleryHint( GalleryHintType::CLOSE_OBJECT, GetName(), pEntry.get() ) );
+    pEntry.reset();
+
+    ImplSetModified( true );
+    ImplBroadcast( nPos );
+}
+
+bool GalleryTheme::ChangeObjectPos(sal_uInt32 nOldPos, sal_uInt32 nNewPos)
+{
+    if (nOldPos == nNewPos || nOldPos >= maGalleryObjectCollection.size())
+        return false;
+
+    std::unique_ptr<GalleryObject> pEntry = std::move(maGalleryObjectCollection.get(nOldPos));
+
+    maGalleryObjectCollection.getObjectList().insert(maGalleryObjectCollection.getObjectList().begin() + nNewPos, std::move(pEntry));
+
+    if (nNewPos < nOldPos)
+        nOldPos++;
+
+    auto it = maGalleryObjectCollection.getObjectList().begin() + nOldPos;
+    maGalleryObjectCollection.getObjectList().erase(it);
+
+    ImplSetModified(true);
+    ImplBroadcast((nNewPos < nOldPos)? nNewPos: (nNewPos - 1));
+
+    return true;
+}
+
+void GalleryTheme::Actualize( const Link<const INetURLObject&, void>& rActualizeLink, GalleryProgress* pProgress )
+{
+    if( IsReadOnly() )
+        return;
+
+    Graphic         aGraphic;
+    OUString        aFormat;
+    const sal_uInt32 nCount = maGalleryObjectCollection.size();
+
+    LockBroadcaster();
+    bAbortActualize = false;
+
+    // reset delete flag
+    for (sal_uInt32 i = 0; i < nCount; i++)
+        maGalleryObjectCollection.get(i)->mbDelete = false;
+
+    for (sal_uInt32 i = 0; ( i < nCount ) && !bAbortActualize; i++)
+    {
+        if( pProgress )
+            pProgress->Update( i, nCount - 1 );
+
+        GalleryObject* pEntry = maGalleryObjectCollection.get(i).get();
+
+        const INetURLObject aURL( pEntry->getURL());
+
+        rActualizeLink.Call( aURL );
+
+        // SvDraw objects will be updated later
+        if( pEntry->eObjKind != SgaObjKind::SvDraw )
+        {
+            // Still a function should be implemented,
+            // which assigns files to the relevant entry.
+            // insert graphics as graphic objects into the gallery
+            if( pEntry->eObjKind == SgaObjKind::Sound )
+            {
+                SgaObjectSound aObjSound( aURL );
+                if( !InsertObject( aObjSound ) )
+                    pEntry->mbDelete = true;
+            }
+            else
+            {
+                aGraphic.Clear();
+
+                if ( GalleryGraphicImport( aURL, aGraphic, aFormat ) != GalleryGraphicImportRet::IMPORT_NONE )
+                {
+                    std::unique_ptr<SgaObject> pNewObj;
+
+                    if ( SgaObjKind::Inet == pEntry->eObjKind )
+                        pNewObj.reset(new SgaObjectINet( aGraphic, aURL ));
+                    else if ( aGraphic.IsAnimated() )
+                        pNewObj.reset(new SgaObjectAnim( aGraphic, aURL ));
+                    else
+                        pNewObj.reset(new SgaObjectBmp( aGraphic, aURL ));
+
+                    if( !InsertObject( *pNewObj ) )
+                        pEntry->mbDelete = true;
+                }
+                else
+                    pEntry->mbDelete = true; // set delete flag
+            }
+        }
+        else
+        {
+            //update SvDraw object
+            if ( mpGalleryStorageEngine->GetSvDrawStorage().is() )
+            {
+                SgaObjectSvDraw aNewObj = mpGalleryStorageEngine->updateSvDrawObject(pEntry);
+                if (aNewObj.IsValid() && !InsertObject(aNewObj))
+                    pEntry->mbDelete = true;
+            }
+        }
+    }
+
+    // remove all entries with set flag
+    for ( auto it = maGalleryObjectCollection.getObjectList().begin(); it != maGalleryObjectCollection.getObjectList().end(); /* increment is in the body of loop */)
+    {
+        if( (*it)->mbDelete )
+        {
+            Broadcast( GalleryHint( GalleryHintType::CLOSE_OBJECT, GetName(), it->get() ) );
+            it = maGalleryObjectCollection.getObjectList().erase( it );
+        }
+        else
+            ++it;
+    }
+
+    // update theme
+    mpGalleryStorageEngine->updateTheme();
+    ImplSetModified( true );
+    if (pThm->IsModified())
+        if (!mpGalleryStorageEngine->implWrite(*this, pThm))
+            ImplSetModified(false);
+    UnlockBroadcaster();
+}
+
+bool GalleryTheme::GetThumb(sal_uInt32 nPos, BitmapEx& rBmp)
+{
+    std::unique_ptr<SgaObject> pObj = AcquireObject( nPos );
+    bool        bRet = false;
+
+    if( pObj )
+    {
+        rBmp = pObj->GetThumbBmp();
+        bRet = true;
+    }
+
+    return bRet;
+}
+
+bool GalleryTheme::GetGraphic(sal_uInt32 nPos, Graphic& rGraphic)
+{
+    const GalleryObject*    pObject = maGalleryObjectCollection.getForPosition( nPos );
+    bool                    bRet = false;
+
+    if( pObject )
+    {
+        const INetURLObject aURL( ImplGetURL( pObject ) );
+
+        switch( pObject->eObjKind )
+        {
+            case SgaObjKind::Bitmap:
+            case SgaObjKind::Animation:
+            case SgaObjKind::Inet:
+            {
+                OUString aFilterDummy;
+                bRet = ( GalleryGraphicImport( aURL, rGraphic, aFilterDummy ) != GalleryGraphicImportRet::IMPORT_NONE );
+            }
+            break;
+
+            case SgaObjKind::SvDraw:
+            {
+                SvxGalleryDrawModel aModel;
+
+                if( aModel.GetModel() )
+                {
+                    if( GetModel( nPos, *aModel.GetModel() ) )
+                    {
+                        ImageMap aIMap;
+
+                        if( CreateIMapGraphic( *aModel.GetModel(), rGraphic, aIMap ) )
+                            bRet = true;
+                        else
+                        {
+                            ScopedVclPtrInstance< VirtualDevice > pVDev;
+                            pVDev->SetMapMode( MapMode( MapUnit::Map100thMM ) );
+                            FmFormView aView(*aModel.GetModel(), pVDev);
+
+                            aView.hideMarkHandles();
+                            aView.ShowSdrPage(aView.GetModel()->GetPage(0));
+                            aView.MarkAll();
+                            rGraphic = aView.GetAllMarkedGraphic();
+                            bRet = true;
+                        }
+                    }
+                }
+            }
+            break;
+
+            case SgaObjKind::Sound:
+            {
+                std::unique_ptr<SgaObject> pObj = AcquireObject( nPos );
+
+                if( pObj )
+                {
+                    rGraphic = pObj->GetThumbBmp();
+                    //Bitmap aBmp( pObj->GetThumbBmp() );
+                    //aBmp.Replace( COL_LIGHTMAGENTA, COL_WHITE );
+                    //rGraphic = aBmp;
+                    bRet = true;
+                }
+            }
+            break;
+
+            default:
+            break;
+        }
+    }
+
+    return bRet;
+}
+
+bool GalleryTheme::InsertGraphic(const Graphic& rGraphic, sal_uInt32 nInsertPos)
+{
+    bool bRet = false;
+
+    if( rGraphic.GetType() != GraphicType::NONE )
+    {
+        ConvertDataFormat nExportFormat = ConvertDataFormat::Unknown;
+        const GfxLink     aGfxLink( rGraphic.GetGfxLink() );
+
+        if( aGfxLink.GetDataSize() )
+        {
+            switch( aGfxLink.GetType() )
+            {
+                case GfxLinkType::EpsBuffer: nExportFormat = ConvertDataFormat::SVM; break;
+                case GfxLinkType::NativeGif: nExportFormat = ConvertDataFormat::GIF; break;
+
+                // #i15508# added BMP type
+                // could not find/trigger a call to this, but should do no harm
+                case GfxLinkType::NativeBmp: nExportFormat = ConvertDataFormat::BMP; break;
+
+                case GfxLinkType::NativeJpg: nExportFormat = ConvertDataFormat::JPG; break;
+                case GfxLinkType::NativePng: nExportFormat = ConvertDataFormat::PNG; break;
+                case GfxLinkType::NativeTif: nExportFormat = ConvertDataFormat::TIF; break;
+                case GfxLinkType::NativeWmf: nExportFormat = ConvertDataFormat::WMF; break;
+                case GfxLinkType::NativeMet: nExportFormat = ConvertDataFormat::MET; break;
+                case GfxLinkType::NativePct: nExportFormat = ConvertDataFormat::PCT; break;
+                case GfxLinkType::NativeSvg: nExportFormat = ConvertDataFormat::SVG; break;
+                case GfxLinkType::NativeWebp: nExportFormat = ConvertDataFormat::WEBP; break;
+                default:
+                    break;
+            }
+        }
+        else
+        {
+            if( rGraphic.GetType() == GraphicType::Bitmap )
+            {
+                if( rGraphic.IsAnimated() )
+                    nExportFormat = ConvertDataFormat::GIF;
+                else
+                    nExportFormat = ConvertDataFormat::PNG;
+            }
+            else
+                nExportFormat = ConvertDataFormat::SVM;
+        }
+
+        const SgaObjectBmp aObjBmp = mpGalleryStorageEngine->insertGraphic(rGraphic, aGfxLink, nExportFormat, GetParent()->GetUserURL());
+
+        if (aObjBmp.IsValid())
+            bRet = InsertObject(aObjBmp, nInsertPos);
+    }
+
+    return bRet;
+}
+
+bool GalleryTheme::GetModel(sal_uInt32 nPos, SdrModel& rModel)
+{
+    const GalleryObject*    pObject = maGalleryObjectCollection.getForPosition( nPos );
+    bool                    bRet = false;
+
+    if( pObject && ( SgaObjKind::SvDraw == pObject->eObjKind ) )
+    {
+        bRet = mpGalleryStorageEngine->readModel(pObject, rModel);
+    }
+
+    return bRet;
+}
+
+bool GalleryTheme::InsertModel(const FmFormModel& rModel, sal_uInt32 nInsertPos)
+{
+    bool bRet = false;
+    SgaObjectSvDraw aObjSvDraw = mpGalleryStorageEngine->insertModel(rModel, GetParent()->GetUserURL());
+    if(aObjSvDraw.IsValid())
+        bRet = InsertObject( aObjSvDraw, nInsertPos );
+    return bRet;
+}
+
+bool GalleryTheme::GetModelStream(sal_uInt32 nPos, tools::SvRef<SotTempStream> const & rxModelStream)
+{
+    const GalleryObject*    pObject = maGalleryObjectCollection.getForPosition( nPos );
+    bool                    bRet = false;
+
+    if( pObject && ( SgaObjKind::SvDraw == pObject->eObjKind ) )
+    {
+        bRet = mpGalleryStorageEngine->readModelStream(pObject, rxModelStream);
+    }
+
+    return bRet;
+}
+
+bool GalleryTheme::InsertModelStream(const tools::SvRef<SotTempStream>& rxModelStream, sal_uInt32 nInsertPos)
+{
+    bool            bRet = false;
+
+    const SgaObjectSvDraw aObjSvDraw = mpGalleryStorageEngine->insertModelStream(rxModelStream, GetParent()->GetUserURL());
+    if(aObjSvDraw.IsValid())
+        bRet = InsertObject( aObjSvDraw, nInsertPos );
+
+    return bRet;
+}
+
+bool GalleryTheme::GetURL(sal_uInt32 nPos, INetURLObject& rURL)
+{
+    const GalleryObject*    pObject = maGalleryObjectCollection.getForPosition( nPos );
+    bool                    bRet = false;
+
+    if( pObject )
+    {
+        rURL = ImplGetURL( pObject );
+        bRet = true;
+    }
+
+    return bRet;
+}
+
+bool GalleryTheme::InsertURL(const INetURLObject& rURL, sal_uInt32 nInsertPos)
+{
+    Graphic         aGraphic;
+    OUString        aFormat;
+    std::unique_ptr<SgaObject> pNewObj;
+    const GalleryGraphicImportRet nImportRet = GalleryGraphicImport( rURL, aGraphic, aFormat );
+    bool            bRet = false;
+
+    if( nImportRet != GalleryGraphicImportRet::IMPORT_NONE )
+    {
+        if ( aGraphic.IsAnimated() )
+            pNewObj.reset(new SgaObjectAnim( aGraphic, rURL ));
+        else
+            pNewObj.reset(new SgaObjectBmp( aGraphic, rURL ));
+    }
+#if HAVE_FEATURE_AVMEDIA
+    else if( ::avmedia::MediaWindow::isMediaURL( rURL.GetMainURL( INetURLObject::DecodeMechanism::Unambiguous ), ""/*TODO?*/ ) )
+        pNewObj.reset(new SgaObjectSound( rURL ));
+#endif
+    if( pNewObj && InsertObject( *pNewObj, nInsertPos ) )
+        bRet = true;
+
+    return bRet;
+}
+
+bool GalleryTheme::InsertFileOrDirURL(const INetURLObject& rFileOrDirURL, sal_uInt32 nInsertPos)
+{
+    bool bRet = false;
+    std::vector< INetURLObject > aURLVector;
+    GalleryBinaryEngine::insertFileOrDirURL(rFileOrDirURL, aURLVector);
+
+    for( const auto& rURL : aURLVector )
+        bRet = bRet || InsertURL( rURL, nInsertPos );
+
+    return bRet;
+}
+
+bool GalleryTheme::InsertTransferable(const uno::Reference< datatransfer::XTransferable >& rxTransferable, sal_uInt32 nInsertPos)
+{
+    bool bRet = false;
+
+    if( rxTransferable.is() )
+    {
+        TransferableDataHelper  aDataHelper( rxTransferable );
+        std::unique_ptr<Graphic> pGraphic;
+
+        if( aDataHelper.HasFormat( SotClipboardFormatId::DRAWING ) )
+        {
+            tools::SvRef<SotTempStream> xModelStm;
+
+            if( aDataHelper.GetSotStorageStream( SotClipboardFormatId::DRAWING, xModelStm ) )
+                bRet = InsertModelStream( xModelStm, nInsertPos );
+        }
+        else if( aDataHelper.HasFormat( SotClipboardFormatId::FILE_LIST ) ||
+                 aDataHelper.HasFormat( SotClipboardFormatId::SIMPLE_FILE ) )
+        {
+            FileList aFileList;
+
+            if( aDataHelper.HasFormat( SotClipboardFormatId::FILE_LIST ) )
+                aDataHelper.GetFileList( SotClipboardFormatId::FILE_LIST, aFileList );
+            else
+            {
+                OUString aFile;
+                if (aDataHelper.GetString(SotClipboardFormatId::SIMPLE_FILE, aFile) && !aFile.isEmpty())
+                    aFileList.AppendFile( aFile );
+            }
+
+            for( sal_uInt32 i = 0, nCount = aFileList.Count(); i < nCount; ++i )
+            {
+                const OUString  aFile( aFileList.GetFile( i ) );
+                INetURLObject   aURL( aFile );
+
+                if( aURL.GetProtocol() == INetProtocol::NotValid )
+                {
+                    OUString aLocalURL;
+
+                    if( osl::FileBase::getFileURLFromSystemPath( aFile, aLocalURL ) == osl::FileBase::E_None )
+                        aURL = INetURLObject( aLocalURL );
+                }
+
+                if( aURL.GetProtocol() != INetProtocol::NotValid )
+                    bRet = InsertFileOrDirURL( aURL, nInsertPos );
+            }
+        }
+        else
+        {
+            Graphic aGraphic;
+            SotClipboardFormatId nFormat = SotClipboardFormatId::NONE;
+
+            if( aDataHelper.HasFormat( SotClipboardFormatId::SVXB ) )
+                nFormat = SotClipboardFormatId::SVXB;
+            else if( aDataHelper.HasFormat( SotClipboardFormatId::GDIMETAFILE ) )
+                nFormat = SotClipboardFormatId::GDIMETAFILE;
+            else if( aDataHelper.HasFormat( SotClipboardFormatId::BITMAP ) )
+                nFormat = SotClipboardFormatId::BITMAP;
+
+            if( nFormat != SotClipboardFormatId::NONE && aDataHelper.GetGraphic( nFormat, aGraphic ) )
+                pGraphic.reset(new Graphic( aGraphic ));
+        }
+
+        if( pGraphic )
+        {
+            bRet = false;
+
+            if( aDataHelper.HasFormat( SotClipboardFormatId::SVIM ) )
+            {
+
+                ImageMap aImageMap;
+
+                // according to KA we don't need a BaseURL here
+                if( aDataHelper.GetImageMap( SotClipboardFormatId::SVIM, aImageMap ) )
+                {
+                    SvxGalleryDrawModel aModel;
+
+                    if( aModel.GetModel() )
+                    {
+                        SdrPage*    pPage = aModel.GetModel()->GetPage(0);
+                        SdrGrafObj* pGrafObj = new SdrGrafObj(*aModel.GetModel(), *pGraphic );
+
+                        pGrafObj->AppendUserData( std::unique_ptr<SdrObjUserData>(new SgaIMapInfo( aImageMap )) );
+                        pPage->InsertObject( pGrafObj );
+                        bRet = InsertModel( *aModel.GetModel(), nInsertPos );
+                    }
+                }
+            }
+
+            if( !bRet )
+                bRet = InsertGraphic( *pGraphic, nInsertPos );
+        }
+    }
+
+    return bRet;
+}
+
+void GalleryTheme::CopyToClipboard(const weld::Widget& rWidget, sal_uInt32 nPos)
+{
+    rtl::Reference<GalleryTransferable> pTransferable = new GalleryTransferable( this, nPos, false );
+    pTransferable->CopyToClipboard(rWidget.get_clipboard());
+}
+
+DateTime GalleryTheme::getModificationDate() const
+{
+    return mpGalleryStorageEngine->getModificationDate();
+}
+
+SvStream& GalleryTheme::ReadData( SvStream& rIStm )
+{
+    sal_uInt32          nCount;
+    sal_uInt16          nVersion;
+
+    rIStm.ReadUInt16( nVersion );
+    read_uInt16_lenPrefixed_uInt8s_ToOString(rIStm);
+    rIStm.ReadUInt32( nCount );
+
+    if( nVersion >= 0x0004 )
+    {
+        sal_uInt16 nTmp16;
+        rIStm.ReadUInt16( nTmp16 );
+    }
+
+    if( nCount <= ( 1 << 14 ) )
+    {
+        INetURLObject   aRelURL1( GetParent()->GetRelativeURL() );
+        INetURLObject   aRelURL2( GetParent()->GetUserURL() );
+        sal_uInt32      nId1, nId2;
+        bool            bRel;
+
+        for(auto & i : maGalleryObjectCollection.getObjectList())
+        {
+            GalleryObject* pObj = i.get();
+            Broadcast( GalleryHint( GalleryHintType::CLOSE_OBJECT, GetName(), pObj ) );
+            i.reset();
+        }
+        maGalleryObjectCollection.clear();
+
+        for( sal_uInt32 i = 0; i < nCount; i++ )
+        {
+            std::unique_ptr<GalleryObject> pObj(new GalleryObject);
+
+            OUString    aFileName;
+            sal_uInt16  nTemp;
+
+            rIStm.ReadCharAsBool( bRel );
+            OString aTempFileName = read_uInt16_lenPrefixed_uInt8s_ToOString(rIStm);
+            rIStm.ReadUInt32( pObj->nOffset );
+            rIStm.ReadUInt16( nTemp ); pObj->eObjKind = static_cast<SgaObjKind>(nTemp);
+
+            aFileName = OStringToOUString(aTempFileName, osl_getThreadTextEncoding());
+
+            pObj->m_pGalleryObjectStorage.reset();
+            pObj->m_pGalleryObjectStorage = std::make_unique<GalleryObjectBinaryStorage>();
+
+            if( bRel )
+            {
+                aFileName = aFileName.replaceAll( "\\", "/" );
+                OUString aPath = aRelURL1.GetMainURL( INetURLObject::DecodeMechanism::NONE );
+
+                if( aFileName[ 0 ] != '/' )
+                        aPath += "/";
+
+                aPath += aFileName;
+
+                pObj->m_pGalleryObjectStorage->setURL(INetURLObject(aPath));
+
+                if (!FileExists(pObj->getURL()))
+                {
+                    aPath = aRelURL2.GetMainURL( INetURLObject::DecodeMechanism::NONE );
+
+                    if( aFileName[0] != '/' )
+                        aPath += "/";
+
+                    aPath += aFileName;
+
+                    // assign this URL, even in the case it is not valid (#94482)
+                    pObj->m_pGalleryObjectStorage->setURL(INetURLObject(aPath));
+                }
+            }
+            else
+            {
+                if( SgaObjKind::SvDraw == pObj->eObjKind )
+                {
+                    OUString aDummyURL = "gallery/svdraw/" + aFileName;
+                    pObj->m_pGalleryObjectStorage->setURL(INetURLObject(aDummyURL, INetProtocol::PrivSoffice));
+                }
+                else
+                {
+                    OUString aLocalURL;
+
+                    pObj->m_pGalleryObjectStorage->setURL(INetURLObject(aFileName));
+
+                    if( ( pObj->getURL().GetProtocol() == INetProtocol::NotValid ) &&
+                        osl::FileBase::getFileURLFromSystemPath( aFileName, aLocalURL ) == osl::FileBase::E_None )
+                    {
+                        pObj->m_pGalleryObjectStorage->setURL(INetURLObject(aLocalURL));
+                    }
+                }
+            }
+            maGalleryObjectCollection.getObjectList().push_back( std::move(pObj) );
+        }
+
+        rIStm.ReadUInt32( nId1 ).ReadUInt32( nId2 );
+
+        // In newer versions a 512 byte reserve buffer is located at the end,
+        // the data is located at the beginning of this buffer and are clamped
+        // by a VersionCompatRead.
+        if( !rIStm.eof() &&
+            nId1 == COMPAT_FORMAT( 'G', 'A', 'L', 'R' ) &&
+            nId2 == COMPAT_FORMAT( 'E', 'S', 'R', 'V' ) )
+        {
+            VersionCompatRead aCompat(rIStm);
+            sal_uInt32      nTemp32;
+            bool            bThemeNameFromResource = false;
+
+            rIStm.ReadUInt32( nTemp32 );
+
+            if( aCompat.GetVersion() >= 2 )
+            {
+                rIStm.ReadCharAsBool( bThemeNameFromResource );
+            }
+
+            SetId( nTemp32, bThemeNameFromResource );
+        }
+    }
+    else
+        rIStm.SetError( SVSTREAM_READ_ERROR );
+
+    ImplSetModified( false );
+
+    return rIStm;
+}
+
+void GalleryTheme::ImplSetModified( bool bModified )
+{
+    pThm->SetModified(bModified);
+}
+
+sal_uInt32 GalleryTheme::GetId() const { return pThm->GetId(); }
+void GalleryTheme::SetId( sal_uInt32 nNewId, bool bResetThemeName ) { pThm->SetId( nNewId, bResetThemeName ); }
+bool GalleryTheme::IsReadOnly() const { return pThm->IsReadOnly(); }
+bool GalleryTheme::IsDefault() const { return pThm->IsDefault(); }
+
+const OUString& GalleryTheme::GetName() const { return pThm->GetThemeName(); }
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */