| /************************************************************** |
| * |
| * 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_sw.hxx" |
| #ifdef PRECOMPILED |
| #include "ui_pch.hxx" |
| #endif |
| |
| |
| #include <com/sun/star/embed/XVisualObject.hpp> |
| #include <com/sun/star/embed/XTransactedObject.hpp> |
| #include <com/sun/star/embed/Aspects.hpp> |
| #include <com/sun/star/embed/XEmbedObjectClipboardCreator.hpp> |
| #include <com/sun/star/embed/NoVisualAreaSizeException.hpp> |
| |
| #include <svtools/embedtransfer.hxx> |
| #include <svtools/insdlg.hxx> |
| #include <unotools/tempfile.hxx> |
| #include <comphelper/storagehelper.hxx> |
| #include <comphelper/processfactory.hxx> |
| #include <unotools/ucbstreamhelper.hxx> |
| #include <sot/filelist.hxx> |
| #include <svx/svxdlg.hxx> |
| #include <toolkit/helper/vclunohelper.hxx> |
| #include <osl/endian.h> |
| #include <sfx2/linkmgr.hxx> |
| #include <tools/urlobj.hxx> |
| #include <vcl/wrkwin.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <sfx2/dispatch.hxx> |
| #include <svl/stritem.hxx> |
| #include <svtools/imap.hxx> |
| #include <sot/storage.hxx> |
| #include <vcl/graph.hxx> |
| #include <svl/urihelper.hxx> |
| #include <svx/svdmodel.hxx> |
| #include <svx/xexch.hxx> |
| #include <svx/xmlexchg.hxx> |
| #include <svx/dbaexchange.hxx> |
| #include <svx/clipfmtitem.hxx> |
| #include <sfx2/mieclip.hxx> |
| #include <svx/svdetc.hxx> |
| #include <svx/xoutbmp.hxx> |
| #include <svl/urlbmk.hxx> |
| #include <svtools/htmlout.hxx> |
| #include <svx/hlnkitem.hxx> |
| #include <svtools/inetimg.hxx> |
| #include <editeng/paperinf.hxx> |
| #include <svx/fmview.hxx> |
| #include <editeng/scripttypeitem.hxx> |
| #include <sfx2/docfilt.hxx> |
| #include <svtools/imapobj.hxx> |
| #include <sfx2/docfile.hxx> |
| #include <unotools/transliterationwrapper.hxx> |
| #include <unotools/streamwrap.hxx> |
| #include <svtools/filter.hxx> |
| |
| #include <svx/unomodel.hxx> |
| #include <fmturl.hxx> |
| #include <fmtinfmt.hxx> |
| #include <fmtfsize.hxx> |
| #include <swdtflvr.hxx> |
| #include <shellio.hxx> |
| #include <ddefld.hxx> |
| #include <doc.hxx> |
| #include <IDocumentUndoRedo.hxx> |
| #include <pagedesc.hxx> |
| #include <IMark.hxx> |
| #include <bookmrk.hxx> |
| #include <docary.hxx> |
| #include <section.hxx> |
| #include <ndtxt.hxx> |
| #include <edtwin.hxx> |
| #include <navicont.hxx> |
| #include <swcont.hxx> |
| #include <wrtsh.hxx> |
| #include <swmodule.hxx> |
| #include <view.hxx> |
| #include <docsh.hxx> |
| #include <wdocsh.hxx> |
| #include <fldbas.hxx> //DDE |
| #include <swundo.hxx> // fuer Undo-Ids |
| #include <pam.hxx> |
| #include <ndole.hxx> |
| #include <swwait.hxx> |
| #include <viewopt.hxx> |
| #include <swunodef.hxx> |
| #include <vcl/sound.hxx> |
| #include <swerror.h> |
| #include <SwCapObjType.hxx> |
| #include <cmdid.h> |
| #include <dochdl.hrc> |
| #include <comcore.hrc> // #111827# |
| #include <sot/stg.hxx> |
| #include <svx/svditer.hxx> |
| #include <editeng/eeitem.hxx> |
| #include <editeng/fhgtitem.hxx> |
| #include <svx/svdpage.hxx> |
| #include <avmedia/mediawindow.hxx> |
| #include <swcrsr.hxx> |
| #include <SwRewriter.hxx> |
| #include <globals.hrc> |
| #include <vos/mutex.hxx> |
| #include <vcl/svapp.hxx> |
| #include <swserv.hxx> |
| #include <switerator.hxx> |
| |
| extern sal_Bool bFrmDrag; |
| extern sal_Bool bDDINetAttr; |
| extern sal_Bool bExecuteDrag; |
| |
| |
| #define OLESIZE 11905 - 2 * lMinBorder, 6 * MM50 |
| |
| #define SWTRANSFER_OBJECTTYPE_DRAWMODEL 0x00000001 |
| #define SWTRANSFER_OBJECTTYPE_HTML 0x00000002 |
| #define SWTRANSFER_OBJECTTYPE_RTF 0x00000004 |
| #define SWTRANSFER_OBJECTTYPE_STRING 0x00000008 |
| #define SWTRANSFER_OBJECTTYPE_SWOLE 0x00000010 |
| #define SWTRANSFER_OBJECTTYPE_DDE 0x00000020 |
| |
| #define SWTRANSFER_GRAPHIC_INSERTED 0x00000040 |
| |
| using namespace ::svx; |
| using ::rtl::OUString; |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::datatransfer; |
| using namespace nsTransferBufferType; |
| |
| #define DDE_TXT_ENCODING gsl_getSystemTextEncoding() |
| |
| class SwTrnsfrDdeLink : public ::sfx2::SvBaseLink |
| { |
| String sName; |
| ::sfx2::SvLinkSourceRef refObj; |
| SwTransferable& rTrnsfr; |
| SwDocShell* pDocShell; |
| sal_uLong nOldTimeOut; |
| sal_Bool bDelBookmrk : 1; |
| sal_Bool bInDisconnect : 1; |
| |
| sal_Bool FindDocShell(); |
| |
| using sfx2::SvBaseLink::Disconnect; |
| |
| protected: |
| virtual ~SwTrnsfrDdeLink(); |
| |
| public: |
| SwTrnsfrDdeLink( SwTransferable& rTrans, SwWrtShell& rSh ); |
| |
| virtual void DataChanged( const String& rMimeType, |
| const uno::Any & rValue ); |
| virtual void Closed(); |
| |
| sal_Bool WriteData( SvStream& rStrm ); |
| |
| void Disconnect( sal_Bool bRemoveDataAdvise ); |
| }; |
| |
| // helper class for Action and Undo enclosing |
| class SwTrnsfrActionAndUndo |
| { |
| SwWrtShell *pSh; |
| SwUndoId eUndoId; |
| public: |
| SwTrnsfrActionAndUndo( SwWrtShell *pS, SwUndoId nId, |
| const SwRewriter * pRewriter = 0, |
| sal_Bool bDelSel = sal_False) |
| : pSh( pS ), eUndoId( nId ) |
| { |
| pSh->StartUndo( eUndoId, pRewriter ); |
| if( bDelSel ) |
| pSh->DelRight(); |
| pSh->StartAllAction(); |
| } |
| ~SwTrnsfrActionAndUndo() |
| { |
| pSh->EndUndo(); |
| pSh->EndAllAction(); |
| } |
| }; |
| |
| |
| // ----------------------------------------------------------------------- |
| |
| SwTransferable::SwTransferable( SwWrtShell& rSh ) |
| : pWrtShell( &rSh ), |
| pCreatorView( 0 ), |
| pClpDocFac( 0 ), |
| pClpGraphic( 0 ), |
| pClpBitmap( 0 ), |
| pOrigGrf( 0 ), |
| pBkmk( 0 ), |
| pImageMap( 0 ), |
| pTargetURL( 0 ), |
| eBufferType( TRNSFR_NONE ) |
| { |
| rSh.GetView().AddTransferable(*this); |
| SwDocShell* pDShell = rSh.GetDoc()->GetDocShell(); |
| if( pDShell ) |
| { |
| pDShell->FillTransferableObjectDescriptor( aObjDesc ); |
| if( pDShell->GetMedium() ) |
| { |
| const INetURLObject& rURLObj = pDShell->GetMedium()->GetURLObject(); |
| aObjDesc.maDisplayName = URIHelper::removePassword( |
| rURLObj.GetMainURL( INetURLObject::NO_DECODE ), |
| INetURLObject::WAS_ENCODED, |
| INetURLObject::DECODE_UNAMBIGUOUS ); |
| } |
| |
| PrepareOLE( aObjDesc ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| SwTransferable::~SwTransferable() |
| { |
| Application::GetSolarMutex().acquire(); |
| |
| // der DDELink braucht noch die WrtShell! |
| if( refDdeLink.Is() ) |
| { |
| ((SwTrnsfrDdeLink*)&refDdeLink)->Disconnect( sal_True ); |
| refDdeLink.Clear(); |
| } |
| |
| pWrtShell = 0; |
| |
| // dvo 2002-05-30, #99239#: release reference to the document so that |
| // aDocShellRef will delete it (if aDocShellRef is set). Otherwise, the OLE |
| // nodes keep references to their sub-storage when the storage is already |
| // dead. |
| delete pClpDocFac; |
| |
| //JP 22.04.95: erst schliessen, dann kann die Ref. auch gecleared werden, |
| // so das die DocShell auch tatsaechlich geloescht wird! |
| if( aDocShellRef.Is() ) |
| { |
| SfxObjectShell * pObj = aDocShellRef; |
| SwDocShell* pDocSh = (SwDocShell*)pObj; |
| pDocSh->DoClose(); |
| } |
| aDocShellRef.Clear(); |
| |
| SwModule* pMod = SW_MOD(); |
| if(pMod) |
| { |
| if ( pMod->pDragDrop == this ) |
| pMod->pDragDrop = 0; |
| else if ( pMod->pXSelection == this ) |
| pMod->pXSelection = 0; |
| } |
| |
| delete pClpGraphic; |
| delete pClpBitmap; |
| delete pImageMap; |
| delete pTargetURL; |
| delete pBkmk; |
| |
| |
| eBufferType = TRNSFR_NONE; |
| |
| Application::GetSolarMutex().release(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static SwDoc * lcl_GetDoc(SwDocFac & rDocFac) |
| { |
| SwDoc *const pDoc = rDocFac.GetDoc(); |
| ASSERT( pDoc, "Document not found" ); |
| if (pDoc) |
| { |
| pDoc->SetClipBoard( true ); |
| } |
| return pDoc; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SwTransferable::ObjectReleased() |
| { |
| SwModule *pMod = SW_MOD(); |
| if( this == pMod->pDragDrop ) |
| pMod->pDragDrop = 0; |
| else if( this == pMod->pXSelection ) |
| pMod->pXSelection = 0; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SwTransferable::AddSupportedFormats() |
| { |
| // only need if we are the current XSelection Object |
| SwModule *pMod = SW_MOD(); |
| if( this == pMod->pXSelection ) |
| { |
| SetDataForDragAndDrop( Point( 0,0) ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SwTransferable::InitOle( SfxObjectShell* pDoc, SwDoc& rDoc ) |
| { |
| //OleVisArea einstellen. Linke obere Ecke der Seite und Groesse |
| //der RealSize in Twips. |
| const Size aSz( OLESIZE ); |
| SwRect aVis( Point( DOCUMENTBORDER, DOCUMENTBORDER ), aSz ); |
| pDoc->SetVisArea( aVis.SVRect() ); |
| rDoc.set(IDocumentSettingAccess::BROWSE_MODE, true ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| uno::Reference < embed::XEmbeddedObject > SwTransferable::FindOLEObj( sal_Int64& nAspect ) const |
| { |
| uno::Reference < embed::XEmbeddedObject > xObj; |
| if( pClpDocFac ) |
| { |
| SwIterator<SwCntntNode,SwFmtColl> aIter( *pClpDocFac->GetDoc()->GetDfltGrfFmtColl() ); |
| for( SwCntntNode* pNd = aIter.First(); pNd; pNd = aIter.Next() ) |
| if( ND_OLENODE == pNd->GetNodeType() ) |
| { |
| xObj = ((SwOLENode*)pNd)->GetOLEObj().GetOleRef(); |
| nAspect = ((SwOLENode*)pNd)->GetAspect(); |
| break; |
| } |
| } |
| return xObj; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| Graphic* SwTransferable::FindOLEReplacementGraphic() const |
| { |
| if( pClpDocFac ) |
| { |
| SwIterator<SwCntntNode,SwFmtColl> aIter( *pClpDocFac->GetDoc()->GetDfltGrfFmtColl() ); |
| for( SwCntntNode* pNd = aIter.First(); pNd; pNd = aIter.Next() ) |
| if( ND_OLENODE == pNd->GetNodeType() ) |
| { |
| return ((SwOLENode*)pNd)->GetGraphic(); |
| } |
| } |
| |
| return NULL; |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| |
| void SwTransferable::RemoveDDELinkFormat( const Window& rWin ) |
| { |
| RemoveFormat( SOT_FORMATSTR_ID_LINK ); |
| CopyToClipboard( (Window*)&rWin ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool SwTransferable::GetData( const DATA_FLAVOR& rFlavor ) |
| { |
| sal_uInt32 nFormat = SotExchange::GetFormat( rFlavor ); |
| |
| // we can only fullfil the request if |
| // 1) we have data for this format |
| // 2) we have either a clipboard document (pClpDocFac), or |
| // we have a SwWrtShell (so we can generate a new clipboard document) |
| if( !HasFormat( nFormat ) || ( pClpDocFac == NULL && pWrtShell == NULL ) ) |
| return sal_False; |
| |
| if( !pClpDocFac ) |
| { |
| SelectionType nSelectionType = pWrtShell->GetSelectionType(); |
| |
| // when pending we will not get the correct type, but nsSelectionType::SEL_TXT |
| // as fallback. This *happens* durning D&D, so we need to check if we are in |
| // the fallback and just try to get a graphic |
| const bool bPending(pWrtShell->BasicActionPend()); |
| |
| // SEL_GRF kommt vom ContentType der editsh |
| if(bPending || ((nsSelectionType::SEL_GRF | nsSelectionType::SEL_DRW_FORM) & nSelectionType)) |
| { |
| pClpGraphic = new Graphic; |
| if( !pWrtShell->GetDrawObjGraphic( FORMAT_GDIMETAFILE, *pClpGraphic )) |
| pOrigGrf = pClpGraphic; |
| pClpBitmap = new Graphic; |
| if( !pWrtShell->GetDrawObjGraphic( FORMAT_BITMAP, *pClpBitmap )) |
| pOrigGrf = pClpBitmap; |
| |
| // ist es ein URL-Button ? |
| String sURL, sDesc; |
| if( pWrtShell->GetURLFromButton( sURL, sDesc ) ) |
| { |
| pBkmk = new INetBookmark( sURL, sDesc ); |
| eBufferType = TRNSFR_INETFLD; |
| } |
| } |
| |
| pClpDocFac = new SwDocFac; |
| SwDoc *const pTmpDoc = lcl_GetDoc(*pClpDocFac); |
| |
| pTmpDoc->LockExpFlds(); // nie die Felder updaten - Text so belassen |
| pWrtShell->Copy( pTmpDoc ); |
| |
| // es wurde in der CORE eine neu angelegt (OLE-Objekte kopiert!) |
| aDocShellRef = pTmpDoc->GetTmpDocShell(); |
| if( aDocShellRef.Is() ) |
| SwTransferable::InitOle( aDocShellRef, *pTmpDoc ); |
| pTmpDoc->SetTmpDocShell( (SfxObjectShell*)NULL ); |
| |
| if( nSelectionType & nsSelectionType::SEL_TXT && !pWrtShell->HasMark() ) |
| { |
| SwContentAtPos aCntntAtPos( SwContentAtPos::SW_INETATTR ); |
| |
| Point aPos( SwEditWin::GetDDStartPosX(), SwEditWin::GetDDStartPosY()); |
| |
| sal_Bool bSelect = bExecuteDrag && |
| pWrtShell->GetView().GetDocShell() && |
| !pWrtShell->GetView().GetDocShell()->IsReadOnly(); |
| if( pWrtShell->GetContentAtPos( aPos, aCntntAtPos, bSelect ) ) |
| { |
| pBkmk = new INetBookmark( |
| ((SwFmtINetFmt*)aCntntAtPos.aFnd.pAttr)->GetValue(), |
| aCntntAtPos.sStr ); |
| eBufferType = TRNSFR_INETFLD; |
| if( bSelect ) |
| pWrtShell->SelectTxtAttr( RES_TXTATR_INETFMT ); |
| } |
| } |
| if( pWrtShell->IsFrmSelected() ) |
| { |
| SfxItemSet aSet( pWrtShell->GetAttrPool(), RES_URL, RES_URL ); |
| pWrtShell->GetFlyFrmAttr( aSet ); |
| const SwFmtURL& rURL = (SwFmtURL&)aSet.Get( RES_URL ); |
| if( rURL.GetMap() ) |
| pImageMap = new ImageMap( *rURL.GetMap() ); |
| else if( rURL.GetURL().Len() ) |
| pTargetURL = new INetImage( aEmptyStr, rURL.GetURL(), |
| rURL.GetTargetFrameName(), |
| aEmptyStr, Size() ); |
| } |
| } |
| |
| sal_Bool bOK = sal_False; |
| if( TRNSFR_OLE == eBufferType ) |
| { |
| //TODO/MBA: testing - is this the "single OLE object" case?! |
| // aus dem ClipDoc das OLE-Object besorgen und von dem die Daten |
| // besorgen. |
| sal_Int64 nAspect = embed::Aspects::MSOLE_CONTENT; // will be set in the next statement |
| uno::Reference < embed::XEmbeddedObject > xObj = FindOLEObj( nAspect ); |
| Graphic* pOLEGraph = FindOLEReplacementGraphic(); |
| if( xObj.is() ) |
| { |
| TransferableDataHelper aD( new SvEmbedTransferHelper( xObj, pOLEGraph, nAspect ) ); |
| uno::Any aAny( aD.GetAny( rFlavor )); |
| if( aAny.hasValue() ) |
| bOK = SetAny( aAny, rFlavor ); |
| } |
| |
| // the following solution will be used in the case when the object can not generate the image |
| // TODO/LATER: in future the transferhelper must probably be created based on object and the replacement stream |
| if ( nFormat == SOT_FORMAT_GDIMETAFILE ) |
| { |
| pOLEGraph = FindOLEReplacementGraphic(); |
| if ( pOLEGraph ) |
| bOK = SetGDIMetaFile( pOLEGraph->GetGDIMetaFile(), rFlavor ); |
| } |
| } |
| else |
| { |
| switch( nFormat ) |
| { |
| case SOT_FORMATSTR_ID_LINK: |
| if( refDdeLink.Is() ) |
| bOK = SetObject( &refDdeLink, |
| SWTRANSFER_OBJECTTYPE_DDE, rFlavor ); |
| break; |
| |
| case SOT_FORMATSTR_ID_OBJECTDESCRIPTOR: |
| case SOT_FORMATSTR_ID_LINKSRCDESCRIPTOR: |
| bOK = SetTransferableObjectDescriptor( aObjDesc, rFlavor ); |
| break; |
| |
| case SOT_FORMATSTR_ID_DRAWING: |
| { |
| SwDoc *const pDoc = lcl_GetDoc(*pClpDocFac); |
| bOK = SetObject( pDoc->GetDrawModel(), |
| SWTRANSFER_OBJECTTYPE_DRAWMODEL, rFlavor ); |
| } |
| break; |
| |
| case SOT_FORMAT_STRING: |
| { |
| SwDoc *const pDoc = lcl_GetDoc(*pClpDocFac); |
| bOK = SetObject( pDoc, SWTRANSFER_OBJECTTYPE_STRING, rFlavor ); |
| } |
| break; |
| case SOT_FORMAT_RTF: |
| { |
| SwDoc *const pDoc = lcl_GetDoc(*pClpDocFac); |
| bOK = SetObject( pDoc, SWTRANSFER_OBJECTTYPE_RTF, rFlavor ); |
| } |
| break; |
| |
| case SOT_FORMATSTR_ID_HTML: |
| { |
| SwDoc *const pDoc = lcl_GetDoc(*pClpDocFac); |
| bOK = SetObject( pDoc, SWTRANSFER_OBJECTTYPE_HTML, rFlavor ); |
| } |
| break; |
| |
| case SOT_FORMATSTR_ID_SVXB: |
| if( eBufferType & TRNSFR_GRAPHIC && pOrigGrf ) |
| bOK = SetGraphic( *pOrigGrf, rFlavor ); |
| break; |
| |
| case SOT_FORMAT_GDIMETAFILE: |
| if( eBufferType & TRNSFR_GRAPHIC ) |
| bOK = SetGDIMetaFile( pClpGraphic->GetGDIMetaFile(), rFlavor ); |
| break; |
| case SOT_FORMAT_BITMAP: |
| case SOT_FORMATSTR_ID_PNG: |
| // #126398# Neither pClpBitmap nor pClpGraphic are necessarily set |
| if( (eBufferType & TRNSFR_GRAPHIC) && (pClpBitmap != 0 || pClpGraphic != 0)) |
| bOK = SetBitmapEx( (pClpBitmap ? pClpBitmap : pClpGraphic)->GetBitmapEx(), rFlavor ); |
| break; |
| |
| case SOT_FORMATSTR_ID_SVIM: |
| if( pImageMap ) |
| bOK = SetImageMap( *pImageMap, rFlavor ); |
| break; |
| |
| case SOT_FORMATSTR_ID_INET_IMAGE: |
| if( pTargetURL ) |
| bOK = SetINetImage( *pTargetURL, rFlavor ); |
| break; |
| |
| case SOT_FORMATSTR_ID_SOLK: |
| case SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK: |
| case SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR: |
| case SOT_FORMATSTR_ID_FILECONTENT: |
| case SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR: |
| case SOT_FORMAT_FILE: |
| if( (TRNSFR_INETFLD & eBufferType) && pBkmk ) |
| bOK = SetINetBookmark( *pBkmk, rFlavor ); |
| break; |
| |
| case SOT_FORMATSTR_ID_EMBED_SOURCE: |
| // default: |
| if( !aDocShellRef.Is() ) |
| { |
| SwDoc *const pDoc = lcl_GetDoc(*pClpDocFac); |
| SwDocShell* pNewDocSh = new SwDocShell( pDoc, |
| SFX_CREATE_MODE_EMBEDDED ); |
| aDocShellRef = pNewDocSh; |
| aDocShellRef->DoInitNew( NULL ); |
| SwTransferable::InitOle( aDocShellRef, *pDoc ); |
| } |
| bOK = SetObject( &aDocShellRef, SWTRANSFER_OBJECTTYPE_SWOLE, |
| rFlavor ); |
| break; |
| } |
| } |
| return bOK; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool SwTransferable::WriteObject( SotStorageStreamRef& xStream, |
| void* pObject, sal_uInt32 nObjectType, |
| const DATA_FLAVOR& /*rFlavor*/ ) |
| { |
| sal_Bool bRet = sal_False; |
| WriterRef xWrt; |
| |
| switch( nObjectType ) |
| { |
| case SWTRANSFER_OBJECTTYPE_DRAWMODEL: |
| { |
| //JP 28.02.2001: dont change the sequence of commands - Bug 8 |
| SdrModel *pModel = (SdrModel*)pObject; |
| xStream->SetBufferSize( 16348 ); |
| |
| // #108584# |
| // for the changed pool defaults from drawing layer pool set those |
| // attributes as hard attributes to preserve them for saving |
| const SfxItemPool& rItemPool = pModel->GetItemPool(); |
| const SvxFontHeightItem& rDefaultFontHeight = (const SvxFontHeightItem&)rItemPool.GetDefaultItem(EE_CHAR_FONTHEIGHT); |
| |
| // SW should have no MasterPages |
| DBG_ASSERT(0L == pModel->GetMasterPageCount(), "SW with MasterPages (!)"); |
| |
| for(sal_uInt16 a(0); a < pModel->GetPageCount(); a++) |
| { |
| const SdrPage* pPage = pModel->GetPage(a); |
| SdrObjListIter aIter(*pPage, IM_DEEPNOGROUPS); |
| |
| while(aIter.IsMore()) |
| { |
| SdrObject* pObj = aIter.Next(); |
| const SvxFontHeightItem& rItem = (const SvxFontHeightItem&)pObj->GetMergedItem(EE_CHAR_FONTHEIGHT); |
| |
| if(rItem.GetHeight() == rDefaultFontHeight.GetHeight()) |
| { |
| pObj->SetMergedItem(rDefaultFontHeight); |
| } |
| } |
| } |
| |
| { |
| uno::Reference<io::XOutputStream> xDocOut( new utl::OOutputStreamWrapper( *xStream ) ); |
| if( SvxDrawingLayerExport( pModel, xDocOut ) ) |
| xStream->Commit(); |
| } |
| |
| bRet = ERRCODE_NONE == xStream->GetError(); |
| } |
| break; |
| |
| case SWTRANSFER_OBJECTTYPE_SWOLE: |
| { |
| SfxObjectShell* pEmbObj = (SfxObjectShell*) pObject; |
| try |
| { |
| ::utl::TempFile aTempFile; |
| aTempFile.EnableKillingFile(); |
| 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 BaseURL 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 ) |
| { |
| xStream->SetBufferSize( 0xff00 ); |
| *xStream << *pSrcStm; |
| delete pSrcStm; |
| } |
| |
| bRet = sal_True; |
| |
| xWorkStore->dispose(); |
| xWorkStore = uno::Reference < embed::XStorage >(); |
| xStream->Commit(); |
| } |
| catch ( uno::Exception& ) |
| {} |
| |
| bRet = ( xStream->GetError() == ERRCODE_NONE ); |
| } |
| break; |
| |
| |
| case SWTRANSFER_OBJECTTYPE_DDE: |
| { |
| xStream->SetBufferSize( 1024 ); |
| SwTrnsfrDdeLink* pDdeLnk = (SwTrnsfrDdeLink*)pObject; |
| if( pDdeLnk->WriteData( *xStream ) ) |
| { |
| xStream->Commit(); |
| bRet = ERRCODE_NONE == xStream->GetError(); |
| } |
| } |
| break; |
| |
| case SWTRANSFER_OBJECTTYPE_HTML: |
| GetHTMLWriter( aEmptyStr, String(), xWrt ); |
| break; |
| |
| case SWTRANSFER_OBJECTTYPE_RTF: |
| GetRTFWriter( aEmptyStr, String(), xWrt ); |
| break; |
| |
| case SWTRANSFER_OBJECTTYPE_STRING: |
| GetASCWriter( aEmptyStr, String(), xWrt ); |
| if( xWrt.Is() ) |
| { |
| SwAsciiOptions aAOpt; |
| aAOpt.SetCharSet( RTL_TEXTENCODING_UTF8 ); |
| xWrt->SetAsciiOptions( aAOpt ); |
| |
| // #102841# no start char for clipboard |
| xWrt->bUCS2_WithStartChar = sal_False; |
| } |
| break; |
| } |
| |
| if( xWrt.Is() ) |
| { |
| SwDoc* pDoc = (SwDoc*)pObject; |
| xWrt->bWriteClipboardDoc = sal_True; |
| xWrt->bWriteOnlyFirstTable = 0 != (TRNSFR_TABELLE & eBufferType); |
| xWrt->SetShowProgress( sal_False ); |
| SwWriter aWrt( *xStream, *pDoc ); |
| if( !IsError( aWrt.Write( xWrt )) ) |
| { |
| *xStream << '\0'; // terminate with a zero |
| xStream->Commit(); |
| bRet = sal_True; |
| } |
| } |
| |
| return bRet; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::Cut() |
| { |
| int nRet = Copy( sal_True ); |
| if( nRet ) |
| DeleteSelection(); |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SwTransferable::DeleteSelection() |
| { |
| if(!pWrtShell) |
| return; |
| // Selektionsart vor Action-Klammerung erfragen |
| const int nSelection = pWrtShell->GetSelectionType(); |
| pWrtShell->StartUndo( UNDO_DELETE ); |
| if( ( nsSelectionType::SEL_TXT | nsSelectionType::SEL_TBL ) & nSelection ) |
| pWrtShell->IntelligentCut( nSelection ); |
| pWrtShell->DelRight(); |
| pWrtShell->EndUndo( UNDO_DELETE ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::PrepareForCopy( sal_Bool bIsCut ) |
| { |
| int nRet = 1; |
| if(!pWrtShell) |
| return 0;; |
| |
| String sGrfNm; |
| const int nSelection = pWrtShell->GetSelectionType(); |
| if( nSelection == nsSelectionType::SEL_GRF ) |
| { |
| pClpGraphic = new Graphic; |
| if( !pWrtShell->GetDrawObjGraphic( FORMAT_GDIMETAFILE, *pClpGraphic )) |
| pOrigGrf = pClpGraphic; |
| pClpBitmap = new Graphic; |
| if( !pWrtShell->GetDrawObjGraphic( FORMAT_BITMAP, *pClpBitmap )) |
| pOrigGrf = pClpBitmap; |
| |
| pClpDocFac = new SwDocFac; |
| SwDoc *const pDoc = lcl_GetDoc(*pClpDocFac); |
| pWrtShell->Copy( pDoc ); |
| |
| if (pOrigGrf && !pOrigGrf->GetBitmap().IsEmpty()) |
| AddFormat( SOT_FORMATSTR_ID_SVXB ); |
| |
| PrepareOLE( aObjDesc ); |
| AddFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ); |
| |
| // --> OD 2005-02-09 #119353# - robust |
| const Graphic* pGrf = pWrtShell->GetGraphic(); |
| if( pGrf && pGrf->IsSupportedGraphic() ) |
| // <-- |
| { |
| AddFormat( FORMAT_GDIMETAFILE ); |
| AddFormat( SOT_FORMATSTR_ID_PNG ); |
| AddFormat( FORMAT_BITMAP ); |
| } |
| eBufferType = TRNSFR_GRAPHIC; |
| pWrtShell->GetGrfNms( &sGrfNm, 0 ); |
| } |
| else if ( nSelection == nsSelectionType::SEL_OLE ) |
| { |
| pClpDocFac = new SwDocFac; |
| SwDoc *const pDoc = lcl_GetDoc(*pClpDocFac); |
| aDocShellRef = new SwDocShell( pDoc, SFX_CREATE_MODE_EMBEDDED); |
| aDocShellRef->DoInitNew( NULL ); |
| pWrtShell->Copy( pDoc ); |
| |
| AddFormat( SOT_FORMATSTR_ID_EMBED_SOURCE ); |
| |
| // --> OD #i98753# |
| // set size of embedded object at the object description structure |
| aObjDesc.maSize = OutputDevice::LogicToLogic( pWrtShell->GetObjSize(), MAP_TWIP, MAP_100TH_MM ); |
| // <-- |
| PrepareOLE( aObjDesc ); |
| AddFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ); |
| |
| AddFormat( FORMAT_GDIMETAFILE ); |
| eBufferType = TRNSFR_OLE; |
| } |
| //Gibt es ueberhaupt etwas zum bereitstellen? |
| else if ( pWrtShell->IsSelection() || pWrtShell->IsFrmSelected() || |
| pWrtShell->IsObjSelected() ) |
| { |
| SwWait *pWait = 0; |
| if( pWrtShell->ShouldWait() ) |
| pWait = new SwWait( *pWrtShell->GetView().GetDocShell(), true ); |
| |
| pClpDocFac = new SwDocFac; |
| |
| // zusaetzlichen Cursor erzeugen, damit eine Gleichbehandlung |
| // von Tastatur- und Mausselektion moeglich ist. |
| // Im AddMode wird bei Tastaturselektion der neue Cursor erst |
| // beim Bewegen des Cursors nach Selektionsende erzeugt. |
| if( pWrtShell->IsAddMode() && pWrtShell->SwCrsrShell::HasSelection() ) |
| pWrtShell->CreateCrsr(); |
| |
| SwDoc *const pTmpDoc = lcl_GetDoc(*pClpDocFac); |
| |
| pTmpDoc->LockExpFlds(); // nie die Felder updaten - Text so belassen |
| pWrtShell->Copy( pTmpDoc ); |
| |
| { |
| IDocumentMarkAccess* const pMarkAccess = pTmpDoc->getIDocumentMarkAccess(); |
| ::std::vector< ::sw::mark::IMark* > vDdeMarks; |
| // find all DDE-Bookmarks |
| for(IDocumentMarkAccess::const_iterator_t ppMark = pMarkAccess->getAllMarksBegin(); |
| ppMark != pMarkAccess->getAllMarksEnd(); |
| ppMark++) |
| { |
| if(IDocumentMarkAccess::DDE_BOOKMARK == IDocumentMarkAccess::GetType(**ppMark)) |
| vDdeMarks.push_back(ppMark->get()); |
| } |
| // remove all DDE-Bookmarks, they are invalid inside the clipdoc! |
| for(::std::vector< ::sw::mark::IMark* >::iterator ppMark = vDdeMarks.begin(); |
| ppMark != vDdeMarks.end(); |
| ppMark++) |
| pMarkAccess->deleteMark(*ppMark); |
| } |
| |
| // es wurde in der CORE eine neu angelegt (OLE-Objekte kopiert!) |
| aDocShellRef = pTmpDoc->GetTmpDocShell(); |
| if( aDocShellRef.Is() ) |
| SwTransferable::InitOle( aDocShellRef, *pTmpDoc ); |
| pTmpDoc->SetTmpDocShell( (SfxObjectShell*)NULL ); |
| |
| if( pWrtShell->IsObjSelected() ) |
| eBufferType = TRNSFR_DRAWING; |
| else |
| { |
| eBufferType = TRNSFR_DOCUMENT; |
| if (pWrtShell->IntelligentCut(nSelection, sal_False) != SwWrtShell::NO_WORD) |
| eBufferType = (TransferBufferType)(TRNSFR_DOCUMENT_WORD | eBufferType); |
| } |
| |
| int bDDELink = pWrtShell->IsSelection(); |
| if( nSelection & nsSelectionType::SEL_TBL_CELLS ) |
| { |
| eBufferType = (TransferBufferType)(TRNSFR_TABELLE | eBufferType); |
| bDDELink = pWrtShell->HasWholeTabSelection(); |
| } |
| |
| //Wenn's einer braucht OLE'n wir ihm was. |
| AddFormat( SOT_FORMATSTR_ID_EMBED_SOURCE ); |
| |
| //RTF vor das Metafile von OLE stellen, weil mit weniger verlusten |
| //behaftet. |
| if( !pWrtShell->IsObjSelected() ) |
| { |
| AddFormat( FORMAT_RTF ); |
| AddFormat( SOT_FORMATSTR_ID_HTML ); |
| } |
| if( pWrtShell->IsSelection() ) |
| AddFormat( FORMAT_STRING ); |
| |
| if( nSelection & ( nsSelectionType::SEL_DRW | nsSelectionType::SEL_DRW_FORM )) |
| { |
| AddFormat( SOT_FORMATSTR_ID_DRAWING ); |
| if ( nSelection & nsSelectionType::SEL_DRW ) |
| { |
| AddFormat( FORMAT_GDIMETAFILE ); |
| AddFormat( SOT_FORMATSTR_ID_PNG ); |
| AddFormat( FORMAT_BITMAP ); |
| } |
| eBufferType = (TransferBufferType)( TRNSFR_GRAPHIC | eBufferType ); |
| |
| pClpGraphic = new Graphic; |
| if( !pWrtShell->GetDrawObjGraphic( FORMAT_GDIMETAFILE, *pClpGraphic )) |
| pOrigGrf = pClpGraphic; |
| pClpBitmap = new Graphic; |
| if( !pWrtShell->GetDrawObjGraphic( FORMAT_BITMAP, *pClpBitmap )) |
| pOrigGrf = pClpBitmap; |
| |
| // ist es ein URL-Button ? |
| String sURL, sDesc; |
| if( pWrtShell->GetURLFromButton( sURL, sDesc ) ) |
| { |
| AddFormat( FORMAT_STRING ); |
| AddFormat( SOT_FORMATSTR_ID_SOLK ); |
| AddFormat( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK ); |
| AddFormat( SOT_FORMATSTR_ID_FILECONTENT ); |
| AddFormat( SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR ); |
| AddFormat( SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR ); |
| eBufferType = (TransferBufferType)( TRNSFR_INETFLD | eBufferType ); |
| nRet = sal_True; |
| } |
| } |
| |
| // beim Cut hat DDE-Link keinen Sinn!! |
| SwDocShell* pDShell; |
| if( !bIsCut && bDDELink && |
| 0 != ( pDShell = pWrtShell->GetDoc()->GetDocShell()) && |
| SFX_CREATE_MODE_STANDARD == pDShell->GetCreateMode() ) |
| { |
| AddFormat( SOT_FORMATSTR_ID_LINK ); |
| refDdeLink = new SwTrnsfrDdeLink( *this, *pWrtShell ); |
| } |
| |
| //ObjectDescriptor wurde bereits aus der alten DocShell gefuellt. |
| //Jetzt noch anpassen. Dadurch kann im GetData die erste Anfrage |
| //auch noch mit delayed rendering beantwortet werden. |
| aObjDesc.mbCanLink = sal_False; |
| Size aSz( OLESIZE ); |
| aObjDesc.maSize = OutputDevice::LogicToLogic( aSz, MAP_TWIP, MAP_100TH_MM ); |
| |
| PrepareOLE( aObjDesc ); |
| AddFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ); |
| |
| delete pWait; |
| } |
| else |
| nRet = 0; |
| |
| if( pWrtShell->IsFrmSelected() ) |
| { |
| SfxItemSet aSet( pWrtShell->GetAttrPool(), RES_URL, RES_URL ); |
| pWrtShell->GetFlyFrmAttr( aSet ); |
| const SwFmtURL& rURL = (SwFmtURL&)aSet.Get( RES_URL ); |
| if( rURL.GetMap() ) |
| { |
| pImageMap = new ImageMap( *rURL.GetMap() ); |
| AddFormat( SOT_FORMATSTR_ID_SVIM ); |
| } |
| else if( rURL.GetURL().Len() ) |
| { |
| pTargetURL = new INetImage( sGrfNm, rURL.GetURL(), |
| rURL.GetTargetFrameName(), |
| aEmptyStr, Size() ); |
| AddFormat( SOT_FORMATSTR_ID_INET_IMAGE ); |
| } |
| } |
| |
| return nRet; |
| } |
| |
| int SwTransferable::Copy( sal_Bool bIsCut ) |
| { |
| int nRet = PrepareForCopy( bIsCut ); |
| if ( nRet ) |
| { |
| CopyToClipboard( &pWrtShell->GetView().GetEditWin() ); |
| } |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::CalculateAndCopy() |
| { |
| if(!pWrtShell) |
| return 0; |
| SwWait aWait( *pWrtShell->GetView().GetDocShell(), true ); |
| |
| String aStr( pWrtShell->Calculate() ); |
| |
| pClpDocFac = new SwDocFac; |
| SwDoc *const pDoc = lcl_GetDoc(*pClpDocFac); |
| pWrtShell->Copy(pDoc, & aStr); |
| eBufferType = TRNSFR_DOCUMENT; |
| AddFormat( FORMAT_STRING ); |
| |
| CopyToClipboard( &pWrtShell->GetView().GetEditWin() ); |
| |
| return 1; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::CopyGlossary( SwTextBlocks& rGlossary, |
| const String& rStr ) |
| { |
| if(!pWrtShell) |
| return 0; |
| SwWait aWait( *pWrtShell->GetView().GetDocShell(), true ); |
| |
| pClpDocFac = new SwDocFac; |
| SwDoc *const pCDoc = lcl_GetDoc(*pClpDocFac); |
| |
| SwNodes& rNds = pCDoc->GetNodes(); |
| SwNodeIndex aNodeIdx( *rNds.GetEndOfContent().StartOfSectionNode() ); |
| SwCntntNode* pCNd = rNds.GoNext( &aNodeIdx ); // gehe zum 1. ContentNode |
| SwPaM aPam( *pCNd ); |
| |
| pCDoc->LockExpFlds(); // nie die Felder updaten - Text so belassen |
| |
| pCDoc->InsertGlossary( rGlossary, rStr, aPam, 0 ); |
| |
| // es wurde in der CORE eine neu angelegt (OLE-Objekte kopiert!) |
| aDocShellRef = pCDoc->GetTmpDocShell(); |
| if( aDocShellRef.Is() ) |
| SwTransferable::InitOle( aDocShellRef, *pCDoc ); |
| pCDoc->SetTmpDocShell( (SfxObjectShell*)NULL ); |
| |
| eBufferType = TRNSFR_DOCUMENT; |
| |
| //Wenn's einer braucht OLE'n wir ihm was. |
| AddFormat( SOT_FORMATSTR_ID_EMBED_SOURCE ); |
| AddFormat( FORMAT_RTF ); |
| AddFormat( SOT_FORMATSTR_ID_HTML ); |
| AddFormat( FORMAT_STRING ); |
| |
| //ObjectDescriptor wurde bereits aus der alten DocShell gefuellt. |
| //Jetzt noch anpassen. Dadurch kann im GetData die erste Anfrage |
| //auch noch mit delayed rendering beantwortet werden. |
| aObjDesc.mbCanLink = sal_False; |
| Size aSz( OLESIZE ); |
| aObjDesc.maSize = OutputDevice::LogicToLogic( aSz, MAP_TWIP, MAP_100TH_MM ); |
| |
| PrepareOLE( aObjDesc ); |
| AddFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ); |
| |
| CopyToClipboard( &pWrtShell->GetView().GetEditWin() ); |
| |
| return 1; |
| } |
| |
| static inline uno::Reference < XTransferable > * lcl_getTransferPointer ( uno::Reference < XTransferable > &xRef ) |
| { |
| return &xRef; |
| } |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool SwTransferable::IsPaste( const SwWrtShell& rSh, |
| const TransferableDataHelper& rData ) |
| { |
| // Check the common case first: We can always paste our own data! |
| // #106503#: If _only_ the internal format can be pasted, this check will |
| // yield 'true', while the one below would give a (wrong) result 'false'. |
| |
| bool bIsPaste = ( GetSwTransferable( rData ) != NULL ); |
| |
| // if it's not our own data, we need to have a closer look: |
| if( ! bIsPaste ) |
| { |
| // determine the proper paste action, and return true if we find one |
| uno::Reference<XTransferable> xTransferable( rData.GetXTransferable() ); |
| |
| sal_uInt16 nDestination = SwTransferable::GetSotDestination( rSh ); |
| sal_uInt16 nSourceOptions = |
| (( EXCHG_DEST_DOC_TEXTFRAME == nDestination || |
| EXCHG_DEST_SWDOC_FREE_AREA == nDestination || |
| EXCHG_DEST_DOC_TEXTFRAME_WEB == nDestination || |
| EXCHG_DEST_SWDOC_FREE_AREA_WEB == nDestination ) |
| ? EXCHG_IN_ACTION_COPY |
| : EXCHG_IN_ACTION_MOVE); |
| |
| sal_uLong nFormat; // output param for GetExchangeAction |
| sal_uInt16 nEventAction; // output param for GetExchangeAction |
| sal_uInt16 nAction = SotExchange::GetExchangeAction( |
| rData.GetDataFlavorExVector(), |
| nDestination, |
| nSourceOptions, /* ?? */ |
| EXCHG_IN_ACTION_DEFAULT, /* ?? */ |
| nFormat, nEventAction, 0, |
| lcl_getTransferPointer ( xTransferable ) ); |
| |
| // if we find a suitable action, we can paste! |
| bIsPaste = (EXCHG_INOUT_ACTION_NONE != nAction); |
| } |
| |
| return bIsPaste; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::Paste( SwWrtShell& rSh, TransferableDataHelper& rData ) |
| { |
| sal_uInt16 nEventAction, nAction=0, |
| nDestination = SwTransferable::GetSotDestination( rSh ); |
| sal_uLong nFormat = 0; |
| |
| if( GetSwTransferable( rData ) ) |
| { |
| nAction = EXCHG_OUT_ACTION_INSERT_PRIVATE; |
| } |
| else |
| { |
| sal_uInt16 nSourceOptions = |
| (( EXCHG_DEST_DOC_TEXTFRAME == nDestination || |
| EXCHG_DEST_SWDOC_FREE_AREA == nDestination || |
| EXCHG_DEST_DOC_TEXTFRAME_WEB == nDestination || |
| EXCHG_DEST_SWDOC_FREE_AREA_WEB == nDestination ) |
| ? EXCHG_IN_ACTION_COPY |
| : EXCHG_IN_ACTION_MOVE); |
| uno::Reference<XTransferable> xTransferable( rData.GetXTransferable() ); |
| nAction = SotExchange::GetExchangeAction( |
| rData.GetDataFlavorExVector(), |
| nDestination, |
| nSourceOptions, /* ?? */ |
| EXCHG_IN_ACTION_DEFAULT, /* ?? */ |
| nFormat, nEventAction, 0, |
| lcl_getTransferPointer ( xTransferable ) ); |
| } |
| |
| // special case for tables from draw application |
| if( EXCHG_OUT_ACTION_INSERT_DRAWOBJ == (nAction & EXCHG_ACTION_MASK) ) |
| { |
| if( rData.HasFormat( SOT_FORMAT_RTF ) ) |
| { |
| nAction = EXCHG_OUT_ACTION_INSERT_STRING | (nAction & !EXCHG_ACTION_MASK); |
| nFormat = SOT_FORMAT_RTF; |
| } |
| } |
| |
| return EXCHG_INOUT_ACTION_NONE != nAction && |
| SwTransferable::PasteData( rData, rSh, nAction, nFormat, |
| nDestination, sal_False, sal_False ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::PasteData( TransferableDataHelper& rData, |
| SwWrtShell& rSh, sal_uInt16 nAction, sal_uLong nFormat, |
| sal_uInt16 nDestination, sal_Bool bIsPasteFmt, |
| sal_Bool bIsDefault, |
| const Point* pPt, sal_Int8 nDropAction, |
| sal_Bool bPasteSelection ) |
| { |
| SwWait aWait( *rSh.GetView().GetDocShell(), false ); |
| SwTrnsfrActionAndUndo* pAction = 0; |
| SwModule* pMod = SW_MOD(); |
| |
| int nRet = 0; |
| bool bCallAutoCaption = false; |
| |
| if( pPt ) |
| { |
| // external Drop |
| if( bPasteSelection ? !pMod->pXSelection : !pMod->pDragDrop ) |
| { |
| switch( nDestination ) |
| { |
| case EXCHG_DEST_DOC_LNKD_GRAPH_W_IMAP: |
| case EXCHG_DEST_DOC_LNKD_GRAPHOBJ: |
| case EXCHG_DEST_DOC_GRAPH_W_IMAP: |
| case EXCHG_DEST_DOC_GRAPHOBJ: |
| case EXCHG_DEST_DOC_OLEOBJ: |
| case EXCHG_DEST_DOC_DRAWOBJ: |
| case EXCHG_DEST_DOC_URLBUTTON: |
| case EXCHG_DEST_DOC_GROUPOBJ: |
| // Rahmen/Objecte selektieren |
| SwTransferable::SetSelInShell( rSh, sal_True, pPt ); |
| break; |
| |
| // case EXCHG_DEST_DOC_TEXTFRAME: |
| // case EXCHG_DEST_SWDOC_FREE_AREA: |
| // case EXCHG_DEST_DOC_URLFIELD: |
| default: |
| SwTransferable::SetSelInShell( rSh, sal_False, pPt ); |
| break; |
| } |
| } |
| } |
| else if( ( !GetSwTransferable( rData ) || bIsPasteFmt ) && |
| !rSh.IsTableMode() && rSh.HasSelection() ) |
| { |
| // dann die Selektionen loeschen |
| |
| //Selektierten Inhalt loeschen, |
| // - nicht bei Tabellen-Selektion |
| // - nicht bei ReRead einer Grafik/DDEDaten |
| // - nicht bei D&D, fuer die richtige Selektion wurde im |
| // Drop-Handler gesorgt |
| sal_Bool bDelSel = sal_False; |
| switch( nDestination ) |
| { |
| case EXCHG_DEST_DOC_TEXTFRAME: |
| case EXCHG_DEST_SWDOC_FREE_AREA: |
| case EXCHG_DEST_DOC_TEXTFRAME_WEB: |
| case EXCHG_DEST_SWDOC_FREE_AREA_WEB: |
| bDelSel = sal_True; |
| break; |
| } |
| |
| if( bDelSel ) |
| // --> FME 2004-10-19 #i34830# |
| pAction = new SwTrnsfrActionAndUndo( &rSh, UNDO_PASTE_CLIPBOARD, NULL, |
| sal_True ); |
| // <-- |
| } |
| |
| SwTransferable *pTrans=0, *pTunneledTrans=GetSwTransferable( rData ); |
| // uno::Reference<XUnoTunnel> xTunnel( rData.GetTransferable(), UNO_QUERY ); |
| // if ( xTunnel.is() ) |
| // { |
| // sal_Int64 nHandle = xTunnel->getSomething( getUnoTunnelId() ); |
| // if ( nHandle ) |
| // pTunneledTrans = (SwTransferable*) (sal_IntPtr) nHandle; |
| // } |
| |
| // check for private drop |
| bool bPrivateDrop(pPt && (bPasteSelection ? 0 != (pTrans = pMod->pXSelection) : 0 != (pTrans = pMod->pDragDrop))); |
| bool bNeedToSelectBeforePaste(false); |
| |
| if(bPrivateDrop && DND_ACTION_LINK == nDropAction) |
| { |
| // internal drop on object, suppress bPrivateDrop to change internal fill |
| bPrivateDrop = false; |
| bNeedToSelectBeforePaste = true; |
| } |
| |
| if(bPrivateDrop && pPt && DND_ACTION_MOVE == nDropAction) |
| { |
| // check if dragged over a useful target. If yes, use as content exchange |
| // drop as if from external |
| const SwFrmFmt* pSwFrmFmt = rSh.GetFmtFromObj(*pPt); |
| |
| if(pSwFrmFmt && 0 != dynamic_cast< const SwDrawFrmFmt* >(pSwFrmFmt)) |
| { |
| bPrivateDrop = false; |
| bNeedToSelectBeforePaste = true; |
| } |
| } |
| |
| if(bPrivateDrop) |
| { |
| // then internal Drag & Drop or XSelection |
| nRet = pTrans->PrivateDrop( rSh, *pPt, DND_ACTION_MOVE == nDropAction, |
| bPasteSelection ); |
| } |
| else if( !pPt && pTunneledTrans && |
| EXCHG_OUT_ACTION_INSERT_PRIVATE == nAction ) |
| { |
| // then internal paste |
| nRet = pTunneledTrans->PrivatePaste( rSh ); |
| } |
| else if( EXCHG_INOUT_ACTION_NONE != nAction ) |
| { |
| if( !pAction ) |
| { |
| // #111827# |
| pAction = new SwTrnsfrActionAndUndo( &rSh, UNDO_PASTE_CLIPBOARD); |
| } |
| |
| // im Drag&Drop duerfen keine MessageBoxen angezeigt werden |
| sal_Bool bMsg = 0 == pPt; |
| sal_uInt8 nActionFlags = static_cast< sal_uInt8 >(( nAction >> 8 ) & 0xFF); |
| |
| sal_uInt16 nClearedAction = ( nAction & EXCHG_ACTION_MASK ); |
| // Selektionen loeschen |
| |
| switch( nClearedAction ) |
| { |
| case EXCHG_OUT_ACTION_INSERT_PRIVATE: |
| ASSERT( pPt, "EXCHG_OUT_ACTION_INSERT_PRIVATE: was soll hier passieren?" ); |
| break; |
| |
| case EXCHG_OUT_ACTION_MOVE_PRIVATE: |
| ASSERT( pPt, "EXCHG_OUT_ACTION_MOVE_PRIVATE: was soll hier passieren?" ); |
| break; |
| |
| |
| case EXCHG_IN_ACTION_MOVE: |
| case EXCHG_IN_ACTION_COPY: |
| case EXCHG_IN_ACTION_LINK: |
| case EXCHG_OUT_ACTION_INSERT_HTML: |
| case EXCHG_OUT_ACTION_INSERT_STRING: |
| case EXCHG_OUT_ACTION_INSERT_IMAGEMAP: |
| case EXCHG_OUT_ACTION_REPLACE_IMAGEMAP: |
| |
| // dann muss ueber das Format gegangen werden |
| switch( nFormat ) |
| { |
| case SOT_FORMATSTR_ID_DRAWING: |
| nRet = SwTransferable::_PasteSdrFormat( rData, rSh, |
| SW_PASTESDR_INSERT, pPt, |
| nActionFlags, bNeedToSelectBeforePaste); |
| break; |
| |
| case SOT_FORMATSTR_ID_HTML: |
| case SOT_FORMATSTR_ID_HTML_SIMPLE: |
| case SOT_FORMATSTR_ID_HTML_NO_COMMENT: |
| case SOT_FORMAT_RTF: |
| case SOT_FORMAT_STRING: |
| nRet = SwTransferable::_PasteFileContent( rData, rSh, |
| nFormat, bMsg ); |
| break; |
| |
| case SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK: |
| { |
| INetBookmark aBkmk; |
| if( rData.GetINetBookmark( nFormat, aBkmk ) ) |
| { |
| SwFmtINetFmt aFmt( aBkmk.GetURL(), aEmptyStr ); |
| rSh.InsertURL( aFmt, aBkmk.GetDescription() ); |
| nRet = 1; |
| } |
| } |
| break; |
| |
| case SOT_FORMATSTR_ID_SD_OLE: |
| nRet = SwTransferable::_PasteOLE( rData, rSh, nFormat, |
| nActionFlags, bMsg ); |
| break; |
| |
| case SOT_FORMATSTR_ID_SVIM: |
| nRet = SwTransferable::_PasteImageMap( rData, rSh ); |
| break; |
| |
| case SOT_FORMATSTR_ID_SVXB: |
| case SOT_FORMAT_BITMAP: |
| case SOT_FORMATSTR_ID_PNG: |
| case SOT_FORMAT_GDIMETAFILE: |
| nRet = SwTransferable::_PasteGrf( rData, rSh, nFormat, |
| SW_PASTESDR_INSERT,pPt, |
| nActionFlags, nDropAction, bNeedToSelectBeforePaste); |
| break; |
| |
| case SOT_FORMATSTR_ID_XFORMS: |
| case SOT_FORMATSTR_ID_SBA_FIELDDATAEXCHANGE: |
| case SOT_FORMATSTR_ID_SBA_DATAEXCHANGE: |
| case SOT_FORMATSTR_ID_SBA_CTRLDATAEXCHANGE: |
| nRet = SwTransferable::_PasteDBData( rData, rSh, nFormat, |
| EXCHG_IN_ACTION_LINK == nClearedAction, |
| pPt, bMsg ); |
| break; |
| |
| case SOT_FORMAT_FILE: |
| nRet = SwTransferable::_PasteFileName( rData, rSh, nFormat, |
| ( EXCHG_IN_ACTION_MOVE == nClearedAction |
| ? SW_PASTESDR_REPLACE |
| : EXCHG_IN_ACTION_LINK == nClearedAction |
| ? SW_PASTESDR_SETATTR |
| : SW_PASTESDR_INSERT), |
| pPt, nActionFlags, bMsg ); |
| break; |
| |
| case SOT_FORMAT_FILE_LIST: |
| // dann nur als Grafiken einfuegen |
| nRet = SwTransferable::_PasteFileList( rData, rSh, |
| EXCHG_IN_ACTION_LINK == nClearedAction, |
| pPt, bMsg ); |
| break; |
| |
| case SOT_FORMATSTR_ID_SONLK: |
| if( pPt ) |
| { |
| NaviContentBookmark aBkmk; |
| if( aBkmk.Paste( rData ) ) |
| { |
| if(bIsDefault) |
| { |
| switch(aBkmk.GetDefaultDragType()) |
| { |
| case REGION_MODE_NONE: nClearedAction = EXCHG_IN_ACTION_COPY; break; |
| case REGION_MODE_EMBEDDED: nClearedAction = EXCHG_IN_ACTION_MOVE; break; |
| case REGION_MODE_LINK: nClearedAction = EXCHG_IN_ACTION_LINK; break; |
| } |
| } |
| rSh.NavigatorPaste( aBkmk, nClearedAction ); |
| nRet = 1; |
| } |
| } |
| break; |
| |
| case SOT_FORMATSTR_ID_INET_IMAGE: |
| case SOT_FORMATSTR_ID_NETSCAPE_IMAGE: |
| nRet = SwTransferable::_PasteTargetURL( rData, rSh, |
| SW_PASTESDR_INSERT, |
| pPt, sal_True ); |
| break; |
| |
| default: |
| ASSERT( pPt, "unbekanntes Format" ); |
| } |
| break; |
| |
| case EXCHG_OUT_ACTION_INSERT_FILE: |
| nRet = SwTransferable::_PasteFileName( rData, rSh, nFormat, |
| SW_PASTESDR_INSERT, pPt, |
| nActionFlags, bMsg ); |
| if( nRet & SWTRANSFER_GRAPHIC_INSERTED ) |
| bCallAutoCaption = true; |
| break; |
| |
| case EXCHG_OUT_ACTION_INSERT_OLE: |
| nRet = SwTransferable::_PasteOLE( rData, rSh, nFormat, |
| nActionFlags,bMsg ); |
| break; |
| |
| case EXCHG_OUT_ACTION_INSERT_DDE: |
| { |
| sal_Bool bReRead = 0 != CNT_HasGrf( rSh.GetCntType() ); |
| nRet = SwTransferable::_PasteDDE( rData, rSh, bReRead, bMsg ); |
| } |
| break; |
| |
| case EXCHG_OUT_ACTION_INSERT_HYPERLINK: |
| { |
| String sURL, sDesc; |
| if( SOT_FORMAT_FILE == nFormat ) |
| { |
| if( rData.GetString( nFormat, sURL ) && sURL.Len() ) |
| { |
| SwTransferable::_CheckForURLOrLNKFile( rData, sURL, &sDesc ); |
| if( !sDesc.Len() ) |
| sDesc = sURL; |
| nRet = 1; |
| } |
| } |
| else |
| { |
| INetBookmark aBkmk; |
| if( rData.GetINetBookmark( nFormat, aBkmk ) ) |
| { |
| sURL = aBkmk.GetURL(); |
| sDesc = aBkmk.GetDescription(); |
| nRet = 1; |
| } |
| } |
| |
| if( nRet ) |
| { |
| SwFmtINetFmt aFmt( sURL, aEmptyStr ); |
| rSh.InsertURL( aFmt, sDesc ); |
| } |
| } |
| break; |
| |
| case EXCHG_OUT_ACTION_GET_ATTRIBUTES: |
| switch( nFormat ) |
| { |
| case SOT_FORMATSTR_ID_DRAWING: |
| nRet = SwTransferable::_PasteSdrFormat( rData, rSh, |
| SW_PASTESDR_SETATTR, pPt, |
| nActionFlags, bNeedToSelectBeforePaste); |
| break; |
| case SOT_FORMATSTR_ID_SVXB: |
| case SOT_FORMAT_GDIMETAFILE: |
| case SOT_FORMAT_BITMAP: |
| case SOT_FORMATSTR_ID_PNG: |
| case SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK: |
| case SOT_FORMAT_FILE: |
| case SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR: |
| case SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR: |
| nRet = SwTransferable::_PasteGrf( rData, rSh, nFormat, |
| SW_PASTESDR_SETATTR, pPt, |
| nActionFlags, nDropAction, bNeedToSelectBeforePaste); |
| break; |
| default: |
| ASSERT( sal_False, "unbekanntes Format" ); |
| } |
| |
| break; |
| |
| case EXCHG_OUT_ACTION_INSERT_DRAWOBJ: |
| nRet = SwTransferable::_PasteSdrFormat( rData, rSh, |
| SW_PASTESDR_INSERT, pPt, |
| nActionFlags, bNeedToSelectBeforePaste); |
| break; |
| case EXCHG_OUT_ACTION_INSERT_SVXB: |
| case EXCHG_OUT_ACTION_INSERT_GDIMETAFILE: |
| case EXCHG_OUT_ACTION_INSERT_BITMAP: |
| case EXCHG_OUT_ACTION_INSERT_GRAPH: |
| nRet = SwTransferable::_PasteGrf( rData, rSh, nFormat, |
| SW_PASTESDR_INSERT, pPt, |
| nActionFlags, nDropAction, bNeedToSelectBeforePaste); |
| break; |
| |
| case EXCHG_OUT_ACTION_REPLACE_DRAWOBJ: |
| nRet = SwTransferable::_PasteSdrFormat( rData, rSh, |
| SW_PASTESDR_REPLACE, pPt, |
| nActionFlags, bNeedToSelectBeforePaste); |
| break; |
| |
| case EXCHG_OUT_ACTION_REPLACE_SVXB: |
| case EXCHG_OUT_ACTION_REPLACE_GDIMETAFILE: |
| case EXCHG_OUT_ACTION_REPLACE_BITMAP: |
| case EXCHG_OUT_ACTION_REPLACE_GRAPH: |
| nRet = SwTransferable::_PasteGrf( rData, rSh, nFormat, |
| SW_PASTESDR_REPLACE,pPt, |
| nActionFlags, nDropAction, bNeedToSelectBeforePaste); |
| break; |
| |
| case EXCHG_OUT_ACTION_INSERT_INTERACTIVE: |
| nRet = SwTransferable::_PasteAsHyperlink( rData, rSh, nFormat ); |
| break; |
| |
| default: |
| ASSERT( sal_False, "unbekannte Action" ); |
| } |
| } |
| |
| if( !bPasteSelection && rSh.IsFrmSelected() ) |
| { |
| rSh.EnterSelFrmMode(); |
| //force ::SelectShell |
| rSh.GetView().StopShellTimer(); |
| } |
| |
| if( pAction ) |
| delete pAction; |
| if( bCallAutoCaption ) |
| rSh.GetView().AutoCaption( GRAPHIC_CAP ); |
| |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_uInt16 SwTransferable::GetSotDestination( const SwWrtShell& rSh, |
| const Point* pPt ) |
| { |
| sal_uInt16 nRet = EXCHG_INOUT_ACTION_NONE; |
| |
| ObjCntType eOType; |
| if( pPt ) |
| { |
| SdrObject *pObj = 0; |
| eOType = rSh.GetObjCntType( *pPt, pObj ); |
| } |
| else |
| eOType = rSh.GetObjCntTypeOfSelection(); |
| |
| switch( eOType ) |
| { |
| case OBJCNT_GRF: |
| { |
| sal_Bool bIMap, bLink; |
| if( pPt ) |
| { |
| bIMap = 0 != rSh.GetFmtFromObj( *pPt )->GetURL().GetMap(); |
| String aDummy; |
| rSh.GetGrfAtPos( *pPt, aDummy, bLink ); |
| } |
| else |
| { |
| bIMap = 0 != rSh.GetFlyFrmFmt()->GetURL().GetMap(); |
| String aDummy; |
| rSh.GetGrfNms( &aDummy, 0 ); |
| bLink = 0 != aDummy.Len(); |
| } |
| |
| if( bLink && bIMap ) |
| nRet = EXCHG_DEST_DOC_LNKD_GRAPH_W_IMAP; |
| else if( bLink ) |
| nRet = EXCHG_DEST_DOC_LNKD_GRAPHOBJ; |
| else if( bIMap ) |
| nRet = EXCHG_DEST_DOC_GRAPH_W_IMAP; |
| else |
| nRet = EXCHG_DEST_DOC_GRAPHOBJ; |
| } |
| break; |
| |
| case OBJCNT_FLY: |
| if( rSh.GetView().GetDocShell()->ISA(SwWebDocShell) ) |
| nRet = EXCHG_DEST_DOC_TEXTFRAME_WEB; |
| else |
| nRet = EXCHG_DEST_DOC_TEXTFRAME; |
| break; |
| case OBJCNT_OLE: nRet = EXCHG_DEST_DOC_OLEOBJ; break; |
| |
| case OBJCNT_CONTROL: /* no Action avail */ |
| case OBJCNT_SIMPLE: nRet = EXCHG_DEST_DOC_DRAWOBJ; break; |
| case OBJCNT_URLBUTTON: nRet = EXCHG_DEST_DOC_URLBUTTON; break; |
| case OBJCNT_GROUPOBJ: nRet = EXCHG_DEST_DOC_GROUPOBJ; break; |
| |
| // was mmchen wir bei Mehrfachselektion??? |
| // case OBJCNT_DONTCARE: |
| default: |
| { |
| /* |
| JP 13.07.98: Bug 52637: es wird ein URL-Feld erkannt also werden nur die |
| Inhalte zugelassen. Das ist aber bestimmt nicht das |
| gewollte. |
| SwContentAtPos aCntntAtPos( SwContentAtPos::SW_INETATTR ); |
| SfxItemSet aSet( (SfxItemPool&)rSh.GetAttrPool(), |
| RES_TXTATR_INETFMT, RES_TXTATR_INETFMT ); |
| if( pPt ? ((SwWrtShell&)rSh).GetContentAtPos( *pPt, aCntntAtPos, sal_False ) |
| : (rSh.GetAttr( aSet ) && aSet.Count()) ) |
| nRet = EXCHG_DEST_DOC_URLFIELD; |
| else |
| */ |
| if( rSh.GetView().GetDocShell()->ISA(SwWebDocShell) ) |
| nRet = EXCHG_DEST_SWDOC_FREE_AREA_WEB; |
| else |
| nRet = EXCHG_DEST_SWDOC_FREE_AREA; |
| } |
| } |
| |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::_PasteFileContent( TransferableDataHelper& rData, |
| SwWrtShell& rSh, sal_uLong nFmt, sal_Bool bMsg ) |
| { |
| sal_uInt16 nResId = MSG_CLPBRD_FORMAT_ERROR; |
| int nRet = 0; |
| |
| MSE40HTMLClipFormatObj aMSE40ClpObj; |
| |
| SotStorageStreamRef xStrm; |
| SvStream* pStream = 0; |
| SwRead pRead = 0; |
| rtl::OUString sData; |
| switch( nFmt ) |
| { |
| case SOT_FORMAT_STRING: |
| { |
| pRead = ReadAscii; |
| if( rData.GetString( nFmt, sData ) ) |
| { |
| pStream = new SvMemoryStream( (void*)sData.getStr(), |
| sData.getLength() * sizeof( sal_Unicode ), |
| STREAM_READ ); |
| #ifdef OSL_BIGENDIAN |
| pStream->SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN ); |
| #else |
| pStream->SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN ); |
| #endif |
| |
| SwAsciiOptions aAOpt; |
| aAOpt.SetCharSet( RTL_TEXTENCODING_UCS2 ); |
| pRead->GetReaderOpt().SetASCIIOpts( aAOpt ); |
| break; |
| } |
| } |
| // no break - because then test if we get a stream |
| |
| default: |
| if( rData.GetSotStorageStream( nFmt, xStrm ) ) |
| { |
| if( ( SOT_FORMATSTR_ID_HTML_SIMPLE == nFmt ) || |
| ( SOT_FORMATSTR_ID_HTML_NO_COMMENT == nFmt ) ) |
| { |
| pStream = aMSE40ClpObj.IsValid( *xStrm ); |
| pRead = ReadHTML; |
| pRead->SetReadUTF8( sal_True ); |
| //pRead->SetBaseURL( aMSE40ClpObj.GetBaseURL() ); |
| |
| sal_Bool bNoComments = |
| ( nFmt == SOT_FORMATSTR_ID_HTML_NO_COMMENT ); |
| pRead->SetIgnoreHTMLComments( bNoComments ); |
| } |
| else |
| { |
| pStream = &xStrm; |
| if( SOT_FORMAT_RTF == nFmt ) |
| pRead = SwReaderWriter::GetReader( READER_WRITER_RTF ); |
| else if( !pRead ) |
| { |
| pRead = ReadHTML; |
| pRead->SetReadUTF8( sal_True ); |
| } |
| } |
| } |
| break; |
| } |
| |
| if( pStream && pRead ) |
| { |
| Link aOldLink( rSh.GetChgLnk() ); |
| rSh.SetChgLnk( Link() ); |
| |
| const SwPosition& rInsPos = *rSh.GetCrsr()->Start(); |
| SwReader aReader( *pStream, aEmptyStr, String(), *rSh.GetCrsr() ); |
| rSh.SaveTblBoxCntnt( &rInsPos ); |
| if( IsError( aReader.Read( *pRead )) ) |
| nResId = ERR_CLPBRD_READ; |
| else |
| nResId = 0, nRet = 1; |
| |
| rSh.SetChgLnk( aOldLink ); |
| if( nRet ) |
| rSh.CallChgLnk(); |
| } |
| else |
| nResId = MSG_CLPBRD_FORMAT_ERROR; |
| |
| // Exist a SvMemoryStream? (data in the OUString and xStrm is empty) |
| if( pStream && !xStrm.Is() ) |
| delete pStream; |
| |
| if( bMsg && nResId ) |
| { |
| InfoBox( 0, SW_RES( nResId )).Execute(); |
| } |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::_PasteOLE( TransferableDataHelper& rData, SwWrtShell& rSh, |
| sal_uLong nFmt, sal_uInt8 nActionFlags, sal_Bool bMsg ) |
| { |
| int nRet = 0; |
| TransferableObjectDescriptor aObjDesc; |
| uno::Reference < io::XInputStream > xStrm; |
| uno::Reference < embed::XStorage > xStore; |
| Reader* pRead = 0; |
| |
| // Get the preferred format |
| SotFormatStringId nId; |
| if( rData.HasFormat( SOT_FORMATSTR_ID_EMBEDDED_OBJ ) ) |
| nId = SOT_FORMATSTR_ID_EMBEDDED_OBJ; |
| else if( rData.HasFormat( SOT_FORMATSTR_ID_EMBED_SOURCE ) && |
| rData.HasFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR )) |
| nId = SOT_FORMATSTR_ID_EMBED_SOURCE; |
| else |
| nId = 0; |
| |
| if( nId && rData.GetInputStream( nId, xStrm ) && xStrm.is() ) |
| { |
| // if there is an embedded object, first try if it's a writer object |
| // this will be inserted into the document by using a Reader |
| try |
| { |
| xStore = comphelper::OStorageHelper::GetStorageFromInputStream( xStrm ); |
| switch( SotStorage::GetFormatID( xStore ) ) |
| { |
| case SOT_FORMATSTR_ID_STARWRITER_60: |
| case SOT_FORMATSTR_ID_STARWRITERWEB_60: |
| case SOT_FORMATSTR_ID_STARWRITERGLOB_60: |
| case SOT_FORMATSTR_ID_STARWRITER_8: |
| case SOT_FORMATSTR_ID_STARWRITERWEB_8: |
| case SOT_FORMATSTR_ID_STARWRITERGLOB_8: |
| pRead = ReadXML; |
| break; |
| default: |
| try |
| { |
| uno::Reference < lang::XComponent > xComp( xStore, uno::UNO_QUERY ); |
| xComp->dispose(); |
| xStore = 0; |
| } |
| catch ( uno::Exception& ) |
| { |
| } |
| |
| break; |
| } |
| } |
| catch ( uno::Exception& ) |
| { |
| // it wasn't a storage, but maybe it's a useful stream |
| } |
| |
| nFmt = nId; |
| } |
| |
| if( pRead ) |
| { |
| SwPaM &rPAM = *rSh.GetCrsr(); |
| SwReader aReader( xStore, aEmptyStr, rPAM ); |
| if( !IsError( aReader.Read( *pRead )) ) |
| nRet = 1; |
| else if( bMsg ) |
| InfoBox( 0, SW_RES(ERR_CLPBRD_READ) ).Execute(); |
| } |
| else |
| { |
| // temporary storage until the object is inserted |
| uno::Reference< embed::XStorage > xTmpStor; |
| uno::Reference < embed::XEmbeddedObject > xObj; |
| ::rtl::OUString aName; |
| comphelper::EmbeddedObjectContainer aCnt; |
| |
| if ( xStrm.is() ) |
| { |
| if ( !rData.GetTransferableObjectDescriptor( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR, aObjDesc ) ) |
| { |
| DBG_ASSERT( !xStrm.is(), "An object without descriptor in clipboard!"); |
| } |
| } |
| else |
| { |
| if( rData.HasFormat( nFmt = SOT_FORMATSTR_ID_OBJECTDESCRIPTOR_OLE ) && rData.GetTransferableObjectDescriptor( nFmt, aObjDesc ) ) |
| { |
| if ( !rData.GetInputStream( SOT_FORMATSTR_ID_EMBED_SOURCE_OLE, xStrm ) ) |
| rData.GetInputStream( SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE, xStrm ); |
| |
| if ( !xStrm.is() ) |
| { |
| // This is MSOLE object that should be created by direct using of system clipboard |
| try |
| { |
| xTmpStor = ::comphelper::OStorageHelper::GetTemporaryStorage(); |
| uno::Reference < embed::XEmbedObjectClipboardCreator > xClipboardCreator( |
| ::comphelper::getProcessServiceFactory()->createInstance( ::rtl::OUString( |
| RTL_CONSTASCII_USTRINGPARAM("com.sun.star.embed.MSOLEObjectSystemCreator")) ), |
| uno::UNO_QUERY_THROW ); |
| |
| embed::InsertedObjectInfo aInfo = xClipboardCreator->createInstanceInitFromClipboard( |
| xTmpStor, |
| ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "DummyName" ) ), |
| uno::Sequence< beans::PropertyValue >() ); |
| |
| // TODO/LATER: in future InsertedObjectInfo will be used to get container related information |
| // for example whether the object should be an iconified one |
| xObj = aInfo.Object; |
| } |
| catch( uno::Exception& ) |
| {} |
| } |
| } |
| } |
| |
| if ( xStrm.is() && !xObj.is() ) |
| xObj = aCnt.InsertEmbeddedObject( xStrm, aName ); |
| |
| if( xObj.is() ) |
| { |
| svt::EmbeddedObjectRef xObjRef( xObj, aObjDesc.mnViewAspect ); |
| |
| // try to get the replacement image from the clipboard |
| Graphic aGraphic; |
| sal_uLong nGrFormat = 0; |
| |
| // (wg. Selection Manager bei Trustet Solaris) |
| #ifndef SOLARIS |
| /* |
| if( rData.GetGraphic( SOT_FORMATSTR_ID_SVXB, aGraphic ) ) |
| nGrFormat = SOT_FORMATSTR_ID_SVXB; |
| else if( rData.GetGraphic( FORMAT_GDIMETAFILE, aGraphic ) ) |
| nGrFormat = SOT_FORMAT_GDIMETAFILE; |
| else if( rData.GetGraphic( FORMAT_BITMAP, aGraphic ) ) |
| nGrFormat = SOT_FORMAT_BITMAP; |
| */ |
| #endif |
| |
| // insert replacement image ( if there is one ) into the object helper |
| if ( nGrFormat ) |
| { |
| datatransfer::DataFlavor aDataFlavor; |
| SotExchange::GetFormatDataFlavor( nGrFormat, aDataFlavor ); |
| xObjRef.SetGraphic( aGraphic, aDataFlavor.MimeType ); |
| } |
| else if ( aObjDesc.mnViewAspect == embed::Aspects::MSOLE_ICON ) |
| { |
| // it is important to have an icon, let an empty graphic be used |
| // if no other graphic is provided |
| // TODO/LATER: in future a default bitmap could be used |
| ::rtl::OUString aMimeType; |
| MapMode aMapMode( MAP_100TH_MM ); |
| aGraphic.SetPrefSize( Size( 2500, 2500 ) ); |
| aGraphic.SetPrefMapMode( aMapMode ); |
| xObjRef.SetGraphic( aGraphic, aMimeType ); |
| } |
| |
| //Size einstellen. Ist ein Hack wg. Auslieferung, die Size sollte |
| //an das InsertOle uebergeben werden!!!!!!!!!! |
| Size aSize; |
| if ( aObjDesc.mnViewAspect == embed::Aspects::MSOLE_ICON ) |
| { |
| if( aObjDesc.maSize.Width() && aObjDesc.maSize.Height() ) |
| aSize = aObjDesc.maSize; |
| else |
| { |
| MapMode aMapMode( MAP_100TH_MM ); |
| aSize = xObjRef.GetSize( &aMapMode ); |
| } |
| } |
| else if( aObjDesc.maSize.Width() && aObjDesc.maSize.Height() ) |
| { |
| aSize = Size( aObjDesc.maSize ); //immer 100TH_MM |
| MapUnit aUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( aObjDesc.mnViewAspect ) ); |
| aSize = OutputDevice::LogicToLogic( aSize, MAP_100TH_MM, aUnit ); |
| awt::Size aSz; |
| try |
| { |
| aSz = xObj->getVisualAreaSize( aObjDesc.mnViewAspect ); |
| } |
| catch( embed::NoVisualAreaSizeException& ) |
| { |
| // in this case the provided size is used |
| } |
| |
| if ( aSz.Width != aSize.Width() || aSz.Height != aSize.Height() ) |
| { |
| aSz.Width = aSize.Width(); |
| aSz.Height = aSize.Height(); |
| xObj->setVisualAreaSize( aObjDesc.mnViewAspect, aSz ); |
| } |
| } |
| else |
| { |
| // the descriptor contains the wrong object size |
| // the following call will let the MSOLE objects cache the size if it is possible |
| // it should be done while the object is running |
| try |
| { |
| xObj->getVisualAreaSize( aObjDesc.mnViewAspect ); |
| } |
| catch( uno::Exception& ) |
| { |
| } |
| } |
| //Ende mit Hack! |
| |
| rSh.InsertOleObject( xObjRef ); |
| nRet = 1; |
| |
| if( nRet && ( nActionFlags & |
| ( EXCHG_OUT_ACTION_FLAG_INSERT_TARGETURL >> 8) )) |
| SwTransferable::_PasteTargetURL( rData, rSh, 0, 0, sal_False ); |
| |
| // let the object be unloaded if possible |
| SwOLEObj::UnloadObject( xObj, rSh.GetDoc(), embed::Aspects::MSOLE_CONTENT ); |
| } |
| } |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::_PasteTargetURL( TransferableDataHelper& rData, |
| SwWrtShell& rSh, sal_uInt16 nAction, |
| const Point* pPt, sal_Bool bInsertGRF ) |
| { |
| int nRet = 0; |
| INetImage aINetImg; |
| if( ( rData.HasFormat( SOT_FORMATSTR_ID_INET_IMAGE ) && |
| rData.GetINetImage( SOT_FORMATSTR_ID_INET_IMAGE, aINetImg )) || |
| ( rData.HasFormat( SOT_FORMATSTR_ID_NETSCAPE_IMAGE ) && |
| rData.GetINetImage( SOT_FORMATSTR_ID_NETSCAPE_IMAGE, aINetImg )) ) |
| { |
| if( aINetImg.GetImageURL().Len() && bInsertGRF ) |
| { |
| String sURL( aINetImg.GetImageURL() ); |
| SwTransferable::_CheckForURLOrLNKFile( rData, sURL ); |
| |
| //!!! auf FileSystem abpruefen - nur dann ist es sinnvoll die |
| // Grafiken zu testen !!!! |
| Graphic aGrf; |
| GraphicFilter *pFlt = GraphicFilter::GetGraphicFilter(); |
| nRet = GRFILTER_OK == GraphicFilter::LoadGraphic( sURL, aEmptyStr, aGrf, pFlt ); |
| if( nRet ) |
| { |
| switch( nAction ) |
| { |
| case SW_PASTESDR_INSERT: |
| SwTransferable::SetSelInShell( rSh, sal_False, pPt ); |
| rSh.Insert( sURL, aEmptyStr, aGrf ); |
| break; |
| |
| case SW_PASTESDR_REPLACE: |
| if( rSh.IsObjSelected() ) |
| { |
| rSh.ReplaceSdrObj( sURL, aEmptyStr, &aGrf ); |
| Point aPt( pPt ? *pPt : rSh.GetCrsrDocPos() ); |
| SwTransferable::SetSelInShell( rSh, sal_True, &aPt ); |
| } |
| else |
| rSh.ReRead( sURL, aEmptyStr, &aGrf ); |
| break; |
| |
| case SW_PASTESDR_SETATTR: |
| if( rSh.IsObjSelected() ) |
| rSh.Paste( aGrf, String() ); |
| else if( OBJCNT_GRF == rSh.GetObjCntTypeOfSelection() ) |
| rSh.ReRead( sURL, aEmptyStr, &aGrf ); |
| else |
| { |
| SwTransferable::SetSelInShell( rSh, sal_False, pPt ); |
| rSh.Insert( sURL, aEmptyStr, aGrf ); |
| } |
| break; |
| default: |
| nRet = 0; |
| } |
| } |
| } |
| else |
| nRet = 1; |
| } |
| |
| if( nRet ) |
| { |
| SfxItemSet aSet( rSh.GetAttrPool(), RES_URL, RES_URL ); |
| rSh.GetFlyFrmAttr( aSet ); |
| SwFmtURL aURL( (SwFmtURL&)aSet.Get( RES_URL ) ); |
| |
| if( aURL.GetURL() != aINetImg.GetTargetURL() || |
| aURL.GetTargetFrameName() != aINetImg.GetTargetFrame() ) |
| { |
| aURL.SetURL( aINetImg.GetTargetURL(), sal_False ); |
| aURL.SetTargetFrameName( aINetImg.GetTargetFrame() ); |
| aSet.Put( aURL ); |
| rSh.SetFlyFrmAttr( aSet ); |
| } |
| } |
| return nRet; |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| |
| void SwTransferable::SetSelInShell( SwWrtShell& rSh, sal_Bool bSelectFrm, |
| const Point* pPt ) |
| { |
| if( bSelectFrm ) |
| { |
| // Rahmen/Objecte selektieren |
| if( pPt && !rSh.GetView().GetViewFrame()->GetDispatcher()->IsLocked() ) |
| { |
| rSh.GetView().NoRotate(); |
| if( rSh.SelectObj( *pPt )) |
| { |
| rSh.HideCrsr(); |
| rSh.EnterSelFrmMode( pPt ); |
| bFrmDrag = sal_True; |
| } |
| } |
| } |
| else |
| { |
| if( rSh.IsFrmSelected() || rSh.IsObjSelected() ) |
| { |
| rSh.UnSelectFrm(); |
| rSh.LeaveSelFrmMode(); |
| rSh.GetView().GetEditWin().StopInsFrm(); |
| bFrmDrag = sal_False; |
| } |
| else if( rSh.GetView().GetDrawFuncPtr() ) |
| rSh.GetView().GetEditWin().StopInsFrm(); |
| |
| rSh.EnterStdMode(); |
| if( pPt ) |
| rSh.SwCrsrShell::SetCrsr( *pPt, sal_True ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::_PasteDDE( TransferableDataHelper& rData, |
| SwWrtShell& rWrtShell, sal_Bool bReReadGrf, |
| sal_Bool bMsg ) |
| { |
| // Daten aus dem Clipboardformat |
| String aApp, aTopic, aItem; |
| |
| { |
| SotStorageStreamRef xStrm; |
| if( !rData.GetSotStorageStream( SOT_FORMATSTR_ID_LINK, xStrm )) |
| { |
| ASSERT( !&rWrtShell, "DDE Data not found." ); |
| return 0; |
| } //sinnvollen Fehler melden!! |
| |
| rtl_TextEncoding eEncoding = DDE_TXT_ENCODING; |
| xStrm->ReadCString( aApp, eEncoding ); |
| xStrm->ReadCString( aTopic, eEncoding ); |
| xStrm->ReadCString( aItem, eEncoding ); |
| } |
| |
| String aCmd; |
| sfx2::MakeLnkName( aCmd, &aApp, aTopic, aItem ); |
| |
| // wollen wir jetzt eine Grafik einlesen ? |
| sal_uLong nFormat; |
| if( !rData.HasFormat( FORMAT_RTF ) && |
| !rData.HasFormat( SOT_FORMATSTR_ID_HTML ) && |
| !rData.HasFormat( FORMAT_STRING ) && |
| (rData.HasFormat( nFormat = FORMAT_GDIMETAFILE ) || |
| rData.HasFormat( nFormat = FORMAT_BITMAP )) ) |
| { |
| Graphic aGrf; |
| int nRet = rData.GetGraphic( nFormat, aGrf ); |
| if( nRet ) |
| { |
| String sLnkTyp( String::CreateFromAscii( |
| RTL_CONSTASCII_STRINGPARAM( "DDE" ))); |
| if ( bReReadGrf ) |
| rWrtShell.ReRead( aCmd, sLnkTyp, &aGrf ); |
| else |
| rWrtShell.Insert( aCmd, sLnkTyp, aGrf ); |
| } |
| return nRet; |
| } |
| |
| SwFieldType* pTyp = 0; |
| sal_uInt16 i = 1,j; |
| String aName; |
| sal_Bool bAlreadyThere = sal_False, bDoublePaste = sal_False; |
| sal_uInt16 nSize = rWrtShell.GetFldTypeCount(); |
| const ::utl::TransliterationWrapper& rColl = ::GetAppCmpStrIgnore(); |
| |
| do { |
| aName = aApp; |
| aName += String::CreateFromInt32( i ); |
| for( j = INIT_FLDTYPES; j < nSize; j++ ) |
| { |
| pTyp = rWrtShell.GetFldType( j ); |
| if( RES_DDEFLD == pTyp->Which() ) |
| { |
| String sTmp( ((SwDDEFieldType*)pTyp)->GetCmd() ); |
| if( rColl.isEqual( sTmp, aCmd ) && |
| sfx2::LINKUPDATE_ALWAYS == ((SwDDEFieldType*)pTyp)->GetType() ) |
| { |
| aName = pTyp->GetName(); |
| bDoublePaste = sal_True; |
| break; |
| } |
| else if( rColl.isEqual( aName, pTyp->GetName() ) ) |
| break; |
| } |
| } |
| if( j == nSize ) |
| bAlreadyThere = sal_False; |
| else |
| { |
| bAlreadyThere = sal_True; |
| i++; |
| } |
| } |
| while( bAlreadyThere && !bDoublePaste ); |
| |
| if( !bDoublePaste ) |
| { |
| SwDDEFieldType aType( aName, aCmd, sfx2::LINKUPDATE_ALWAYS ); |
| pTyp = rWrtShell.InsertFldType( aType ); |
| } |
| |
| |
| SwDDEFieldType* pDDETyp = (SwDDEFieldType*)pTyp; |
| |
| String aExpand; |
| if( rData.GetString( FORMAT_STRING, aExpand )) |
| { |
| do { // middle checked loop |
| |
| // Wenn die Daten von einer Tabellenkalkulation kommen |
| // fuegen wir eine DDE-Tabelle ein |
| if( ( rData.HasFormat( SOT_FORMATSTR_ID_SYLK ) || |
| rData.HasFormat( SOT_FORMATSTR_ID_SYLK_BIGCAPS ) ) && |
| aExpand.Len() && |
| ( 1 < aExpand.GetTokenCount( '\n' ) || |
| aExpand.GetTokenCount( '\t' )) ) |
| { |
| String sTmp( aExpand ); |
| xub_StrLen nRows = sTmp.GetTokenCount( '\n' ); |
| if( nRows ) |
| --nRows; |
| sTmp = sTmp.GetToken( 0, '\n' ); |
| xub_StrLen nCols = sTmp.GetTokenCount( '\t' ); |
| |
| // mindestens eine Spalte & Zeile muss vorhanden sein |
| if( !nRows || !nCols ) |
| { |
| if( bMsg ) |
| InfoBox(0, SW_RESSTR(STR_NO_TABLE)).Execute(); |
| pDDETyp = 0; |
| break; |
| } |
| |
| rWrtShell.InsertDDETable( |
| SwInsertTableOptions( tabopts::HEADLINE_NO_BORDER, 1 ), // TODO MULTIHEADER |
| pDDETyp, nRows, nCols ); |
| } |
| else if( 1 < aExpand.GetTokenCount( '\n' ) ) |
| { |
| // mehrere Absaetze -> eine geschuetzte Section einfuegen |
| if( rWrtShell.HasSelection() ) |
| rWrtShell.DelRight(); |
| |
| SwSectionData aSect( DDE_LINK_SECTION, aName ); |
| aSect.SetLinkFileName( aCmd ); |
| aSect.SetProtectFlag(true); |
| rWrtShell.InsertSection( aSect ); |
| |
| pDDETyp = 0; // FeldTypen wieder entfernen |
| } |
| else |
| { |
| // Einfuegen |
| SwDDEField aSwDDEField( pDDETyp ); |
| rWrtShell.Insert( aSwDDEField ); |
| } |
| |
| } while( sal_False ); |
| } |
| else |
| pDDETyp = 0; // FeldTypen wieder entfernen |
| |
| if( !pDDETyp && !bDoublePaste ) |
| { |
| // FeldTyp wieder entfernen - Fehler aufgetreten! |
| for( j = nSize; j >= INIT_FLDTYPES; --j ) |
| if( pTyp == rWrtShell.GetFldType( j ) ) |
| { |
| rWrtShell.RemoveFldType( j ); |
| break; |
| } |
| } |
| |
| return 1; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::_PasteSdrFormat( TransferableDataHelper& rData, |
| SwWrtShell& rSh, sal_uInt16 nAction, |
| const Point* pPt, sal_uInt8 nActionFlags, bool bNeedToSelectBeforePaste) |
| { |
| int nRet = 0; |
| SotStorageStreamRef xStrm; |
| if( rData.GetSotStorageStream( SOT_FORMATSTR_ID_DRAWING, xStrm )) |
| { |
| xStrm->SetVersion( SOFFICE_FILEFORMAT_50 ); |
| |
| if(bNeedToSelectBeforePaste && pPt) |
| { |
| // if this is an internal drag, need to set the target right (select it), else |
| // still the source will be selected |
| SwTransferable::SetSelInShell( rSh, sal_True, pPt ); |
| } |
| |
| rSh.Paste( *xStrm, nAction, pPt ); |
| nRet = 1; |
| |
| if( nRet && ( nActionFlags & |
| ( EXCHG_OUT_ACTION_FLAG_INSERT_TARGETURL >> 8) )) |
| SwTransferable::_PasteTargetURL( rData, rSh, 0, 0, sal_False ); |
| } |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::_PasteGrf( TransferableDataHelper& rData, SwWrtShell& rSh, |
| sal_uLong nFmt, sal_uInt16 nAction, const Point* pPt, |
| sal_uInt8 nActionFlags, sal_Int8 nDropAction, bool bNeedToSelectBeforePaste) |
| { |
| int nRet = 0; |
| |
| Graphic aGrf; |
| INetBookmark aBkmk; |
| sal_Bool bCheckForGrf = sal_False, bCheckForImageMap = sal_False; |
| |
| switch( nFmt ) |
| { |
| case SOT_FORMAT_BITMAP: |
| case SOT_FORMATSTR_ID_PNG: |
| case SOT_FORMAT_GDIMETAFILE: |
| nRet = rData.GetGraphic( nFmt, aGrf ); |
| break; |
| |
| case SOT_FORMATSTR_ID_SVXB: |
| { |
| SotStorageStreamRef xStm; |
| |
| if(rData.GetSotStorageStream(SOT_FORMATSTR_ID_SVXB, xStm)) |
| { |
| *xStm >> aGrf; |
| nRet = (GRAPHIC_NONE != aGrf.GetType() && GRAPHIC_DEFAULT != aGrf.GetType()); |
| } |
| |
| break; |
| } |
| |
| case SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK: |
| case SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR: |
| case SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR: |
| if( 0 != ( nRet = rData.GetINetBookmark( nFmt, aBkmk ) )) |
| { |
| /* if( SW_PASTESDR_SETATTR != nAction ) |
| { |
| INetURLObject aURL( aBkmk.GetURL() ); |
| bCheckForGrf = INET_PROT_FILE == aURL.GetProtocol(); |
| nRet = 0 != bCheckForGrf; |
| } |
| */ |
| if( SW_PASTESDR_SETATTR == nAction ) |
| nFmt = SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK; |
| else |
| bCheckForGrf = sal_True; |
| } |
| break; |
| |
| case SOT_FORMAT_FILE: |
| { |
| String sTxt; |
| if( 0 != ( nRet = rData.GetString( nFmt, sTxt ) ) ) |
| { |
| String sDesc; |
| SwTransferable::_CheckForURLOrLNKFile( rData, sTxt, &sDesc ); |
| |
| aBkmk = INetBookmark( |
| URIHelper::SmartRel2Abs(INetURLObject(), sTxt, Link(), false ), |
| sDesc ); |
| bCheckForGrf = sal_True; |
| bCheckForImageMap = SW_PASTESDR_REPLACE == nAction; |
| } |
| } |
| break; |
| |
| default: |
| nRet = rData.GetGraphic( nFmt, aGrf ); |
| break; |
| } |
| |
| if( bCheckForGrf ) |
| { |
| //!!! auf FileSystem abpruefen - nur dann ist es sinnvoll die |
| // Grafiken zu testen !!!! |
| GraphicFilter *pFlt = GraphicFilter::GetGraphicFilter(); |
| nRet = GRFILTER_OK == GraphicFilter::LoadGraphic( aBkmk.GetURL(), aEmptyStr, |
| aGrf, pFlt ); |
| if( !nRet && SW_PASTESDR_SETATTR == nAction && |
| SOT_FORMAT_FILE == nFmt && |
| // Bug 63031 - nur bei Rahmenselektion |
| rSh.IsFrmSelected() ) |
| { |
| // dann als Hyperlink hinter die Grafik setzen |
| nFmt = SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK; |
| nRet = sal_True; |
| } |
| } |
| |
| if(pPt && bNeedToSelectBeforePaste) |
| { |
| // when using internal D&Ds, still the source object is selected and |
| // this is necessary to get the correct source data which is also |
| // dependent from selection. After receiving the drag data it is |
| // now tiime to select the correct target object |
| SwTransferable::SetSelInShell( rSh, sal_True, pPt ); |
| } |
| |
| if( nRet ) |
| { |
| String sURL; |
| |
| if( rSh.GetView().GetDocShell()->ISA(SwWebDocShell) |
| // #123922# if link action is noted, also take URL |
| || DND_ACTION_LINK == nDropAction) |
| { |
| sURL = aBkmk.GetURL(); |
| } |
| |
| switch( nAction ) |
| { |
| case SW_PASTESDR_INSERT: |
| { |
| SwTransferable::SetSelInShell( rSh, sal_False, pPt ); |
| rSh.Insert( sURL, aEmptyStr, aGrf ); |
| break; |
| } |
| |
| case SW_PASTESDR_REPLACE: |
| { |
| if( rSh.IsObjSelected() ) |
| { |
| // #123922# for D&D on draw objects, do for now the same for |
| // SW_PASTESDR_REPLACE (D&D) as for SW_PASTESDR_SETATTR (D&D and |
| // CTRL+SHIFT). The code below replaces the draw object with |
| // a writer graphic; maybe this is an option later again if wanted |
| rSh.Paste( aGrf, sURL ); |
| |
| // rSh.ReplaceSdrObj( sURL, aEmptyStr, &aGrf ); |
| // Point aPt( pPt ? *pPt : rSh.GetCrsrDocPos() ); |
| // SwTransferable::SetSelInShell( rSh, sal_True, &aPt ); |
| } |
| else |
| { |
| // set graphic at writer graphic without link |
| rSh.ReRead( sURL, aEmptyStr, &aGrf ); |
| } |
| |
| break; |
| } |
| |
| case SW_PASTESDR_SETATTR: |
| { |
| if( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK == nFmt ) |
| { |
| if( rSh.IsFrmSelected() ) |
| { |
| SfxItemSet aSet( rSh.GetAttrPool(), RES_URL, RES_URL ); |
| rSh.GetFlyFrmAttr( aSet ); |
| SwFmtURL aURL( (SwFmtURL&)aSet.Get( RES_URL ) ); |
| aURL.SetURL( aBkmk.GetURL(), sal_False ); |
| aSet.Put( aURL ); |
| rSh.SetFlyFrmAttr( aSet ); |
| } |
| } |
| else if( rSh.IsObjSelected() ) |
| { |
| // set as attribute at DrawObject |
| rSh.Paste( aGrf, sURL ); |
| } |
| else if( OBJCNT_GRF == rSh.GetObjCntTypeOfSelection() ) |
| { |
| // set as linked graphic at writer graphic frame |
| rSh.ReRead( sURL, aEmptyStr, &aGrf ); |
| } |
| else |
| { |
| SwTransferable::SetSelInShell( rSh, sal_False, pPt ); |
| rSh.Insert( aBkmk.GetURL(), aEmptyStr, aGrf ); |
| } |
| break; |
| } |
| default: |
| { |
| nRet = 0; |
| break; |
| } |
| } |
| } |
| |
| if( nRet ) |
| { |
| |
| if( nActionFlags & |
| (( EXCHG_OUT_ACTION_FLAG_INSERT_IMAGEMAP | |
| EXCHG_OUT_ACTION_FLAG_REPLACE_IMAGEMAP ) >> 8) ) |
| SwTransferable::_PasteImageMap( rData, rSh ); |
| |
| if( nActionFlags & |
| ( EXCHG_OUT_ACTION_FLAG_INSERT_TARGETURL >> 8) ) |
| SwTransferable::_PasteTargetURL( rData, rSh, 0, 0, sal_False ); |
| } |
| else if( bCheckForImageMap ) |
| { |
| // oder sollte das File ein ImageMap-File sein? |
| ImageMap aMap; |
| SfxMedium aMed( INetURLObject(aBkmk.GetURL()).GetFull(), |
| STREAM_STD_READ, sal_False ); |
| SvStream* pStream = aMed.GetInStream(); |
| if( pStream != NULL && |
| !pStream->GetError() && |
| // mba: no BaseURL for clipboard functionality |
| aMap.Read( *pStream, IMAP_FORMAT_DETECT, String() ) == IMAP_ERR_OK && |
| aMap.GetIMapObjectCount() ) |
| { |
| SfxItemSet aSet( rSh.GetAttrPool(), RES_URL, RES_URL ); |
| rSh.GetFlyFrmAttr( aSet ); |
| SwFmtURL aURL( (SwFmtURL&)aSet.Get( RES_URL ) ); |
| aURL.SetMap( &aMap ); |
| aSet.Put( aURL ); |
| rSh.SetFlyFrmAttr( aSet ); |
| nRet = 1; |
| } |
| } |
| |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::_PasteImageMap( TransferableDataHelper& rData, |
| SwWrtShell& rSh ) |
| { |
| int nRet = 0; |
| if( rData.HasFormat( SOT_FORMATSTR_ID_SVIM )) |
| { |
| SfxItemSet aSet( rSh.GetAttrPool(), RES_URL, RES_URL ); |
| rSh.GetFlyFrmAttr( aSet ); |
| SwFmtURL aURL( (SwFmtURL&)aSet.Get( RES_URL ) ); |
| const ImageMap* pOld = aURL.GetMap(); |
| |
| // setzen oder ersetzen ist hier die Frage |
| ImageMap aImageMap; |
| if( rData.GetImageMap( SOT_FORMATSTR_ID_SVIM, aImageMap ) && |
| ( !pOld || aImageMap != *pOld )) |
| { |
| aURL.SetMap( &aImageMap ); |
| aSet.Put( aURL ); |
| rSh.SetFlyFrmAttr( aSet ); |
| } |
| nRet = 1; |
| } |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::_PasteAsHyperlink( TransferableDataHelper& rData, |
| SwWrtShell& rSh, sal_uLong nFmt ) |
| { |
| int nRet = 0; |
| String sFile; |
| if( rData.GetString( nFmt, sFile ) && sFile.Len() ) |
| { |
| String sDesc; |
| SwTransferable::_CheckForURLOrLNKFile( rData, sFile, &sDesc ); |
| |
| //#41801# ersteinmal die URL absolut machen |
| INetURLObject aURL; |
| aURL.SetSmartProtocol( INET_PROT_FILE ); |
| aURL.SetSmartURL( sFile ); |
| sFile = aURL.GetMainURL( INetURLObject::NO_DECODE ); |
| |
| switch( rSh.GetObjCntTypeOfSelection() ) |
| { |
| case OBJCNT_FLY: |
| case OBJCNT_GRF: |
| case OBJCNT_OLE: |
| { |
| SfxItemSet aSet( rSh.GetAttrPool(), RES_URL, RES_URL ); |
| rSh.GetFlyFrmAttr( aSet ); |
| SwFmtURL aURL2( (SwFmtURL&)aSet.Get( RES_URL ) ); |
| aURL2.SetURL( sFile, sal_False ); |
| if( !aURL2.GetName().Len() ) |
| aURL2.SetName( sFile ); |
| aSet.Put( aURL2 ); |
| rSh.SetFlyFrmAttr( aSet ); |
| } |
| break; |
| |
| default: |
| { |
| rSh.InsertURL( SwFmtINetFmt( sFile, aEmptyStr ), |
| sDesc.Len() ? sDesc : sFile ); |
| } |
| } |
| nRet = sal_True; |
| } |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::_PasteFileName( TransferableDataHelper& rData, |
| SwWrtShell& rSh, sal_uLong nFmt, |
| sal_uInt16 nAction, const Point* pPt, |
| sal_uInt8 nActionFlags, sal_Bool /* bMsg */) |
| { |
| int nRet = SwTransferable::_PasteGrf( rData, rSh, nFmt, nAction, |
| pPt, nActionFlags, 0, false); |
| if( nRet ) |
| nRet |= SWTRANSFER_GRAPHIC_INSERTED; |
| if( !nRet ) |
| { |
| String sFile, sDesc; |
| if( rData.GetString( nFmt, sFile ) && sFile.Len() ) |
| { |
| INetURLObject aMediaURL; |
| |
| aMediaURL.SetSmartURL( sFile ); |
| const String aMediaURLStr( aMediaURL.GetMainURL( INetURLObject::NO_DECODE ) ); |
| |
| if( ::avmedia::MediaWindow::isMediaURL( aMediaURLStr ) ) |
| { |
| const SfxStringItem aMediaURLItem( SID_INSERT_AVMEDIA, aMediaURLStr ); |
| rSh.GetView().GetViewFrame()->GetDispatcher()->Execute( |
| SID_INSERT_AVMEDIA, SFX_CALLMODE_SYNCHRON, |
| &aMediaURLItem, 0L ); |
| } |
| else |
| { |
| sal_Bool bIsURLFile = SwTransferable::_CheckForURLOrLNKFile( rData, sFile, &sDesc ); |
| |
| //Eigenes FileFormat? -->Einfuegen, nicht fuer StarWriter/Web |
| String sFileURL = URIHelper::SmartRel2Abs(INetURLObject(), sFile, Link(), false ); |
| const SfxFilter* pFlt = SW_PASTESDR_SETATTR == nAction |
| ? 0 : SwIoSystem::GetFileFilter( |
| sFileURL, aEmptyStr ); |
| if( pFlt && !rSh.GetView().GetDocShell()->ISA(SwWebDocShell) |
| /* |
| JP 02.07.98: warum nur fuer die Formate ?? |
| && ( pFlt->GetUserData() == FILTER_SW5 || |
| pFlt->GetUserData() == FILTER_SW4 || |
| pFlt->GetUserData() == FILTER_SW3 || |
| pFlt->GetUserData() == FILTER_SWG ) |
| */ |
| ) |
| { |
| // und dann per PostUser Event den Bereich-Einfuegen-Dialog hochreissen |
| SwSectionData * pSect = new SwSectionData( |
| FILE_LINK_SECTION, |
| rSh.GetDoc()->GetUniqueSectionName() ); |
| pSect->SetLinkFileName( sFileURL ); |
| pSect->SetProtectFlag( true ); |
| |
| Application::PostUserEvent( STATIC_LINK( &rSh, SwWrtShell, |
| InsertRegionDialog ), pSect ); |
| nRet = 1; |
| } |
| else if( SW_PASTESDR_SETATTR == nAction || |
| ( bIsURLFile && SW_PASTESDR_INSERT == nAction )) |
| { |
| //Fremde Files koennen wir immerhin noch als Links |
| //Einfuegen. |
| |
| //#41801# ersteinmal die URL absolut machen |
| INetURLObject aURL; |
| aURL.SetSmartProtocol( INET_PROT_FILE ); |
| aURL.SetSmartURL( sFile ); |
| sFile = aURL.GetMainURL( INetURLObject::NO_DECODE ); |
| |
| switch( rSh.GetObjCntTypeOfSelection() ) |
| { |
| case OBJCNT_FLY: |
| case OBJCNT_GRF: |
| case OBJCNT_OLE: |
| { |
| SfxItemSet aSet( rSh.GetAttrPool(), RES_URL, RES_URL ); |
| rSh.GetFlyFrmAttr( aSet ); |
| SwFmtURL aURL2( (SwFmtURL&)aSet.Get( RES_URL ) ); |
| aURL2.SetURL( sFile, sal_False ); |
| if( !aURL2.GetName().Len() ) |
| aURL2.SetName( sFile ); |
| aSet.Put( aURL2 ); |
| rSh.SetFlyFrmAttr( aSet ); |
| } |
| break; |
| |
| default: |
| { |
| rSh.InsertURL( SwFmtINetFmt( sFile, aEmptyStr ), |
| sDesc.Len() ? sDesc : sFile ); |
| } |
| } |
| nRet = sal_True; |
| } |
| } |
| } |
| } |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::_PasteDBData( TransferableDataHelper& rData, |
| SwWrtShell& rSh, sal_uLong nFmt, sal_Bool bLink, |
| const Point* pDragPt, sal_Bool bMsg ) |
| { |
| int nRet = 0; |
| String sTxt; |
| if( rData.GetString( nFmt, sTxt ) && sTxt.Len() ) |
| { |
| sal_uInt16 nWh = SOT_FORMATSTR_ID_SBA_CTRLDATAEXCHANGE == nFmt |
| ? 0 |
| : SOT_FORMATSTR_ID_SBA_DATAEXCHANGE == nFmt |
| ? (bLink |
| ? FN_QRY_MERGE_FIELD |
| : FN_QRY_INSERT) |
| : (bLink |
| ? 0 |
| : FN_QRY_INSERT_FIELD ); |
| DataFlavorExVector& rVector = rData.GetDataFlavorExVector(); |
| sal_Bool bHaveColumnDescriptor = OColumnTransferable::canExtractColumnDescriptor(rVector, CTF_COLUMN_DESCRIPTOR | CTF_CONTROL_EXCHANGE); |
| if ( SOT_FORMATSTR_ID_XFORMS == nFmt ) |
| { |
| SdrObject* pObj; |
| rSh.MakeDrawView(); |
| FmFormView* pFmView = PTR_CAST( FmFormView, rSh.GetDrawView() ); |
| if(pFmView) { |
| const OXFormsDescriptor &rDesc = OXFormsTransferable::extractDescriptor(rData); |
| if(0 != (pObj = pFmView->CreateXFormsControl(rDesc))) |
| { |
| rSh.SwFEShell::InsertDrawObj( *pObj, *pDragPt ); |
| } |
| } |
| } |
| else if( nWh ) |
| { |
| SfxUsrAnyItem* pConnectionItem = 0; |
| SfxUsrAnyItem* pCursorItem = 0; |
| SfxUsrAnyItem* pColumnItem = 0; |
| SfxUsrAnyItem* pSourceItem = 0; |
| SfxUsrAnyItem* pCommandItem = 0; |
| SfxUsrAnyItem* pCommandTypeItem = 0; |
| SfxUsrAnyItem* pColumnNameItem = 0; |
| SfxUsrAnyItem* pSelectionItem = 0; |
| |
| sal_Bool bDataAvailable = sal_True; |
| ODataAccessDescriptor aDesc; |
| if(bHaveColumnDescriptor) |
| aDesc = OColumnTransferable::extractColumnDescriptor(rData); |
| else if(ODataAccessObjectTransferable::canExtractObjectDescriptor(rVector) ) |
| aDesc = ODataAccessObjectTransferable::extractObjectDescriptor(rData); |
| else |
| bDataAvailable = sal_False; |
| |
| if ( bDataAvailable ) |
| { |
| pConnectionItem = new SfxUsrAnyItem(FN_DB_CONNECTION_ANY, aDesc[daConnection]); |
| pColumnItem = new SfxUsrAnyItem(FN_DB_COLUMN_ANY, aDesc[daColumnObject]); |
| pSourceItem = new SfxUsrAnyItem(FN_DB_DATA_SOURCE_ANY, makeAny(aDesc.getDataSource())); |
| pCommandItem = new SfxUsrAnyItem(FN_DB_DATA_COMMAND_ANY, aDesc[daCommand]); |
| pCommandTypeItem = new SfxUsrAnyItem(FN_DB_DATA_COMMAND_TYPE_ANY, aDesc[daCommandType]); |
| pColumnNameItem = new SfxUsrAnyItem(FN_DB_DATA_COLUMN_NAME_ANY, aDesc[daColumnName]); |
| pSelectionItem = new SfxUsrAnyItem(FN_DB_DATA_SELECTION_ANY, aDesc[daSelection]); |
| pCursorItem = new SfxUsrAnyItem(FN_DB_DATA_CURSOR_ANY, aDesc[daCursor]); |
| } |
| |
| SwView& rView = rSh.GetView(); |
| //force ::SelectShell |
| rView.StopShellTimer(); |
| |
| SfxStringItem aDataDesc( nWh, sTxt ); |
| rView.GetViewFrame()->GetDispatcher()->Execute( |
| nWh, SFX_CALLMODE_ASYNCHRON, &aDataDesc, |
| pConnectionItem, pColumnItem, |
| pSourceItem, pCommandItem, pCommandTypeItem, |
| pColumnNameItem, pSelectionItem, pCursorItem,0L); |
| delete pConnectionItem; |
| delete pColumnItem; |
| delete pSourceItem; |
| delete pCommandItem; |
| delete pCommandTypeItem; |
| delete pColumnNameItem; |
| delete pSelectionItem; |
| delete pCursorItem; |
| } |
| else |
| { |
| SdrObject* pObj; |
| rSh.MakeDrawView(); |
| FmFormView* pFmView = PTR_CAST( FmFormView, rSh.GetDrawView() ); |
| if (pFmView && bHaveColumnDescriptor) |
| { |
| if ( 0 != (pObj = pFmView->CreateFieldControl( OColumnTransferable::extractColumnDescriptor(rData) ) ) ) |
| rSh.SwFEShell::InsertDrawObj( *pObj, *pDragPt ); |
| } |
| } |
| nRet = 1; |
| } |
| else if( bMsg ) |
| { |
| InfoBox( 0, SW_RES(MSG_CLPBRD_FORMAT_ERROR)).Execute(); |
| } |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::_PasteFileList( TransferableDataHelper& rData, |
| SwWrtShell& rSh, sal_Bool bLink, |
| const Point* pPt, sal_Bool bMsg ) |
| { |
| int nRet = 0; |
| FileList aFileList; |
| if( rData.GetFileList( SOT_FORMAT_FILE_LIST, aFileList ) && |
| aFileList.Count() ) |
| { |
| sal_uInt16 nAct = bLink ? SW_PASTESDR_SETATTR : SW_PASTESDR_INSERT; |
| String sFlyNm; |
| // iterate over the filelist |
| for( sal_uLong n = 0, nEnd = aFileList.Count(); n < nEnd; ++n ) |
| { |
| TransferDataContainer* pHlp = new TransferDataContainer; |
| pHlp->CopyString( FORMAT_FILE, aFileList.GetFile( n )); |
| TransferableDataHelper aData( pHlp ); |
| |
| if( SwTransferable::_PasteFileName( aData, rSh, SOT_FORMAT_FILE, nAct, |
| pPt, sal_False, bMsg )) |
| { |
| if( bLink ) |
| { |
| sFlyNm = rSh.GetFlyName(); |
| SwTransferable::SetSelInShell( rSh, sal_False, pPt ); |
| } |
| nRet = 1; |
| } |
| } |
| if( sFlyNm.Len() ) |
| rSh.GotoFly( sFlyNm ); |
| } |
| else if( bMsg ) |
| { |
| InfoBox( 0, SW_RES(MSG_CLPBRD_FORMAT_ERROR)).Execute(); |
| } |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool SwTransferable::_CheckForURLOrLNKFile( TransferableDataHelper& rData, |
| String& rFileName, String* pTitle ) |
| { |
| sal_Bool bIsURLFile = sal_False; |
| INetBookmark aBkmk; |
| if( rData.GetINetBookmark( SOT_FORMATSTR_ID_SOLK, aBkmk ) ) |
| { |
| rFileName = aBkmk.GetURL(); |
| if( pTitle ) |
| *pTitle = aBkmk.GetDescription(); |
| bIsURLFile = sal_True; |
| } |
| else |
| { |
| xub_StrLen nLen = rFileName.Len(); |
| if( 4 < nLen && '.' == rFileName.GetChar( nLen - 4 )) |
| { |
| String sExt( rFileName.Copy( nLen - 3 )); |
| if( sExt.EqualsIgnoreCaseAscii( "url" )) |
| { |
| ASSERT( !&rFileName, "how do we read today .URL - Files?" ); |
| } |
| } |
| } |
| return bIsURLFile; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool SwTransferable::IsPasteSpecial( const SwWrtShell& rWrtShell, |
| const TransferableDataHelper& rData ) |
| { |
| // we can paste-special if there's an entry in the paste-special-format list |
| SvxClipboardFmtItem aClipboardFmtItem(0); |
| FillClipFmtItem( rWrtShell, rData, aClipboardFmtItem); |
| return aClipboardFmtItem.Count() > 0; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::PasteFormat( SwWrtShell& rSh, |
| TransferableDataHelper& rData, |
| sal_uLong nFormat ) |
| { |
| SwWait aWait( *rSh.GetView().GetDocShell(), false ); |
| int nRet = 0; |
| |
| sal_uLong nPrivateFmt = FORMAT_PRIVATE; |
| SwTransferable *pClipboard = GetSwTransferable( rData ); |
| if( pClipboard && |
| ((TRNSFR_DOCUMENT|TRNSFR_GRAPHIC|TRNSFR_OLE) & pClipboard->eBufferType )) |
| nPrivateFmt = SOT_FORMATSTR_ID_EMBED_SOURCE; |
| |
| if( pClipboard && nPrivateFmt == nFormat ) |
| nRet = pClipboard->PrivatePaste( rSh ); |
| else if( rData.HasFormat( nFormat ) ) |
| { |
| uno::Reference<XTransferable> xTransferable( rData.GetXTransferable() ); |
| sal_uInt16 nEventAction, |
| nDestination = SwTransferable::GetSotDestination( rSh ), |
| nSourceOptions = |
| (( EXCHG_DEST_DOC_TEXTFRAME == nDestination || |
| EXCHG_DEST_SWDOC_FREE_AREA == nDestination || |
| EXCHG_DEST_DOC_TEXTFRAME_WEB == nDestination || |
| EXCHG_DEST_SWDOC_FREE_AREA_WEB == nDestination ) |
| ? EXCHG_IN_ACTION_COPY |
| : EXCHG_IN_ACTION_MOVE), |
| nAction = SotExchange::GetExchangeAction( |
| rData.GetDataFlavorExVector(), |
| nDestination, |
| nSourceOptions, /* ?? */ |
| EXCHG_IN_ACTION_DEFAULT, /* ?? */ |
| nFormat, nEventAction, nFormat, |
| lcl_getTransferPointer ( xTransferable ) ); |
| |
| if( EXCHG_INOUT_ACTION_NONE != nAction ) |
| nRet = SwTransferable::PasteData( rData, rSh, nAction, nFormat, |
| nDestination, sal_True, sal_False ); |
| } |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::_TestAllowedFormat( const TransferableDataHelper& rData, |
| sal_uLong nFormat, sal_uInt16 nDestination ) |
| { |
| sal_uInt16 nAction = EXCHG_INOUT_ACTION_NONE, nEventAction; |
| if( rData.HasFormat( nFormat )) { |
| uno::Reference<XTransferable> xTransferable( rData.GetXTransferable() ); |
| nAction = SotExchange::GetExchangeAction( |
| rData.GetDataFlavorExVector(), |
| nDestination, EXCHG_IN_ACTION_COPY, |
| EXCHG_IN_ACTION_COPY, nFormat, |
| nEventAction, nFormat, |
| lcl_getTransferPointer ( xTransferable ) ); |
| } |
| return EXCHG_INOUT_ACTION_NONE != nAction; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| /** |
| * the list of formats which will be offered to the user in the 'Paste |
| * Special...' dialog and the paste button menu |
| */ |
| static sal_uInt16 aPasteSpecialIds[] = |
| { |
| SOT_FORMATSTR_ID_HTML, |
| SOT_FORMATSTR_ID_HTML_SIMPLE, |
| SOT_FORMATSTR_ID_HTML_NO_COMMENT, |
| FORMAT_RTF, |
| FORMAT_STRING, |
| SOT_FORMATSTR_ID_SONLK, |
| SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK, |
| SOT_FORMATSTR_ID_DRAWING, |
| SOT_FORMATSTR_ID_SVXB, |
| FORMAT_GDIMETAFILE, |
| FORMAT_BITMAP, |
| SOT_FORMATSTR_ID_SVIM, |
| SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR, |
| 0 |
| }; |
| |
| |
| int SwTransferable::PasteUnformatted( SwWrtShell& rSh, TransferableDataHelper& rData ) |
| { |
| // Plain text == unformatted |
| return SwTransferable::PasteFormat( rSh, rData, SOT_FORMAT_STRING ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| int SwTransferable::PasteSpecial( SwWrtShell& rSh, TransferableDataHelper& rData, sal_uLong& rFormatUsed ) |
| { |
| int nRet = 0; |
| SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); |
| SfxAbstractPasteDialog* pDlg = pFact->CreatePasteDialog( &rSh.GetView().GetEditWin() ); |
| |
| DataFlavorExVector aFormats( rData.GetDataFlavorExVector() ); |
| TransferableObjectDescriptor aDesc; |
| |
| sal_uInt16 nDest = SwTransferable::GetSotDestination( rSh ); |
| |
| SwTransferable *pClipboard = GetSwTransferable( rData ); |
| if( pClipboard ) |
| { |
| aDesc = pClipboard->aObjDesc; |
| sal_uInt16 nResId; |
| if( pClipboard->eBufferType & TRNSFR_DOCUMENT ) |
| nResId = STR_PRIVATETEXT; |
| else if( pClipboard->eBufferType & TRNSFR_GRAPHIC ) |
| nResId = STR_PRIVATEGRAPHIC; |
| else if( pClipboard->eBufferType == TRNSFR_OLE ) |
| nResId = STR_PRIVATEOLE; |
| else |
| nResId = 0; |
| |
| if( nResId ) |
| { |
| if( STR_PRIVATEOLE == nResId || STR_PRIVATEGRAPHIC == nResId ) |
| { |
| // add SOT_FORMATSTR_ID_EMBED_SOURCE to the formats. This |
| // format display then the private format name. |
| DataFlavorEx aFlavorEx; |
| aFlavorEx.mnSotId = SOT_FORMATSTR_ID_EMBED_SOURCE; |
| aFormats.insert( aFormats.begin(), aFlavorEx ); |
| } |
| pDlg->SetObjName( pClipboard->aObjDesc.maClassName, |
| SW_RES( nResId ) ); |
| pDlg->Insert( SOT_FORMATSTR_ID_EMBED_SOURCE, aEmptyStr ); |
| } |
| } |
| else |
| { |
| if( rData.HasFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ) ) |
| rData.GetTransferableObjectDescriptor( |
| SOT_FORMATSTR_ID_OBJECTDESCRIPTOR, aDesc ); |
| |
| if( SwTransferable::_TestAllowedFormat( rData, SOT_FORMATSTR_ID_EMBED_SOURCE, nDest )) |
| pDlg->Insert( SOT_FORMATSTR_ID_EMBED_SOURCE, aEmptyStr ); |
| if( SwTransferable::_TestAllowedFormat( rData, SOT_FORMATSTR_ID_LINK_SOURCE, nDest )) |
| pDlg->Insert( SOT_FORMATSTR_ID_LINK_SOURCE, aEmptyStr ); |
| } |
| |
| if( SwTransferable::_TestAllowedFormat( rData, SOT_FORMATSTR_ID_LINK, nDest )) |
| pDlg->Insert( SOT_FORMATSTR_ID_LINK, SW_RES(STR_DDEFORMAT) ); |
| |
| for( sal_uInt16* pIds = aPasteSpecialIds; *pIds; ++pIds ) |
| if( SwTransferable::_TestAllowedFormat( rData, *pIds, nDest )) |
| pDlg->Insert( *pIds, aEmptyStr ); |
| |
| sal_uLong nFormat = pDlg->GetFormat( rData.GetTransferable() ); |
| |
| if( nFormat ) |
| nRet = SwTransferable::PasteFormat( rSh, rData, nFormat ); |
| |
| if ( nRet ) |
| rFormatUsed = nFormat; |
| |
| delete pDlg; |
| return nRet; |
| } |
| |
| |
| void SwTransferable::FillClipFmtItem( const SwWrtShell& rSh, |
| const TransferableDataHelper& rData, |
| SvxClipboardFmtItem & rToFill ) |
| { |
| sal_uInt16 nDest = SwTransferable::GetSotDestination( rSh ); |
| |
| SwTransferable *pClipboard = GetSwTransferable( rData ); |
| if( pClipboard ) |
| { |
| sal_uInt16 nResId; |
| if( pClipboard->eBufferType & TRNSFR_DOCUMENT ) |
| nResId = STR_PRIVATETEXT; |
| else if( pClipboard->eBufferType & TRNSFR_GRAPHIC ) |
| nResId = STR_PRIVATEGRAPHIC; |
| else if( pClipboard->eBufferType == TRNSFR_OLE ) |
| nResId = STR_PRIVATEOLE; |
| else |
| nResId = 0; |
| |
| if( nResId ) |
| rToFill.AddClipbrdFormat( SOT_FORMATSTR_ID_EMBED_SOURCE, |
| SW_RES( nResId ) ); |
| } |
| else |
| { |
| TransferableObjectDescriptor aDesc; |
| if( rData.HasFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ) ) |
| ((TransferableDataHelper&)rData).GetTransferableObjectDescriptor( |
| SOT_FORMATSTR_ID_OBJECTDESCRIPTOR, aDesc ); |
| |
| if( SwTransferable::_TestAllowedFormat( rData, SOT_FORMATSTR_ID_EMBED_SOURCE, nDest )) |
| rToFill.AddClipbrdFormat( SOT_FORMATSTR_ID_EMBED_SOURCE, |
| aDesc.maTypeName ); |
| if( SwTransferable::_TestAllowedFormat( rData, SOT_FORMATSTR_ID_LINK_SOURCE, nDest )) |
| rToFill.AddClipbrdFormat( SOT_FORMATSTR_ID_LINK_SOURCE ); |
| |
| SotFormatStringId nFormat; |
| if ( rData.HasFormat(nFormat = SOT_FORMATSTR_ID_EMBED_SOURCE_OLE) || rData.HasFormat(nFormat = SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE) ) |
| { |
| String sName,sSource; |
| if ( SvPasteObjectHelper::GetEmbeddedName(rData,sName,sSource,nFormat) ) |
| rToFill.AddClipbrdFormat( nFormat, sName ); |
| } |
| } |
| |
| if( SwTransferable::_TestAllowedFormat( rData, SOT_FORMATSTR_ID_LINK, nDest )) |
| rToFill.AddClipbrdFormat( SOT_FORMATSTR_ID_LINK, SW_RES(STR_DDEFORMAT) ); |
| |
| for( sal_uInt16* pIds = aPasteSpecialIds; *pIds; ++pIds ) |
| if( SwTransferable::_TestAllowedFormat( rData, *pIds, nDest )) |
| rToFill.AddClipbrdFormat( *pIds, aEmptyStr ); |
| } |
| |
| void SwTransferable::SetDataForDragAndDrop( const Point& rSttPos ) |
| { |
| if(!pWrtShell) |
| return; |
| String sGrfNm; |
| const int nSelection = pWrtShell->GetSelectionType(); |
| if( nsSelectionType::SEL_GRF == nSelection) |
| { |
| AddFormat( SOT_FORMATSTR_ID_SVXB ); |
| // --> OD 2005-02-09 #119353# - robust |
| const Graphic* pGrf = pWrtShell->GetGraphic(); |
| if ( pGrf && pGrf->IsSupportedGraphic() ) |
| // <-- |
| { |
| AddFormat( FORMAT_GDIMETAFILE ); |
| AddFormat( SOT_FORMATSTR_ID_PNG ); |
| AddFormat( FORMAT_BITMAP ); |
| } |
| eBufferType = TRNSFR_GRAPHIC; |
| pWrtShell->GetGrfNms( &sGrfNm, 0 ); |
| } |
| else if( nsSelectionType::SEL_OLE == nSelection ) |
| { |
| AddFormat( SOT_FORMATSTR_ID_EMBED_SOURCE ); |
| PrepareOLE( aObjDesc ); |
| AddFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ); |
| AddFormat( FORMAT_GDIMETAFILE ); |
| eBufferType = TRNSFR_OLE; |
| } |
| //Gibt es ueberhaupt etwas zum bereitstellen? |
| else if ( pWrtShell->IsSelection() || pWrtShell->IsFrmSelected() || |
| pWrtShell->IsObjSelected() ) |
| { |
| if( pWrtShell->IsObjSelected() ) |
| eBufferType = TRNSFR_DRAWING; |
| else |
| { |
| eBufferType = TRNSFR_DOCUMENT; |
| if( SwWrtShell::NO_WORD != |
| pWrtShell->IntelligentCut( nSelection, sal_False )) |
| eBufferType = TransferBufferType( TRNSFR_DOCUMENT_WORD |
| | eBufferType); |
| } |
| |
| if( nSelection & nsSelectionType::SEL_TBL_CELLS ) |
| eBufferType = (TransferBufferType)(TRNSFR_TABELLE | eBufferType); |
| |
| AddFormat( SOT_FORMATSTR_ID_EMBED_SOURCE ); |
| |
| //RTF vor das Metafile von OLE stellen, weil mit weniger verlusten |
| //behaftet. |
| if( !pWrtShell->IsObjSelected() ) |
| { |
| AddFormat( FORMAT_RTF ); |
| AddFormat( SOT_FORMATSTR_ID_HTML ); |
| } |
| if( pWrtShell->IsSelection() ) |
| AddFormat( FORMAT_STRING ); |
| |
| if( nSelection & ( nsSelectionType::SEL_DRW | nsSelectionType::SEL_DRW_FORM )) |
| { |
| AddFormat( SOT_FORMATSTR_ID_DRAWING ); |
| if ( nSelection & nsSelectionType::SEL_DRW ) |
| { |
| AddFormat( FORMAT_GDIMETAFILE ); |
| AddFormat( SOT_FORMATSTR_ID_PNG ); |
| AddFormat( FORMAT_BITMAP ); |
| } |
| eBufferType = (TransferBufferType)( TRNSFR_GRAPHIC | eBufferType ); |
| |
| pClpGraphic = new Graphic; |
| if( !pWrtShell->GetDrawObjGraphic( FORMAT_GDIMETAFILE, *pClpGraphic )) |
| pOrigGrf = pClpGraphic; |
| pClpBitmap = new Graphic; |
| if( !pWrtShell->GetDrawObjGraphic( FORMAT_BITMAP, *pClpBitmap )) |
| pOrigGrf = pClpBitmap; |
| |
| // ist es ein URL-Button ? |
| String sURL, sDesc; |
| if( pWrtShell->GetURLFromButton( sURL, sDesc ) ) |
| { |
| AddFormat( FORMAT_STRING ); |
| AddFormat( SOT_FORMATSTR_ID_SOLK ); |
| AddFormat( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK ); |
| AddFormat( SOT_FORMATSTR_ID_FILECONTENT ); |
| AddFormat( SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR ); |
| AddFormat( SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR ); |
| eBufferType = (TransferBufferType)( TRNSFR_INETFLD | eBufferType ); |
| } |
| } |
| |
| //ObjectDescriptor wurde bereits aus der alten DocShell gefuellt. |
| //Jetzt noch anpassen. Dadurch kann im GetData die erste Anfrage |
| //auch noch mit delayed rendering beantwortet werden. |
| aObjDesc.mbCanLink = sal_False; |
| aObjDesc.maDragStartPos = rSttPos; |
| aObjDesc.maSize = OutputDevice::LogicToLogic( Size( OLESIZE ), |
| MAP_TWIP, MAP_100TH_MM ); |
| PrepareOLE( aObjDesc ); |
| AddFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ); |
| } |
| else if( nSelection & nsSelectionType::SEL_TXT && !pWrtShell->HasMark() ) |
| { |
| // ist nur ein Feld - Selektiert? |
| SwContentAtPos aCntntAtPos( SwContentAtPos::SW_INETATTR ); |
| Point aPos( SwEditWin::GetDDStartPosX(), SwEditWin::GetDDStartPosY()); |
| |
| if( pWrtShell->GetContentAtPos( aPos, aCntntAtPos ) ) |
| { |
| AddFormat( FORMAT_STRING ); |
| AddFormat( SOT_FORMATSTR_ID_SOLK ); |
| AddFormat( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK ); |
| AddFormat( SOT_FORMATSTR_ID_FILECONTENT ); |
| AddFormat( SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR ); |
| AddFormat( SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR ); |
| eBufferType = TRNSFR_INETFLD; |
| } |
| } |
| |
| if( pWrtShell->IsFrmSelected() ) |
| { |
| SfxItemSet aSet( pWrtShell->GetAttrPool(), RES_URL, RES_URL ); |
| pWrtShell->GetFlyFrmAttr( aSet ); |
| const SwFmtURL& rURL = (SwFmtURL&)aSet.Get( RES_URL ); |
| if( rURL.GetMap() ) |
| { |
| pImageMap = new ImageMap( *rURL.GetMap() ); |
| AddFormat( SOT_FORMATSTR_ID_SVIM ); |
| } |
| else if( rURL.GetURL().Len() ) |
| { |
| pTargetURL = new INetImage( sGrfNm, rURL.GetURL(), |
| rURL.GetTargetFrameName(), |
| aEmptyStr, Size() ); |
| AddFormat( SOT_FORMATSTR_ID_INET_IMAGE ); |
| } |
| } |
| } |
| |
| void SwTransferable::StartDrag( Window* pWin, const Point& rPos ) |
| { |
| if(!pWrtShell) |
| return; |
| bOldIdle = pWrtShell->GetViewOptions()->IsIdle(); |
| bCleanUp = sal_True; |
| |
| ((SwViewOption *)pWrtShell->GetViewOptions())->SetIdle( sal_False ); |
| |
| if( pWrtShell->IsSelFrmMode() ) |
| pWrtShell->ShowCrsr(); |
| |
| SW_MOD()->pDragDrop = this; |
| |
| SetDataForDragAndDrop( rPos ); |
| |
| sal_Int8 nDragOptions = DND_ACTION_COPYMOVE | DND_ACTION_LINK; |
| SwDocShell* pDShell = pWrtShell->GetView().GetDocShell(); |
| if( ( pDShell && pDShell->IsReadOnly() ) || pWrtShell->HasReadonlySel() ) |
| nDragOptions &= ~DND_ACTION_MOVE; |
| |
| TransferableHelper::StartDrag( pWin, nDragOptions ); |
| } |
| |
| void SwTransferable::DragFinished( sal_Int8 nAction ) |
| { |
| //Und noch die letzten Nacharbeiten damit alle Stati stimmen. |
| if( DND_ACTION_MOVE == nAction ) |
| { |
| if( bCleanUp ) |
| { |
| //Es wurde auserhalb des Writers gedroped. Wir muessen noch |
| //loeschen. |
| |
| pWrtShell->StartAllAction(); |
| pWrtShell->StartUndo( UNDO_UI_DRAG_AND_MOVE ); |
| if ( pWrtShell->IsTableMode() ) |
| pWrtShell->DeleteTblSel(); |
| else |
| { |
| if ( !(pWrtShell->IsSelFrmMode() || pWrtShell->IsObjSelected()) ) |
| //SmartCut, eines der Blanks mitnehmen. |
| pWrtShell->IntelligentCut( pWrtShell->GetSelectionType(), sal_True ); |
| pWrtShell->DelRight(); |
| } |
| pWrtShell->EndUndo( UNDO_UI_DRAG_AND_MOVE ); |
| pWrtShell->EndAllAction(); |
| } |
| else |
| { |
| const int nSelection = pWrtShell->GetSelectionType(); |
| if( ( nsSelectionType::SEL_FRM | nsSelectionType::SEL_GRF | |
| nsSelectionType::SEL_OLE | nsSelectionType::SEL_DRW ) & nSelection ) |
| { |
| pWrtShell->EnterSelFrmMode(); |
| } |
| } |
| } |
| pWrtShell->GetView().GetEditWin().DragFinished(); |
| |
| if( pWrtShell->IsSelFrmMode() ) |
| pWrtShell->HideCrsr(); |
| else |
| pWrtShell->ShowCrsr(); |
| //!! else if( DND_ACTION_NONE != nAction ) |
| //!! pWrtShell->ShowCrsr(); |
| //!! else |
| //!! { |
| //!! //Muss wohl sein weil gescrollt wurde und ?...? |
| //!! pWrtShell->StartAction(); |
| //!! pWrtShell->EndAction(); |
| //!! } |
| |
| ((SwViewOption *)pWrtShell->GetViewOptions())->SetIdle( bOldIdle ); |
| } |
| |
| |
| /* */ |
| |
| int SwTransferable::PrivatePaste( SwWrtShell& rShell ) |
| { |
| // erst den SelectionType erfragen, dann Action-Klammerung !!!! |
| // (sonst wird nicht in eine TabellenSelektion gepastet!!!) |
| ASSERT( !rShell.ActionPend(), "Paste darf nie eine Actionklammerung haben" ); |
| if ( !pClpDocFac ) |
| return sal_False; // the return value of the SwFEShell::Paste also is sal_Bool! |
| |
| const int nSelection = rShell.GetSelectionType(); |
| |
| // #111827# |
| SwRewriter aRewriter; |
| |
| SwTrnsfrActionAndUndo aAction( &rShell, UNDO_PASTE_CLIPBOARD); |
| |
| bool bKillPaMs = false; |
| |
| //Selektierten Inhalt loeschen, nicht bei Tabellen-Selektion und |
| //Tabelle im Clipboard |
| if( rShell.HasSelection() && !( nSelection & nsSelectionType::SEL_TBL_CELLS)) |
| { |
| bKillPaMs = true; |
| rShell.SetRetainSelection( true ); |
| rShell.DelRight(); |
| // war ein Fly selektiert, so muss jetzt fuer eine gueltige |
| // Cursor-Position gesorgt werden! (geparkter Cursor!) |
| if( ( nsSelectionType::SEL_FRM | nsSelectionType::SEL_GRF | |
| nsSelectionType::SEL_OLE | nsSelectionType::SEL_DRW | |
| nsSelectionType::SEL_DRW_FORM ) & nSelection ) |
| { |
| // den Cursor wieder positionieren |
| Point aPt( rShell.GetCharRect().Pos() ); |
| rShell.SwCrsrShell::SetCrsr( aPt, sal_True ); |
| } |
| rShell.SetRetainSelection( false ); |
| } |
| |
| sal_Bool bInWrd = sal_False, bEndWrd = sal_False, bSttWrd = sal_False, |
| bSmart = 0 != (TRNSFR_DOCUMENT_WORD & eBufferType); |
| if( bSmart ) |
| { |
| // #108491# Why not for other Scripts? If TRNSFR_DOCUMENT_WORD is set, we have |
| // a word in the buffer, word in this context means 'something with spaces at |
| // beginning and end'. In this case we definitely want these spaces to be inserted |
| // here. |
| // if( SCRIPTTYPE_LATIN != rShell.GetScriptType() ) |
| // bSmart = sal_False; |
| // else |
| // { |
| bInWrd = rShell.IsInWrd(); |
| bEndWrd = rShell.IsEndWrd(); |
| bSmart = bInWrd || bEndWrd; |
| if( bSmart ) |
| { |
| bSttWrd = rShell.IsSttWrd(); |
| if( bSmart && !bSttWrd && (bInWrd || bEndWrd) ) |
| rShell.SwEditShell::Insert(' '); |
| } |
| // } |
| } |
| |
| int nRet = rShell.Paste( pClpDocFac->GetDoc() ); |
| |
| if( bKillPaMs ) |
| rShell.KillPams(); |
| |
| // Wenn Smart Paste dann Leerzeichen einfuegen |
| if( nRet && bSmart && ((bInWrd && !bEndWrd )|| bSttWrd) ) |
| rShell.SwEditShell::Insert(' '); |
| |
| return nRet; |
| } |
| |
| int SwTransferable::PrivateDrop( SwWrtShell& rSh, const Point& rDragPt, |
| sal_Bool bMove, sal_Bool bIsXSelection ) |
| { |
| int cWord = 0; |
| sal_Bool bInWrd = sal_False; |
| sal_Bool bEndWrd = sal_False; |
| sal_Bool bSttWrd = sal_False; |
| sal_Bool bSttPara= sal_False; |
| sal_Bool bTblSel = sal_False; |
| sal_Bool bFrmSel = sal_False; |
| |
| SwWrtShell& rSrcSh = *GetShell(); |
| |
| rSh.UnSetVisCrsr(); |
| |
| if( TRNSFR_INETFLD == eBufferType ) |
| { |
| if( rSh.GetFmtFromObj( rDragPt ) ) |
| { |
| INetBookmark aTmp; |
| if( (TRNSFR_INETFLD & eBufferType) && pBkmk ) |
| aTmp = *pBkmk; |
| |
| // Zielgrafik selektieren |
| if( rSh.SelectObj( rDragPt ) ) |
| { |
| rSh.HideCrsr(); |
| rSh.EnterSelFrmMode( &rDragPt ); |
| bFrmDrag = sal_True; |
| } |
| |
| const int nSelection = rSh.GetSelectionType(); |
| |
| // Draw-Objekte erstmal noch nicht beruecksichtigen |
| if( nsSelectionType::SEL_GRF & nSelection ) |
| { |
| SfxItemSet aSet( rSh.GetAttrPool(), RES_URL, RES_URL ); |
| rSh.GetFlyFrmAttr( aSet ); |
| SwFmtURL aURL( (SwFmtURL&)aSet.Get( RES_URL ) ); |
| aURL.SetURL( aTmp.GetURL(), sal_False ); |
| aSet.Put( aURL ); |
| rSh.SetFlyFrmAttr( aSet ); |
| return 1; |
| } |
| |
| if( nsSelectionType::SEL_DRW & nSelection ) |
| { |
| rSh.LeaveSelFrmMode(); |
| rSh.UnSelectFrm(); |
| rSh.ShowCrsr(); |
| bFrmDrag = sal_False; |
| } |
| } |
| } |
| |
| if( &rSh != &rSrcSh && (nsSelectionType::SEL_GRF & rSh.GetSelectionType()) && |
| TRNSFR_GRAPHIC == eBufferType ) |
| { |
| // ReRead auf die Grafik |
| String sGrfNm, sFltNm; |
| rSrcSh.GetGrfNms( &sGrfNm, &sFltNm ); |
| rSh.ReRead( sGrfNm, sFltNm, rSrcSh.GetGraphic() ); |
| return 1; |
| } |
| |
| //Nicht in Selektionen oder selektierten Rahmen |
| if( rSh.ChgCurrPam( rDragPt ) || |
| ( rSh.IsSelFrmMode() && rSh.IsInsideSelectedObj( rDragPt )) ) |
| return 0; |
| |
| if( rSrcSh.IsTableMode() ) |
| bTblSel = sal_True; |
| else if( rSrcSh.IsSelFrmMode() || rSrcSh.IsObjSelected() ) |
| { |
| // keine positionsgeschuetzten Objecte verschieben! |
| if( bMove && rSrcSh.IsSelObjProtected( FLYPROTECT_POS ) ) |
| return 0; |
| |
| bFrmSel = sal_True; |
| } |
| |
| const int nSel = rSrcSh.GetSelectionType(); |
| |
| SwUndoId eUndoId = bMove ? UNDO_UI_DRAG_AND_MOVE : UNDO_UI_DRAG_AND_COPY; |
| |
| // #111827# |
| SwRewriter aRewriter; |
| |
| aRewriter.AddRule(UNDO_ARG1, rSrcSh.GetSelDescr()); |
| |
| if(rSrcSh.GetDoc() != rSh.GetDoc()) |
| rSrcSh.StartUndo( eUndoId, &aRewriter ); |
| rSh.StartUndo( eUndoId, &aRewriter ); |
| |
| rSh.StartAction(); |
| rSrcSh.StartAction(); |
| |
| if( &rSrcSh != &rSh ) |
| { |
| rSh.EnterStdMode(); |
| rSh.SwCrsrShell::SetCrsr( rDragPt, sal_True ); |
| cWord = rSrcSh.IntelligentCut( nSel, sal_False ); |
| } |
| else if( !bTblSel && !bFrmSel ) |
| { |
| if( !rSh.IsAddMode() ) |
| { |
| // --> OD 2008-03-19 #i87233# |
| if ( rSh.IsBlockMode() ) |
| { |
| // preserve order of cursors for block mode |
| rSh.GoPrevCrsr(); |
| } |
| // <-- |
| rSh.SwCrsrShell::CreateCrsr(); |
| } |
| rSh.SwCrsrShell::SetCrsr( rDragPt, sal_True, false ); |
| rSh.GoPrevCrsr(); |
| cWord = rSh.IntelligentCut( rSh.GetSelectionType(), sal_False ); |
| rSh.GoNextCrsr(); |
| } |
| |
| bInWrd = rSh.IsInWrd(); |
| bEndWrd = rSh.IsEndWrd(); |
| bSttWrd = !bEndWrd && rSh.IsSttWrd(); |
| bSttPara= rSh.IsSttPara(); |
| |
| Point aSttPt( SwEditWin::GetDDStartPosX(), SwEditWin::GetDDStartPosY() ); |
| |
| //JP 05.03.96: INetFelder erstmal selektieren ! |
| if( TRNSFR_INETFLD == eBufferType ) |
| { |
| if( &rSrcSh == &rSh ) |
| { |
| rSh.GoPrevCrsr(); |
| rSh.SwCrsrShell::SetCrsr( aSttPt, sal_True ); |
| rSh.SelectTxtAttr( RES_TXTATR_INETFMT ); |
| if( rSh.ChgCurrPam( rDragPt ) ) |
| { |
| // nicht in sich selbst kopieren/verschieben |
| rSh.DestroyCrsr(); |
| rSh.EndUndo(); |
| rSh.EndAction(); |
| rSh.EndAction(); |
| return 0; |
| } |
| rSh.GoNextCrsr(); |
| } |
| else |
| { |
| rSrcSh.SwCrsrShell::SetCrsr( aSttPt, sal_True ); |
| rSrcSh.SelectTxtAttr( RES_TXTATR_INETFMT ); |
| } |
| |
| // ist am Einfuege Punkt ein URL-Attribut? Dann das ersetzen, |
| // also einfach eine Selektion aufspannen? |
| rSh.DelINetAttrWithText(); |
| bDDINetAttr = sal_True; |
| } |
| |
| if ( rSrcSh.IsSelFrmMode() ) |
| { |
| //Hack: Spezialbehandlung austricksen |
| aSttPt -= aSttPt - rSrcSh.GetObjRect().Pos(); |
| } |
| |
| sal_Bool bRet = rSrcSh.SwFEShell::Copy( &rSh, aSttPt, rDragPt, bMove, |
| !bIsXSelection ); |
| |
| if( !bIsXSelection ) |
| { |
| rSrcSh.Push(); |
| if ( bRet && bMove && !bFrmSel ) |
| { |
| if ( bTblSel ) |
| { |
| /* #109590# delete table contents not cells */ |
| rSrcSh.Delete(); |
| } |
| else |
| { |
| //SmartCut, eines der Blank mitnehmen. |
| rSh.SwCrsrShell::DestroyCrsr(); |
| if ( cWord == SwWrtShell::WORD_SPACE_BEFORE ) |
| rSh.ExtendSelection( sal_False ); |
| else if ( cWord == SwWrtShell::WORD_SPACE_AFTER ) |
| rSh.ExtendSelection(); |
| rSrcSh.DelRight(); |
| } |
| } |
| rSrcSh.KillPams(); |
| rSrcSh.Pop( sal_False ); |
| |
| /* #109590# after dragging a table selection inside one shell |
| set cursor to the drop position. */ |
| if( &rSh == &rSrcSh && ( bTblSel || rSh.IsBlockMode() ) ) |
| { |
| rSrcSh.SwCrsrShell::SetCrsr(rDragPt); |
| rSrcSh.GetSwCrsr()->SetMark(); |
| } |
| } |
| |
| if( bRet && !bTblSel && !bFrmSel ) |
| { |
| if( (bInWrd || bEndWrd) && |
| (cWord == SwWrtShell::WORD_SPACE_AFTER || |
| cWord == SwWrtShell::WORD_SPACE_BEFORE) ) |
| { |
| if ( bSttWrd || (bInWrd && !bEndWrd)) |
| rSh.SwEditShell::Insert(' ', bIsXSelection); |
| if ( !bSttWrd || (bInWrd && !bSttPara) ) |
| { |
| rSh.SwapPam(); |
| if ( !bSttWrd ) |
| rSh.SwEditShell::Insert(' ', bIsXSelection); |
| rSh.SwapPam(); |
| } |
| } |
| |
| if( bIsXSelection ) |
| { |
| if( &rSrcSh == &rSh && !rSh.IsAddMode() ) |
| { |
| rSh.SwCrsrShell::DestroyCrsr(); |
| rSh.GoPrevCrsr(); |
| } |
| else |
| { |
| rSh.SwapPam(); |
| rSh.SwCrsrShell::ClearMark(); |
| } |
| } |
| else |
| { |
| if( rSh.IsAddMode() ) |
| rSh.SwCrsrShell::CreateCrsr(); |
| else |
| { |
| // Selektionsmodus einschalten |
| rSh.SttSelect(); |
| rSh.EndSelect(); |
| } |
| } |
| } |
| |
| if( bRet && bMove && bFrmSel ) |
| rSrcSh.LeaveSelFrmMode(); |
| |
| if( rSrcSh.GetDoc() != rSh.GetDoc() ) |
| rSrcSh.EndUndo(); |
| rSh.EndUndo(); |
| |
| // Shell in den richtigen Status versetzen |
| if( &rSrcSh != &rSh && ( rSh.IsFrmSelected() || rSh.IsObjSelected() )) |
| rSh.EnterSelFrmMode(); |
| |
| rSrcSh.EndAction(); |
| rSh.EndAction(); |
| return 1; |
| } |
| |
| // Interfaces for Selection |
| void SwTransferable::CreateSelection( SwWrtShell& rSh, |
| const ViewShell * _pCreatorView ) |
| { |
| SwModule *pMod = SW_MOD(); |
| SwTransferable* pNew = new SwTransferable( rSh ); |
| |
| /* #96392#*/ |
| pNew->pCreatorView = _pCreatorView; |
| |
| uno::Reference< |
| datatransfer::XTransferable > xRef( pNew ); |
| pMod->pXSelection = pNew; |
| pNew->CopyToSelection( rSh.GetWin() ); |
| } |
| |
| void SwTransferable::ClearSelection( SwWrtShell& rSh, |
| const ViewShell * _pCreatorView) |
| { |
| SwModule *pMod = SW_MOD(); |
| if( pMod->pXSelection && |
| ((!pMod->pXSelection->pWrtShell) || (pMod->pXSelection->pWrtShell == &rSh)) && |
| /* #96392# */ |
| (!_pCreatorView || (pMod->pXSelection->pCreatorView == _pCreatorView)) ) |
| { |
| TransferableHelper::ClearSelection( rSh.GetWin() ); |
| } |
| } |
| /* -----------------3/31/2003 11:46AM---------------- |
| |
| --------------------------------------------------*/ |
| const Sequence< sal_Int8 >& SwTransferable::getUnoTunnelId() |
| { |
| static Sequence< sal_Int8 > aSeq; |
| if( !aSeq.getLength() ) |
| { |
| static osl::Mutex aCreateMutex; |
| osl::Guard< osl::Mutex > aGuard( aCreateMutex ); |
| aSeq.realloc( 16 ); |
| rtl_createUuid( reinterpret_cast< sal_uInt8* >( aSeq.getArray() ), 0, sal_True ); |
| } |
| return aSeq; |
| } |
| /* -----------------3/31/2003 11:46AM---------------- |
| |
| --------------------------------------------------*/ |
| sal_Int64 SwTransferable::getSomething( const Sequence< sal_Int8 >& rId ) throw( 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 = TransferableHelper::getSomething(rId); |
| return nRet; |
| } |
| |
| SwTransferable* SwTransferable::GetSwTransferable( const TransferableDataHelper& rData ) |
| { |
| SwTransferable* pSwTransferable = NULL; |
| |
| uno::Reference<XUnoTunnel> xTunnel( rData.GetTransferable(), UNO_QUERY ); |
| if ( xTunnel.is() ) |
| { |
| sal_Int64 nHandle = xTunnel->getSomething( getUnoTunnelId() ); |
| if ( nHandle ) |
| pSwTransferable = (SwTransferable*) (sal_IntPtr) nHandle; |
| } |
| |
| return pSwTransferable; |
| |
| } |
| |
| /* */ |
| |
| // ----------------------------------------------------------------------- |
| |
| SwTrnsfrDdeLink::SwTrnsfrDdeLink( SwTransferable& rTrans, SwWrtShell& rSh ) |
| : rTrnsfr( rTrans ), pDocShell( 0 ), |
| bDelBookmrk( sal_False ), bInDisconnect( sal_False ) |
| { |
| // hier kommen wir nur bei Tabellen- oder Text-Selection an |
| const int nSelection = rSh.GetSelectionType(); |
| if( nsSelectionType::SEL_TBL_CELLS & nSelection ) |
| { |
| SwFrmFmt* pFmt = rSh.GetTableFmt(); |
| if( pFmt ) |
| sName = pFmt->GetName(); |
| } |
| else |
| { |
| // creating a temp. bookmark without undo |
| sal_Bool bUndo = rSh.DoesUndo(); |
| rSh.DoUndo( sal_False ); |
| sal_Bool bIsModified = rSh.IsModified(); |
| |
| ::sw::mark::IMark* pMark = rSh.SetBookmark( |
| KeyCode(), |
| ::rtl::OUString(), |
| ::rtl::OUString(), |
| IDocumentMarkAccess::DDE_BOOKMARK); |
| if(pMark) |
| { |
| sName = pMark->GetName(); |
| bDelBookmrk = sal_True; |
| if( !bIsModified ) |
| rSh.ResetModified(); |
| } |
| else |
| sName.Erase(); |
| rSh.DoUndo( bUndo ); |
| } |
| |
| if( sName.Len() && |
| 0 != ( pDocShell = rSh.GetDoc()->GetDocShell() ) ) |
| { |
| // dann erzeugen wir uns mal unseren "Server" und connecten uns |
| // zu diesem |
| refObj = pDocShell->DdeCreateLinkSource( sName ); |
| if( refObj.Is() ) |
| { |
| refObj->AddConnectAdvise( this ); |
| refObj->AddDataAdvise( this, |
| // SotExchange::GetFormatMimeType( FORMAT_RTF ), |
| aEmptyStr, |
| ADVISEMODE_NODATA | ADVISEMODE_ONLYONCE ); |
| nOldTimeOut = refObj->GetUpdateTimeout(); |
| refObj->SetUpdateTimeout( 0 ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| SwTrnsfrDdeLink::~SwTrnsfrDdeLink() |
| { |
| if( refObj.Is() ) |
| Disconnect( sal_True ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SwTrnsfrDdeLink::DataChanged( const String& , |
| const uno::Any& ) |
| { |
| // tja das wars dann mit dem Link |
| if( !bInDisconnect ) |
| { |
| if( FindDocShell() && pDocShell->GetView() ) |
| rTrnsfr.RemoveDDELinkFormat( pDocShell->GetView()->GetEditWin() ); |
| Disconnect( sal_False ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool SwTrnsfrDdeLink::WriteData( SvStream& rStrm ) |
| { |
| if( !refObj.Is() || !FindDocShell() ) |
| return sal_False; |
| |
| rtl_TextEncoding eEncoding = DDE_TXT_ENCODING; |
| const ByteString aAppNm( GetpApp()->GetAppName(), eEncoding ); |
| const ByteString aTopic( pDocShell->GetTitle( SFX_TITLE_FULLNAME ), |
| eEncoding ); |
| const ByteString aName( sName, eEncoding ); |
| |
| sal_Char* pMem = new char[ aAppNm.Len() + aTopic.Len() + aName.Len() + 4 ]; |
| |
| xub_StrLen nLen = aAppNm.Len(); |
| memcpy( pMem, aAppNm.GetBuffer(), nLen ); |
| pMem[ nLen++ ] = 0; |
| memcpy( pMem + nLen, aTopic.GetBuffer(), aTopic.Len() ); |
| nLen = nLen + aTopic.Len(); |
| pMem[ nLen++ ] = 0; |
| memcpy( pMem + nLen, aName.GetBuffer(), aName.Len() ); |
| nLen = nLen + aName.Len(); |
| pMem[ nLen++ ] = 0; |
| pMem[ nLen++ ] = 0; |
| |
| rStrm.Write( pMem, nLen ); |
| delete[] pMem; |
| |
| IDocumentMarkAccess* const pMarkAccess = pDocShell->GetDoc()->getIDocumentMarkAccess(); |
| IDocumentMarkAccess::const_iterator_t ppMark = pMarkAccess->findMark(sName); |
| if(ppMark != pMarkAccess->getAllMarksEnd() |
| && IDocumentMarkAccess::GetType(**ppMark) != IDocumentMarkAccess::BOOKMARK) |
| { |
| // the mark is still a DdeBookmark |
| // we replace it with a Bookmark, so it will get saved etc. |
| ::sw::mark::IMark* const pMark = ppMark->get(); |
| SwServerObject* const pServerObject = dynamic_cast<SwServerObject *>(&refObj); |
| |
| // collecting state of old mark |
| SwPaM aPaM(pMark->GetMarkStart()); |
| *aPaM.GetPoint() = pMark->GetMarkStart(); |
| if(pMark->IsExpanded()) |
| { |
| aPaM.SetMark(); |
| *aPaM.GetMark() = pMark->GetMarkEnd(); |
| } |
| ::rtl::OUString sMarkName = pMark->GetName(); |
| |
| // remove mark |
| pServerObject->SetNoServer(); // this removes the connection between SwServerObject and mark |
| // N.B. ppMark was not loaded from file and cannot have xml:id |
| pMarkAccess->deleteMark(ppMark); |
| |
| // recreate as Bookmark |
| ::sw::mark::IMark* const pNewMark = pMarkAccess->makeMark( |
| aPaM, |
| sMarkName, |
| IDocumentMarkAccess::BOOKMARK); |
| pServerObject->SetDdeBookmark(*pNewMark); |
| } |
| |
| bDelBookmrk = false; |
| return true; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SwTrnsfrDdeLink::Disconnect( sal_Bool bRemoveDataAdvise ) |
| { |
| //JP 29.01.96 Bug 24432: |
| // kein DataChanged mehr entgegen nehmen, wenn man |
| // sich schon im Disconnet befindet! |
| // (DTOR vom Bookmark verschickt einen DataChanged!) |
| const sal_Bool bOldDisconnect = bInDisconnect; |
| bInDisconnect = sal_True; |
| |
| // den nicht verwendeten Bookmark wieder zerstoeren (ohne Undo!)? |
| if( bDelBookmrk && refObj.Is() && FindDocShell() ) |
| { |
| SwDoc* pDoc = pDocShell->GetDoc(); |
| ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo()); |
| |
| // --> OD, CD, OS 2005-11-25 #i58448# |
| Link aSavedOle2Link( pDoc->GetOle2Link() ); |
| pDoc->SetOle2Link( Link() ); |
| // <-- |
| sal_Bool bIsModified = pDoc->IsModified(); |
| |
| IDocumentMarkAccess* const pMarkAccess = pDoc->getIDocumentMarkAccess(); |
| // check, if DdeBookmark is already in its destruction |
| IDocumentMarkAccess::const_iterator_t ppMark = pMarkAccess->findMark(sName); |
| if ( ppMark != pMarkAccess->getAllMarksEnd() ) |
| { |
| ::sw::mark::DdeBookmark* const pDdeBookmark = dynamic_cast< ::sw::mark::DdeBookmark* >(ppMark->get()); |
| if ( pDdeBookmark && !pDdeBookmark->IsInDestruction() ) |
| { |
| pMarkAccess->deleteMark(ppMark); |
| } |
| } |
| |
| if( !bIsModified ) |
| pDoc->ResetModified(); |
| pDoc->SetOle2Link( aSavedOle2Link ); |
| |
| bDelBookmrk = sal_False; |
| } |
| |
| if( refObj.Is() ) |
| { |
| refObj->SetUpdateTimeout( nOldTimeOut ); |
| refObj->RemoveConnectAdvise( this ); |
| if( bRemoveDataAdvise ) |
| // in einem DataChanged darf das SelectionObject NIE geloescht |
| // werden; wird schon von der Basisklasse erledigt |
| // (ADVISEMODE_ONLYONCE!!!!) |
| // Im normalen Disconnet aber schon! |
| refObj->RemoveAllDataAdvise( this ); |
| refObj.Clear(); |
| } |
| bInDisconnect = bOldDisconnect; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool SwTrnsfrDdeLink::FindDocShell() |
| { |
| TypeId aType( TYPE( SwDocShell ) ); |
| SfxObjectShell* pTmpSh = SfxObjectShell::GetFirst( &aType ); |
| while( pTmpSh ) |
| { |
| if( pTmpSh == pDocShell ) // die wollen wir haben |
| { |
| if( pDocShell->GetDoc() ) |
| return sal_True; |
| break; // das Doc ist nicht mehr vorhanden, also raus! |
| } |
| pTmpSh = SfxObjectShell::GetNext( *pTmpSh, &aType ); |
| } |
| |
| pDocShell = 0; |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SwTrnsfrDdeLink::Closed() |
| { |
| if( !bInDisconnect && refObj.Is() ) |
| { |
| refObj->RemoveAllDataAdvise( this ); |
| refObj->RemoveConnectAdvise( this ); |
| refObj.Clear(); |
| } |
| } |