| /************************************************************** |
| * |
| * 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 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sd.hxx" |
| #include <com/sun/star/embed/XTransactedObject.hpp> |
| #include <com/sun/star/embed/XEmbedPersist.hpp> |
| #include <com/sun/star/embed/ElementModes.hpp> |
| #include <com/sun/star/lang/XComponent.hpp> |
| #include <vos/mutex.hxx> |
| #include <unotools/ucbstreamhelper.hxx> |
| #ifndef _UNTOOLS_TEMPFILE_HXX |
| #include <unotools/tempfile.hxx> |
| #endif |
| #include <editeng/eeitem.hxx> |
| #include <editeng/flditem.hxx> |
| #include <svx/svdpagv.hxx> |
| #include <sfx2/app.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <svx/svdoole2.hxx> |
| #include <svx/svdograf.hxx> |
| #include <svx/svdotext.hxx> |
| #include <editeng/outlobj.hxx> |
| #include <sot/storage.hxx> |
| #include <svl/itempool.hxx> |
| #include <editeng/editobj.hxx> |
| #include <svx/fmglob.hxx> |
| #include <svx/svdouno.hxx> |
| #include <tools/urlobj.hxx> |
| #include <sot/formats.hxx> |
| #include <svl/urlbmk.hxx> |
| #include <editeng/outliner.hxx> |
| |
| //#ifndef _SVDETC_HXX //autogen |
| //#include <svx/svdetc.hxx> |
| //#endif |
| #include <com/sun/star/form/FormButtonType.hpp> |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <unotools/streamwrap.hxx> |
| |
| #include <svx/svdotable.hxx> |
| #include <svx/unomodel.hxx> |
| #include <svx/svditer.hxx> |
| #include <sfx2/docfile.hxx> |
| #include <comphelper/storagehelper.hxx> |
| #include <svtools/embedtransfer.hxx> |
| #include "DrawDocShell.hxx" |
| #include "View.hxx" |
| #include "sdpage.hxx" |
| #include "drawview.hxx" |
| #include "drawdoc.hxx" |
| #include "stlpool.hxx" |
| #include "strings.hrc" |
| #include "sdresid.hxx" |
| #include "imapinfo.hxx" |
| #include "sdxfer.hxx" |
| #include "unomodel.hxx" |
| #include <vcl/virdev.hxx> |
| |
| // -------------- |
| // - Namespaces - |
| // -------------- |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::io; |
| using namespace ::com::sun::star::datatransfer; |
| using namespace ::com::sun::star::datatransfer::clipboard; |
| |
| // ----------- |
| // - Defines - |
| // ----------- |
| |
| #define SDTRANSFER_OBJECTTYPE_DRAWMODEL 0x00000001 |
| #define SDTRANSFER_OBJECTTYPE_DRAWOLE 0x00000002 |
| |
| // ------------------ |
| // - SdTransferable - |
| // ------------------ |
| |
| SdTransferable::SdTransferable( SdDrawDocument* pSrcDoc, ::sd::View* pWorkView, sal_Bool bInitOnGetData ) |
| : mpPageDocShell( NULL ) |
| , mpOLEDataHelper( NULL ) |
| , mpObjDesc( NULL ) |
| , mpSdView( pWorkView ) |
| , mpSdViewIntern( pWorkView ) |
| , mpSdDrawDocument( NULL ) |
| , mpSdDrawDocumentIntern( NULL ) |
| , mpSourceDoc( pSrcDoc ) |
| , mpVDev( NULL ) |
| , mpBookmark( NULL ) |
| , mpGraphic( NULL ) |
| , mpImageMap( NULL ) |
| , mbInternalMove( sal_False ) |
| , mbOwnDocument( sal_False ) |
| , mbOwnView( sal_False ) |
| , mbLateInit( bInitOnGetData ) |
| , mbPageTransferable( sal_False ) |
| , mbPageTransferablePersistent( sal_False ) |
| , mbIsUnoObj( false ) |
| , maUserData() |
| { |
| if( mpSourceDoc ) |
| StartListening( *mpSourceDoc ); |
| |
| if( pWorkView ) |
| StartListening( *pWorkView ); |
| |
| if( !mbLateInit ) |
| CreateData(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| SdTransferable::~SdTransferable() |
| { |
| if( mpSourceDoc ) |
| EndListening( *mpSourceDoc ); |
| |
| if( mpSdView ) |
| EndListening( *const_cast< sd::View *>( mpSdView) ); |
| |
| Application::GetSolarMutex().acquire(); |
| |
| ObjectReleased(); |
| |
| for( void* p = maPageBookmarks.First(); p; p = maPageBookmarks.Next() ) |
| delete static_cast< String* >( p ); |
| |
| if( mbOwnView ) |
| delete mpSdViewIntern; |
| |
| delete mpOLEDataHelper; |
| |
| if( maDocShellRef.Is() ) |
| { |
| SfxObjectShell* pObj = maDocShellRef; |
| ::sd::DrawDocShell* pDocSh = static_cast< ::sd::DrawDocShell*>(pObj); |
| pDocSh->DoClose(); |
| } |
| |
| maDocShellRef.Clear(); |
| |
| if( mbOwnDocument ) |
| delete mpSdDrawDocumentIntern; |
| |
| delete mpGraphic; |
| delete mpBookmark; |
| delete mpImageMap; |
| |
| delete mpVDev; |
| delete mpObjDesc; |
| |
| Application::GetSolarMutex().release(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdTransferable::CreateObjectReplacement( SdrObject* pObj ) |
| { |
| if( pObj ) |
| { |
| delete mpOLEDataHelper, mpOLEDataHelper = NULL; |
| delete mpGraphic, mpGraphic = NULL; |
| delete mpBookmark, mpBookmark = NULL; |
| delete mpImageMap, mpImageMap = NULL; |
| |
| if( pObj->ISA( SdrOle2Obj ) ) |
| { |
| try |
| { |
| uno::Reference < embed::XEmbeddedObject > xObj = static_cast< SdrOle2Obj* >( pObj )->GetObjRef(); |
| uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY ); |
| if( xObj.is() && xPersist.is() && xPersist->hasEntry() ) |
| { |
| mpOLEDataHelper = new TransferableDataHelper( new SvEmbedTransferHelper( xObj, static_cast< SdrOle2Obj* >( pObj )->GetGraphic(), static_cast< SdrOle2Obj* >( pObj )->GetAspect() ) ); |
| |
| // TODO/LATER: the standalone handling of the graphic should not be used any more in future |
| // The EmbedDataHelper should bring the graphic in future |
| Graphic* pObjGr = static_cast< SdrOle2Obj* >( pObj )->GetGraphic(); |
| if ( pObjGr ) |
| mpGraphic = new Graphic( *pObjGr ); |
| } |
| } |
| catch( uno::Exception& ) |
| {} |
| } |
| else if( pObj->ISA( SdrGrafObj ) && (mpSourceDoc && !mpSourceDoc->GetAnimationInfo( pObj )) ) |
| { |
| mpGraphic = new Graphic( static_cast< SdrGrafObj* >( pObj )->GetTransformedGraphic() ); |
| } |
| else if( pObj->IsUnoObj() && FmFormInventor == pObj->GetObjInventor() && ( pObj->GetObjIdentifier() == (sal_uInt16) OBJ_FM_BUTTON ) ) |
| { |
| SdrUnoObj* pUnoCtrl = static_cast< SdrUnoObj* >( pObj ); |
| |
| if (pUnoCtrl && FmFormInventor == pUnoCtrl->GetObjInventor()) |
| { |
| Reference< ::com::sun::star::awt::XControlModel > xControlModel( pUnoCtrl->GetUnoControlModel() ); |
| |
| if( !xControlModel.is() ) |
| return; |
| |
| Reference< ::com::sun::star::beans::XPropertySet > xPropSet( xControlModel, UNO_QUERY ); |
| |
| if( !xPropSet.is() ) |
| return; |
| |
| ::com::sun::star::form::FormButtonType eButtonType; |
| Any aTmp( xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ButtonType" ) ) ) ); |
| |
| if( aTmp >>= eButtonType ) |
| { |
| ::rtl::OUString aLabel, aURL; |
| |
| xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Label" ) ) ) >>= aLabel; |
| xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("TargetURL") ) ) >>= aURL; |
| |
| mpBookmark = new INetBookmark( String( aURL ), String( aLabel ) ); |
| } |
| } |
| } |
| else if( pObj->ISA( SdrTextObj ) ) |
| { |
| const OutlinerParaObject* pPara; |
| |
| if( (pPara = static_cast< SdrTextObj* >( pObj )->GetOutlinerParaObject()) != 0 ) |
| { |
| const SvxFieldItem* pField; |
| |
| if( (pField = pPara->GetTextObject().GetField()) != 0 ) |
| { |
| const SvxFieldData* pData = pField->GetField(); |
| |
| if( pData && pData->ISA( SvxURLField ) ) |
| { |
| const SvxURLField* pURL = (SvxURLField*) pData; |
| |
| mpBookmark = new INetBookmark( pURL->GetURL(), pURL->GetRepresentation() ); |
| } |
| } |
| } |
| } |
| |
| SdIMapInfo* pInfo = static_cast< SdDrawDocument* >( pObj->GetModel() )->GetIMapInfo( static_cast< SdrObject* >( pObj ) ); |
| |
| if( pInfo ) |
| mpImageMap = new ImageMap( pInfo->GetImageMap() ); |
| |
| mbIsUnoObj = pObj && pObj->IsUnoObj(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdTransferable::CreateData() |
| { |
| if( mpSdDrawDocument && !mpSdViewIntern ) |
| { |
| mbOwnView = sal_True; |
| |
| SdPage* pPage = mpSdDrawDocument->GetSdPage(0, PK_STANDARD); |
| |
| if( 1 == pPage->GetObjCount() ) |
| CreateObjectReplacement( pPage->GetObj( 0 ) ); |
| |
| mpVDev = new VirtualDevice( *Application::GetDefaultDevice() ); |
| mpVDev->SetMapMode( MapMode( mpSdDrawDocumentIntern->GetScaleUnit(), Point(), mpSdDrawDocumentIntern->GetScaleFraction(), mpSdDrawDocumentIntern->GetScaleFraction() ) ); |
| mpSdViewIntern = new ::sd::View( mpSdDrawDocumentIntern, mpVDev ); |
| mpSdViewIntern->EndListening(*mpSdDrawDocumentIntern ); |
| mpSdViewIntern->hideMarkHandles(); |
| SdrPageView* pPageView = mpSdViewIntern->ShowSdrPage(pPage); |
| ((SdrMarkView*)mpSdViewIntern)->MarkAllObj(pPageView); |
| } |
| else if( mpSdView && !mpSdDrawDocumentIntern ) |
| { |
| const SdrMarkList& rMarkList = mpSdView->GetMarkedObjectList(); |
| |
| if( rMarkList.GetMarkCount() == 1 ) |
| CreateObjectReplacement( rMarkList.GetMark( 0 )->GetMarkedSdrObj() ); |
| |
| if( mpSourceDoc ) |
| mpSourceDoc->CreatingDataObj(this); |
| mpSdDrawDocumentIntern = (SdDrawDocument*) mpSdView->GetAllMarkedModel(); |
| if( mpSourceDoc ) |
| mpSourceDoc->CreatingDataObj(0); |
| |
| if( !maDocShellRef.Is() && mpSdDrawDocumentIntern->GetDocSh() ) |
| maDocShellRef = mpSdDrawDocumentIntern->GetDocSh(); |
| |
| if( !maDocShellRef.Is() ) |
| { |
| DBG_ERROR( "SdTransferable::CreateData(), failed to create a model with persist, clipboard operation will fail for OLE objects!" ); |
| mbOwnDocument = sal_True; |
| } |
| |
| // Groesse der Source-Seite uebernehmen |
| SdrPageView* pPgView = mpSdView->GetSdrPageView(); |
| SdPage* pOldPage = (SdPage*) pPgView->GetPage(); |
| SdrModel* pOldModel = mpSdView->GetModel(); |
| SdStyleSheetPool* pOldStylePool = (SdStyleSheetPool*) pOldModel->GetStyleSheetPool(); |
| SdStyleSheetPool* pNewStylePool = (SdStyleSheetPool*) mpSdDrawDocumentIntern->GetStyleSheetPool(); |
| SdPage* pPage = mpSdDrawDocumentIntern->GetSdPage( 0, PK_STANDARD ); |
| String aOldLayoutName( pOldPage->GetLayoutName() ); |
| |
| pPage->SetSize( pOldPage->GetSize() ); |
| pPage->SetLayoutName( aOldLayoutName ); |
| pNewStylePool->CopyGraphicSheets( *pOldStylePool ); |
| pNewStylePool->CopyCellSheets( *pOldStylePool ); |
| pNewStylePool->CopyTableStyles( *pOldStylePool ); |
| aOldLayoutName.Erase( aOldLayoutName.SearchAscii( SD_LT_SEPARATOR ) ); |
| SdStyleSheetVector aCreatedSheets; |
| pNewStylePool->CopyLayoutSheets( aOldLayoutName, *pOldStylePool, aCreatedSheets ); |
| } |
| |
| // set VisArea and adjust objects if neccessary |
| if( maVisArea.IsEmpty() && |
| mpSdDrawDocumentIntern && mpSdViewIntern && |
| mpSdDrawDocumentIntern->GetPageCount() ) |
| { |
| SdPage* pPage = mpSdDrawDocumentIntern->GetSdPage( 0, PK_STANDARD ); |
| |
| if( 1 == mpSdDrawDocumentIntern->GetPageCount() ) |
| { |
| // #112978# need to use GetAllMarkedBoundRect instead of GetAllMarkedRect to get |
| // fat lines correctly |
| Point aOrigin( ( maVisArea = mpSdViewIntern->GetAllMarkedBoundRect() ).TopLeft() ); |
| Size aVector( -aOrigin.X(), -aOrigin.Y() ); |
| |
| for( sal_uLong nObj = 0, nObjCount = pPage->GetObjCount(); nObj < nObjCount; nObj++ ) |
| { |
| SdrObject* pObj = pPage->GetObj( nObj ); |
| pObj->NbcMove( aVector ); |
| } |
| } |
| else |
| maVisArea.SetSize( pPage->GetSize() ); |
| |
| // Die Ausgabe soll am Nullpunkt erfolgen |
| maVisArea.SetPos( Point() ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool lcl_HasOnlyControls( SdrModel* pModel ) |
| { |
| sal_Bool bOnlyControls = sal_False; // default if there are no objects |
| |
| if ( pModel ) |
| { |
| SdrPage* pPage = pModel->GetPage(0); |
| if (pPage) |
| { |
| SdrObjListIter aIter( *pPage, IM_DEEPNOGROUPS ); |
| SdrObject* pObj = aIter.Next(); |
| if ( pObj ) |
| { |
| bOnlyControls = sal_True; // only set if there are any objects at all |
| while ( pObj ) |
| { |
| if (!pObj->ISA(SdrUnoObj)) |
| { |
| bOnlyControls = sal_False; |
| break; |
| } |
| pObj = aIter.Next(); |
| } |
| } |
| } |
| } |
| |
| return bOnlyControls; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| bool lcl_HasOnlyOneTable( SdrModel* pModel ) |
| { |
| if ( pModel ) |
| { |
| SdrPage* pPage = pModel->GetPage(0); |
| if (pPage && pPage->GetObjCount() == 1 ) |
| { |
| if( dynamic_cast< sdr::table::SdrTableObj* >( pPage->GetObj(0) ) != 0 ) |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdTransferable::AddSupportedFormats() |
| { |
| if( !mbPageTransferable || mbPageTransferablePersistent ) |
| { |
| if( !mbLateInit ) |
| CreateData(); |
| |
| if( mpObjDesc ) |
| AddFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ); |
| |
| if( mpOLEDataHelper ) |
| { |
| AddFormat( SOT_FORMATSTR_ID_EMBED_SOURCE ); |
| |
| DataFlavorExVector aVector( mpOLEDataHelper->GetDataFlavorExVector() ); |
| DataFlavorExVector::iterator aIter( aVector.begin() ), aEnd( aVector.end() ); |
| |
| while( aIter != aEnd ) |
| AddFormat( *aIter++ ); |
| } |
| else if( mpGraphic ) |
| { |
| // #i25616# |
| AddFormat( SOT_FORMATSTR_ID_DRAWING ); |
| |
| AddFormat( SOT_FORMATSTR_ID_SVXB ); |
| |
| if( mpGraphic->GetType() == GRAPHIC_BITMAP ) |
| { |
| AddFormat( SOT_FORMATSTR_ID_PNG ); |
| AddFormat( SOT_FORMAT_BITMAP ); |
| AddFormat( SOT_FORMAT_GDIMETAFILE ); |
| } |
| else |
| { |
| AddFormat( SOT_FORMAT_GDIMETAFILE ); |
| AddFormat( SOT_FORMATSTR_ID_PNG ); |
| AddFormat( SOT_FORMAT_BITMAP ); |
| } |
| } |
| else if( mpBookmark ) |
| { |
| AddFormat( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK ); |
| AddFormat( FORMAT_STRING ); |
| } |
| else |
| { |
| AddFormat( SOT_FORMATSTR_ID_EMBED_SOURCE ); |
| AddFormat( SOT_FORMATSTR_ID_DRAWING ); |
| if( !mpSdDrawDocument || !lcl_HasOnlyControls( mpSdDrawDocument ) ) |
| { |
| AddFormat( SOT_FORMAT_GDIMETAFILE ); |
| AddFormat( SOT_FORMATSTR_ID_PNG ); |
| AddFormat( SOT_FORMAT_BITMAP ); |
| } |
| |
| if( lcl_HasOnlyOneTable( mpSdDrawDocument ) ) |
| AddFormat( SOT_FORMAT_RTF ); |
| } |
| |
| if( mpImageMap ) |
| AddFormat( SOT_FORMATSTR_ID_SVIM ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdTransferable::GetData( const DataFlavor& rFlavor ) |
| { |
| if (SD_MOD()==NULL) |
| return sal_False; |
| |
| sal_uInt32 nFormat = SotExchange::GetFormat( rFlavor ); |
| sal_Bool bOK = sal_False; |
| |
| CreateData(); |
| |
| if( nFormat == SOT_FORMAT_RTF && lcl_HasOnlyOneTable( mpSdDrawDocument ) ) |
| { |
| bOK = SetTableRTF( mpSdDrawDocument, rFlavor ); |
| } |
| else if( mpOLEDataHelper && mpOLEDataHelper->HasFormat( rFlavor ) ) |
| { |
| sal_uLong nOldSwapMode = 0; |
| |
| if( mpSdDrawDocumentIntern ) |
| { |
| nOldSwapMode = mpSdDrawDocumentIntern->GetSwapGraphicsMode(); |
| mpSdDrawDocumentIntern->SetSwapGraphicsMode( SDR_SWAPGRAPHICSMODE_PURGE ); |
| } |
| |
| // TODO/LATER: support all the graphical formats, the embedded object scenario should not have separated handling |
| if( nFormat == FORMAT_GDIMETAFILE && mpGraphic ) |
| bOK = SetGDIMetaFile( mpGraphic->GetGDIMetaFile(), rFlavor ); |
| else |
| bOK = SetAny( mpOLEDataHelper->GetAny( rFlavor ), rFlavor ); |
| |
| if( mpSdDrawDocumentIntern ) |
| mpSdDrawDocumentIntern->SetSwapGraphicsMode( nOldSwapMode ); |
| } |
| else if( HasFormat( nFormat ) ) |
| { |
| if( ( nFormat == SOT_FORMATSTR_ID_LINKSRCDESCRIPTOR || nFormat == SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ) && mpObjDesc ) |
| { |
| bOK = SetTransferableObjectDescriptor( *mpObjDesc, rFlavor ); |
| } |
| else if( nFormat == SOT_FORMATSTR_ID_DRAWING ) |
| { |
| SfxObjectShellRef aOldRef( maDocShellRef ); |
| |
| maDocShellRef.Clear(); |
| |
| if( mpSdViewIntern ) |
| { |
| SdDrawDocument* pInternDoc = mpSdViewIntern->GetDoc(); |
| if( pInternDoc ) |
| pInternDoc->CreatingDataObj(this); |
| SdDrawDocument* pDoc = dynamic_cast< SdDrawDocument* >( mpSdViewIntern->GetAllMarkedModel() ); |
| if( pInternDoc ) |
| pInternDoc->CreatingDataObj(0); |
| |
| bOK = SetObject( pDoc, SDTRANSFER_OBJECTTYPE_DRAWMODEL, rFlavor ); |
| |
| if( maDocShellRef.Is() ) |
| { |
| maDocShellRef->DoClose(); |
| } |
| else |
| { |
| delete pDoc; |
| } |
| } |
| |
| maDocShellRef = aOldRef; |
| } |
| else if( nFormat == FORMAT_GDIMETAFILE ) |
| { |
| if( mpSdViewIntern ) |
| bOK = SetGDIMetaFile( mpSdViewIntern->GetMarkedObjMetaFile(true), rFlavor ); |
| } |
| else if( FORMAT_BITMAP == nFormat || SOT_FORMATSTR_ID_PNG == nFormat ) |
| { |
| if( mpSdViewIntern ) |
| bOK = SetBitmapEx( mpSdViewIntern->GetMarkedObjBitmapEx(true), rFlavor ); |
| } |
| else if( ( nFormat == FORMAT_STRING ) && mpBookmark ) |
| { |
| bOK = SetString( mpBookmark->GetURL(), rFlavor ); |
| } |
| else if( ( nFormat == SOT_FORMATSTR_ID_SVXB ) && mpGraphic ) |
| { |
| bOK = SetGraphic( *mpGraphic, rFlavor ); |
| } |
| else if( ( nFormat == SOT_FORMATSTR_ID_SVIM ) && mpImageMap ) |
| { |
| bOK = SetImageMap( *mpImageMap, rFlavor ); |
| } |
| else if( mpBookmark ) |
| { |
| bOK = SetINetBookmark( *mpBookmark, rFlavor ); |
| } |
| else if( nFormat == SOT_FORMATSTR_ID_EMBED_SOURCE ) |
| { |
| sal_uLong nOldSwapMode = 0; |
| |
| if( mpSdDrawDocumentIntern ) |
| { |
| nOldSwapMode = mpSdDrawDocumentIntern->GetSwapGraphicsMode(); |
| mpSdDrawDocumentIntern->SetSwapGraphicsMode( SDR_SWAPGRAPHICSMODE_PURGE ); |
| } |
| |
| if( !maDocShellRef.Is() ) |
| { |
| maDocShellRef = new ::sd::DrawDocShell( |
| mpSdDrawDocumentIntern, |
| SFX_CREATE_MODE_EMBEDDED, |
| sal_True, |
| mpSdDrawDocumentIntern->GetDocumentType()); |
| mbOwnDocument = sal_False; |
| maDocShellRef->DoInitNew( NULL ); |
| } |
| |
| maDocShellRef->SetVisArea( maVisArea ); |
| bOK = SetObject( &maDocShellRef, SDTRANSFER_OBJECTTYPE_DRAWOLE, rFlavor ); |
| |
| if( mpSdDrawDocumentIntern ) |
| mpSdDrawDocumentIntern->SetSwapGraphicsMode( nOldSwapMode ); |
| } |
| } |
| |
| return bOK; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| /* testcode |
| #include <sfx2/docfile.hxx> |
| */ |
| |
| sal_Bool SdTransferable::WriteObject( SotStorageStreamRef& rxOStm, void* pObject, sal_uInt32 nObjectType, const DataFlavor& ) |
| { |
| sal_Bool bRet = sal_False; |
| |
| switch( nObjectType ) |
| { |
| case( SDTRANSFER_OBJECTTYPE_DRAWMODEL ): |
| { |
| try |
| { |
| static const sal_Bool bDontBurnInStyleSheet = ( getenv( "AVOID_BURN_IN_FOR_GALLERY_THEME" ) != NULL ); |
| SdDrawDocument* pDoc = (SdDrawDocument*) pObject; |
| if ( !bDontBurnInStyleSheet ) |
| pDoc->BurnInStyleSheetAttributes(); |
| rxOStm->SetBufferSize( 16348 ); |
| |
| Reference< XComponent > xComponent( new SdXImpressDocument( pDoc, sal_True ) ); |
| pDoc->setUnoModel( Reference< XInterface >::query( xComponent ) ); |
| |
| { |
| com::sun::star::uno::Reference<com::sun::star::io::XOutputStream> xDocOut( new utl::OOutputStreamWrapper( *rxOStm ) ); |
| if( SvxDrawingLayerExport( pDoc, xDocOut, xComponent, (pDoc->GetDocumentType() == DOCUMENT_TYPE_IMPRESS) ? "com.sun.star.comp.Impress.XMLClipboardExporter" : "com.sun.star.comp.DrawingLayer.XMLExporter" ) ) |
| rxOStm->Commit(); |
| } |
| |
| /* testcode |
| { |
| const rtl::OUString aURL( RTL_CONSTASCII_USTRINGPARAM( "file:///e:/test.xml" ) ); |
| SfxMedium aMedium( aURL, STREAM_WRITE | STREAM_TRUNC, sal_True ); |
| aMedium.IsRemote(); |
| com::sun::star::uno::Reference<com::sun::star::io::XOutputStream> xDocOut( new utl::OOutputStreamWrapper( *aMedium.GetOutStream() ) ); |
| if( SvxDrawingLayerExport( pDoc, xDocOut, xComponent, (pDoc->GetDocumentType() == DOCUMENT_TYPE_IMPRESS) ? "com.sun.star.comp.Impress.XMLClipboardExporter" : "com.sun.star.comp.DrawingLayer.XMLExporter" ) ) |
| aMedium.Commit(); |
| } |
| */ |
| |
| xComponent->dispose(); |
| bRet = ( rxOStm->GetError() == ERRCODE_NONE ); |
| } |
| catch( Exception& ) |
| { |
| DBG_ERROR( "sd::SdTransferable::WriteObject(), exception catched!" ); |
| bRet = sal_False; |
| } |
| } |
| break; |
| |
| case( SDTRANSFER_OBJECTTYPE_DRAWOLE ): |
| { |
| SfxObjectShell* pEmbObj = (SfxObjectShell*) pObject; |
| ::utl::TempFile aTempFile; |
| aTempFile.EnableKillingFile(); |
| |
| try |
| { |
| uno::Reference< embed::XStorage > xWorkStore = |
| ::comphelper::OStorageHelper::GetStorageFromURL( aTempFile.GetURL(), embed::ElementModes::READWRITE ); |
| |
| // write document storage |
| pEmbObj->SetupStorage( xWorkStore, SOFFICE_FILEFORMAT_CURRENT, sal_False ); |
| // mba: no relative ULRs for clipboard! |
| SfxMedium aMedium( xWorkStore, String() ); |
| bRet = pEmbObj->DoSaveObjectAs( aMedium, sal_False ); |
| pEmbObj->DoSaveCompleted(); |
| |
| uno::Reference< embed::XTransactedObject > xTransact( xWorkStore, uno::UNO_QUERY ); |
| if ( xTransact.is() ) |
| xTransact->commit(); |
| |
| SvStream* pSrcStm = ::utl::UcbStreamHelper::CreateStream( aTempFile.GetURL(), STREAM_READ ); |
| if( pSrcStm ) |
| { |
| rxOStm->SetBufferSize( 0xff00 ); |
| *rxOStm << *pSrcStm; |
| delete pSrcStm; |
| } |
| |
| bRet = sal_True; |
| rxOStm->Commit(); |
| } |
| catch ( Exception& ) |
| {} |
| } |
| |
| break; |
| |
| default: |
| break; |
| } |
| |
| return bRet; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdTransferable::DragFinished( sal_Int8 nDropAction ) |
| { |
| if( mpSdView ) |
| ( (::sd::View*) mpSdView )->DragFinished( nDropAction ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdTransferable::ObjectReleased() |
| { |
| if( this == SD_MOD()->pTransferClip ) |
| SD_MOD()->pTransferClip = NULL; |
| |
| if( this == SD_MOD()->pTransferDrag ) |
| SD_MOD()->pTransferDrag = NULL; |
| |
| if( this == SD_MOD()->pTransferSelection ) |
| SD_MOD()->pTransferSelection = NULL; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdTransferable::SetObjectDescriptor( const TransferableObjectDescriptor& rObjDesc ) |
| { |
| delete mpObjDesc; |
| mpObjDesc = new TransferableObjectDescriptor( rObjDesc ); |
| PrepareOLE( rObjDesc ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdTransferable::SetPageBookmarks( const List& rPageBookmarks, sal_Bool bPersistent ) |
| { |
| if( mpSourceDoc ) |
| { |
| if( mpSdViewIntern ) |
| mpSdViewIntern->HideSdrPage(); |
| |
| // #116168# |
| mpSdDrawDocument->ClearModel(sal_False); |
| |
| mpPageDocShell = NULL; |
| |
| for( void* p = maPageBookmarks.First(); p; p = maPageBookmarks.Next() ) |
| delete static_cast< String* >( p ); |
| |
| if( bPersistent ) |
| { |
| mpSdDrawDocument->CreateFirstPages(mpSourceDoc); |
| mpSdDrawDocument->InsertBookmarkAsPage( const_cast< List* >( &rPageBookmarks ), NULL, sal_False, sal_True, 1, sal_True, mpSourceDoc->GetDocSh(), sal_True, sal_True, sal_False ); |
| } |
| else |
| { |
| mpPageDocShell = mpSourceDoc->GetDocSh(); |
| |
| for( sal_uLong i = 0; i < rPageBookmarks.Count(); i++ ) |
| maPageBookmarks.Insert( new String( *static_cast< String* >( rPageBookmarks.GetObject( i ) ) ), LIST_APPEND ); |
| } |
| |
| if( mpSdViewIntern && mpSdDrawDocument ) |
| { |
| SdPage* pPage = mpSdDrawDocument->GetSdPage( 0, PK_STANDARD ); |
| |
| if( pPage ) |
| { |
| ( (SdrMarkView*) mpSdViewIntern )->MarkAllObj( (SdrPageView*) mpSdViewIntern->ShowSdrPage( pPage ) ); |
| } |
| } |
| |
| // set flags for page transferable; if ( mbPageTransferablePersistent == sal_False ), |
| // don't offer any formats => it's just for internal puposes |
| mbPageTransferable = sal_True; |
| mbPageTransferablePersistent = bPersistent; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Int64 SAL_CALL SdTransferable::getSomething( const ::com::sun::star::uno::Sequence< sal_Int8 >& rId ) throw( ::com::sun::star::uno::RuntimeException ) |
| { |
| sal_Int64 nRet; |
| |
| if( ( rId.getLength() == 16 ) && |
| ( 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(), rId.getConstArray(), 16 ) ) ) |
| { |
| nRet = sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this)); |
| } |
| else |
| { |
| nRet = 0; |
| } |
| |
| return nRet; |
| } |
| |
| |
| |
| |
| SdDrawDocument* SdTransferable::GetSourceDoc (void) const |
| { |
| return mpSourceDoc; |
| } |
| |
| |
| |
| |
| void SdTransferable::AddUserData (const ::boost::shared_ptr<UserData>& rpData) |
| { |
| maUserData.push_back(rpData); |
| } |
| |
| |
| |
| |
| void SdTransferable::RemoveUserData (const ::boost::shared_ptr<UserData>& rpData) |
| { |
| maUserData.erase(::std::find(maUserData.begin(), maUserData.end(), rpData)); |
| } |
| |
| |
| |
| |
| sal_Int32 SdTransferable::GetUserDataCount (void) const |
| { |
| return maUserData.size(); |
| } |
| |
| |
| |
| |
| ::boost::shared_ptr<SdTransferable::UserData> SdTransferable::GetUserData (const sal_Int32 nIndex) const |
| { |
| if (nIndex>=0 && nIndex<sal_Int32(maUserData.size())) |
| return maUserData[nIndex]; |
| else |
| return ::boost::shared_ptr<UserData>(); |
| } |
| |
| |
| |
| |
| // ----------------------------------------------------------------------------- |
| |
| const ::com::sun::star::uno::Sequence< sal_Int8 >& SdTransferable::getUnoTunnelId() |
| { |
| static ::com::sun::star::uno::Sequence< sal_Int8 > aSeq; |
| |
| if( !aSeq.getLength() ) |
| { |
| static osl::Mutex aCreateMutex; |
| osl::MutexGuard aGuard( aCreateMutex ); |
| |
| aSeq.realloc( 16 ); |
| rtl_createUuid( reinterpret_cast< sal_uInt8* >( aSeq.getArray() ), 0, sal_True ); |
| } |
| |
| return aSeq; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| SdTransferable* SdTransferable::getImplementation( const Reference< XInterface >& rxData ) throw() |
| { |
| try |
| { |
| Reference< ::com::sun::star::lang::XUnoTunnel > xUnoTunnel( rxData, UNO_QUERY_THROW ); |
| return reinterpret_cast<SdTransferable*>(sal::static_int_cast<sal_uIntPtr>(xUnoTunnel->getSomething( SdTransferable::getUnoTunnelId()) ) ); |
| } |
| catch( const ::com::sun::star::uno::Exception& ) |
| { |
| } |
| return NULL; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| // SfxListener |
| void SdTransferable::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) |
| { |
| const SdrHint* pSdrHint = dynamic_cast< const SdrHint* >( &rHint ); |
| if( pSdrHint ) |
| { |
| if( HINT_MODELCLEARED == pSdrHint->GetKind() ) |
| { |
| EndListening(*mpSourceDoc); |
| mpSourceDoc = 0; |
| } |
| } |
| else |
| { |
| const SfxSimpleHint* pSimpleHint = dynamic_cast< const SfxSimpleHint * >(&rHint); |
| if(pSimpleHint && (pSimpleHint->GetId() == SFX_HINT_DYING) ) |
| { |
| if( &rBC == mpSourceDoc ) |
| mpSourceDoc = 0; |
| if( &rBC == mpSdViewIntern ) |
| mpSdViewIntern = 0; |
| if( &rBC == mpSdView ) |
| mpSdView = 0; |
| } |
| } |
| } |
| |
| sal_Bool SdTransferable::SetTableRTF( SdDrawDocument* pModel, const DataFlavor& rFlavor) |
| { |
| if ( pModel ) |
| { |
| SdrPage* pPage = pModel->GetPage(0); |
| if (pPage && pPage->GetObjCount() == 1 ) |
| { |
| sdr::table::SdrTableObj* pTableObj = dynamic_cast< sdr::table::SdrTableObj* >( pPage->GetObj(0) ); |
| if( pTableObj ) |
| { |
| SvMemoryStream aMemStm( 65535, 65535 ); |
| sdr::table::SdrTableObj::ExportAsRTF( aMemStm, *pTableObj ); |
| return SetAny( Any( Sequence< sal_Int8 >( reinterpret_cast< const sal_Int8* >( aMemStm.GetData() ), aMemStm.Seek( STREAM_SEEK_TO_END ) ) ), rFlavor ); |
| } |
| } |
| } |
| |
| return sal_False; |
| } |