/**************************************************************
*
* 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 <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(), sal_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->getMarksBegin();
ppMark != pMarkAccess->getMarksEnd();
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(), sal_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(), sal_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(), sal_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_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_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 );
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_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) )
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() )
{
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( 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() )
rSh.Paste( aGrf );
else if( OBJCNT_GRF == rSh.GetObjCntTypeOfSelection() )
rSh.ReRead( sURL, aEmptyStr, &aGrf );
else
{
SwTransferable::SetSelInShell( rSh, sal_False, pPt );
rSh.Insert( aBkmk.GetURL(), aEmptyStr, aGrf );
}
break;
default:
nRet = 0;
}
}
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 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(), sal_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;
//if( bDelBookmrk )
//{
// // er wird das erstemal abgeholt, also ins Undo mitaufnehmen
// // aber wie??
//}
IDocumentMarkAccess* const pMarkAccess = pDocShell->GetDoc()->getIDocumentMarkAccess();
IDocumentMarkAccess::const_iterator_t ppMark = pMarkAccess->findMark(sName);
if(ppMark != pMarkAccess->getMarksEnd()
&& 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!)
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();
pMarkAccess->deleteMark(pMarkAccess->findMark(sName));
if( !bIsModified )
pDoc->ResetModified();
// --> OD, CD, OS 2005-11-25 #i58448#
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();
}
}