778 lines
25 KiB
C++
778 lines
25 KiB
C++
/* -*- 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 <galleryfilestorage.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*>(static_cast<sal_uIntPtr>(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)->m_oStorageUrl == 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->m_oStorageUrl );
|
|
|
|
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, SvStream& rModelStream)
|
|
{
|
|
const GalleryObject* pObject = maGalleryObjectCollection.getForPosition( nPos );
|
|
bool bRet = false;
|
|
|
|
if( pObject && ( SgaObjKind::SvDraw == pObject->eObjKind ) )
|
|
{
|
|
bRet = mpGalleryStorageEngine->readModelStream(pObject, rModelStream);
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
bool GalleryTheme::InsertModelStream(SvStream& rModelStream, sal_uInt32 nInsertPos)
|
|
{
|
|
bool bRet = false;
|
|
|
|
const SgaObjectSvDraw aObjSvDraw = mpGalleryStorageEngine->insertModelStream(rModelStream, GetParent()->GetUserURL());
|
|
if(aObjSvDraw.IsValid())
|
|
bRet = InsertObject( aObjSvDraw, nInsertPos );
|
|
|
|
return bRet;
|
|
}
|
|
|
|
bool GalleryTheme::GetURL(sal_uInt32 nPos, INetURLObject& rURL) const
|
|
{
|
|
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 ), u""_ustr/*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;
|
|
GalleryFileStorage::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::optional<Graphic> oGraphic;
|
|
|
|
if( aDataHelper.HasFormat( SotClipboardFormatId::DRAWING ) )
|
|
{
|
|
if (std::unique_ptr<SvStream> xModelStm = aDataHelper.GetSotStorageStream( SotClipboardFormatId::DRAWING ) )
|
|
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 ) )
|
|
oGraphic.emplace( aGraphic );
|
|
}
|
|
|
|
if( oGraphic )
|
|
{
|
|
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);
|
|
rtl::Reference<SdrGrafObj> pGrafObj = new SdrGrafObj(*aModel.GetModel(), *oGraphic );
|
|
|
|
pGrafObj->AppendUserData( std::unique_ptr<SdrObjUserData>(new SgaIMapInfo( aImageMap )) );
|
|
pPage->InsertObject( pGrafObj.get() );
|
|
bRet = InsertModel( *aModel.GetModel(), nInsertPos );
|
|
}
|
|
}
|
|
}
|
|
|
|
if( !bRet )
|
|
bRet = InsertGraphic( *oGraphic, 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_oStorageUrl.emplace();
|
|
|
|
if( bRel )
|
|
{
|
|
aFileName = aFileName.replaceAll( "\\", "/" );
|
|
OUString aPath = aRelURL1.GetMainURL( INetURLObject::DecodeMechanism::NONE );
|
|
|
|
if( aFileName[ 0 ] != '/' )
|
|
aPath += "/";
|
|
|
|
aPath += aFileName;
|
|
|
|
pObj->m_oStorageUrl = INetURLObject(aPath);
|
|
|
|
if (!FileExists(*pObj->m_oStorageUrl))
|
|
{
|
|
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_oStorageUrl = INetURLObject(aPath);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( SgaObjKind::SvDraw == pObj->eObjKind )
|
|
{
|
|
OUString aDummyURL = "gallery/svdraw/" + aFileName;
|
|
pObj->m_oStorageUrl = INetURLObject(aDummyURL, INetProtocol::PrivSoffice);
|
|
}
|
|
else
|
|
{
|
|
OUString aLocalURL;
|
|
|
|
pObj->m_oStorageUrl = INetURLObject(aFileName);
|
|
|
|
if( ( pObj->m_oStorageUrl->GetProtocol() == INetProtocol::NotValid ) &&
|
|
osl::FileBase::getFileURLFromSystemPath( aFileName, aLocalURL ) == osl::FileBase::E_None )
|
|
{
|
|
pObj->m_oStorageUrl = 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(); }
|
|
const INetURLObject& GalleryTheme::getThemeURL() const { return mpGalleryStorageEngine->getThemeURL(); }
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|