Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <com/sun/star/embed/XVisualObject.hpp>
21 : #include <com/sun/star/embed/XTransactedObject.hpp>
22 : #include <com/sun/star/embed/Aspects.hpp>
23 : #include <com/sun/star/embed/XEmbedObjectClipboardCreator.hpp>
24 : #include <com/sun/star/embed/NoVisualAreaSizeException.hpp>
25 : #include <com/sun/star/embed/MSOLEObjectSystemCreator.hpp>
26 :
27 : #include <svtools/embedtransfer.hxx>
28 : #include <svtools/insdlg.hxx>
29 : #include <unotools/tempfile.hxx>
30 : #include <comphelper/processfactory.hxx>
31 : #include <comphelper/servicehelper.hxx>
32 : #include <comphelper/storagehelper.hxx>
33 : #include <comphelper/string.hxx>
34 : #include <unotools/ucbstreamhelper.hxx>
35 : #include <sot/filelist.hxx>
36 : #include <svx/svxdlg.hxx>
37 : #include <toolkit/helper/vclunohelper.hxx>
38 : #include <osl/endian.h>
39 : #include <sfx2/linkmgr.hxx>
40 : #include <tools/urlobj.hxx>
41 : #include <vcl/wrkwin.hxx>
42 : #include <vcl/msgbox.hxx>
43 : #include <sfx2/dispatch.hxx>
44 : #include <svl/stritem.hxx>
45 : #include <svtools/imap.hxx>
46 : #include <sot/storage.hxx>
47 : #include <vcl/graph.hxx>
48 : #include <svl/urihelper.hxx>
49 : #include <svx/svdmodel.hxx>
50 : #include <svx/xexch.hxx>
51 : #include <svx/xmlexchg.hxx>
52 : #include <svx/dbaexchange.hxx>
53 : #include <svx/clipfmtitem.hxx>
54 : #include <sfx2/mieclip.hxx>
55 : #include <svx/svdetc.hxx>
56 : #include <svx/xoutbmp.hxx>
57 : #include <svl/urlbmk.hxx>
58 : #include <svtools/htmlout.hxx>
59 : #include <svx/hlnkitem.hxx>
60 : #include <svtools/inetimg.hxx>
61 : #include <editeng/paperinf.hxx>
62 : #include <svx/fmview.hxx>
63 : #include <editeng/scripttypeitem.hxx>
64 : #include <sfx2/docfilt.hxx>
65 : #include <svtools/imapobj.hxx>
66 : #include <sfx2/docfile.hxx>
67 : #include <unotools/transliterationwrapper.hxx>
68 : #include <unotools/streamwrap.hxx>
69 : #include <vcl/graphicfilter.hxx>
70 :
71 : #include <svx/unomodel.hxx>
72 : #include <fmturl.hxx>
73 : #include <fmtinfmt.hxx>
74 : #include <fmtfsize.hxx>
75 : #include <swdtflvr.hxx>
76 : #include <shellio.hxx>
77 : #include <ddefld.hxx>
78 : #include <doc.hxx>
79 : #include <IDocumentUndoRedo.hxx>
80 : #include <pagedesc.hxx>
81 : #include <IMark.hxx>
82 : #include <docary.hxx>
83 : #include <section.hxx>
84 : #include <ndtxt.hxx>
85 : #include <edtwin.hxx>
86 : #include <navicont.hxx>
87 : #include <swcont.hxx>
88 : #include <wrtsh.hxx>
89 : #include <swmodule.hxx>
90 : #include <view.hxx>
91 : #include <docsh.hxx>
92 : #include <wdocsh.hxx>
93 : #include <fldbas.hxx>
94 : #include <swundo.hxx>
95 : #include <pam.hxx>
96 : #include <ndole.hxx>
97 : #include <swwait.hxx>
98 : #include <viewopt.hxx>
99 : #include <swerror.h>
100 : #include <SwCapObjType.hxx>
101 : #include <cmdid.h>
102 : #include <dochdl.hrc>
103 : #include <comcore.hrc>
104 : #include <sot/stg.hxx>
105 : #include <svx/svditer.hxx>
106 : #include <editeng/eeitem.hxx>
107 : #include <editeng/fhgtitem.hxx>
108 : #include <svx/svdpage.hxx>
109 : #include <avmedia/mediawindow.hxx>
110 : #include <swcrsr.hxx>
111 : #include <SwRewriter.hxx>
112 : #include <globals.hrc>
113 : #include <app.hrc>
114 : #include <osl/mutex.hxx>
115 : #include <vcl/svapp.hxx>
116 : #include <swserv.hxx>
117 : #include <switerator.hxx>
118 :
119 : #include <vcl/GraphicNativeTransform.hxx>
120 : #include <vcl/GraphicNativeMetadata.hxx>
121 :
122 : #include <boost/scoped_ptr.hpp>
123 :
124 : extern bool bFrmDrag;
125 : extern bool bDDINetAttr;
126 : extern bool bExecuteDrag;
127 :
128 : #define OLESIZE 11905 - 2 * lMinBorder, 6 * MM50
129 :
130 : #define SWTRANSFER_OBJECTTYPE_DRAWMODEL 0x00000001
131 : #define SWTRANSFER_OBJECTTYPE_HTML 0x00000002
132 : #define SWTRANSFER_OBJECTTYPE_RTF 0x00000004
133 : #define SWTRANSFER_OBJECTTYPE_STRING 0x00000008
134 : #define SWTRANSFER_OBJECTTYPE_SWOLE 0x00000010
135 : #define SWTRANSFER_OBJECTTYPE_DDE 0x00000020
136 :
137 : using namespace ::svx;
138 : using namespace ::com::sun::star;
139 : using namespace ::com::sun::star::uno;
140 : using namespace ::com::sun::star::datatransfer;
141 : using namespace nsTransferBufferType;
142 :
143 : #define DDE_TXT_ENCODING osl_getThreadTextEncoding()
144 :
145 : class SwTrnsfrDdeLink : public ::sfx2::SvBaseLink
146 : {
147 : OUString sName;
148 : ::sfx2::SvLinkSourceRef refObj;
149 : SwTransferable& rTrnsfr;
150 : SwDocShell* pDocShell;
151 : sal_uLong nOldTimeOut;
152 : sal_Bool bDelBookmrk : 1;
153 : sal_Bool bInDisconnect : 1;
154 :
155 : sal_Bool FindDocShell();
156 :
157 : using sfx2::SvBaseLink::Disconnect;
158 :
159 : protected:
160 : virtual ~SwTrnsfrDdeLink();
161 :
162 : public:
163 : SwTrnsfrDdeLink( SwTransferable& rTrans, SwWrtShell& rSh );
164 :
165 : virtual ::sfx2::SvBaseLink::UpdateResult DataChanged(
166 : const OUString& rMimeType, const ::com::sun::star::uno::Any & rValue ) SAL_OVERRIDE;
167 : virtual void Closed() SAL_OVERRIDE;
168 :
169 : sal_Bool WriteData( SvStream& rStrm );
170 :
171 : void Disconnect( sal_Bool bRemoveDataAdvise );
172 : };
173 :
174 : // helper class for Action and Undo enclosing
175 : class SwTrnsfrActionAndUndo
176 : {
177 : SwWrtShell *pSh;
178 : SwUndoId eUndoId;
179 : public:
180 1 : SwTrnsfrActionAndUndo( SwWrtShell *pS, SwUndoId nId,
181 : const SwRewriter * pRewriter = 0,
182 : sal_Bool bDelSel = sal_False)
183 1 : : pSh( pS ), eUndoId( nId )
184 : {
185 1 : pSh->StartUndo( eUndoId, pRewriter );
186 1 : if( bDelSel )
187 0 : pSh->DelRight();
188 1 : pSh->StartAllAction();
189 1 : }
190 1 : ~SwTrnsfrActionAndUndo()
191 : {
192 1 : pSh->EndUndo();
193 1 : pSh->EndAllAction();
194 1 : }
195 : };
196 :
197 20 : SwTransferable::SwTransferable( SwWrtShell& rSh )
198 : : pWrtShell( &rSh ),
199 : pCreatorView( 0 ),
200 : pClpDocFac( 0 ),
201 : pClpGraphic( 0 ),
202 : pClpBitmap( 0 ),
203 : pOrigGrf( 0 ),
204 : pBkmk( 0 ),
205 : pImageMap( 0 ),
206 : pTargetURL( 0 ),
207 20 : eBufferType( TRNSFR_NONE )
208 : {
209 20 : rSh.GetView().AddTransferable(*this);
210 20 : SwDocShell* pDShell = rSh.GetDoc()->GetDocShell();
211 20 : if( pDShell )
212 : {
213 20 : pDShell->FillTransferableObjectDescriptor( aObjDesc );
214 20 : if( pDShell->GetMedium() )
215 : {
216 20 : const INetURLObject& rURLObj = pDShell->GetMedium()->GetURLObject();
217 40 : aObjDesc.maDisplayName = URIHelper::removePassword(
218 : rURLObj.GetMainURL( INetURLObject::NO_DECODE ),
219 : INetURLObject::WAS_ENCODED,
220 20 : INetURLObject::DECODE_UNAMBIGUOUS );
221 : }
222 :
223 20 : PrepareOLE( aObjDesc );
224 : }
225 20 : }
226 :
227 57 : SwTransferable::~SwTransferable()
228 : {
229 19 : Application::GetSolarMutex().acquire();
230 :
231 : // the DDELink still needs the WrtShell!
232 19 : if( refDdeLink.Is() )
233 : {
234 0 : ((SwTrnsfrDdeLink*)&refDdeLink)->Disconnect( sal_True );
235 0 : refDdeLink.Clear();
236 : }
237 :
238 19 : pWrtShell = 0;
239 :
240 : // release reference to the document so that aDocShellRef will delete
241 : // it (if aDocShellRef is set). Otherwise, the OLE nodes keep references
242 : // to their sub-storage when the storage is already dead.
243 19 : delete pClpDocFac;
244 :
245 : // first close, then the Ref. can be cleared as well, so that
246 : // the DocShell really gets deleted!
247 19 : if( aDocShellRef.Is() )
248 : {
249 0 : SfxObjectShell * pObj = aDocShellRef;
250 0 : SwDocShell* pDocSh = (SwDocShell*)pObj;
251 0 : pDocSh->DoClose();
252 : }
253 19 : aDocShellRef.Clear();
254 :
255 19 : SwModule* pMod = SW_MOD();
256 19 : if(pMod)
257 : {
258 19 : if ( pMod->pDragDrop == this )
259 0 : pMod->pDragDrop = 0;
260 19 : else if ( pMod->pXSelection == this )
261 0 : pMod->pXSelection = 0;
262 : }
263 :
264 19 : delete pClpGraphic;
265 19 : delete pClpBitmap;
266 19 : delete pImageMap;
267 19 : delete pTargetURL;
268 19 : delete pBkmk;
269 :
270 19 : eBufferType = TRNSFR_NONE;
271 :
272 19 : Application::GetSolarMutex().release();
273 38 : }
274 :
275 1 : static SwDoc * lcl_GetDoc(SwDocFac & rDocFac)
276 : {
277 1 : SwDoc *const pDoc = rDocFac.GetDoc();
278 : OSL_ENSURE( pDoc, "Document not found" );
279 1 : if (pDoc)
280 : {
281 1 : pDoc->SetClipBoard( true );
282 : }
283 1 : return pDoc;
284 : }
285 :
286 19 : void SwTransferable::ObjectReleased()
287 : {
288 19 : SwModule *pMod = SW_MOD();
289 19 : if( this == pMod->pDragDrop )
290 0 : pMod->pDragDrop = 0;
291 19 : else if( this == pMod->pXSelection )
292 19 : pMod->pXSelection = 0;
293 19 : }
294 :
295 0 : void SwTransferable::AddSupportedFormats()
296 : {
297 : // only need if we are the current XSelection Object
298 0 : SwModule *pMod = SW_MOD();
299 0 : if( this == pMod->pXSelection )
300 : {
301 0 : SetDataForDragAndDrop( Point( 0,0) );
302 : }
303 0 : }
304 :
305 56 : void SwTransferable::InitOle( SfxObjectShell* pDoc, SwDoc& rDoc )
306 : {
307 : //set OleVisArea. Upper left corner of the page and size of
308 : //RealSize in Twips.
309 56 : const Size aSz( OLESIZE );
310 56 : SwRect aVis( Point( DOCUMENTBORDER, DOCUMENTBORDER ), aSz );
311 56 : pDoc->SetVisArea( aVis.SVRect() );
312 56 : rDoc.set(IDocumentSettingAccess::BROWSE_MODE, true );
313 56 : }
314 :
315 0 : uno::Reference < embed::XEmbeddedObject > SwTransferable::FindOLEObj( sal_Int64& nAspect ) const
316 : {
317 0 : uno::Reference < embed::XEmbeddedObject > xObj;
318 0 : if( pClpDocFac )
319 : {
320 0 : SwIterator<SwCntntNode,SwFmtColl> aIter( *pClpDocFac->GetDoc()->GetDfltGrfFmtColl() );
321 0 : for( SwCntntNode* pNd = aIter.First(); pNd; pNd = aIter.Next() )
322 0 : if( ND_OLENODE == pNd->GetNodeType() )
323 : {
324 0 : xObj = ((SwOLENode*)pNd)->GetOLEObj().GetOleRef();
325 0 : nAspect = ((SwOLENode*)pNd)->GetAspect();
326 0 : break;
327 0 : }
328 : }
329 0 : return xObj;
330 : }
331 :
332 0 : const Graphic* SwTransferable::FindOLEReplacementGraphic() const
333 : {
334 0 : if( pClpDocFac )
335 : {
336 0 : SwIterator<SwCntntNode,SwFmtColl> aIter( *pClpDocFac->GetDoc()->GetDfltGrfFmtColl() );
337 0 : for( SwCntntNode* pNd = aIter.First(); pNd; pNd = aIter.Next() )
338 0 : if( ND_OLENODE == pNd->GetNodeType() )
339 : {
340 0 : return ((SwOLENode*)pNd)->GetGraphic();
341 0 : }
342 : }
343 :
344 0 : return NULL;
345 : }
346 :
347 0 : void SwTransferable::RemoveDDELinkFormat( const Window& rWin )
348 : {
349 0 : RemoveFormat( SOT_FORMATSTR_ID_LINK );
350 0 : CopyToClipboard( (Window*)&rWin );
351 0 : }
352 :
353 : namespace
354 : {
355 : //Resolves: fdo#40717 surely when we create a clipboard document we should
356 : //overwrite the clipboard documents styles and settings with that of the
357 : //source, so that we can WYSIWYG paste. If we want that the destinations
358 : //styles are used over the source styles, that's a matter of the
359 : //destination paste code to handle, not the source paste code.
360 1 : void lclOverWriteDoc(SwWrtShell &rSrcWrtShell, SwDoc &rDest)
361 : {
362 1 : const SwDoc &rSrc = *rSrcWrtShell.GetDoc();
363 :
364 1 : rDest.ReplaceCompatabilityOptions(rSrc);
365 1 : rDest.ReplaceDefaults(rSrc);
366 :
367 : //It would probably make most sense here to only insert the styles used
368 : //by the selection, e.g. apply SwDoc::IsUsed on styles ?
369 1 : rDest.ReplaceStyles(rSrc, false);
370 :
371 1 : rSrcWrtShell.Copy(&rDest);
372 1 : }
373 :
374 0 : void lclCheckAndPerformRotation(Graphic& aGraphic)
375 : {
376 0 : GraphicNativeMetadata aMetadata;
377 0 : if ( aMetadata.read(aGraphic) )
378 : {
379 0 : sal_uInt16 aRotation = aMetadata.getRotation();
380 0 : if (aRotation != 0)
381 : {
382 0 : MessageDialog aQueryBox( 0,"QueryRotateIntoStandardOrientationDialog","modules/swriter/ui/queryrotateintostandarddialog.ui");
383 0 : if (aQueryBox.Execute() == RET_YES)
384 : {
385 0 : GraphicNativeTransform aTransform( aGraphic );
386 0 : aTransform.rotate( aRotation );
387 0 : }
388 : }
389 0 : }
390 0 : }
391 : }
392 :
393 0 : bool SwTransferable::GetData( const DataFlavor& rFlavor )
394 : {
395 0 : sal_uInt32 nFormat = SotExchange::GetFormat( rFlavor );
396 :
397 : // we can only fullfil the request if
398 : // 1) we have data for this format
399 : // 2) we have either a clipboard document (pClpDocFac), or
400 : // we have a SwWrtShell (so we can generate a new clipboard document)
401 0 : if( !HasFormat( nFormat ) || ( pClpDocFac == NULL && pWrtShell == NULL ) )
402 0 : return false;
403 :
404 0 : if( !pClpDocFac )
405 : {
406 0 : SelectionType nSelectionType = pWrtShell->GetSelectionType();
407 :
408 : // when pending we will not get the correct type, but nsSelectionType::SEL_TXT
409 : // as fallback. This *happens* durning D&D, so we need to check if we are in
410 : // the fallback and just try to get a graphic
411 0 : const bool bPending(pWrtShell->BasicActionPend());
412 :
413 : // SEL_GRF kommt vom ContentType der editsh
414 0 : if(bPending || ((nsSelectionType::SEL_GRF | nsSelectionType::SEL_DRW_FORM) & nSelectionType))
415 : {
416 0 : pClpGraphic = new Graphic;
417 0 : if( !pWrtShell->GetDrawObjGraphic( FORMAT_GDIMETAFILE, *pClpGraphic ))
418 0 : pOrigGrf = pClpGraphic;
419 0 : pClpBitmap = new Graphic;
420 0 : if( !pWrtShell->GetDrawObjGraphic( FORMAT_BITMAP, *pClpBitmap ))
421 0 : pOrigGrf = pClpBitmap;
422 :
423 : // is it an URL-Button ?
424 0 : OUString sURL;
425 0 : OUString sDesc;
426 0 : if( pWrtShell->GetURLFromButton( sURL, sDesc ) )
427 : {
428 0 : pBkmk = new INetBookmark( sURL, sDesc );
429 0 : eBufferType = TRNSFR_INETFLD;
430 0 : }
431 : }
432 :
433 0 : pClpDocFac = new SwDocFac;
434 0 : SwDoc *const pTmpDoc = lcl_GetDoc(*pClpDocFac);
435 :
436 0 : pTmpDoc->LockExpFlds(); // never update fields - leave text as it is
437 0 : lclOverWriteDoc(*pWrtShell, *pTmpDoc);
438 :
439 : // in CORE a new one was created (OLE-Objekte copied!)
440 0 : aDocShellRef = pTmpDoc->GetTmpDocShell();
441 0 : if( aDocShellRef.Is() )
442 0 : SwTransferable::InitOle( aDocShellRef, *pTmpDoc );
443 0 : pTmpDoc->SetTmpDocShell( (SfxObjectShell*)NULL );
444 :
445 0 : if( nSelectionType & nsSelectionType::SEL_TXT && !pWrtShell->HasMark() )
446 : {
447 0 : SwContentAtPos aCntntAtPos( SwContentAtPos::SW_INETATTR );
448 :
449 0 : Point aPos( SwEditWin::GetDDStartPosX(), SwEditWin::GetDDStartPosY());
450 :
451 0 : sal_Bool bSelect = bExecuteDrag &&
452 0 : pWrtShell->GetView().GetDocShell() &&
453 0 : !pWrtShell->GetView().GetDocShell()->IsReadOnly();
454 0 : if( pWrtShell->GetContentAtPos( aPos, aCntntAtPos, bSelect ) )
455 : {
456 : pBkmk = new INetBookmark(
457 0 : ((SwFmtINetFmt*)aCntntAtPos.aFnd.pAttr)->GetValue(),
458 0 : aCntntAtPos.sStr );
459 0 : eBufferType = TRNSFR_INETFLD;
460 0 : if( bSelect )
461 0 : pWrtShell->SelectTxtAttr( RES_TXTATR_INETFMT );
462 0 : }
463 : }
464 0 : if( pWrtShell->IsFrmSelected() )
465 : {
466 0 : SfxItemSet aSet( pWrtShell->GetAttrPool(), RES_URL, RES_URL );
467 0 : pWrtShell->GetFlyFrmAttr( aSet );
468 0 : const SwFmtURL& rURL = (SwFmtURL&)aSet.Get( RES_URL );
469 0 : if( rURL.GetMap() )
470 0 : pImageMap = new ImageMap( *rURL.GetMap() );
471 0 : else if( !rURL.GetURL().isEmpty() )
472 : pTargetURL = new INetImage( aEmptyOUStr, rURL.GetURL(),
473 : rURL.GetTargetFrameName(),
474 0 : aEmptyOUStr, Size() );
475 : }
476 : }
477 :
478 0 : sal_Bool bOK = sal_False;
479 0 : if( TRNSFR_OLE == eBufferType )
480 : {
481 : //TODO/MBA: testing - is this the "single OLE object" case?!
482 : // get OLE-Object from ClipDoc and get the data from that.
483 0 : sal_Int64 nAspect = embed::Aspects::MSOLE_CONTENT; // will be set in the next statement
484 0 : uno::Reference < embed::XEmbeddedObject > xObj = FindOLEObj( nAspect );
485 0 : const Graphic* pOLEGraph = FindOLEReplacementGraphic();
486 0 : if( xObj.is() )
487 : {
488 0 : TransferableDataHelper aD( new SvEmbedTransferHelper( xObj, pOLEGraph, nAspect ) );
489 0 : uno::Any aAny( aD.GetAny( rFlavor ));
490 0 : if( aAny.hasValue() )
491 0 : bOK = SetAny( aAny, rFlavor );
492 : }
493 :
494 : // the following solution will be used in the case when the object can not generate the image
495 : // TODO/LATER: in future the transferhelper must probably be created based on object and the replacement stream
496 0 : if ( nFormat == SOT_FORMAT_GDIMETAFILE )
497 : {
498 0 : pOLEGraph = FindOLEReplacementGraphic();
499 0 : if ( pOLEGraph )
500 0 : bOK = SetGDIMetaFile( pOLEGraph->GetGDIMetaFile(), rFlavor );
501 0 : }
502 : }
503 : else
504 : {
505 0 : switch( nFormat )
506 : {
507 : case SOT_FORMATSTR_ID_LINK:
508 0 : if( refDdeLink.Is() )
509 0 : bOK = SetObject( &refDdeLink,
510 0 : SWTRANSFER_OBJECTTYPE_DDE, rFlavor );
511 0 : break;
512 :
513 : case SOT_FORMATSTR_ID_OBJECTDESCRIPTOR:
514 : case SOT_FORMATSTR_ID_LINKSRCDESCRIPTOR:
515 0 : bOK = SetTransferableObjectDescriptor( aObjDesc, rFlavor );
516 0 : break;
517 :
518 : case SOT_FORMATSTR_ID_DRAWING:
519 : {
520 0 : SwDoc *const pDoc = lcl_GetDoc(*pClpDocFac);
521 0 : bOK = SetObject( pDoc->GetDrawModel(),
522 0 : SWTRANSFER_OBJECTTYPE_DRAWMODEL, rFlavor );
523 : }
524 0 : break;
525 :
526 : case SOT_FORMAT_STRING:
527 : {
528 0 : SwDoc *const pDoc = lcl_GetDoc(*pClpDocFac);
529 0 : bOK = SetObject( pDoc, SWTRANSFER_OBJECTTYPE_STRING, rFlavor );
530 : }
531 0 : break;
532 : case SOT_FORMAT_RTF:
533 : {
534 0 : SwDoc *const pDoc = lcl_GetDoc(*pClpDocFac);
535 0 : bOK = SetObject( pDoc, SWTRANSFER_OBJECTTYPE_RTF, rFlavor );
536 : }
537 0 : break;
538 :
539 : case SOT_FORMATSTR_ID_HTML:
540 : {
541 0 : SwDoc *const pDoc = lcl_GetDoc(*pClpDocFac);
542 0 : bOK = SetObject( pDoc, SWTRANSFER_OBJECTTYPE_HTML, rFlavor );
543 : }
544 0 : break;
545 :
546 : case SOT_FORMATSTR_ID_SVXB:
547 0 : if( eBufferType & TRNSFR_GRAPHIC && pOrigGrf )
548 0 : bOK = SetGraphic( *pOrigGrf, rFlavor );
549 0 : break;
550 :
551 : case SOT_FORMAT_GDIMETAFILE:
552 0 : if( eBufferType & TRNSFR_GRAPHIC )
553 0 : bOK = SetGDIMetaFile( pClpGraphic->GetGDIMetaFile(), rFlavor );
554 0 : break;
555 : case SOT_FORMAT_BITMAP:
556 : case SOT_FORMATSTR_ID_PNG:
557 : // Neither pClpBitmap nor pClpGraphic are necessarily set
558 0 : if( (eBufferType & TRNSFR_GRAPHIC) && (pClpBitmap != 0 || pClpGraphic != 0))
559 0 : bOK = SetBitmapEx( (pClpBitmap ? pClpBitmap : pClpGraphic)->GetBitmapEx(), rFlavor );
560 0 : break;
561 :
562 : case SOT_FORMATSTR_ID_SVIM:
563 0 : if( pImageMap )
564 0 : bOK = SetImageMap( *pImageMap, rFlavor );
565 0 : break;
566 :
567 : case SOT_FORMATSTR_ID_INET_IMAGE:
568 0 : if( pTargetURL )
569 0 : bOK = SetINetImage( *pTargetURL, rFlavor );
570 0 : break;
571 :
572 : case SOT_FORMATSTR_ID_SOLK:
573 : case SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK:
574 : case SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR:
575 : case SOT_FORMATSTR_ID_FILECONTENT:
576 : case SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR:
577 : case SOT_FORMAT_FILE:
578 0 : if( (TRNSFR_INETFLD & eBufferType) && pBkmk )
579 0 : bOK = SetINetBookmark( *pBkmk, rFlavor );
580 0 : break;
581 :
582 : case SOT_FORMATSTR_ID_EMBED_SOURCE:
583 0 : if( !aDocShellRef.Is() )
584 : {
585 0 : SwDoc *const pDoc = lcl_GetDoc(*pClpDocFac);
586 : SwDocShell* pNewDocSh = new SwDocShell( pDoc,
587 0 : SFX_CREATE_MODE_EMBEDDED );
588 0 : aDocShellRef = pNewDocSh;
589 0 : aDocShellRef->DoInitNew( NULL );
590 0 : SwTransferable::InitOle( aDocShellRef, *pDoc );
591 : }
592 0 : bOK = SetObject( &aDocShellRef, SWTRANSFER_OBJECTTYPE_SWOLE,
593 0 : rFlavor );
594 0 : break;
595 : }
596 : }
597 0 : return bOK;
598 : }
599 :
600 0 : bool SwTransferable::WriteObject( SotStorageStreamRef& xStream,
601 : void* pObject, sal_uInt32 nObjectType,
602 : const DataFlavor& /*rFlavor*/ )
603 : {
604 0 : bool bRet = false;
605 0 : WriterRef xWrt;
606 :
607 0 : switch( nObjectType )
608 : {
609 : case SWTRANSFER_OBJECTTYPE_DRAWMODEL:
610 : {
611 : // don't change the sequence of commands
612 0 : SdrModel *pModel = (SdrModel*)pObject;
613 0 : xStream->SetBufferSize( 16348 );
614 :
615 : // for the changed pool defaults from drawing layer pool set those
616 : // attributes as hard attributes to preserve them for saving
617 0 : const SfxItemPool& rItemPool = pModel->GetItemPool();
618 0 : const SvxFontHeightItem& rDefaultFontHeight = (const SvxFontHeightItem&)rItemPool.GetDefaultItem(EE_CHAR_FONTHEIGHT);
619 :
620 : // SW should have no MasterPages
621 : OSL_ENSURE(0L == pModel->GetMasterPageCount(), "SW with MasterPages (!)");
622 :
623 0 : for(sal_uInt16 a(0); a < pModel->GetPageCount(); a++)
624 : {
625 0 : const SdrPage* pPage = pModel->GetPage(a);
626 0 : SdrObjListIter aIter(*pPage, IM_DEEPNOGROUPS);
627 :
628 0 : while(aIter.IsMore())
629 : {
630 0 : SdrObject* pObj = aIter.Next();
631 0 : const SvxFontHeightItem& rItem = (const SvxFontHeightItem&)pObj->GetMergedItem(EE_CHAR_FONTHEIGHT);
632 :
633 0 : if(rItem.GetHeight() == rDefaultFontHeight.GetHeight())
634 : {
635 0 : pObj->SetMergedItem(rDefaultFontHeight);
636 : }
637 : }
638 0 : }
639 :
640 : {
641 0 : uno::Reference<io::XOutputStream> xDocOut( new utl::OOutputStreamWrapper( *xStream ) );
642 0 : if( SvxDrawingLayerExport( pModel, xDocOut ) )
643 0 : xStream->Commit();
644 : }
645 :
646 0 : bRet = ERRCODE_NONE == xStream->GetError();
647 : }
648 0 : break;
649 :
650 : case SWTRANSFER_OBJECTTYPE_SWOLE:
651 : {
652 0 : SfxObjectShell* pEmbObj = (SfxObjectShell*) pObject;
653 : try
654 : {
655 0 : ::utl::TempFile aTempFile;
656 0 : aTempFile.EnableKillingFile();
657 : uno::Reference< embed::XStorage > xWorkStore =
658 0 : ::comphelper::OStorageHelper::GetStorageFromURL( aTempFile.GetURL(), embed::ElementModes::READWRITE );
659 :
660 : // write document storage
661 0 : pEmbObj->SetupStorage( xWorkStore, SOFFICE_FILEFORMAT_CURRENT, false );
662 : // mba: no BaseURL for clipboard
663 0 : SfxMedium aMedium( xWorkStore, OUString() );
664 0 : bRet = pEmbObj->DoSaveObjectAs( aMedium, false );
665 0 : pEmbObj->DoSaveCompleted();
666 :
667 0 : uno::Reference< embed::XTransactedObject > xTransact( xWorkStore, uno::UNO_QUERY );
668 0 : if ( xTransact.is() )
669 0 : xTransact->commit();
670 :
671 0 : boost::scoped_ptr<SvStream> pSrcStm(::utl::UcbStreamHelper::CreateStream( aTempFile.GetURL(), STREAM_READ ));
672 0 : if( pSrcStm )
673 : {
674 0 : xStream->SetBufferSize( 0xff00 );
675 0 : xStream->WriteStream( *pSrcStm );
676 0 : pSrcStm.reset();
677 : }
678 :
679 0 : bRet = true;
680 :
681 0 : xWorkStore->dispose();
682 0 : xWorkStore = uno::Reference < embed::XStorage >();
683 0 : xStream->Commit();
684 : }
685 0 : catch (const uno::Exception&)
686 : {
687 : }
688 :
689 0 : bRet = ( xStream->GetError() == ERRCODE_NONE );
690 : }
691 0 : break;
692 :
693 : case SWTRANSFER_OBJECTTYPE_DDE:
694 : {
695 0 : xStream->SetBufferSize( 1024 );
696 0 : SwTrnsfrDdeLink* pDdeLnk = (SwTrnsfrDdeLink*)pObject;
697 0 : if( pDdeLnk->WriteData( *xStream ) )
698 : {
699 0 : xStream->Commit();
700 0 : bRet = ERRCODE_NONE == xStream->GetError();
701 : }
702 : }
703 0 : break;
704 :
705 : case SWTRANSFER_OBJECTTYPE_HTML:
706 0 : GetHTMLWriter( aEmptyOUStr, OUString(), xWrt );
707 0 : break;
708 :
709 : case SWTRANSFER_OBJECTTYPE_RTF:
710 0 : GetRTFWriter( aEmptyOUStr, OUString(), xWrt );
711 0 : break;
712 :
713 : case SWTRANSFER_OBJECTTYPE_STRING:
714 0 : GetASCWriter( aEmptyOUStr, OUString(), xWrt );
715 0 : if( xWrt.Is() )
716 : {
717 0 : SwAsciiOptions aAOpt;
718 0 : aAOpt.SetCharSet( RTL_TEXTENCODING_UTF8 );
719 0 : xWrt->SetAsciiOptions( aAOpt );
720 :
721 : // no start char for clipboard
722 0 : xWrt->bUCS2_WithStartChar = sal_False;
723 : }
724 0 : break;
725 : }
726 :
727 0 : if( xWrt.Is() )
728 : {
729 0 : SwDoc* pDoc = (SwDoc*)pObject;
730 0 : xWrt->bWriteClipboardDoc = sal_True;
731 0 : xWrt->bWriteOnlyFirstTable = 0 != (TRNSFR_TABELLE & eBufferType);
732 0 : xWrt->SetShowProgress( sal_False );
733 :
734 : #if defined(DEBUGPASTE)
735 : SvFileStream aPasteDebug(OUString(
736 : "PASTEBUFFER.debug"), STREAM_WRITE|STREAM_TRUNC);
737 : SwWriter aDbgWrt( aPasteDebug, *pDoc );
738 : aDbgWrt.Write( xWrt );
739 : #endif
740 :
741 0 : SwWriter aWrt( *xStream, *pDoc );
742 0 : if( !IsError( aWrt.Write( xWrt )) )
743 : {
744 0 : xStream->WriteChar( '\0' ); // terminate with a zero
745 0 : xStream->Commit();
746 0 : bRet = true;
747 0 : }
748 : }
749 :
750 0 : return bRet;
751 : }
752 :
753 0 : int SwTransferable::Cut()
754 : {
755 0 : int nRet = Copy( sal_True );
756 0 : if( nRet )
757 0 : DeleteSelection();
758 0 : return nRet;
759 : }
760 :
761 0 : void SwTransferable::DeleteSelection()
762 : {
763 0 : if(!pWrtShell)
764 0 : return;
765 : // ask for type of selection before action-bracketing
766 0 : const int nSelection = pWrtShell->GetSelectionType();
767 0 : pWrtShell->StartUndo( UNDO_DELETE );
768 0 : if( ( nsSelectionType::SEL_TXT | nsSelectionType::SEL_TBL ) & nSelection )
769 0 : pWrtShell->IntelligentCut( nSelection );
770 0 : pWrtShell->DelRight();
771 0 : pWrtShell->EndUndo( UNDO_DELETE );
772 : }
773 :
774 1 : int SwTransferable::PrepareForCopy( sal_Bool bIsCut )
775 : {
776 1 : int nRet = 1;
777 1 : if(!pWrtShell)
778 0 : return 0;
779 :
780 1 : OUString sGrfNm;
781 1 : const int nSelection = pWrtShell->GetSelectionType();
782 1 : if( nSelection == nsSelectionType::SEL_GRF )
783 : {
784 0 : pClpGraphic = new Graphic;
785 0 : if( !pWrtShell->GetDrawObjGraphic( FORMAT_GDIMETAFILE, *pClpGraphic ))
786 0 : pOrigGrf = pClpGraphic;
787 0 : pClpBitmap = new Graphic;
788 0 : if( !pWrtShell->GetDrawObjGraphic( FORMAT_BITMAP, *pClpBitmap ))
789 0 : pOrigGrf = pClpBitmap;
790 :
791 0 : pClpDocFac = new SwDocFac;
792 0 : SwDoc *const pDoc = lcl_GetDoc(*pClpDocFac);
793 0 : pWrtShell->Copy( pDoc );
794 :
795 0 : if (pOrigGrf && !pOrigGrf->GetBitmap().IsEmpty())
796 0 : AddFormat( SOT_FORMATSTR_ID_SVXB );
797 :
798 0 : PrepareOLE( aObjDesc );
799 0 : AddFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR );
800 :
801 0 : const Graphic* pGrf = pWrtShell->GetGraphic();
802 0 : if( pGrf && pGrf->IsSupportedGraphic() )
803 : {
804 0 : AddFormat( FORMAT_GDIMETAFILE );
805 0 : AddFormat( SOT_FORMATSTR_ID_PNG );
806 0 : AddFormat( FORMAT_BITMAP );
807 : }
808 0 : eBufferType = TRNSFR_GRAPHIC;
809 0 : pWrtShell->GetGrfNms( &sGrfNm, 0 );
810 : }
811 1 : else if ( nSelection == nsSelectionType::SEL_OLE )
812 : {
813 0 : pClpDocFac = new SwDocFac;
814 0 : SwDoc *const pDoc = lcl_GetDoc(*pClpDocFac);
815 0 : aDocShellRef = new SwDocShell( pDoc, SFX_CREATE_MODE_EMBEDDED);
816 0 : aDocShellRef->DoInitNew( NULL );
817 0 : pWrtShell->Copy( pDoc );
818 :
819 0 : AddFormat( SOT_FORMATSTR_ID_EMBED_SOURCE );
820 :
821 : // --> OD #i98753#
822 : // set size of embedded object at the object description structure
823 0 : aObjDesc.maSize = OutputDevice::LogicToLogic( pWrtShell->GetObjSize(), MAP_TWIP, MAP_100TH_MM );
824 : // <--
825 0 : PrepareOLE( aObjDesc );
826 0 : AddFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR );
827 :
828 0 : AddFormat( FORMAT_GDIMETAFILE );
829 0 : eBufferType = TRNSFR_OLE;
830 : }
831 : // Is there anything to provide anyway?
832 1 : else if ( pWrtShell->IsSelection() || pWrtShell->IsFrmSelected() ||
833 0 : pWrtShell->IsObjSelected() )
834 : {
835 1 : boost::scoped_ptr<SwWait> pWait;
836 1 : if( pWrtShell->ShouldWait() )
837 1 : pWait.reset(new SwWait( *pWrtShell->GetView().GetDocShell(), true ));
838 :
839 1 : pClpDocFac = new SwDocFac;
840 :
841 : // create additional cursor so that equal treatment of keyboard
842 : // and mouse selection is possible.
843 : // In AddMode with keyboard selection, the new cursor is not created
844 : // before the cursor is moved after end of selection.
845 1 : if( pWrtShell->IsAddMode() && pWrtShell->SwCrsrShell::HasSelection() )
846 0 : pWrtShell->CreateCrsr();
847 :
848 1 : SwDoc *const pTmpDoc = lcl_GetDoc(*pClpDocFac);
849 :
850 1 : pTmpDoc->LockExpFlds(); // Never update fields - leave text as is
851 1 : lclOverWriteDoc(*pWrtShell, *pTmpDoc);
852 :
853 : {
854 1 : IDocumentMarkAccess* const pMarkAccess = pTmpDoc->getIDocumentMarkAccess();
855 1 : ::std::vector< ::sw::mark::IMark* > vDdeMarks;
856 : // find all DDE-Bookmarks
857 3 : for(IDocumentMarkAccess::const_iterator_t ppMark = pMarkAccess->getAllMarksBegin();
858 2 : ppMark != pMarkAccess->getAllMarksEnd();
859 : ++ppMark)
860 : {
861 0 : if(IDocumentMarkAccess::DDE_BOOKMARK == IDocumentMarkAccess::GetType(**ppMark))
862 0 : vDdeMarks.push_back(ppMark->get());
863 : }
864 : // remove all DDE-Bookmarks, they are invalid inside the clipdoc!
865 3 : for(::std::vector< ::sw::mark::IMark* >::iterator ppMark = vDdeMarks.begin();
866 2 : ppMark != vDdeMarks.end();
867 : ++ppMark)
868 1 : pMarkAccess->deleteMark(*ppMark);
869 : }
870 :
871 : // a new one was created in CORE (OLE objects copied!)
872 1 : aDocShellRef = pTmpDoc->GetTmpDocShell();
873 1 : if( aDocShellRef.Is() )
874 0 : SwTransferable::InitOle( aDocShellRef, *pTmpDoc );
875 1 : pTmpDoc->SetTmpDocShell( (SfxObjectShell*)NULL );
876 :
877 1 : if( pWrtShell->IsObjSelected() )
878 0 : eBufferType = TRNSFR_DRAWING;
879 : else
880 : {
881 1 : eBufferType = TRNSFR_DOCUMENT;
882 1 : if (pWrtShell->IntelligentCut(nSelection, sal_False) != SwWrtShell::NO_WORD)
883 0 : eBufferType = (TransferBufferType)(TRNSFR_DOCUMENT_WORD | eBufferType);
884 : }
885 :
886 1 : int bDDELink = pWrtShell->IsSelection();
887 1 : if( nSelection & nsSelectionType::SEL_TBL_CELLS )
888 : {
889 0 : eBufferType = (TransferBufferType)(TRNSFR_TABELLE | eBufferType);
890 0 : bDDELink = pWrtShell->HasWholeTabSelection();
891 : }
892 :
893 : //When someone needs it, we 'OLE' him something
894 1 : AddFormat( SOT_FORMATSTR_ID_EMBED_SOURCE );
895 :
896 : //put RTF ahead of the OLE's Metafile to have less loss
897 1 : if( !pWrtShell->IsObjSelected() )
898 : {
899 1 : AddFormat( FORMAT_RTF );
900 1 : AddFormat( SOT_FORMATSTR_ID_HTML );
901 : }
902 1 : if( pWrtShell->IsSelection() )
903 1 : AddFormat( FORMAT_STRING );
904 :
905 1 : if( nSelection & ( nsSelectionType::SEL_DRW | nsSelectionType::SEL_DRW_FORM ))
906 : {
907 0 : AddFormat( SOT_FORMATSTR_ID_DRAWING );
908 0 : if ( nSelection & nsSelectionType::SEL_DRW )
909 : {
910 0 : AddFormat( FORMAT_GDIMETAFILE );
911 0 : AddFormat( SOT_FORMATSTR_ID_PNG );
912 0 : AddFormat( FORMAT_BITMAP );
913 : }
914 0 : eBufferType = (TransferBufferType)( TRNSFR_GRAPHIC | eBufferType );
915 :
916 0 : pClpGraphic = new Graphic;
917 0 : if( !pWrtShell->GetDrawObjGraphic( FORMAT_GDIMETAFILE, *pClpGraphic ))
918 0 : pOrigGrf = pClpGraphic;
919 0 : pClpBitmap = new Graphic;
920 0 : if( !pWrtShell->GetDrawObjGraphic( FORMAT_BITMAP, *pClpBitmap ))
921 0 : pOrigGrf = pClpBitmap;
922 :
923 : // is it an URL-Button ?
924 0 : OUString sURL;
925 0 : OUString sDesc;
926 0 : if( pWrtShell->GetURLFromButton( sURL, sDesc ) )
927 : {
928 0 : AddFormat( FORMAT_STRING );
929 0 : AddFormat( SOT_FORMATSTR_ID_SOLK );
930 0 : AddFormat( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK );
931 0 : AddFormat( SOT_FORMATSTR_ID_FILECONTENT );
932 0 : AddFormat( SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR );
933 0 : AddFormat( SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR );
934 0 : eBufferType = (TransferBufferType)( TRNSFR_INETFLD | eBufferType );
935 0 : nRet = sal_True;
936 0 : }
937 : }
938 :
939 : // at Cut, DDE-Link doesn't make sense!!
940 : SwDocShell* pDShell;
941 3 : if( !bIsCut && bDDELink &&
942 3 : 0 != ( pDShell = pWrtShell->GetDoc()->GetDocShell()) &&
943 1 : SFX_CREATE_MODE_STANDARD == pDShell->GetCreateMode() )
944 : {
945 1 : AddFormat( SOT_FORMATSTR_ID_LINK );
946 1 : refDdeLink = new SwTrnsfrDdeLink( *this, *pWrtShell );
947 : }
948 :
949 : //ObjectDescriptor was already filly from the old DocShell.
950 : //Now adjust it. Thus in GetData the first query can still
951 : //be answered with delayed rendering.
952 1 : aObjDesc.mbCanLink = false;
953 1 : Size aSz( OLESIZE );
954 1 : aObjDesc.maSize = OutputDevice::LogicToLogic( aSz, MAP_TWIP, MAP_100TH_MM );
955 :
956 1 : PrepareOLE( aObjDesc );
957 1 : AddFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR );
958 : }
959 : else
960 0 : nRet = 0;
961 :
962 1 : if( pWrtShell->IsFrmSelected() )
963 : {
964 0 : SfxItemSet aSet( pWrtShell->GetAttrPool(), RES_URL, RES_URL );
965 0 : pWrtShell->GetFlyFrmAttr( aSet );
966 0 : const SwFmtURL& rURL = (SwFmtURL&)aSet.Get( RES_URL );
967 0 : if( rURL.GetMap() )
968 : {
969 0 : pImageMap = new ImageMap( *rURL.GetMap() );
970 0 : AddFormat( SOT_FORMATSTR_ID_SVIM );
971 : }
972 0 : else if( !rURL.GetURL().isEmpty() )
973 : {
974 : pTargetURL = new INetImage( sGrfNm, rURL.GetURL(),
975 : rURL.GetTargetFrameName(),
976 0 : aEmptyOUStr, Size() );
977 0 : AddFormat( SOT_FORMATSTR_ID_INET_IMAGE );
978 0 : }
979 : }
980 :
981 1 : return nRet;
982 : }
983 :
984 1 : int SwTransferable::Copy( sal_Bool bIsCut )
985 : {
986 1 : int nRet = PrepareForCopy( bIsCut );
987 1 : if ( nRet )
988 : {
989 1 : CopyToClipboard( &pWrtShell->GetView().GetEditWin() );
990 : }
991 1 : return nRet;
992 : }
993 :
994 0 : int SwTransferable::CalculateAndCopy()
995 : {
996 0 : if(!pWrtShell)
997 0 : return 0;
998 0 : SwWait aWait( *pWrtShell->GetView().GetDocShell(), true );
999 :
1000 0 : OUString aStr( pWrtShell->Calculate() );
1001 :
1002 0 : pClpDocFac = new SwDocFac;
1003 0 : SwDoc *const pDoc = lcl_GetDoc(*pClpDocFac);
1004 0 : pWrtShell->Copy(pDoc, & aStr);
1005 0 : eBufferType = TRNSFR_DOCUMENT;
1006 0 : AddFormat( FORMAT_STRING );
1007 :
1008 0 : CopyToClipboard( &pWrtShell->GetView().GetEditWin() );
1009 :
1010 0 : return 1;
1011 : }
1012 :
1013 0 : int SwTransferable::CopyGlossary( SwTextBlocks& rGlossary,
1014 : const OUString& rStr )
1015 : {
1016 0 : if(!pWrtShell)
1017 0 : return 0;
1018 0 : SwWait aWait( *pWrtShell->GetView().GetDocShell(), true );
1019 :
1020 0 : pClpDocFac = new SwDocFac;
1021 0 : SwDoc *const pCDoc = lcl_GetDoc(*pClpDocFac);
1022 :
1023 0 : SwNodes& rNds = pCDoc->GetNodes();
1024 0 : SwNodeIndex aNodeIdx( *rNds.GetEndOfContent().StartOfSectionNode() );
1025 0 : SwCntntNode* pCNd = rNds.GoNext( &aNodeIdx ); // go to 1st ContentNode
1026 0 : SwPaM aPam( *pCNd );
1027 :
1028 0 : pCDoc->LockExpFlds(); // never update fields - leave text as it is
1029 :
1030 0 : pCDoc->InsertGlossary( rGlossary, rStr, aPam, 0 );
1031 :
1032 : // a new one was created in CORE (OLE-Objects copied!)
1033 0 : aDocShellRef = pCDoc->GetTmpDocShell();
1034 0 : if( aDocShellRef.Is() )
1035 0 : SwTransferable::InitOle( aDocShellRef, *pCDoc );
1036 0 : pCDoc->SetTmpDocShell( (SfxObjectShell*)NULL );
1037 :
1038 0 : eBufferType = TRNSFR_DOCUMENT;
1039 :
1040 : //When someone needs it, we 'OLE' her something.
1041 0 : AddFormat( SOT_FORMATSTR_ID_EMBED_SOURCE );
1042 0 : AddFormat( FORMAT_RTF );
1043 0 : AddFormat( SOT_FORMATSTR_ID_HTML );
1044 0 : AddFormat( FORMAT_STRING );
1045 :
1046 : //ObjectDescriptor was already filled from the old DocShell.
1047 : //Now adjust it. Thus in GetData the first query can still
1048 : //be answered with delayed rendering.
1049 0 : aObjDesc.mbCanLink = false;
1050 0 : Size aSz( OLESIZE );
1051 0 : aObjDesc.maSize = OutputDevice::LogicToLogic( aSz, MAP_TWIP, MAP_100TH_MM );
1052 :
1053 0 : PrepareOLE( aObjDesc );
1054 0 : AddFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR );
1055 :
1056 0 : CopyToClipboard( &pWrtShell->GetView().GetEditWin() );
1057 :
1058 0 : return 1;
1059 : }
1060 :
1061 0 : static inline uno::Reference < XTransferable > * lcl_getTransferPointer ( uno::Reference < XTransferable > &xRef )
1062 : {
1063 0 : return &xRef;
1064 : }
1065 :
1066 0 : sal_Bool SwTransferable::IsPaste( const SwWrtShell& rSh,
1067 : const TransferableDataHelper& rData )
1068 : {
1069 : // Check the common case first: We can always paste our own data!
1070 : // If _only_ the internal format can be pasted, this check will
1071 : // yield 'true', while the one below would give a (wrong) result 'false'.
1072 :
1073 0 : bool bIsPaste = ( GetSwTransferable( rData ) != NULL );
1074 :
1075 : // if it's not our own data, we need to have a closer look:
1076 0 : if( ! bIsPaste )
1077 : {
1078 : // determine the proper paste action, and return true if we find one
1079 0 : uno::Reference<XTransferable> xTransferable( rData.GetXTransferable() );
1080 :
1081 0 : sal_uInt16 nDestination = SwTransferable::GetSotDestination( rSh );
1082 : sal_uInt16 nSourceOptions =
1083 0 : (( EXCHG_DEST_DOC_TEXTFRAME == nDestination ||
1084 0 : EXCHG_DEST_SWDOC_FREE_AREA == nDestination ||
1085 0 : EXCHG_DEST_DOC_TEXTFRAME_WEB == nDestination ||
1086 : EXCHG_DEST_SWDOC_FREE_AREA_WEB == nDestination )
1087 : ? EXCHG_IN_ACTION_COPY
1088 0 : : EXCHG_IN_ACTION_MOVE);
1089 :
1090 : sal_uLong nFormat; // output param for GetExchangeAction
1091 : sal_uInt16 nEventAction; // output param for GetExchangeAction
1092 : sal_uInt16 nAction = SotExchange::GetExchangeAction(
1093 0 : rData.GetDataFlavorExVector(),
1094 : nDestination,
1095 : nSourceOptions, /* ?? */
1096 : EXCHG_IN_ACTION_DEFAULT, /* ?? */
1097 : nFormat, nEventAction, 0,
1098 0 : lcl_getTransferPointer ( xTransferable ) );
1099 :
1100 : // if we find a suitable action, we can paste!
1101 0 : bIsPaste = (EXCHG_INOUT_ACTION_NONE != nAction);
1102 : }
1103 :
1104 0 : return bIsPaste;
1105 : }
1106 :
1107 1 : bool SwTransferable::Paste( SwWrtShell& rSh, TransferableDataHelper& rData )
1108 : {
1109 1 : sal_uInt16 nEventAction, nAction=0,
1110 1 : nDestination = SwTransferable::GetSotDestination( rSh );
1111 1 : sal_uLong nFormat = 0;
1112 :
1113 1 : if( GetSwTransferable( rData ) )
1114 : {
1115 1 : nAction = EXCHG_OUT_ACTION_INSERT_PRIVATE;
1116 : }
1117 : else
1118 : {
1119 : sal_uInt16 nSourceOptions =
1120 0 : (( EXCHG_DEST_DOC_TEXTFRAME == nDestination ||
1121 0 : EXCHG_DEST_SWDOC_FREE_AREA == nDestination ||
1122 0 : EXCHG_DEST_DOC_TEXTFRAME_WEB == nDestination ||
1123 : EXCHG_DEST_SWDOC_FREE_AREA_WEB == nDestination )
1124 : ? EXCHG_IN_ACTION_COPY
1125 0 : : EXCHG_IN_ACTION_MOVE);
1126 0 : uno::Reference<XTransferable> xTransferable( rData.GetXTransferable() );
1127 : nAction = SotExchange::GetExchangeAction(
1128 0 : rData.GetDataFlavorExVector(),
1129 : nDestination,
1130 : nSourceOptions, /* ?? */
1131 : EXCHG_IN_ACTION_DEFAULT, /* ?? */
1132 : nFormat, nEventAction, 0,
1133 0 : lcl_getTransferPointer ( xTransferable ) );
1134 : }
1135 :
1136 : // special case for tables from draw application
1137 1 : if( EXCHG_OUT_ACTION_INSERT_DRAWOBJ == (nAction & EXCHG_ACTION_MASK) )
1138 : {
1139 0 : if( rData.HasFormat( SOT_FORMAT_RTF ) )
1140 : {
1141 0 : nAction = EXCHG_OUT_ACTION_INSERT_STRING | (nAction & ~EXCHG_ACTION_MASK);
1142 0 : nFormat = SOT_FORMAT_RTF;
1143 : }
1144 : }
1145 :
1146 2 : return EXCHG_INOUT_ACTION_NONE != nAction &&
1147 : SwTransferable::PasteData( rData, rSh, nAction, nFormat,
1148 2 : nDestination, sal_False, sal_False );
1149 : }
1150 :
1151 1 : bool SwTransferable::PasteData( TransferableDataHelper& rData,
1152 : SwWrtShell& rSh, sal_uInt16 nAction, sal_uLong nFormat,
1153 : sal_uInt16 nDestination, sal_Bool bIsPasteFmt,
1154 : sal_Bool bIsDefault,
1155 : const Point* pPt, sal_Int8 nDropAction,
1156 : sal_Bool bPasteSelection )
1157 : {
1158 1 : SwWait aWait( *rSh.GetView().GetDocShell(), false );
1159 2 : boost::scoped_ptr<SwTrnsfrActionAndUndo> pAction;
1160 1 : SwModule* pMod = SW_MOD();
1161 :
1162 1 : bool nRet = false;
1163 1 : bool bCallAutoCaption = false;
1164 :
1165 1 : if( pPt )
1166 : {
1167 : // external Drop
1168 0 : if( bPasteSelection ? !pMod->pXSelection : !pMod->pDragDrop )
1169 : {
1170 0 : switch( nDestination )
1171 : {
1172 : case EXCHG_DEST_DOC_LNKD_GRAPH_W_IMAP:
1173 : case EXCHG_DEST_DOC_LNKD_GRAPHOBJ:
1174 : case EXCHG_DEST_DOC_GRAPH_W_IMAP:
1175 : case EXCHG_DEST_DOC_GRAPHOBJ:
1176 : case EXCHG_DEST_DOC_OLEOBJ:
1177 : case EXCHG_DEST_DOC_DRAWOBJ:
1178 : case EXCHG_DEST_DOC_URLBUTTON:
1179 : case EXCHG_DEST_DOC_GROUPOBJ:
1180 : // select frames/objects
1181 0 : SwTransferable::SetSelInShell( rSh, sal_True, pPt );
1182 0 : break;
1183 :
1184 : default:
1185 0 : SwTransferable::SetSelInShell( rSh, sal_False, pPt );
1186 0 : break;
1187 : }
1188 : }
1189 : }
1190 3 : else if( ( !GetSwTransferable( rData ) || bIsPasteFmt ) &&
1191 1 : !rSh.IsTableMode() && rSh.HasSelection() )
1192 : {
1193 : // then delete the selections
1194 :
1195 : //don't delete selected content
1196 : // - at table-selection
1197 : // - at ReRead of a graphic/DDEData
1198 : // - at D&D, for the right selection was taken care of
1199 : // in Drop-Handler
1200 0 : sal_Bool bDelSel = sal_False;
1201 0 : switch( nDestination )
1202 : {
1203 : case EXCHG_DEST_DOC_TEXTFRAME:
1204 : case EXCHG_DEST_SWDOC_FREE_AREA:
1205 : case EXCHG_DEST_DOC_TEXTFRAME_WEB:
1206 : case EXCHG_DEST_SWDOC_FREE_AREA_WEB:
1207 0 : bDelSel = sal_True;
1208 0 : break;
1209 : }
1210 :
1211 0 : if( bDelSel )
1212 : // #i34830#
1213 : pAction.reset(new SwTrnsfrActionAndUndo( &rSh, UNDO_PASTE_CLIPBOARD, NULL,
1214 0 : sal_True ));
1215 : }
1216 :
1217 1 : SwTransferable *pTrans=0, *pTunneledTrans=GetSwTransferable( rData );
1218 :
1219 : // check for private drop
1220 1 : bool bPrivateDrop(pPt && (bPasteSelection ? 0 != (pTrans = pMod->pXSelection) : 0 != (pTrans = pMod->pDragDrop)));
1221 1 : bool bNeedToSelectBeforePaste(false);
1222 :
1223 1 : if(bPrivateDrop && DND_ACTION_LINK == nDropAction)
1224 : {
1225 : // internal drop on object, suppress bPrivateDrop to change internal fill
1226 0 : bPrivateDrop = false;
1227 0 : bNeedToSelectBeforePaste = true;
1228 : }
1229 :
1230 1 : if(bPrivateDrop && pPt && DND_ACTION_MOVE == nDropAction)
1231 : {
1232 : // check if dragged over a useful target. If yes, use as content exchange
1233 : // drop as if from external
1234 0 : const SwFrmFmt* pSwFrmFmt = rSh.GetFmtFromObj(*pPt);
1235 :
1236 0 : if(pSwFrmFmt && 0 != dynamic_cast< const SwDrawFrmFmt* >(pSwFrmFmt))
1237 : {
1238 0 : bPrivateDrop = false;
1239 0 : bNeedToSelectBeforePaste = true;
1240 : }
1241 : }
1242 :
1243 1 : if(bPrivateDrop)
1244 : {
1245 : // then internal Drag & Drop or XSelection
1246 : nRet = pTrans->PrivateDrop( rSh, *pPt, DND_ACTION_MOVE == nDropAction,
1247 0 : bPasteSelection );
1248 : }
1249 1 : else if( !pPt && pTunneledTrans &&
1250 : EXCHG_OUT_ACTION_INSERT_PRIVATE == nAction )
1251 : {
1252 : // then internal paste
1253 1 : nRet = pTunneledTrans->PrivatePaste( rSh );
1254 : }
1255 0 : else if( EXCHG_INOUT_ACTION_NONE != nAction )
1256 : {
1257 0 : if( !pAction )
1258 : {
1259 0 : pAction.reset(new SwTrnsfrActionAndUndo( &rSh, UNDO_PASTE_CLIPBOARD));
1260 : }
1261 :
1262 : // in Drag&Drop MessageBoxes must not be showed
1263 0 : sal_Bool bMsg = 0 == pPt;
1264 0 : sal_uInt8 nActionFlags = static_cast< sal_uInt8 >(( nAction >> 8 ) & 0xFF);
1265 :
1266 0 : sal_uInt16 nClearedAction = ( nAction & EXCHG_ACTION_MASK );
1267 : // delete selections
1268 :
1269 0 : switch( nClearedAction )
1270 : {
1271 : case EXCHG_OUT_ACTION_INSERT_PRIVATE:
1272 : OSL_ENSURE( pPt, "EXCHG_OUT_ACTION_INSERT_PRIVATE: what should happen here?" );
1273 0 : break;
1274 :
1275 : case EXCHG_OUT_ACTION_MOVE_PRIVATE:
1276 : OSL_ENSURE( pPt, "EXCHG_OUT_ACTION_MOVE_PRIVATE: what should happen here?" );
1277 0 : break;
1278 :
1279 : case EXCHG_IN_ACTION_MOVE:
1280 : case EXCHG_IN_ACTION_COPY:
1281 : case EXCHG_IN_ACTION_LINK:
1282 : case EXCHG_OUT_ACTION_INSERT_HTML:
1283 : case EXCHG_OUT_ACTION_INSERT_STRING:
1284 : case EXCHG_OUT_ACTION_INSERT_IMAGEMAP:
1285 : case EXCHG_OUT_ACTION_REPLACE_IMAGEMAP:
1286 :
1287 : // then we have to use the format
1288 0 : switch( nFormat )
1289 : {
1290 : case SOT_FORMATSTR_ID_DRAWING:
1291 : nRet = SwTransferable::_PasteSdrFormat( rData, rSh,
1292 : SW_PASTESDR_INSERT, pPt,
1293 0 : nActionFlags, bNeedToSelectBeforePaste);
1294 0 : break;
1295 :
1296 : case SOT_FORMATSTR_ID_HTML:
1297 : case SOT_FORMATSTR_ID_HTML_SIMPLE:
1298 : case SOT_FORMATSTR_ID_HTML_NO_COMMENT:
1299 : case SOT_FORMAT_RTF:
1300 : case SOT_FORMAT_STRING:
1301 : nRet = SwTransferable::_PasteFileContent( rData, rSh,
1302 0 : nFormat, bMsg );
1303 0 : break;
1304 :
1305 : case SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK:
1306 : {
1307 0 : INetBookmark aBkmk;
1308 0 : if( rData.GetINetBookmark( nFormat, aBkmk ) )
1309 : {
1310 0 : SwFmtINetFmt aFmt( aBkmk.GetURL(), OUString() );
1311 0 : rSh.InsertURL( aFmt, aBkmk.GetDescription() );
1312 0 : nRet = true;
1313 0 : }
1314 : }
1315 0 : break;
1316 :
1317 : case SOT_FORMATSTR_ID_SD_OLE:
1318 : nRet = SwTransferable::_PasteOLE( rData, rSh, nFormat,
1319 0 : nActionFlags, bMsg );
1320 0 : break;
1321 :
1322 : case SOT_FORMATSTR_ID_SVIM:
1323 0 : nRet = SwTransferable::_PasteImageMap( rData, rSh );
1324 0 : break;
1325 :
1326 : case SOT_FORMATSTR_ID_SVXB:
1327 : case SOT_FORMAT_BITMAP:
1328 : case SOT_FORMATSTR_ID_PNG:
1329 : case SOT_FORMAT_GDIMETAFILE:
1330 : nRet = SwTransferable::_PasteGrf( rData, rSh, nFormat,
1331 : SW_PASTESDR_INSERT,pPt,
1332 0 : nActionFlags, nDropAction, bNeedToSelectBeforePaste);
1333 0 : break;
1334 :
1335 : case SOT_FORMATSTR_ID_XFORMS:
1336 : case SOT_FORMATSTR_ID_SBA_FIELDDATAEXCHANGE:
1337 : case SOT_FORMATSTR_ID_SBA_DATAEXCHANGE:
1338 : case SOT_FORMATSTR_ID_SBA_CTRLDATAEXCHANGE:
1339 : nRet = SwTransferable::_PasteDBData( rData, rSh, nFormat,
1340 : EXCHG_IN_ACTION_LINK == nClearedAction,
1341 0 : pPt, bMsg );
1342 0 : break;
1343 :
1344 : case SOT_FORMAT_FILE:
1345 : nRet = SwTransferable::_PasteFileName( rData, rSh, nFormat,
1346 : ( EXCHG_IN_ACTION_MOVE == nClearedAction
1347 : ? SW_PASTESDR_REPLACE
1348 : : EXCHG_IN_ACTION_LINK == nClearedAction
1349 : ? SW_PASTESDR_SETATTR
1350 : : SW_PASTESDR_INSERT),
1351 0 : pPt, nActionFlags, bMsg, 0 );
1352 0 : break;
1353 :
1354 : case SOT_FORMAT_FILE_LIST:
1355 : // then insert as graphics only
1356 : nRet = SwTransferable::_PasteFileList( rData, rSh,
1357 : EXCHG_IN_ACTION_LINK == nClearedAction,
1358 0 : pPt, bMsg );
1359 0 : break;
1360 :
1361 : case SOT_FORMATSTR_ID_SONLK:
1362 0 : if( pPt )
1363 : {
1364 0 : NaviContentBookmark aBkmk;
1365 0 : if( aBkmk.Paste( rData ) )
1366 : {
1367 0 : if(bIsDefault)
1368 : {
1369 0 : switch(aBkmk.GetDefaultDragType())
1370 : {
1371 0 : case REGION_MODE_NONE: nClearedAction = EXCHG_IN_ACTION_COPY; break;
1372 0 : case REGION_MODE_EMBEDDED: nClearedAction = EXCHG_IN_ACTION_MOVE; break;
1373 0 : case REGION_MODE_LINK: nClearedAction = EXCHG_IN_ACTION_LINK; break;
1374 : }
1375 : }
1376 0 : rSh.NavigatorPaste( aBkmk, nClearedAction );
1377 0 : nRet = true;
1378 0 : }
1379 : }
1380 0 : break;
1381 :
1382 : case SOT_FORMATSTR_ID_INET_IMAGE:
1383 : case SOT_FORMATSTR_ID_NETSCAPE_IMAGE:
1384 : nRet = SwTransferable::_PasteTargetURL( rData, rSh,
1385 : SW_PASTESDR_INSERT,
1386 0 : pPt, sal_True );
1387 0 : break;
1388 :
1389 : default:
1390 : OSL_ENSURE( pPt, "unknown format" );
1391 : }
1392 0 : break;
1393 :
1394 : case EXCHG_OUT_ACTION_INSERT_FILE:
1395 : {
1396 : bool graphicInserted;
1397 : nRet = SwTransferable::_PasteFileName( rData, rSh, nFormat,
1398 : SW_PASTESDR_INSERT, pPt,
1399 : nActionFlags, bMsg,
1400 0 : &graphicInserted );
1401 0 : if( graphicInserted )
1402 0 : bCallAutoCaption = true;
1403 : }
1404 0 : break;
1405 :
1406 : case EXCHG_OUT_ACTION_INSERT_OLE:
1407 : nRet = SwTransferable::_PasteOLE( rData, rSh, nFormat,
1408 0 : nActionFlags,bMsg );
1409 0 : break;
1410 :
1411 : case EXCHG_OUT_ACTION_INSERT_DDE:
1412 : {
1413 0 : sal_Bool bReRead = 0 != CNT_HasGrf( rSh.GetCntType() );
1414 0 : nRet = SwTransferable::_PasteDDE( rData, rSh, bReRead, bMsg );
1415 : }
1416 0 : break;
1417 :
1418 : case EXCHG_OUT_ACTION_INSERT_HYPERLINK:
1419 : {
1420 0 : OUString sURL, sDesc;
1421 0 : if( SOT_FORMAT_FILE == nFormat )
1422 : {
1423 0 : if( rData.GetString( nFormat, sURL ) && !sURL.isEmpty() )
1424 : {
1425 0 : SwTransferable::_CheckForURLOrLNKFile( rData, sURL, &sDesc );
1426 0 : if( sDesc.isEmpty() )
1427 0 : sDesc = sURL;
1428 0 : nRet = true;
1429 : }
1430 : }
1431 : else
1432 : {
1433 0 : INetBookmark aBkmk;
1434 0 : if( rData.GetINetBookmark( nFormat, aBkmk ) )
1435 : {
1436 0 : sURL = aBkmk.GetURL();
1437 0 : sDesc = aBkmk.GetDescription();
1438 0 : nRet = true;
1439 0 : }
1440 : }
1441 :
1442 0 : if( nRet )
1443 : {
1444 0 : SwFmtINetFmt aFmt( sURL, OUString() );
1445 0 : rSh.InsertURL( aFmt, sDesc );
1446 0 : }
1447 : }
1448 0 : break;
1449 :
1450 : case EXCHG_OUT_ACTION_GET_ATTRIBUTES:
1451 0 : switch( nFormat )
1452 : {
1453 : case SOT_FORMATSTR_ID_DRAWING:
1454 : nRet = SwTransferable::_PasteSdrFormat( rData, rSh,
1455 : SW_PASTESDR_SETATTR, pPt,
1456 0 : nActionFlags, bNeedToSelectBeforePaste);
1457 0 : break;
1458 : case SOT_FORMATSTR_ID_SVXB:
1459 : case SOT_FORMAT_GDIMETAFILE:
1460 : case SOT_FORMAT_BITMAP:
1461 : case SOT_FORMATSTR_ID_PNG:
1462 : case SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK:
1463 : case SOT_FORMAT_FILE:
1464 : case SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR:
1465 : case SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR:
1466 : nRet = SwTransferable::_PasteGrf( rData, rSh, nFormat,
1467 : SW_PASTESDR_SETATTR, pPt,
1468 0 : nActionFlags, nDropAction, bNeedToSelectBeforePaste);
1469 0 : break;
1470 : default:
1471 : OSL_FAIL( "unknown format" );
1472 : }
1473 :
1474 0 : break;
1475 :
1476 : case EXCHG_OUT_ACTION_INSERT_DRAWOBJ:
1477 : nRet = SwTransferable::_PasteSdrFormat( rData, rSh,
1478 : SW_PASTESDR_INSERT, pPt,
1479 0 : nActionFlags, bNeedToSelectBeforePaste);
1480 0 : break;
1481 : case EXCHG_OUT_ACTION_INSERT_SVXB:
1482 : case EXCHG_OUT_ACTION_INSERT_GDIMETAFILE:
1483 : case EXCHG_OUT_ACTION_INSERT_BITMAP:
1484 : case EXCHG_OUT_ACTION_INSERT_GRAPH:
1485 : nRet = SwTransferable::_PasteGrf( rData, rSh, nFormat,
1486 : SW_PASTESDR_INSERT, pPt,
1487 0 : nActionFlags, nDropAction, bNeedToSelectBeforePaste);
1488 0 : break;
1489 :
1490 : case EXCHG_OUT_ACTION_REPLACE_DRAWOBJ:
1491 : nRet = SwTransferable::_PasteSdrFormat( rData, rSh,
1492 : SW_PASTESDR_REPLACE, pPt,
1493 0 : nActionFlags, bNeedToSelectBeforePaste);
1494 0 : break;
1495 :
1496 : case EXCHG_OUT_ACTION_REPLACE_SVXB:
1497 : case EXCHG_OUT_ACTION_REPLACE_GDIMETAFILE:
1498 : case EXCHG_OUT_ACTION_REPLACE_BITMAP:
1499 : case EXCHG_OUT_ACTION_REPLACE_GRAPH:
1500 : nRet = SwTransferable::_PasteGrf( rData, rSh, nFormat,
1501 : SW_PASTESDR_REPLACE,pPt,
1502 0 : nActionFlags, nDropAction, bNeedToSelectBeforePaste);
1503 0 : break;
1504 :
1505 : case EXCHG_OUT_ACTION_INSERT_INTERACTIVE:
1506 0 : nRet = SwTransferable::_PasteAsHyperlink( rData, rSh, nFormat );
1507 0 : break;
1508 :
1509 : default:
1510 : OSL_FAIL("unknown action" );
1511 : }
1512 : }
1513 :
1514 1 : if( !bPasteSelection && rSh.IsFrmSelected() )
1515 : {
1516 0 : rSh.EnterSelFrmMode();
1517 : //force ::SelectShell
1518 0 : rSh.GetView().StopShellTimer();
1519 : }
1520 :
1521 1 : pAction.reset();
1522 1 : if( bCallAutoCaption )
1523 0 : rSh.GetView().AutoCaption( GRAPHIC_CAP );
1524 :
1525 2 : return nRet;
1526 : }
1527 :
1528 2289 : sal_uInt16 SwTransferable::GetSotDestination( const SwWrtShell& rSh,
1529 : const Point* pPt )
1530 : {
1531 2289 : sal_uInt16 nRet = EXCHG_INOUT_ACTION_NONE;
1532 :
1533 : ObjCntType eOType;
1534 2289 : if( pPt )
1535 : {
1536 0 : SdrObject *pObj = 0;
1537 0 : eOType = rSh.GetObjCntType( *pPt, pObj );
1538 : }
1539 : else
1540 2289 : eOType = rSh.GetObjCntTypeOfSelection();
1541 :
1542 2289 : switch( eOType )
1543 : {
1544 : case OBJCNT_GRF:
1545 : {
1546 : sal_Bool bIMap, bLink;
1547 0 : if( pPt )
1548 : {
1549 0 : bIMap = 0 != rSh.GetFmtFromObj( *pPt )->GetURL().GetMap();
1550 0 : OUString aDummy;
1551 0 : rSh.GetGrfAtPos( *pPt, aDummy, bLink );
1552 : }
1553 : else
1554 : {
1555 0 : bIMap = 0 != rSh.GetFlyFrmFmt()->GetURL().GetMap();
1556 0 : OUString aDummy;
1557 0 : rSh.GetGrfNms( &aDummy, 0 );
1558 0 : bLink = !aDummy.isEmpty();
1559 : }
1560 :
1561 0 : if( bLink && bIMap )
1562 0 : nRet = EXCHG_DEST_DOC_LNKD_GRAPH_W_IMAP;
1563 0 : else if( bLink )
1564 0 : nRet = EXCHG_DEST_DOC_LNKD_GRAPHOBJ;
1565 0 : else if( bIMap )
1566 0 : nRet = EXCHG_DEST_DOC_GRAPH_W_IMAP;
1567 : else
1568 0 : nRet = EXCHG_DEST_DOC_GRAPHOBJ;
1569 : }
1570 0 : break;
1571 :
1572 : case OBJCNT_FLY:
1573 0 : if( rSh.GetView().GetDocShell()->ISA(SwWebDocShell) )
1574 0 : nRet = EXCHG_DEST_DOC_TEXTFRAME_WEB;
1575 : else
1576 0 : nRet = EXCHG_DEST_DOC_TEXTFRAME;
1577 0 : break;
1578 0 : case OBJCNT_OLE: nRet = EXCHG_DEST_DOC_OLEOBJ; break;
1579 :
1580 : case OBJCNT_CONTROL: /* no Action avail */
1581 0 : case OBJCNT_SIMPLE: nRet = EXCHG_DEST_DOC_DRAWOBJ; break;
1582 0 : case OBJCNT_URLBUTTON: nRet = EXCHG_DEST_DOC_URLBUTTON; break;
1583 0 : case OBJCNT_GROUPOBJ: nRet = EXCHG_DEST_DOC_GROUPOBJ; break;
1584 :
1585 : // what do we do at multiple selections???
1586 : default:
1587 : {
1588 2289 : if( rSh.GetView().GetDocShell()->ISA(SwWebDocShell) )
1589 2 : nRet = EXCHG_DEST_SWDOC_FREE_AREA_WEB;
1590 : else
1591 2287 : nRet = EXCHG_DEST_SWDOC_FREE_AREA;
1592 : }
1593 : }
1594 :
1595 2289 : return nRet;
1596 : }
1597 :
1598 0 : bool SwTransferable::_PasteFileContent( TransferableDataHelper& rData,
1599 : SwWrtShell& rSh, sal_uLong nFmt, sal_Bool bMsg )
1600 : {
1601 0 : sal_uInt16 nResId = MSG_CLPBRD_FORMAT_ERROR;
1602 0 : bool nRet = false;
1603 :
1604 0 : MSE40HTMLClipFormatObj aMSE40ClpObj;
1605 :
1606 0 : SotStorageStreamRef xStrm;
1607 0 : SvStream* pStream = 0;
1608 0 : SwRead pRead = 0;
1609 0 : OUString sData;
1610 0 : switch( nFmt )
1611 : {
1612 : case SOT_FORMAT_STRING:
1613 : {
1614 0 : pRead = ReadAscii;
1615 0 : if( rData.GetString( nFmt, sData ) )
1616 : {
1617 : pStream = new SvMemoryStream( (void*)sData.getStr(),
1618 0 : sData.getLength() * sizeof( sal_Unicode ),
1619 0 : STREAM_READ );
1620 : #ifdef OSL_BIGENDIAN
1621 : pStream->SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
1622 : #else
1623 0 : pStream->SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
1624 : #endif
1625 :
1626 0 : SwAsciiOptions aAOpt;
1627 0 : aAOpt.SetCharSet( RTL_TEXTENCODING_UCS2 );
1628 0 : pRead->GetReaderOpt().SetASCIIOpts( aAOpt );
1629 0 : break;
1630 : }
1631 : }
1632 : // no break - because then test if we get a stream
1633 :
1634 : default:
1635 0 : if( rData.GetSotStorageStream( nFmt, xStrm ) )
1636 : {
1637 0 : if( ( SOT_FORMATSTR_ID_HTML_SIMPLE == nFmt ) ||
1638 : ( SOT_FORMATSTR_ID_HTML_NO_COMMENT == nFmt ) )
1639 : {
1640 0 : pStream = aMSE40ClpObj.IsValid( *xStrm );
1641 0 : pRead = ReadHTML;
1642 0 : pRead->SetReadUTF8( sal_True );
1643 :
1644 : sal_Bool bNoComments =
1645 0 : ( nFmt == SOT_FORMATSTR_ID_HTML_NO_COMMENT );
1646 0 : pRead->SetIgnoreHTMLComments( bNoComments );
1647 : }
1648 : else
1649 : {
1650 0 : pStream = &xStrm;
1651 0 : if( SOT_FORMAT_RTF == nFmt )
1652 0 : pRead = SwReaderWriter::GetReader( READER_WRITER_RTF );
1653 0 : else if( !pRead )
1654 : {
1655 0 : pRead = ReadHTML;
1656 0 : pRead->SetReadUTF8( sal_True );
1657 : }
1658 : }
1659 : }
1660 0 : break;
1661 : }
1662 :
1663 0 : if( pStream && pRead )
1664 : {
1665 0 : Link aOldLink( rSh.GetChgLnk() );
1666 0 : rSh.SetChgLnk( Link() );
1667 :
1668 0 : const SwPosition& rInsPos = *rSh.GetCrsr()->Start();
1669 0 : SwReader aReader( *pStream, aEmptyOUStr, OUString(), *rSh.GetCrsr() );
1670 0 : rSh.SaveTblBoxCntnt( &rInsPos );
1671 0 : if( IsError( aReader.Read( *pRead )) )
1672 0 : nResId = ERR_CLPBRD_READ;
1673 : else
1674 0 : nResId = 0, nRet = true;
1675 :
1676 0 : rSh.SetChgLnk( aOldLink );
1677 0 : if( nRet )
1678 0 : rSh.CallChgLnk();
1679 : }
1680 : else
1681 0 : nResId = MSG_CLPBRD_FORMAT_ERROR;
1682 :
1683 : // Exist a SvMemoryStream? (data in the OUString and xStrm is empty)
1684 0 : if( pStream && !xStrm.Is() )
1685 0 : delete pStream;
1686 :
1687 0 : if( bMsg && nResId )
1688 : {
1689 0 : InfoBox( 0, SW_RES( nResId )).Execute();
1690 : }
1691 0 : return nRet;
1692 : }
1693 :
1694 0 : bool SwTransferable::_PasteOLE( TransferableDataHelper& rData, SwWrtShell& rSh,
1695 : sal_uLong nFmt, sal_uInt8 nActionFlags, sal_Bool bMsg )
1696 : {
1697 0 : bool nRet = false;
1698 0 : TransferableObjectDescriptor aObjDesc;
1699 0 : uno::Reference < io::XInputStream > xStrm;
1700 0 : uno::Reference < embed::XStorage > xStore;
1701 0 : Reader* pRead = 0;
1702 :
1703 : // Get the preferred format
1704 : SotFormatStringId nId;
1705 0 : if( rData.HasFormat( SOT_FORMATSTR_ID_EMBEDDED_OBJ ) )
1706 0 : nId = SOT_FORMATSTR_ID_EMBEDDED_OBJ;
1707 0 : else if( rData.HasFormat( SOT_FORMATSTR_ID_EMBED_SOURCE ) &&
1708 0 : rData.HasFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ))
1709 0 : nId = SOT_FORMATSTR_ID_EMBED_SOURCE;
1710 : else
1711 0 : nId = 0;
1712 :
1713 0 : if( nId && rData.GetInputStream( nId, xStrm ) && xStrm.is() )
1714 : {
1715 : // if there is an embedded object, first try if it's a writer object
1716 : // this will be inserted into the document by using a Reader
1717 : try
1718 : {
1719 0 : xStore = comphelper::OStorageHelper::GetStorageFromInputStream( xStrm );
1720 0 : switch( SotStorage::GetFormatID( xStore ) )
1721 : {
1722 : case SOT_FORMATSTR_ID_STARWRITER_60:
1723 : case SOT_FORMATSTR_ID_STARWRITERWEB_60:
1724 : case SOT_FORMATSTR_ID_STARWRITERGLOB_60:
1725 : case SOT_FORMATSTR_ID_STARWRITER_8:
1726 : case SOT_FORMATSTR_ID_STARWRITERWEB_8:
1727 : case SOT_FORMATSTR_ID_STARWRITERGLOB_8:
1728 0 : pRead = ReadXML;
1729 0 : break;
1730 : default:
1731 : try
1732 : {
1733 0 : uno::Reference < lang::XComponent > xComp( xStore, uno::UNO_QUERY );
1734 0 : xComp->dispose();
1735 0 : xStore = 0;
1736 : }
1737 0 : catch (const uno::Exception&)
1738 : {
1739 : }
1740 :
1741 0 : break;
1742 : }
1743 : }
1744 0 : catch (const uno::Exception&)
1745 : {
1746 : // it wasn't a storage, but maybe it's a useful stream
1747 : }
1748 :
1749 0 : nFmt = nId;
1750 : }
1751 :
1752 0 : if( pRead )
1753 : {
1754 0 : SwPaM &rPAM = *rSh.GetCrsr();
1755 0 : SwReader aReader( xStore, aEmptyOUStr, rPAM );
1756 0 : if( !IsError( aReader.Read( *pRead )) )
1757 0 : nRet = true;
1758 0 : else if( bMsg )
1759 0 : InfoBox( 0, SW_RES(ERR_CLPBRD_READ) ).Execute();
1760 : }
1761 : else
1762 : {
1763 : // temporary storage until the object is inserted
1764 0 : uno::Reference< embed::XStorage > xTmpStor;
1765 0 : uno::Reference < embed::XEmbeddedObject > xObj;
1766 0 : OUString aName;
1767 0 : comphelper::EmbeddedObjectContainer aCnt;
1768 :
1769 0 : if ( xStrm.is() )
1770 : {
1771 0 : if ( !rData.GetTransferableObjectDescriptor( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR, aObjDesc ) )
1772 : {
1773 : OSL_ENSURE( !xStrm.is(), "An object without descriptor in clipboard!");
1774 : }
1775 : }
1776 : else
1777 : {
1778 0 : if( rData.HasFormat( nFmt = SOT_FORMATSTR_ID_OBJECTDESCRIPTOR_OLE ) && rData.GetTransferableObjectDescriptor( nFmt, aObjDesc ) )
1779 : {
1780 0 : if ( !rData.GetInputStream( SOT_FORMATSTR_ID_EMBED_SOURCE_OLE, xStrm ) )
1781 0 : rData.GetInputStream( SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE, xStrm );
1782 :
1783 0 : if ( !xStrm.is() )
1784 : {
1785 : // This is MSOLE object that should be created by direct using of system clipboard
1786 : try
1787 : {
1788 0 : xTmpStor = ::comphelper::OStorageHelper::GetTemporaryStorage();
1789 : uno::Reference < embed::XEmbedObjectClipboardCreator > xClipboardCreator =
1790 0 : embed::MSOLEObjectSystemCreator::create( ::comphelper::getProcessComponentContext() );
1791 :
1792 0 : embed::InsertedObjectInfo aInfo = xClipboardCreator->createInstanceInitFromClipboard(
1793 : xTmpStor,
1794 : OUString( "DummyName" ),
1795 0 : uno::Sequence< beans::PropertyValue >() );
1796 :
1797 : // TODO/LATER: in future InsertedObjectInfo will be used to get container related information
1798 : // for example whether the object should be an iconified one
1799 0 : xObj = aInfo.Object;
1800 : }
1801 0 : catch (const uno::Exception&)
1802 : {
1803 : }
1804 : }
1805 : }
1806 : }
1807 :
1808 0 : if ( xStrm.is() && !xObj.is() )
1809 0 : xObj = aCnt.InsertEmbeddedObject( xStrm, aName );
1810 :
1811 0 : if( xObj.is() )
1812 : {
1813 0 : svt::EmbeddedObjectRef xObjRef( xObj, aObjDesc.mnViewAspect );
1814 :
1815 : // try to get the replacement image from the clipboard
1816 0 : Graphic aGraphic;
1817 0 : sal_uLong nGrFormat = 0;
1818 :
1819 : // limit the size of the preview metafile to 100000 actions
1820 0 : GDIMetaFile aMetafile;
1821 0 : if (rData.GetGDIMetaFile(FORMAT_GDIMETAFILE, aMetafile, 100000))
1822 : {
1823 0 : nGrFormat = SOT_FORMAT_GDIMETAFILE;
1824 0 : aGraphic = aMetafile;
1825 : }
1826 :
1827 : // insert replacement image ( if there is one ) into the object helper
1828 0 : if ( nGrFormat )
1829 : {
1830 0 : DataFlavor aDataFlavor;
1831 0 : SotExchange::GetFormatDataFlavor( nGrFormat, aDataFlavor );
1832 0 : xObjRef.SetGraphic( aGraphic, aDataFlavor.MimeType );
1833 : }
1834 0 : else if ( aObjDesc.mnViewAspect == embed::Aspects::MSOLE_ICON )
1835 : {
1836 : // it is important to have an icon, let an empty graphic be used
1837 : // if no other graphic is provided
1838 : // TODO/LATER: in future a default bitmap could be used
1839 0 : OUString aMimeType;
1840 0 : MapMode aMapMode( MAP_100TH_MM );
1841 0 : aGraphic.SetPrefSize( Size( 2500, 2500 ) );
1842 0 : aGraphic.SetPrefMapMode( aMapMode );
1843 0 : xObjRef.SetGraphic( aGraphic, aMimeType );
1844 : }
1845 :
1846 : //set size. This is a hack because of handing over, size should be
1847 : //passed to the InsertOle!!!!!!!!!!
1848 0 : Size aSize;
1849 0 : if ( aObjDesc.mnViewAspect == embed::Aspects::MSOLE_ICON )
1850 : {
1851 0 : if( aObjDesc.maSize.Width() && aObjDesc.maSize.Height() )
1852 0 : aSize = aObjDesc.maSize;
1853 : else
1854 : {
1855 0 : MapMode aMapMode( MAP_100TH_MM );
1856 0 : aSize = xObjRef.GetSize( &aMapMode );
1857 : }
1858 : }
1859 0 : else if( aObjDesc.maSize.Width() && aObjDesc.maSize.Height() )
1860 : {
1861 0 : aSize = Size( aObjDesc.maSize ); //always 100TH_MM
1862 0 : MapUnit aUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( aObjDesc.mnViewAspect ) );
1863 0 : aSize = OutputDevice::LogicToLogic( aSize, MAP_100TH_MM, aUnit );
1864 0 : awt::Size aSz;
1865 : try
1866 : {
1867 0 : aSz = xObj->getVisualAreaSize( aObjDesc.mnViewAspect );
1868 : }
1869 0 : catch (const embed::NoVisualAreaSizeException&)
1870 : {
1871 : // in this case the provided size is used
1872 : }
1873 :
1874 0 : if ( aSz.Width != aSize.Width() || aSz.Height != aSize.Height() )
1875 : {
1876 0 : aSz.Width = aSize.Width();
1877 0 : aSz.Height = aSize.Height();
1878 0 : xObj->setVisualAreaSize( aObjDesc.mnViewAspect, aSz );
1879 : }
1880 : }
1881 : else
1882 : {
1883 : // the descriptor contains the wrong object size
1884 : // the following call will let the MSOLE objects cache the size if it is possible
1885 : // it should be done while the object is running
1886 : try
1887 : {
1888 0 : xObj->getVisualAreaSize( aObjDesc.mnViewAspect );
1889 : }
1890 0 : catch (const uno::Exception&)
1891 : {
1892 : }
1893 : }
1894 : //End of Hack!
1895 :
1896 0 : rSh.InsertOleObject( xObjRef );
1897 0 : nRet = true;
1898 :
1899 0 : if( nRet && ( nActionFlags &
1900 : ( EXCHG_OUT_ACTION_FLAG_INSERT_TARGETURL >> 8) ))
1901 0 : SwTransferable::_PasteTargetURL( rData, rSh, 0, 0, sal_False );
1902 :
1903 : // let the object be unloaded if possible
1904 0 : SwOLEObj::UnloadObject( xObj, rSh.GetDoc(), embed::Aspects::MSOLE_CONTENT );
1905 0 : }
1906 : }
1907 0 : return nRet;
1908 : }
1909 :
1910 0 : bool SwTransferable::_PasteTargetURL( TransferableDataHelper& rData,
1911 : SwWrtShell& rSh, sal_uInt16 nAction,
1912 : const Point* pPt, sal_Bool bInsertGRF )
1913 : {
1914 0 : bool nRet = false;
1915 0 : INetImage aINetImg;
1916 0 : if( ( rData.HasFormat( SOT_FORMATSTR_ID_INET_IMAGE ) &&
1917 0 : rData.GetINetImage( SOT_FORMATSTR_ID_INET_IMAGE, aINetImg )) ||
1918 0 : ( rData.HasFormat( SOT_FORMATSTR_ID_NETSCAPE_IMAGE ) &&
1919 0 : rData.GetINetImage( SOT_FORMATSTR_ID_NETSCAPE_IMAGE, aINetImg )) )
1920 : {
1921 0 : if( !aINetImg.GetImageURL().isEmpty() && bInsertGRF )
1922 : {
1923 0 : OUString sURL( aINetImg.GetImageURL() );
1924 0 : SwTransferable::_CheckForURLOrLNKFile( rData, sURL );
1925 :
1926 : //!!! check at FileSystem - only then it make sense to test graphics !!!
1927 0 : Graphic aGraphic;
1928 0 : GraphicFilter &rFlt = GraphicFilter::GetGraphicFilter();
1929 0 : nRet = GRFILTER_OK == GraphicFilter::LoadGraphic( sURL, aEmptyOUStr, aGraphic, &rFlt );
1930 :
1931 0 : if( nRet )
1932 : {
1933 : //Check and Perform rotation if needed
1934 0 : lclCheckAndPerformRotation(aGraphic);
1935 :
1936 0 : switch( nAction )
1937 : {
1938 : case SW_PASTESDR_INSERT:
1939 0 : SwTransferable::SetSelInShell( rSh, sal_False, pPt );
1940 0 : rSh.Insert( sURL, aEmptyOUStr, aGraphic );
1941 0 : break;
1942 :
1943 : case SW_PASTESDR_REPLACE:
1944 0 : if( rSh.IsObjSelected() )
1945 : {
1946 0 : rSh.ReplaceSdrObj( sURL, aEmptyOUStr, &aGraphic );
1947 0 : Point aPt( pPt ? *pPt : rSh.GetCrsrDocPos() );
1948 0 : SwTransferable::SetSelInShell( rSh, sal_True, &aPt );
1949 : }
1950 : else
1951 0 : rSh.ReRead( sURL, aEmptyOUStr, &aGraphic );
1952 0 : break;
1953 :
1954 : case SW_PASTESDR_SETATTR:
1955 0 : if( rSh.IsObjSelected() )
1956 0 : rSh.Paste( aGraphic, OUString() );
1957 0 : else if( OBJCNT_GRF == rSh.GetObjCntTypeOfSelection() )
1958 0 : rSh.ReRead( sURL, aEmptyOUStr, &aGraphic );
1959 : else
1960 : {
1961 0 : SwTransferable::SetSelInShell( rSh, sal_False, pPt );
1962 0 : rSh.Insert( sURL, aEmptyOUStr, aGraphic );
1963 : }
1964 0 : break;
1965 : default:
1966 0 : nRet = false;
1967 : }
1968 0 : }
1969 : }
1970 : else
1971 0 : nRet = true;
1972 : }
1973 :
1974 0 : if( nRet )
1975 : {
1976 0 : SfxItemSet aSet( rSh.GetAttrPool(), RES_URL, RES_URL );
1977 0 : rSh.GetFlyFrmAttr( aSet );
1978 0 : SwFmtURL aURL( (SwFmtURL&)aSet.Get( RES_URL ) );
1979 :
1980 0 : if( aURL.GetURL() != aINetImg.GetTargetURL() ||
1981 0 : aURL.GetTargetFrameName() != aINetImg.GetTargetFrame() )
1982 : {
1983 0 : aURL.SetURL( aINetImg.GetTargetURL(), false );
1984 0 : aURL.SetTargetFrameName( aINetImg.GetTargetFrame() );
1985 0 : aSet.Put( aURL );
1986 0 : rSh.SetFlyFrmAttr( aSet );
1987 0 : }
1988 : }
1989 0 : return nRet;
1990 : }
1991 :
1992 0 : void SwTransferable::SetSelInShell( SwWrtShell& rSh, sal_Bool bSelectFrm,
1993 : const Point* pPt )
1994 : {
1995 0 : if( bSelectFrm )
1996 : {
1997 : // select frames/objects
1998 0 : if( pPt && !rSh.GetView().GetViewFrame()->GetDispatcher()->IsLocked() )
1999 : {
2000 0 : rSh.GetView().NoRotate();
2001 0 : if( rSh.SelectObj( *pPt ))
2002 : {
2003 0 : rSh.HideCrsr();
2004 0 : rSh.EnterSelFrmMode( pPt );
2005 0 : bFrmDrag = true;
2006 : }
2007 : }
2008 : }
2009 : else
2010 : {
2011 0 : if( rSh.IsFrmSelected() || rSh.IsObjSelected() )
2012 : {
2013 0 : rSh.UnSelectFrm();
2014 0 : rSh.LeaveSelFrmMode();
2015 0 : rSh.GetView().GetEditWin().StopInsFrm();
2016 0 : bFrmDrag = false;
2017 : }
2018 0 : else if( rSh.GetView().GetDrawFuncPtr() )
2019 0 : rSh.GetView().GetEditWin().StopInsFrm();
2020 :
2021 0 : rSh.EnterStdMode();
2022 0 : if( pPt )
2023 0 : rSh.SwCrsrShell::SetCrsr( *pPt, sal_True );
2024 : }
2025 0 : }
2026 :
2027 0 : bool SwTransferable::_PasteDDE( TransferableDataHelper& rData,
2028 : SwWrtShell& rWrtShell, sal_Bool bReReadGrf,
2029 : sal_Bool bMsg )
2030 : {
2031 : // data from Clipboardformat
2032 0 : OUString aApp, aTopic, aItem;
2033 :
2034 : {
2035 0 : SotStorageStreamRef xStrm;
2036 0 : if( !rData.GetSotStorageStream( SOT_FORMATSTR_ID_LINK, xStrm ))
2037 : {
2038 : OSL_ENSURE( !&rWrtShell, "DDE Data not found." );
2039 0 : return false;
2040 : } // report useful error!!
2041 :
2042 0 : rtl_TextEncoding eEncoding = DDE_TXT_ENCODING;
2043 0 : aApp = read_zeroTerminated_uInt8s_ToOUString(*xStrm, eEncoding);
2044 0 : aTopic = read_zeroTerminated_uInt8s_ToOUString(*xStrm, eEncoding);
2045 0 : aItem = read_zeroTerminated_uInt8s_ToOUString(*xStrm, eEncoding);
2046 : }
2047 :
2048 0 : OUString aCmd;
2049 0 : sfx2::MakeLnkName( aCmd, &aApp, aTopic, aItem );
2050 :
2051 : // do we want to read in a graphic now?
2052 : sal_uLong nFormat;
2053 0 : if( !rData.HasFormat( FORMAT_RTF ) &&
2054 0 : !rData.HasFormat( SOT_FORMATSTR_ID_HTML ) &&
2055 0 : !rData.HasFormat( FORMAT_STRING ) &&
2056 0 : (rData.HasFormat( nFormat = FORMAT_GDIMETAFILE ) ||
2057 0 : rData.HasFormat( nFormat = FORMAT_BITMAP )) )
2058 : {
2059 0 : Graphic aGrf;
2060 0 : bool nRet = rData.GetGraphic( nFormat, aGrf );
2061 0 : if( nRet )
2062 : {
2063 0 : OUString sLnkTyp("DDE");
2064 0 : if ( bReReadGrf )
2065 0 : rWrtShell.ReRead( aCmd, sLnkTyp, &aGrf );
2066 : else
2067 0 : rWrtShell.Insert( aCmd, sLnkTyp, aGrf );
2068 : }
2069 0 : return nRet;
2070 : }
2071 :
2072 0 : SwFieldType* pTyp = 0;
2073 0 : sal_uInt16 i = 1,j;
2074 0 : OUString aName;
2075 0 : sal_Bool bAlreadyThere = sal_False, bDoublePaste = sal_False;
2076 0 : sal_uInt16 nSize = rWrtShell.GetFldTypeCount();
2077 0 : const ::utl::TransliterationWrapper& rColl = ::GetAppCmpStrIgnore();
2078 :
2079 0 : do {
2080 0 : aName = aApp;
2081 0 : aName += OUString::number( i );
2082 0 : for( j = INIT_FLDTYPES; j < nSize; j++ )
2083 : {
2084 0 : pTyp = rWrtShell.GetFldType( j );
2085 0 : if( RES_DDEFLD == pTyp->Which() )
2086 : {
2087 0 : OUString sTmp( ((SwDDEFieldType*)pTyp)->GetCmd() );
2088 0 : if( rColl.isEqual( sTmp, aCmd ) &&
2089 0 : sfx2::LINKUPDATE_ALWAYS == ((SwDDEFieldType*)pTyp)->GetType() )
2090 : {
2091 0 : aName = pTyp->GetName();
2092 0 : bDoublePaste = sal_True;
2093 0 : break;
2094 : }
2095 0 : else if( rColl.isEqual( aName, pTyp->GetName() ) )
2096 0 : break;
2097 : }
2098 : }
2099 0 : if( j == nSize )
2100 0 : bAlreadyThere = sal_False;
2101 : else
2102 : {
2103 0 : bAlreadyThere = sal_True;
2104 0 : i++;
2105 : }
2106 : }
2107 0 : while( bAlreadyThere && !bDoublePaste );
2108 :
2109 0 : if( !bDoublePaste )
2110 : {
2111 0 : SwDDEFieldType aType( aName, aCmd, sfx2::LINKUPDATE_ALWAYS );
2112 0 : pTyp = rWrtShell.InsertFldType( aType );
2113 : }
2114 :
2115 0 : SwDDEFieldType* pDDETyp = (SwDDEFieldType*)pTyp;
2116 :
2117 0 : OUString aExpand;
2118 0 : if( rData.GetString( FORMAT_STRING, aExpand ))
2119 : {
2120 : do { // middle checked loop
2121 :
2122 : // When data comes from a spreadsheet, we add a DDE-table
2123 0 : if( ( rData.HasFormat( SOT_FORMATSTR_ID_SYLK ) ||
2124 0 : rData.HasFormat( SOT_FORMATSTR_ID_SYLK_BIGCAPS ) ) &&
2125 0 : !aExpand.isEmpty() &&
2126 0 : ( 1 < comphelper::string::getTokenCount(aExpand, '\n') ||
2127 0 : comphelper::string::getTokenCount(aExpand, '\t') ) )
2128 : {
2129 0 : OUString sTmp( aExpand );
2130 0 : sal_Int32 nRows = comphelper::string::getTokenCount(sTmp, '\n');
2131 0 : if( nRows )
2132 0 : --nRows;
2133 0 : sTmp = sTmp.getToken( 0, '\n' );
2134 0 : sal_Int32 nCols = comphelper::string::getTokenCount(sTmp, '\t');
2135 :
2136 : // at least one column & row must be there
2137 0 : if( !nRows || !nCols )
2138 : {
2139 0 : if( bMsg )
2140 0 : InfoBox(0, SW_RESSTR(STR_NO_TABLE)).Execute();
2141 0 : pDDETyp = 0;
2142 0 : break;
2143 : }
2144 :
2145 : rWrtShell.InsertDDETable(
2146 : SwInsertTableOptions( tabopts::SPLIT_LAYOUT, 1 ), // TODO MULTIHEADER
2147 0 : pDDETyp, nRows, nCols );
2148 : }
2149 0 : else if( 1 < comphelper::string::getTokenCount(aExpand, '\n') )
2150 : {
2151 : // multiple paragraphs -> insert a protected section
2152 0 : if( rWrtShell.HasSelection() )
2153 0 : rWrtShell.DelRight();
2154 :
2155 0 : SwSectionData aSect( DDE_LINK_SECTION, aName );
2156 0 : aSect.SetLinkFileName( aCmd );
2157 0 : aSect.SetProtectFlag(true);
2158 0 : rWrtShell.InsertSection( aSect );
2159 :
2160 0 : pDDETyp = 0; // remove FieldTypes again
2161 : }
2162 : else
2163 : {
2164 : // Einfuegen
2165 0 : SwDDEField aSwDDEField( pDDETyp );
2166 0 : rWrtShell.Insert( aSwDDEField );
2167 : }
2168 :
2169 : } while( false );
2170 : }
2171 : else
2172 0 : pDDETyp = 0; // remove FieldTypes again
2173 :
2174 0 : if( !pDDETyp && !bDoublePaste )
2175 : {
2176 : // remove FieldType again - error occurred!
2177 0 : for( j = nSize; j >= INIT_FLDTYPES; --j )
2178 0 : if( pTyp == rWrtShell.GetFldType( j ) )
2179 : {
2180 0 : rWrtShell.RemoveFldType( j );
2181 0 : break;
2182 : }
2183 : }
2184 :
2185 0 : return true;
2186 : }
2187 :
2188 0 : bool SwTransferable::_PasteSdrFormat( TransferableDataHelper& rData,
2189 : SwWrtShell& rSh, sal_uInt16 nAction,
2190 : const Point* pPt, sal_uInt8 nActionFlags, bool bNeedToSelectBeforePaste)
2191 : {
2192 0 : bool nRet = false;
2193 0 : SotStorageStreamRef xStrm;
2194 0 : if( rData.GetSotStorageStream( SOT_FORMATSTR_ID_DRAWING, xStrm ))
2195 : {
2196 0 : xStrm->SetVersion( SOFFICE_FILEFORMAT_50 );
2197 :
2198 0 : if(bNeedToSelectBeforePaste && pPt)
2199 : {
2200 : // if this is an internal drag, need to set the target right (select it), else
2201 : // still the source will be selected
2202 0 : SwTransferable::SetSelInShell( rSh, sal_True, pPt );
2203 : }
2204 :
2205 0 : rSh.Paste( *xStrm, nAction, pPt );
2206 0 : nRet = true;
2207 :
2208 0 : if( nRet && ( nActionFlags &
2209 : ( EXCHG_OUT_ACTION_FLAG_INSERT_TARGETURL >> 8) ))
2210 0 : SwTransferable::_PasteTargetURL( rData, rSh, 0, 0, sal_False );
2211 : }
2212 0 : return nRet;
2213 : }
2214 :
2215 0 : bool SwTransferable::_PasteGrf( TransferableDataHelper& rData, SwWrtShell& rSh,
2216 : sal_uLong nFmt, sal_uInt16 nAction, const Point* pPt,
2217 : sal_uInt8 nActionFlags, sal_Int8 nDropAction, bool bNeedToSelectBeforePaste)
2218 : {
2219 0 : bool nRet = false;
2220 :
2221 0 : Graphic aGraphic;
2222 0 : INetBookmark aBkmk;
2223 0 : sal_Bool bCheckForGrf = sal_False, bCheckForImageMap = sal_False;
2224 :
2225 0 : switch( nFmt )
2226 : {
2227 : case SOT_FORMAT_BITMAP:
2228 : case SOT_FORMATSTR_ID_PNG:
2229 : case SOT_FORMAT_GDIMETAFILE:
2230 0 : nRet = rData.GetGraphic( nFmt, aGraphic );
2231 0 : break;
2232 :
2233 : case SOT_FORMATSTR_ID_SVXB:
2234 : {
2235 0 : SotStorageStreamRef xStm;
2236 :
2237 0 : if(rData.GetSotStorageStream(SOT_FORMATSTR_ID_SVXB, xStm))
2238 : {
2239 0 : ReadGraphic( *xStm, aGraphic );
2240 0 : nRet = (GRAPHIC_NONE != aGraphic.GetType() && GRAPHIC_DEFAULT != aGraphic.GetType());
2241 : }
2242 :
2243 0 : break;
2244 : }
2245 :
2246 : case SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK:
2247 : case SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR:
2248 : case SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR:
2249 0 : if( ( nRet = rData.GetINetBookmark( nFmt, aBkmk ) ))
2250 : {
2251 0 : if( SW_PASTESDR_SETATTR == nAction )
2252 0 : nFmt = SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK;
2253 : else
2254 0 : bCheckForGrf = sal_True;
2255 : }
2256 0 : break;
2257 :
2258 : case SOT_FORMAT_FILE:
2259 : {
2260 0 : OUString sTxt;
2261 0 : if( ( nRet = rData.GetString( nFmt, sTxt ) ) )
2262 : {
2263 0 : OUString sDesc;
2264 0 : SwTransferable::_CheckForURLOrLNKFile( rData, sTxt, &sDesc );
2265 :
2266 0 : aBkmk = INetBookmark(
2267 : URIHelper::SmartRel2Abs(INetURLObject(), sTxt, Link(), false ),
2268 0 : sDesc );
2269 0 : bCheckForGrf = sal_True;
2270 0 : bCheckForImageMap = SW_PASTESDR_REPLACE == nAction;
2271 0 : }
2272 : }
2273 0 : break;
2274 :
2275 : default:
2276 0 : nRet = rData.GetGraphic( nFmt, aGraphic );
2277 0 : break;
2278 : }
2279 :
2280 0 : if( bCheckForGrf )
2281 : {
2282 : //!!! check at FileSystem - only then it makes sense to test the graphics !!!
2283 0 : GraphicFilter &rFlt = GraphicFilter::GetGraphicFilter();
2284 0 : nRet = GRFILTER_OK == GraphicFilter::LoadGraphic( aBkmk.GetURL(), aEmptyOUStr,
2285 0 : aGraphic, &rFlt );
2286 :
2287 0 : if( !nRet && SW_PASTESDR_SETATTR == nAction &&
2288 0 : SOT_FORMAT_FILE == nFmt &&
2289 : // only at frame selection
2290 0 : rSh.IsFrmSelected() )
2291 : {
2292 : // then set as hyperlink after the graphic
2293 0 : nFmt = SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK;
2294 0 : nRet = true;
2295 : }
2296 : }
2297 :
2298 0 : if(pPt && bNeedToSelectBeforePaste)
2299 : {
2300 : // when using internal D&Ds, still the source object is selected and
2301 : // this is necessary to get the correct source data which is also
2302 : // dependent from selection. After receiving the drag data it is
2303 : // now tiime to select the correct target object
2304 0 : SwTransferable::SetSelInShell( rSh, sal_True, pPt );
2305 : }
2306 :
2307 0 : if( nRet )
2308 : {
2309 : //Check and Perform rotation if needed
2310 0 : lclCheckAndPerformRotation(aGraphic);
2311 :
2312 0 : OUString sURL;
2313 0 : if( rSh.GetView().GetDocShell()->ISA(SwWebDocShell)
2314 : // #i123922# if link action is noted, also take URL
2315 0 : || DND_ACTION_LINK == nDropAction)
2316 : {
2317 0 : sURL = aBkmk.GetURL();
2318 : }
2319 :
2320 0 : switch( nAction )
2321 : {
2322 : case SW_PASTESDR_INSERT:
2323 : {
2324 0 : SwTransferable::SetSelInShell( rSh, sal_False, pPt );
2325 0 : rSh.Insert( sURL, aEmptyOUStr, aGraphic );
2326 0 : break;
2327 : }
2328 :
2329 : case SW_PASTESDR_REPLACE:
2330 : {
2331 0 : if( rSh.IsObjSelected() )
2332 : {
2333 : // #i123922# for D&D on draw objects, do for now the same for
2334 : // SW_PASTESDR_REPLACE (D&D) as for SW_PASTESDR_SETATTR (D&D and
2335 : // CTRL+SHIFT). The code below replaces the draw object with
2336 : // a writer graphic; maybe this is an option later again if wanted
2337 0 : rSh.Paste( aGraphic, sURL );
2338 :
2339 : // rSh.ReplaceSdrObj( sURL, aEmptyOUStr, &aGraphic );
2340 : // Point aPt( pPt ? *pPt : rSh.GetCrsrDocPos() );
2341 : // SwTransferable::SetSelInShell( rSh, sal_True, &aPt );
2342 : }
2343 : else
2344 : {
2345 : // set graphic at writer graphic without link
2346 0 : rSh.ReRead( sURL, aEmptyOUStr, &aGraphic );
2347 : }
2348 :
2349 0 : break;
2350 : }
2351 :
2352 : case SW_PASTESDR_SETATTR:
2353 : {
2354 0 : if( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK == nFmt )
2355 : {
2356 0 : if( rSh.IsFrmSelected() )
2357 : {
2358 0 : SfxItemSet aSet( rSh.GetAttrPool(), RES_URL, RES_URL );
2359 0 : rSh.GetFlyFrmAttr( aSet );
2360 0 : SwFmtURL aURL( (SwFmtURL&)aSet.Get( RES_URL ) );
2361 0 : aURL.SetURL( aBkmk.GetURL(), false );
2362 0 : aSet.Put( aURL );
2363 0 : rSh.SetFlyFrmAttr( aSet );
2364 : }
2365 : }
2366 0 : else if( rSh.IsObjSelected() )
2367 : {
2368 : // set as attribute at DrawObject
2369 0 : rSh.Paste( aGraphic, sURL );
2370 : }
2371 0 : else if( OBJCNT_GRF == rSh.GetObjCntTypeOfSelection() )
2372 : {
2373 : // set as linked graphic at writer graphic frame
2374 0 : rSh.ReRead( sURL, aEmptyOUStr, &aGraphic );
2375 : }
2376 : else
2377 : {
2378 0 : SwTransferable::SetSelInShell( rSh, sal_False, pPt );
2379 0 : rSh.Insert( aBkmk.GetURL(), aEmptyOUStr, aGraphic );
2380 : }
2381 0 : break;
2382 : }
2383 : default:
2384 : {
2385 0 : nRet = false;
2386 0 : break;
2387 : }
2388 0 : }
2389 : }
2390 :
2391 0 : if( nRet )
2392 : {
2393 :
2394 0 : if( nActionFlags &
2395 : (( EXCHG_OUT_ACTION_FLAG_INSERT_IMAGEMAP |
2396 : EXCHG_OUT_ACTION_FLAG_REPLACE_IMAGEMAP ) >> 8) )
2397 0 : SwTransferable::_PasteImageMap( rData, rSh );
2398 :
2399 0 : if( nActionFlags &
2400 : ( EXCHG_OUT_ACTION_FLAG_INSERT_TARGETURL >> 8) )
2401 0 : SwTransferable::_PasteTargetURL( rData, rSh, 0, 0, sal_False );
2402 : }
2403 0 : else if( bCheckForImageMap )
2404 : {
2405 : // or should the file be an ImageMap-File?
2406 0 : ImageMap aMap;
2407 0 : SfxMedium aMed( INetURLObject(aBkmk.GetURL()).GetFull(),
2408 0 : STREAM_STD_READ );
2409 0 : SvStream* pStream = aMed.GetInStream();
2410 0 : if( pStream != NULL &&
2411 0 : !pStream->GetError() &&
2412 : // mba: no BaseURL for clipboard functionality
2413 0 : aMap.Read( *pStream, IMAP_FORMAT_DETECT, OUString() ) == IMAP_ERR_OK &&
2414 0 : aMap.GetIMapObjectCount() )
2415 : {
2416 0 : SfxItemSet aSet( rSh.GetAttrPool(), RES_URL, RES_URL );
2417 0 : rSh.GetFlyFrmAttr( aSet );
2418 0 : SwFmtURL aURL( (SwFmtURL&)aSet.Get( RES_URL ) );
2419 0 : aURL.SetMap( &aMap );
2420 0 : aSet.Put( aURL );
2421 0 : rSh.SetFlyFrmAttr( aSet );
2422 0 : nRet = true;
2423 0 : }
2424 : }
2425 :
2426 0 : return nRet;
2427 : }
2428 :
2429 0 : bool SwTransferable::_PasteImageMap( TransferableDataHelper& rData,
2430 : SwWrtShell& rSh )
2431 : {
2432 0 : bool nRet = false;
2433 0 : if( rData.HasFormat( SOT_FORMATSTR_ID_SVIM ))
2434 : {
2435 0 : SfxItemSet aSet( rSh.GetAttrPool(), RES_URL, RES_URL );
2436 0 : rSh.GetFlyFrmAttr( aSet );
2437 0 : SwFmtURL aURL( (SwFmtURL&)aSet.Get( RES_URL ) );
2438 0 : const ImageMap* pOld = aURL.GetMap();
2439 :
2440 : // set or replace, that is the question
2441 0 : ImageMap aImageMap;
2442 0 : if( rData.GetImageMap( SOT_FORMATSTR_ID_SVIM, aImageMap ) &&
2443 0 : ( !pOld || aImageMap != *pOld ))
2444 : {
2445 0 : aURL.SetMap( &aImageMap );
2446 0 : aSet.Put( aURL );
2447 0 : rSh.SetFlyFrmAttr( aSet );
2448 : }
2449 0 : nRet = true;
2450 : }
2451 0 : return nRet;
2452 : }
2453 :
2454 0 : bool SwTransferable::_PasteAsHyperlink( TransferableDataHelper& rData,
2455 : SwWrtShell& rSh, sal_uLong nFmt )
2456 : {
2457 0 : bool nRet = false;
2458 0 : OUString sFile;
2459 0 : if( rData.GetString( nFmt, sFile ) && !sFile.isEmpty() )
2460 : {
2461 0 : OUString sDesc;
2462 0 : SwTransferable::_CheckForURLOrLNKFile( rData, sFile, &sDesc );
2463 :
2464 : // first, make the URL absolute
2465 0 : INetURLObject aURL;
2466 0 : aURL.SetSmartProtocol( INET_PROT_FILE );
2467 0 : aURL.SetSmartURL( sFile );
2468 0 : sFile = aURL.GetMainURL( INetURLObject::NO_DECODE );
2469 :
2470 0 : switch( rSh.GetObjCntTypeOfSelection() )
2471 : {
2472 : case OBJCNT_FLY:
2473 : case OBJCNT_GRF:
2474 : case OBJCNT_OLE:
2475 : {
2476 0 : SfxItemSet aSet( rSh.GetAttrPool(), RES_URL, RES_URL );
2477 0 : rSh.GetFlyFrmAttr( aSet );
2478 0 : SwFmtURL aURL2( (SwFmtURL&)aSet.Get( RES_URL ) );
2479 0 : aURL2.SetURL( sFile, false );
2480 0 : if( aURL2.GetName().isEmpty() )
2481 0 : aURL2.SetName( sFile );
2482 0 : aSet.Put( aURL2 );
2483 0 : rSh.SetFlyFrmAttr( aSet );
2484 : }
2485 0 : break;
2486 :
2487 : default:
2488 : {
2489 : rSh.InsertURL( SwFmtINetFmt( sFile, OUString() ),
2490 0 : sDesc.isEmpty() ? sFile : sDesc);
2491 : }
2492 : }
2493 0 : nRet = true;
2494 : }
2495 0 : return nRet;
2496 : }
2497 :
2498 0 : bool SwTransferable::_PasteFileName( TransferableDataHelper& rData,
2499 : SwWrtShell& rSh, sal_uLong nFmt,
2500 : sal_uInt16 nAction, const Point* pPt,
2501 : sal_uInt8 nActionFlags, sal_Bool /* bMsg */,
2502 : bool * graphicInserted)
2503 : {
2504 : bool nRet = SwTransferable::_PasteGrf( rData, rSh, nFmt, nAction,
2505 0 : pPt, nActionFlags, 0, false);
2506 0 : if (graphicInserted != 0) {
2507 0 : *graphicInserted = nRet;
2508 : }
2509 0 : if( !nRet )
2510 : {
2511 0 : OUString sFile, sDesc;
2512 0 : if( rData.GetString( nFmt, sFile ) && !sFile.isEmpty() )
2513 : {
2514 0 : INetURLObject aMediaURL;
2515 :
2516 0 : aMediaURL.SetSmartURL( sFile );
2517 0 : const OUString aMediaURLStr( aMediaURL.GetMainURL( INetURLObject::NO_DECODE ) );
2518 :
2519 0 : if( ::avmedia::MediaWindow::isMediaURL( aMediaURLStr, ""/*TODO?*/ ) )
2520 : {
2521 0 : const SfxStringItem aMediaURLItem( SID_INSERT_AVMEDIA, aMediaURLStr );
2522 0 : rSh.GetView().GetViewFrame()->GetDispatcher()->Execute(
2523 : SID_INSERT_AVMEDIA, SFX_CALLMODE_SYNCHRON,
2524 0 : &aMediaURLItem, 0L );
2525 : }
2526 : else
2527 : {
2528 0 : sal_Bool bIsURLFile = SwTransferable::_CheckForURLOrLNKFile( rData, sFile, &sDesc );
2529 :
2530 : //Own FileFormat? --> insert, not for StarWriter/Web
2531 0 : OUString sFileURL = URIHelper::SmartRel2Abs(INetURLObject(), sFile, Link(), false );
2532 : const SfxFilter* pFlt = SW_PASTESDR_SETATTR == nAction
2533 : ? 0 : SwIoSystem::GetFileFilter(
2534 0 : sFileURL, aEmptyOUStr );
2535 0 : if( pFlt && !rSh.GetView().GetDocShell()->ISA(SwWebDocShell) )
2536 : {
2537 : // and then pull up the insert-region-dialog by PostUser event
2538 : SwSectionData * pSect = new SwSectionData(
2539 : FILE_LINK_SECTION,
2540 0 : rSh.GetDoc()->GetUniqueSectionName() );
2541 0 : pSect->SetLinkFileName( sFileURL );
2542 0 : pSect->SetProtectFlag( true );
2543 :
2544 : Application::PostUserEvent( STATIC_LINK( &rSh, SwWrtShell,
2545 0 : InsertRegionDialog ), pSect );
2546 0 : nRet = true;
2547 : }
2548 0 : else if( SW_PASTESDR_SETATTR == nAction ||
2549 0 : ( bIsURLFile && SW_PASTESDR_INSERT == nAction ))
2550 : {
2551 : //we can insert foreign files as links after all
2552 :
2553 : // first, make the URL absolute
2554 0 : INetURLObject aURL;
2555 0 : aURL.SetSmartProtocol( INET_PROT_FILE );
2556 0 : aURL.SetSmartURL( sFile );
2557 0 : sFile = aURL.GetMainURL( INetURLObject::NO_DECODE );
2558 :
2559 0 : switch( rSh.GetObjCntTypeOfSelection() )
2560 : {
2561 : case OBJCNT_FLY:
2562 : case OBJCNT_GRF:
2563 : case OBJCNT_OLE:
2564 : {
2565 0 : SfxItemSet aSet( rSh.GetAttrPool(), RES_URL, RES_URL );
2566 0 : rSh.GetFlyFrmAttr( aSet );
2567 0 : SwFmtURL aURL2( (SwFmtURL&)aSet.Get( RES_URL ) );
2568 0 : aURL2.SetURL( sFile, false );
2569 0 : if( aURL2.GetName().isEmpty() )
2570 0 : aURL2.SetName( sFile );
2571 0 : aSet.Put( aURL2 );
2572 0 : rSh.SetFlyFrmAttr( aSet );
2573 : }
2574 0 : break;
2575 :
2576 : default:
2577 : {
2578 : rSh.InsertURL( SwFmtINetFmt( sFile, OUString() ),
2579 0 : sDesc.isEmpty() ? sFile : sDesc );
2580 : }
2581 : }
2582 0 : nRet = true;
2583 0 : }
2584 0 : }
2585 0 : }
2586 : }
2587 0 : return nRet;
2588 : }
2589 :
2590 0 : bool SwTransferable::_PasteDBData( TransferableDataHelper& rData,
2591 : SwWrtShell& rSh, sal_uLong nFmt, sal_Bool bLink,
2592 : const Point* pDragPt, sal_Bool bMsg )
2593 : {
2594 0 : bool nRet = false;
2595 0 : OUString sTxt;
2596 0 : if( rData.GetString( nFmt, sTxt ) && !sTxt.isEmpty() )
2597 : {
2598 : sal_uInt16 nWh = SOT_FORMATSTR_ID_SBA_CTRLDATAEXCHANGE == nFmt
2599 : ? 0
2600 : : SOT_FORMATSTR_ID_SBA_DATAEXCHANGE == nFmt
2601 : ? (bLink
2602 : ? FN_QRY_MERGE_FIELD
2603 : : FN_QRY_INSERT)
2604 : : (bLink
2605 : ? 0
2606 0 : : FN_QRY_INSERT_FIELD );
2607 0 : DataFlavorExVector& rVector = rData.GetDataFlavorExVector();
2608 0 : sal_Bool bHaveColumnDescriptor = OColumnTransferable::canExtractColumnDescriptor(rVector, CTF_COLUMN_DESCRIPTOR | CTF_CONTROL_EXCHANGE);
2609 0 : if ( SOT_FORMATSTR_ID_XFORMS == nFmt )
2610 : {
2611 : SdrObject* pObj;
2612 0 : rSh.MakeDrawView();
2613 0 : FmFormView* pFmView = PTR_CAST( FmFormView, rSh.GetDrawView() );
2614 0 : if(pFmView) {
2615 0 : const OXFormsDescriptor &rDesc = OXFormsTransferable::extractDescriptor(rData);
2616 0 : if(0 != (pObj = pFmView->CreateXFormsControl(rDesc)))
2617 : {
2618 0 : rSh.SwFEShell::InsertDrawObj( *pObj, *pDragPt );
2619 : }
2620 : }
2621 : }
2622 0 : else if( nWh )
2623 : {
2624 0 : SfxUsrAnyItem* pConnectionItem = 0;
2625 0 : SfxUsrAnyItem* pCursorItem = 0;
2626 0 : SfxUsrAnyItem* pColumnItem = 0;
2627 0 : SfxUsrAnyItem* pSourceItem = 0;
2628 0 : SfxUsrAnyItem* pCommandItem = 0;
2629 0 : SfxUsrAnyItem* pCommandTypeItem = 0;
2630 0 : SfxUsrAnyItem* pColumnNameItem = 0;
2631 0 : SfxUsrAnyItem* pSelectionItem = 0;
2632 :
2633 0 : sal_Bool bDataAvailable = sal_True;
2634 0 : ODataAccessDescriptor aDesc;
2635 0 : if(bHaveColumnDescriptor)
2636 0 : aDesc = OColumnTransferable::extractColumnDescriptor(rData);
2637 0 : else if(ODataAccessObjectTransferable::canExtractObjectDescriptor(rVector) )
2638 0 : aDesc = ODataAccessObjectTransferable::extractObjectDescriptor(rData);
2639 : else
2640 0 : bDataAvailable = sal_False;
2641 :
2642 0 : if ( bDataAvailable )
2643 : {
2644 0 : pConnectionItem = new SfxUsrAnyItem(FN_DB_CONNECTION_ANY, aDesc[daConnection]);
2645 0 : pColumnItem = new SfxUsrAnyItem(FN_DB_COLUMN_ANY, aDesc[daColumnObject]);
2646 0 : pSourceItem = new SfxUsrAnyItem(FN_DB_DATA_SOURCE_ANY, makeAny(aDesc.getDataSource()));
2647 0 : pCommandItem = new SfxUsrAnyItem(FN_DB_DATA_COMMAND_ANY, aDesc[daCommand]);
2648 0 : pCommandTypeItem = new SfxUsrAnyItem(FN_DB_DATA_COMMAND_TYPE_ANY, aDesc[daCommandType]);
2649 0 : pColumnNameItem = new SfxUsrAnyItem(FN_DB_DATA_COLUMN_NAME_ANY, aDesc[daColumnName]);
2650 0 : pSelectionItem = new SfxUsrAnyItem(FN_DB_DATA_SELECTION_ANY, aDesc[daSelection]);
2651 0 : pCursorItem = new SfxUsrAnyItem(FN_DB_DATA_CURSOR_ANY, aDesc[daCursor]);
2652 : }
2653 :
2654 0 : SwView& rView = rSh.GetView();
2655 : //force ::SelectShell
2656 0 : rView.StopShellTimer();
2657 :
2658 0 : SfxStringItem aDataDesc( nWh, sTxt );
2659 : rView.GetViewFrame()->GetDispatcher()->Execute(
2660 : nWh, SFX_CALLMODE_ASYNCHRON, &aDataDesc,
2661 : pConnectionItem, pColumnItem,
2662 : pSourceItem, pCommandItem, pCommandTypeItem,
2663 0 : pColumnNameItem, pSelectionItem, pCursorItem,0L);
2664 0 : delete pConnectionItem;
2665 0 : delete pColumnItem;
2666 0 : delete pSourceItem;
2667 0 : delete pCommandItem;
2668 0 : delete pCommandTypeItem;
2669 0 : delete pColumnNameItem;
2670 0 : delete pSelectionItem;
2671 0 : delete pCursorItem;
2672 : }
2673 : else
2674 : {
2675 : SdrObject* pObj;
2676 0 : rSh.MakeDrawView();
2677 0 : FmFormView* pFmView = PTR_CAST( FmFormView, rSh.GetDrawView() );
2678 0 : if (pFmView && bHaveColumnDescriptor)
2679 : {
2680 0 : if ( 0 != (pObj = pFmView->CreateFieldControl( OColumnTransferable::extractColumnDescriptor(rData) ) ) )
2681 0 : rSh.SwFEShell::InsertDrawObj( *pObj, *pDragPt );
2682 : }
2683 : }
2684 0 : nRet = true;
2685 : }
2686 0 : else if( bMsg )
2687 : {
2688 0 : InfoBox( 0, SW_RES(MSG_CLPBRD_FORMAT_ERROR)).Execute();
2689 : }
2690 0 : return nRet;
2691 : }
2692 :
2693 0 : bool SwTransferable::_PasteFileList( TransferableDataHelper& rData,
2694 : SwWrtShell& rSh, sal_Bool bLink,
2695 : const Point* pPt, sal_Bool bMsg )
2696 : {
2697 0 : bool nRet = false;
2698 0 : FileList aFileList;
2699 0 : if( rData.GetFileList( SOT_FORMAT_FILE_LIST, aFileList ) &&
2700 0 : aFileList.Count() )
2701 : {
2702 0 : sal_uInt16 nAct = bLink ? SW_PASTESDR_SETATTR : SW_PASTESDR_INSERT;
2703 0 : OUString sFlyNm;
2704 : // iterate over the filelist
2705 0 : for( sal_uLong n = 0, nEnd = aFileList.Count(); n < nEnd; ++n )
2706 : {
2707 0 : TransferDataContainer* pHlp = new TransferDataContainer;
2708 0 : pHlp->CopyString( FORMAT_FILE, aFileList.GetFile( n ));
2709 0 : TransferableDataHelper aData( pHlp );
2710 :
2711 0 : if( SwTransferable::_PasteFileName( aData, rSh, SOT_FORMAT_FILE, nAct,
2712 0 : pPt, sal_False, bMsg, 0 ))
2713 : {
2714 0 : if( bLink )
2715 : {
2716 0 : sFlyNm = rSh.GetFlyName();
2717 0 : SwTransferable::SetSelInShell( rSh, sal_False, pPt );
2718 : }
2719 0 : nRet = true;
2720 : }
2721 0 : }
2722 0 : if( !sFlyNm.isEmpty() )
2723 0 : rSh.GotoFly( sFlyNm );
2724 : }
2725 0 : else if( bMsg )
2726 : {
2727 0 : InfoBox( 0, SW_RES(MSG_CLPBRD_FORMAT_ERROR)).Execute();
2728 : }
2729 0 : return nRet;
2730 : }
2731 :
2732 0 : sal_Bool SwTransferable::_CheckForURLOrLNKFile( TransferableDataHelper& rData,
2733 : OUString& rFileName, OUString* pTitle )
2734 : {
2735 0 : sal_Bool bIsURLFile = sal_False;
2736 0 : INetBookmark aBkmk;
2737 0 : if( rData.GetINetBookmark( SOT_FORMATSTR_ID_SOLK, aBkmk ) )
2738 : {
2739 0 : rFileName = aBkmk.GetURL();
2740 0 : if( pTitle )
2741 0 : *pTitle = aBkmk.GetDescription();
2742 0 : bIsURLFile = sal_True;
2743 : }
2744 : else
2745 : {
2746 0 : sal_Int32 nLen = rFileName.getLength();
2747 0 : if( 4 < nLen && '.' == rFileName[ nLen - 4 ])
2748 : {
2749 0 : OUString sExt( rFileName.copy( nLen - 3 ));
2750 0 : if( sExt.equalsIgnoreAsciiCase( "url" ))
2751 : {
2752 : OSL_ENSURE( !&rFileName, "how do we read today .URL - Files?" );
2753 0 : }
2754 : }
2755 : }
2756 0 : return bIsURLFile;
2757 : }
2758 :
2759 0 : sal_Bool SwTransferable::IsPasteSpecial( const SwWrtShell& rWrtShell,
2760 : const TransferableDataHelper& rData )
2761 : {
2762 : // we can paste-special if there's an entry in the paste-special-format list
2763 0 : SvxClipboardFmtItem aClipboardFmtItem(0);
2764 0 : FillClipFmtItem( rWrtShell, rData, aClipboardFmtItem);
2765 0 : return aClipboardFmtItem.Count() > 0;
2766 : }
2767 :
2768 0 : bool SwTransferable::PasteFormat( SwWrtShell& rSh,
2769 : TransferableDataHelper& rData,
2770 : sal_uLong nFormat )
2771 : {
2772 0 : SwWait aWait( *rSh.GetView().GetDocShell(), false );
2773 0 : bool nRet = false;
2774 :
2775 0 : sal_uLong nPrivateFmt = FORMAT_PRIVATE;
2776 0 : SwTransferable *pClipboard = GetSwTransferable( rData );
2777 0 : if( pClipboard &&
2778 0 : ((TRNSFR_DOCUMENT|TRNSFR_GRAPHIC|TRNSFR_OLE) & pClipboard->eBufferType ))
2779 0 : nPrivateFmt = SOT_FORMATSTR_ID_EMBED_SOURCE;
2780 :
2781 0 : if( pClipboard && nPrivateFmt == nFormat )
2782 0 : nRet = pClipboard->PrivatePaste( rSh );
2783 0 : else if( rData.HasFormat( nFormat ) )
2784 : {
2785 0 : uno::Reference<XTransferable> xTransferable( rData.GetXTransferable() );
2786 : sal_uInt16 nEventAction,
2787 0 : nDestination = SwTransferable::GetSotDestination( rSh ),
2788 : nSourceOptions =
2789 0 : (( EXCHG_DEST_DOC_TEXTFRAME == nDestination ||
2790 0 : EXCHG_DEST_SWDOC_FREE_AREA == nDestination ||
2791 0 : EXCHG_DEST_DOC_TEXTFRAME_WEB == nDestination ||
2792 : EXCHG_DEST_SWDOC_FREE_AREA_WEB == nDestination )
2793 : ? EXCHG_IN_ACTION_COPY
2794 0 : : EXCHG_IN_ACTION_MOVE),
2795 : nAction = SotExchange::GetExchangeAction(
2796 0 : rData.GetDataFlavorExVector(),
2797 : nDestination,
2798 : nSourceOptions, /* ?? */
2799 : EXCHG_IN_ACTION_DEFAULT, /* ?? */
2800 : nFormat, nEventAction, nFormat,
2801 0 : lcl_getTransferPointer ( xTransferable ) );
2802 :
2803 0 : if( EXCHG_INOUT_ACTION_NONE != nAction )
2804 : nRet = SwTransferable::PasteData( rData, rSh, nAction, nFormat,
2805 0 : nDestination, sal_True, sal_False );
2806 : }
2807 0 : return nRet;
2808 : }
2809 :
2810 18112 : bool SwTransferable::_TestAllowedFormat( const TransferableDataHelper& rData,
2811 : sal_uLong nFormat, sal_uInt16 nDestination )
2812 : {
2813 18112 : sal_uInt16 nAction = EXCHG_INOUT_ACTION_NONE, nEventAction;
2814 18112 : if( rData.HasFormat( nFormat )) {
2815 0 : uno::Reference<XTransferable> xTransferable( rData.GetXTransferable() );
2816 : nAction = SotExchange::GetExchangeAction(
2817 0 : rData.GetDataFlavorExVector(),
2818 : nDestination, EXCHG_IN_ACTION_COPY,
2819 : EXCHG_IN_ACTION_COPY, nFormat,
2820 : nEventAction, nFormat,
2821 0 : lcl_getTransferPointer ( xTransferable ) );
2822 : }
2823 18112 : return EXCHG_INOUT_ACTION_NONE != nAction;
2824 : }
2825 :
2826 : /**
2827 : * the list of formats which will be offered to the user in the 'Paste
2828 : * Special...' dialog and the paste button menu
2829 : */
2830 : static sal_uInt16 aPasteSpecialIds[] =
2831 : {
2832 : SOT_FORMATSTR_ID_HTML,
2833 : SOT_FORMATSTR_ID_HTML_SIMPLE,
2834 : SOT_FORMATSTR_ID_HTML_NO_COMMENT,
2835 : FORMAT_RTF,
2836 : FORMAT_STRING,
2837 : SOT_FORMATSTR_ID_SONLK,
2838 : SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK,
2839 : SOT_FORMATSTR_ID_DRAWING,
2840 : SOT_FORMATSTR_ID_SVXB,
2841 : FORMAT_GDIMETAFILE,
2842 : FORMAT_BITMAP,
2843 : SOT_FORMATSTR_ID_SVIM,
2844 : SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR,
2845 : 0
2846 : };
2847 :
2848 0 : bool SwTransferable::PasteUnformatted( SwWrtShell& rSh, TransferableDataHelper& rData )
2849 : {
2850 : // Plain text == unformatted
2851 0 : return SwTransferable::PasteFormat( rSh, rData, SOT_FORMAT_STRING );
2852 : }
2853 :
2854 0 : bool SwTransferable::PasteSpecial( SwWrtShell& rSh, TransferableDataHelper& rData, sal_uLong& rFormatUsed )
2855 : {
2856 0 : bool nRet = false;
2857 0 : SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
2858 0 : boost::scoped_ptr<SfxAbstractPasteDialog> pDlg(pFact->CreatePasteDialog( &rSh.GetView().GetEditWin() ));
2859 :
2860 0 : DataFlavorExVector aFormats( rData.GetDataFlavorExVector() );
2861 0 : TransferableObjectDescriptor aDesc;
2862 :
2863 0 : sal_uInt16 nDest = SwTransferable::GetSotDestination( rSh );
2864 :
2865 0 : SwTransferable *pClipboard = GetSwTransferable( rData );
2866 0 : if( pClipboard )
2867 : {
2868 0 : aDesc = pClipboard->aObjDesc;
2869 : sal_uInt16 nResId;
2870 0 : if( pClipboard->eBufferType & TRNSFR_DOCUMENT )
2871 0 : nResId = STR_PRIVATETEXT;
2872 0 : else if( pClipboard->eBufferType & TRNSFR_GRAPHIC )
2873 0 : nResId = STR_PRIVATEGRAPHIC;
2874 0 : else if( pClipboard->eBufferType == TRNSFR_OLE )
2875 0 : nResId = STR_PRIVATEOLE;
2876 : else
2877 0 : nResId = 0;
2878 :
2879 0 : if( nResId )
2880 : {
2881 0 : if( STR_PRIVATEOLE == nResId || STR_PRIVATEGRAPHIC == nResId )
2882 : {
2883 : // add SOT_FORMATSTR_ID_EMBED_SOURCE to the formats. This
2884 : // format display then the private format name.
2885 0 : DataFlavorEx aFlavorEx;
2886 0 : aFlavorEx.mnSotId = SOT_FORMATSTR_ID_EMBED_SOURCE;
2887 0 : aFormats.insert( aFormats.begin(), aFlavorEx );
2888 : }
2889 0 : pDlg->SetObjName( pClipboard->aObjDesc.maClassName,
2890 0 : SW_RES( nResId ) );
2891 0 : pDlg->Insert( SOT_FORMATSTR_ID_EMBED_SOURCE, aEmptyOUStr );
2892 : }
2893 : }
2894 : else
2895 : {
2896 0 : if( rData.HasFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ) )
2897 : rData.GetTransferableObjectDescriptor(
2898 0 : SOT_FORMATSTR_ID_OBJECTDESCRIPTOR, aDesc );
2899 :
2900 0 : if( SwTransferable::_TestAllowedFormat( rData, SOT_FORMATSTR_ID_EMBED_SOURCE, nDest ))
2901 0 : pDlg->Insert( SOT_FORMATSTR_ID_EMBED_SOURCE, aEmptyOUStr );
2902 0 : if( SwTransferable::_TestAllowedFormat( rData, SOT_FORMATSTR_ID_LINK_SOURCE, nDest ))
2903 0 : pDlg->Insert( SOT_FORMATSTR_ID_LINK_SOURCE, aEmptyOUStr );
2904 : }
2905 :
2906 0 : if( SwTransferable::_TestAllowedFormat( rData, SOT_FORMATSTR_ID_LINK, nDest ))
2907 0 : pDlg->Insert( SOT_FORMATSTR_ID_LINK, SW_RES(STR_DDEFORMAT) );
2908 :
2909 0 : for( sal_uInt16* pIds = aPasteSpecialIds; *pIds; ++pIds )
2910 0 : if( SwTransferable::_TestAllowedFormat( rData, *pIds, nDest ))
2911 0 : pDlg->Insert( *pIds, aEmptyOUStr );
2912 :
2913 0 : sal_uLong nFormat = pDlg->GetFormat( rData.GetTransferable() );
2914 :
2915 0 : if( nFormat )
2916 0 : nRet = SwTransferable::PasteFormat( rSh, rData, nFormat );
2917 :
2918 0 : if ( nRet )
2919 0 : rFormatUsed = nFormat;
2920 :
2921 0 : return nRet;
2922 : }
2923 :
2924 1132 : void SwTransferable::FillClipFmtItem( const SwWrtShell& rSh,
2925 : const TransferableDataHelper& rData,
2926 : SvxClipboardFmtItem & rToFill )
2927 : {
2928 1132 : sal_uInt16 nDest = SwTransferable::GetSotDestination( rSh );
2929 :
2930 1132 : SwTransferable *pClipboard = GetSwTransferable( rData );
2931 1132 : if( pClipboard )
2932 : {
2933 : sal_uInt16 nResId;
2934 0 : if( pClipboard->eBufferType & TRNSFR_DOCUMENT )
2935 0 : nResId = STR_PRIVATETEXT;
2936 0 : else if( pClipboard->eBufferType & TRNSFR_GRAPHIC )
2937 0 : nResId = STR_PRIVATEGRAPHIC;
2938 0 : else if( pClipboard->eBufferType == TRNSFR_OLE )
2939 0 : nResId = STR_PRIVATEOLE;
2940 : else
2941 0 : nResId = 0;
2942 :
2943 0 : if( nResId )
2944 : rToFill.AddClipbrdFormat( SOT_FORMATSTR_ID_EMBED_SOURCE,
2945 0 : SW_RESSTR( nResId ) );
2946 : }
2947 : else
2948 : {
2949 1132 : TransferableObjectDescriptor aDesc;
2950 1132 : if( rData.HasFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ) )
2951 : ((TransferableDataHelper&)rData).GetTransferableObjectDescriptor(
2952 0 : SOT_FORMATSTR_ID_OBJECTDESCRIPTOR, aDesc );
2953 :
2954 1132 : if( SwTransferable::_TestAllowedFormat( rData, SOT_FORMATSTR_ID_EMBED_SOURCE, nDest ))
2955 : rToFill.AddClipbrdFormat( SOT_FORMATSTR_ID_EMBED_SOURCE,
2956 0 : aDesc.maTypeName );
2957 1132 : if( SwTransferable::_TestAllowedFormat( rData, SOT_FORMATSTR_ID_LINK_SOURCE, nDest ))
2958 0 : rToFill.AddClipbrdFormat( SOT_FORMATSTR_ID_LINK_SOURCE );
2959 :
2960 : SotFormatStringId nFormat;
2961 1132 : if ( rData.HasFormat(nFormat = SOT_FORMATSTR_ID_EMBED_SOURCE_OLE) || rData.HasFormat(nFormat = SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE) )
2962 : {
2963 0 : OUString sName,sSource;
2964 0 : if ( SvPasteObjectHelper::GetEmbeddedName(rData,sName,sSource,nFormat) )
2965 0 : rToFill.AddClipbrdFormat( nFormat, sName );
2966 1132 : }
2967 : }
2968 :
2969 1132 : if( SwTransferable::_TestAllowedFormat( rData, SOT_FORMATSTR_ID_LINK, nDest ))
2970 0 : rToFill.AddClipbrdFormat( SOT_FORMATSTR_ID_LINK, SW_RESSTR(STR_DDEFORMAT) );
2971 :
2972 15848 : for( sal_uInt16* pIds = aPasteSpecialIds; *pIds; ++pIds )
2973 14716 : if( SwTransferable::_TestAllowedFormat( rData, *pIds, nDest ))
2974 0 : rToFill.AddClipbrdFormat( *pIds, aEmptyOUStr );
2975 1132 : }
2976 :
2977 0 : void SwTransferable::SetDataForDragAndDrop( const Point& rSttPos )
2978 : {
2979 0 : if(!pWrtShell)
2980 0 : return;
2981 0 : OUString sGrfNm;
2982 0 : const int nSelection = pWrtShell->GetSelectionType();
2983 0 : if( nsSelectionType::SEL_GRF == nSelection)
2984 : {
2985 0 : AddFormat( SOT_FORMATSTR_ID_SVXB );
2986 0 : const Graphic* pGrf = pWrtShell->GetGraphic();
2987 0 : if ( pGrf && pGrf->IsSupportedGraphic() )
2988 : {
2989 0 : AddFormat( FORMAT_GDIMETAFILE );
2990 0 : AddFormat( SOT_FORMATSTR_ID_PNG );
2991 0 : AddFormat( FORMAT_BITMAP );
2992 : }
2993 0 : eBufferType = TRNSFR_GRAPHIC;
2994 0 : pWrtShell->GetGrfNms( &sGrfNm, 0 );
2995 : }
2996 0 : else if( nsSelectionType::SEL_OLE == nSelection )
2997 : {
2998 0 : AddFormat( SOT_FORMATSTR_ID_EMBED_SOURCE );
2999 0 : PrepareOLE( aObjDesc );
3000 0 : AddFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR );
3001 0 : AddFormat( FORMAT_GDIMETAFILE );
3002 0 : eBufferType = TRNSFR_OLE;
3003 : }
3004 : //Is there anything to provide anyway?
3005 0 : else if ( pWrtShell->IsSelection() || pWrtShell->IsFrmSelected() ||
3006 0 : pWrtShell->IsObjSelected() )
3007 : {
3008 0 : if( pWrtShell->IsObjSelected() )
3009 0 : eBufferType = TRNSFR_DRAWING;
3010 : else
3011 : {
3012 0 : eBufferType = TRNSFR_DOCUMENT;
3013 0 : if( SwWrtShell::NO_WORD !=
3014 0 : pWrtShell->IntelligentCut( nSelection, sal_False ))
3015 : eBufferType = TransferBufferType( TRNSFR_DOCUMENT_WORD
3016 0 : | eBufferType);
3017 : }
3018 :
3019 0 : if( nSelection & nsSelectionType::SEL_TBL_CELLS )
3020 0 : eBufferType = (TransferBufferType)(TRNSFR_TABELLE | eBufferType);
3021 :
3022 0 : AddFormat( SOT_FORMATSTR_ID_EMBED_SOURCE );
3023 :
3024 : //put RTF ahead of the OLE's Metafile for less loss
3025 0 : if( !pWrtShell->IsObjSelected() )
3026 : {
3027 0 : AddFormat( FORMAT_RTF );
3028 0 : AddFormat( SOT_FORMATSTR_ID_HTML );
3029 : }
3030 0 : if( pWrtShell->IsSelection() )
3031 0 : AddFormat( FORMAT_STRING );
3032 :
3033 0 : if( nSelection & ( nsSelectionType::SEL_DRW | nsSelectionType::SEL_DRW_FORM ))
3034 : {
3035 0 : AddFormat( SOT_FORMATSTR_ID_DRAWING );
3036 0 : if ( nSelection & nsSelectionType::SEL_DRW )
3037 : {
3038 0 : AddFormat( FORMAT_GDIMETAFILE );
3039 0 : AddFormat( SOT_FORMATSTR_ID_PNG );
3040 0 : AddFormat( FORMAT_BITMAP );
3041 : }
3042 0 : eBufferType = (TransferBufferType)( TRNSFR_GRAPHIC | eBufferType );
3043 :
3044 0 : pClpGraphic = new Graphic;
3045 0 : if( !pWrtShell->GetDrawObjGraphic( FORMAT_GDIMETAFILE, *pClpGraphic ))
3046 0 : pOrigGrf = pClpGraphic;
3047 0 : pClpBitmap = new Graphic;
3048 0 : if( !pWrtShell->GetDrawObjGraphic( FORMAT_BITMAP, *pClpBitmap ))
3049 0 : pOrigGrf = pClpBitmap;
3050 :
3051 : // is it an URL-Button ?
3052 0 : OUString sURL;
3053 0 : OUString sDesc;
3054 0 : if( pWrtShell->GetURLFromButton( sURL, sDesc ) )
3055 : {
3056 0 : AddFormat( FORMAT_STRING );
3057 0 : AddFormat( SOT_FORMATSTR_ID_SOLK );
3058 0 : AddFormat( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK );
3059 0 : AddFormat( SOT_FORMATSTR_ID_FILECONTENT );
3060 0 : AddFormat( SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR );
3061 0 : AddFormat( SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR );
3062 0 : eBufferType = (TransferBufferType)( TRNSFR_INETFLD | eBufferType );
3063 0 : }
3064 : }
3065 :
3066 : //ObjectDescriptor was already filled from the old DocShell.
3067 : //Now adjust it. Thus in GetData the first query can still
3068 : //be answered with delayed rendering.
3069 0 : aObjDesc.mbCanLink = false;
3070 0 : aObjDesc.maDragStartPos = rSttPos;
3071 : aObjDesc.maSize = OutputDevice::LogicToLogic( Size( OLESIZE ),
3072 0 : MAP_TWIP, MAP_100TH_MM );
3073 0 : PrepareOLE( aObjDesc );
3074 0 : AddFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR );
3075 : }
3076 0 : else if( nSelection & nsSelectionType::SEL_TXT && !pWrtShell->HasMark() )
3077 : {
3078 : // is only one field - selected?
3079 0 : SwContentAtPos aCntntAtPos( SwContentAtPos::SW_INETATTR );
3080 0 : Point aPos( SwEditWin::GetDDStartPosX(), SwEditWin::GetDDStartPosY());
3081 :
3082 0 : if( pWrtShell->GetContentAtPos( aPos, aCntntAtPos ) )
3083 : {
3084 0 : AddFormat( FORMAT_STRING );
3085 0 : AddFormat( SOT_FORMATSTR_ID_SOLK );
3086 0 : AddFormat( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK );
3087 0 : AddFormat( SOT_FORMATSTR_ID_FILECONTENT );
3088 0 : AddFormat( SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR );
3089 0 : AddFormat( SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR );
3090 0 : eBufferType = TRNSFR_INETFLD;
3091 0 : }
3092 : }
3093 :
3094 0 : if( pWrtShell->IsFrmSelected() )
3095 : {
3096 0 : SfxItemSet aSet( pWrtShell->GetAttrPool(), RES_URL, RES_URL );
3097 0 : pWrtShell->GetFlyFrmAttr( aSet );
3098 0 : const SwFmtURL& rURL = (SwFmtURL&)aSet.Get( RES_URL );
3099 0 : if( rURL.GetMap() )
3100 : {
3101 0 : pImageMap = new ImageMap( *rURL.GetMap() );
3102 0 : AddFormat( SOT_FORMATSTR_ID_SVIM );
3103 : }
3104 0 : else if( !rURL.GetURL().isEmpty() )
3105 : {
3106 : pTargetURL = new INetImage( sGrfNm, rURL.GetURL(),
3107 : rURL.GetTargetFrameName(),
3108 0 : aEmptyOUStr, Size() );
3109 0 : AddFormat( SOT_FORMATSTR_ID_INET_IMAGE );
3110 0 : }
3111 0 : }
3112 : }
3113 :
3114 0 : void SwTransferable::StartDrag( Window* pWin, const Point& rPos )
3115 : {
3116 0 : if(!pWrtShell)
3117 0 : return;
3118 0 : bOldIdle = pWrtShell->GetViewOptions()->IsIdle();
3119 0 : bCleanUp = sal_True;
3120 :
3121 0 : ((SwViewOption *)pWrtShell->GetViewOptions())->SetIdle( sal_False );
3122 :
3123 0 : if( pWrtShell->IsSelFrmMode() )
3124 0 : pWrtShell->ShowCrsr();
3125 :
3126 0 : SW_MOD()->pDragDrop = this;
3127 :
3128 0 : SetDataForDragAndDrop( rPos );
3129 :
3130 0 : sal_Int8 nDragOptions = DND_ACTION_COPYMOVE | DND_ACTION_LINK;
3131 0 : SwDocShell* pDShell = pWrtShell->GetView().GetDocShell();
3132 0 : if( ( pDShell && pDShell->IsReadOnly() ) || pWrtShell->HasReadonlySel() )
3133 0 : nDragOptions &= ~DND_ACTION_MOVE;
3134 :
3135 0 : TransferableHelper::StartDrag( pWin, nDragOptions );
3136 : }
3137 :
3138 0 : void SwTransferable::DragFinished( sal_Int8 nAction )
3139 : {
3140 : //And the last finishing work so that all statuses are right
3141 0 : if( DND_ACTION_MOVE == nAction )
3142 : {
3143 0 : if( bCleanUp )
3144 : {
3145 : //It was dropped outside of Writer. We still have to
3146 : //delete.
3147 :
3148 0 : pWrtShell->StartAllAction();
3149 0 : pWrtShell->StartUndo( UNDO_UI_DRAG_AND_MOVE );
3150 0 : if ( pWrtShell->IsTableMode() )
3151 0 : pWrtShell->DeleteTblSel();
3152 : else
3153 : {
3154 0 : if ( !(pWrtShell->IsSelFrmMode() || pWrtShell->IsObjSelected()) )
3155 : //SmartCut, take one of the blanks along
3156 0 : pWrtShell->IntelligentCut( pWrtShell->GetSelectionType(), sal_True );
3157 0 : pWrtShell->DelRight();
3158 : }
3159 0 : pWrtShell->EndUndo( UNDO_UI_DRAG_AND_MOVE );
3160 0 : pWrtShell->EndAllAction();
3161 : }
3162 : else
3163 : {
3164 0 : const int nSelection = pWrtShell->GetSelectionType();
3165 0 : if( ( nsSelectionType::SEL_FRM | nsSelectionType::SEL_GRF |
3166 0 : nsSelectionType::SEL_OLE | nsSelectionType::SEL_DRW ) & nSelection )
3167 : {
3168 0 : pWrtShell->EnterSelFrmMode();
3169 : }
3170 : }
3171 : }
3172 0 : pWrtShell->GetView().GetEditWin().DragFinished();
3173 :
3174 0 : if( pWrtShell->IsSelFrmMode() )
3175 0 : pWrtShell->HideCrsr();
3176 : else
3177 0 : pWrtShell->ShowCrsr();
3178 :
3179 0 : ((SwViewOption *)pWrtShell->GetViewOptions())->SetIdle( bOldIdle );
3180 0 : }
3181 :
3182 1 : bool SwTransferable::PrivatePaste( SwWrtShell& rShell )
3183 : {
3184 : // first, ask for the SelectionType, then action-bracketing !!!!
3185 : // (otherwise it's not pasted into a TableSelection!!!)
3186 : OSL_ENSURE( !rShell.ActionPend(), "Paste must never have an ActionPend" );
3187 1 : if ( !pClpDocFac )
3188 0 : return false; // the return value of the SwFEShell::Paste also is sal_Bool!
3189 :
3190 1 : const int nSelection = rShell.GetSelectionType();
3191 :
3192 1 : SwRewriter aRewriter;
3193 :
3194 2 : SwTrnsfrActionAndUndo aAction( &rShell, UNDO_PASTE_CLIPBOARD);
3195 :
3196 1 : bool bKillPaMs = false;
3197 :
3198 : //Delete selected content, not at table-selection and table in Clipboard
3199 1 : if( rShell.HasSelection() && !( nSelection & nsSelectionType::SEL_TBL_CELLS))
3200 : {
3201 0 : bKillPaMs = true;
3202 0 : rShell.SetRetainSelection( true );
3203 0 : rShell.DelRight();
3204 : // when a Fly was selected, a valid cursor position has to be found now
3205 : // (parked Cursor!)
3206 0 : if( ( nsSelectionType::SEL_FRM | nsSelectionType::SEL_GRF |
3207 : nsSelectionType::SEL_OLE | nsSelectionType::SEL_DRW |
3208 0 : nsSelectionType::SEL_DRW_FORM ) & nSelection )
3209 : {
3210 : // position the cursor again
3211 0 : Point aPt( rShell.GetCharRect().Pos() );
3212 0 : rShell.SwCrsrShell::SetCrsr( aPt, sal_True );
3213 : }
3214 0 : rShell.SetRetainSelection( false );
3215 : }
3216 :
3217 1 : sal_Bool bInWrd = sal_False, bEndWrd = sal_False, bSttWrd = sal_False,
3218 1 : bSmart = 0 != (TRNSFR_DOCUMENT_WORD & eBufferType);
3219 1 : if( bSmart )
3220 : {
3221 : // Why not for other Scripts? If TRNSFR_DOCUMENT_WORD is set, we have a word
3222 : // in the buffer, word in this context means 'something with spaces at beginning
3223 : // and end'. In this case we definitely want these spaces to be inserted here.
3224 0 : bInWrd = rShell.IsInWrd();
3225 0 : bEndWrd = rShell.IsEndWrd();
3226 0 : bSmart = bInWrd || bEndWrd;
3227 0 : if( bSmart )
3228 : {
3229 0 : bSttWrd = rShell.IsSttWrd();
3230 0 : if( bSmart && !bSttWrd && (bInWrd || bEndWrd) )
3231 0 : rShell.SwEditShell::Insert(' ');
3232 : }
3233 : }
3234 :
3235 1 : bool nRet = rShell.Paste( pClpDocFac->GetDoc() );
3236 :
3237 1 : if( bKillPaMs )
3238 0 : rShell.KillPams();
3239 :
3240 : // If Smart Paste then insert blank
3241 1 : if( nRet && bSmart && ((bInWrd && !bEndWrd )|| bSttWrd) )
3242 0 : rShell.SwEditShell::Insert(' ');
3243 :
3244 2 : return nRet;
3245 : }
3246 :
3247 0 : bool SwTransferable::PrivateDrop( SwWrtShell& rSh, const Point& rDragPt,
3248 : sal_Bool bMove, sal_Bool bIsXSelection )
3249 : {
3250 0 : int cWord = 0;
3251 0 : sal_Bool bInWrd = sal_False;
3252 0 : sal_Bool bEndWrd = sal_False;
3253 0 : sal_Bool bSttWrd = sal_False;
3254 0 : bool bSttPara = false;
3255 0 : sal_Bool bTblSel = sal_False;
3256 0 : sal_Bool bFrmSel = sal_False;
3257 :
3258 0 : SwWrtShell& rSrcSh = *GetShell();
3259 :
3260 0 : rSh.UnSetVisCrsr();
3261 :
3262 0 : if( TRNSFR_INETFLD == eBufferType )
3263 : {
3264 0 : if( rSh.GetFmtFromObj( rDragPt ) )
3265 : {
3266 0 : INetBookmark aTmp;
3267 0 : if( (TRNSFR_INETFLD & eBufferType) && pBkmk )
3268 0 : aTmp = *pBkmk;
3269 :
3270 : // select target graphic
3271 0 : if( rSh.SelectObj( rDragPt ) )
3272 : {
3273 0 : rSh.HideCrsr();
3274 0 : rSh.EnterSelFrmMode( &rDragPt );
3275 0 : bFrmDrag = true;
3276 : }
3277 :
3278 0 : const int nSelection = rSh.GetSelectionType();
3279 :
3280 : // not yet consider Draw objects
3281 0 : if( nsSelectionType::SEL_GRF & nSelection )
3282 : {
3283 0 : SfxItemSet aSet( rSh.GetAttrPool(), RES_URL, RES_URL );
3284 0 : rSh.GetFlyFrmAttr( aSet );
3285 0 : SwFmtURL aURL( (SwFmtURL&)aSet.Get( RES_URL ) );
3286 0 : aURL.SetURL( aTmp.GetURL(), false );
3287 0 : aSet.Put( aURL );
3288 0 : rSh.SetFlyFrmAttr( aSet );
3289 0 : return true;
3290 : }
3291 :
3292 0 : if( nsSelectionType::SEL_DRW & nSelection )
3293 : {
3294 0 : rSh.LeaveSelFrmMode();
3295 0 : rSh.UnSelectFrm();
3296 0 : rSh.ShowCrsr();
3297 0 : bFrmDrag = false;
3298 0 : }
3299 : }
3300 : }
3301 :
3302 0 : if( &rSh != &rSrcSh && (nsSelectionType::SEL_GRF & rSh.GetSelectionType()) &&
3303 0 : TRNSFR_GRAPHIC == eBufferType )
3304 : {
3305 : // ReRead the graphic
3306 0 : OUString sGrfNm;
3307 0 : OUString sFltNm;
3308 0 : rSrcSh.GetGrfNms( &sGrfNm, &sFltNm );
3309 0 : rSh.ReRead( sGrfNm, sFltNm, rSrcSh.GetGraphic() );
3310 0 : return true;
3311 : }
3312 :
3313 : //not in selections or selected frames
3314 0 : if( rSh.ChgCurrPam( rDragPt ) ||
3315 0 : ( rSh.IsSelFrmMode() && rSh.IsInsideSelectedObj( rDragPt )) )
3316 0 : return false;
3317 :
3318 0 : if( rSrcSh.IsTableMode() )
3319 0 : bTblSel = sal_True;
3320 0 : else if( rSrcSh.IsSelFrmMode() || rSrcSh.IsObjSelected() )
3321 : {
3322 : // don't move position-protected objects!
3323 0 : if( bMove && rSrcSh.IsSelObjProtected( FLYPROTECT_POS ) )
3324 0 : return false;
3325 :
3326 0 : bFrmSel = sal_True;
3327 : }
3328 :
3329 0 : const int nSel = rSrcSh.GetSelectionType();
3330 :
3331 0 : SwUndoId eUndoId = bMove ? UNDO_UI_DRAG_AND_MOVE : UNDO_UI_DRAG_AND_COPY;
3332 :
3333 0 : SwRewriter aRewriter;
3334 :
3335 0 : aRewriter.AddRule(UndoArg1, rSrcSh.GetSelDescr());
3336 :
3337 0 : if(rSrcSh.GetDoc() != rSh.GetDoc())
3338 0 : rSrcSh.StartUndo( eUndoId, &aRewriter );
3339 0 : rSh.StartUndo( eUndoId, &aRewriter );
3340 :
3341 0 : rSh.StartAction();
3342 0 : rSrcSh.StartAction();
3343 :
3344 0 : if( &rSrcSh != &rSh )
3345 : {
3346 0 : rSh.EnterStdMode();
3347 0 : rSh.SwCrsrShell::SetCrsr( rDragPt, sal_True );
3348 0 : cWord = rSrcSh.IntelligentCut( nSel, sal_False );
3349 : }
3350 0 : else if( !bTblSel && !bFrmSel )
3351 : {
3352 0 : if( !rSh.IsAddMode() )
3353 : {
3354 : // #i87233#
3355 0 : if ( rSh.IsBlockMode() )
3356 : {
3357 : // preserve order of cursors for block mode
3358 0 : rSh.GoPrevCrsr();
3359 : }
3360 :
3361 0 : rSh.SwCrsrShell::CreateCrsr();
3362 : }
3363 0 : rSh.SwCrsrShell::SetCrsr( rDragPt, sal_True, false );
3364 0 : rSh.GoPrevCrsr();
3365 0 : cWord = rSh.IntelligentCut( rSh.GetSelectionType(), sal_False );
3366 0 : rSh.GoNextCrsr();
3367 : }
3368 :
3369 0 : bInWrd = rSh.IsInWrd();
3370 0 : bEndWrd = rSh.IsEndWrd();
3371 0 : bSttWrd = !bEndWrd && rSh.IsSttWrd();
3372 0 : bSttPara= rSh.IsSttPara();
3373 :
3374 0 : Point aSttPt( SwEditWin::GetDDStartPosX(), SwEditWin::GetDDStartPosY() );
3375 :
3376 : // at first, select INetFelder!
3377 0 : if( TRNSFR_INETFLD == eBufferType )
3378 : {
3379 0 : if( &rSrcSh == &rSh )
3380 : {
3381 0 : rSh.GoPrevCrsr();
3382 0 : rSh.SwCrsrShell::SetCrsr( aSttPt, sal_True );
3383 0 : rSh.SelectTxtAttr( RES_TXTATR_INETFMT );
3384 0 : if( rSh.ChgCurrPam( rDragPt ) )
3385 : {
3386 : // don't copy/move inside of yourself
3387 0 : rSh.DestroyCrsr();
3388 0 : rSh.EndUndo();
3389 0 : rSh.EndAction();
3390 0 : rSh.EndAction();
3391 0 : return false;
3392 : }
3393 0 : rSh.GoNextCrsr();
3394 : }
3395 : else
3396 : {
3397 0 : rSrcSh.SwCrsrShell::SetCrsr( aSttPt, sal_True );
3398 0 : rSrcSh.SelectTxtAttr( RES_TXTATR_INETFMT );
3399 : }
3400 :
3401 : // is there an URL attribute at the insert point? Then replace that,
3402 : // so simply put up a selection?
3403 0 : rSh.DelINetAttrWithText();
3404 0 : bDDINetAttr = true;
3405 : }
3406 :
3407 0 : if ( rSrcSh.IsSelFrmMode() )
3408 : {
3409 : //Hack: fool the special treatment
3410 0 : aSttPt -= aSttPt - rSrcSh.GetObjRect().Pos();
3411 : }
3412 :
3413 : sal_Bool bRet = rSrcSh.SwFEShell::Copy( &rSh, aSttPt, rDragPt, bMove,
3414 0 : !bIsXSelection );
3415 :
3416 0 : if( !bIsXSelection )
3417 : {
3418 0 : rSrcSh.Push();
3419 0 : if ( bRet && bMove && !bFrmSel )
3420 : {
3421 0 : if ( bTblSel )
3422 : {
3423 : /* delete table contents not cells */
3424 0 : rSrcSh.Delete();
3425 : }
3426 : else
3427 : {
3428 : //SmartCut, take one of the blanks along.
3429 0 : rSh.SwCrsrShell::DestroyCrsr();
3430 0 : if ( cWord == SwWrtShell::WORD_SPACE_BEFORE )
3431 0 : rSh.ExtendSelection( sal_False );
3432 0 : else if ( cWord == SwWrtShell::WORD_SPACE_AFTER )
3433 0 : rSh.ExtendSelection();
3434 0 : rSrcSh.DelRight();
3435 : }
3436 : }
3437 0 : rSrcSh.KillPams();
3438 0 : rSrcSh.Pop( sal_False );
3439 :
3440 : /* after dragging a table selection inside one shell
3441 : set cursor to the drop position. */
3442 0 : if( &rSh == &rSrcSh && ( bTblSel || rSh.IsBlockMode() ) )
3443 : {
3444 0 : rSrcSh.SwCrsrShell::SetCrsr(rDragPt);
3445 0 : rSrcSh.GetSwCrsr()->SetMark();
3446 : }
3447 : }
3448 :
3449 0 : if( bRet && !bTblSel && !bFrmSel )
3450 : {
3451 0 : if( (bInWrd || bEndWrd) &&
3452 0 : (cWord == SwWrtShell::WORD_SPACE_AFTER ||
3453 : cWord == SwWrtShell::WORD_SPACE_BEFORE) )
3454 : {
3455 0 : if ( bSttWrd || (bInWrd && !bEndWrd))
3456 0 : rSh.SwEditShell::Insert(' ', bIsXSelection);
3457 0 : if ( !bSttWrd || (bInWrd && !bSttPara) )
3458 : {
3459 0 : rSh.SwapPam();
3460 0 : if ( !bSttWrd )
3461 0 : rSh.SwEditShell::Insert(' ', bIsXSelection);
3462 0 : rSh.SwapPam();
3463 : }
3464 : }
3465 :
3466 0 : if( bIsXSelection )
3467 : {
3468 0 : if( &rSrcSh == &rSh && !rSh.IsAddMode() )
3469 : {
3470 0 : rSh.SwCrsrShell::DestroyCrsr();
3471 0 : rSh.GoPrevCrsr();
3472 : }
3473 : else
3474 : {
3475 0 : rSh.SwapPam();
3476 0 : rSh.SwCrsrShell::ClearMark();
3477 : }
3478 : }
3479 : else
3480 : {
3481 0 : if( rSh.IsAddMode() )
3482 0 : rSh.SwCrsrShell::CreateCrsr();
3483 : else
3484 : {
3485 : // turn on selection mode
3486 0 : rSh.SttSelect();
3487 0 : rSh.EndSelect();
3488 : }
3489 : }
3490 : }
3491 :
3492 0 : if( bRet && bMove && bFrmSel )
3493 0 : rSrcSh.LeaveSelFrmMode();
3494 :
3495 0 : if( rSrcSh.GetDoc() != rSh.GetDoc() )
3496 0 : rSrcSh.EndUndo();
3497 0 : rSh.EndUndo();
3498 :
3499 : // put the shell in the right state
3500 0 : if( &rSrcSh != &rSh && ( rSh.IsFrmSelected() || rSh.IsObjSelected() ))
3501 0 : rSh.EnterSelFrmMode();
3502 :
3503 0 : rSrcSh.EndAction();
3504 0 : rSh.EndAction();
3505 0 : return true;
3506 : }
3507 :
3508 : // Interfaces for Selection
3509 19 : void SwTransferable::CreateSelection( SwWrtShell& rSh,
3510 : const SwViewShell * _pCreatorView )
3511 : {
3512 19 : SwModule *pMod = SW_MOD();
3513 19 : SwTransferable* pNew = new SwTransferable( rSh );
3514 :
3515 19 : pNew->pCreatorView = _pCreatorView;
3516 :
3517 19 : uno::Reference< XTransferable > xRef( pNew );
3518 19 : pMod->pXSelection = pNew;
3519 19 : pNew->CopyToSelection( rSh.GetWin() );
3520 19 : }
3521 :
3522 1822 : void SwTransferable::ClearSelection( SwWrtShell& rSh,
3523 : const SwViewShell * _pCreatorView)
3524 : {
3525 1822 : SwModule *pMod = SW_MOD();
3526 1841 : if( pMod->pXSelection &&
3527 29 : ((!pMod->pXSelection->pWrtShell) || (pMod->pXSelection->pWrtShell == &rSh)) &&
3528 0 : (!_pCreatorView || (pMod->pXSelection->pCreatorView == _pCreatorView)) )
3529 : {
3530 19 : TransferableHelper::ClearSelection( rSh.GetWin() );
3531 : }
3532 1822 : }
3533 :
3534 : namespace
3535 : {
3536 : class theSwTransferableUnoTunnelId : public rtl::Static< UnoTunnelIdInit, SwTransferable > {};
3537 : }
3538 :
3539 26 : const Sequence< sal_Int8 >& SwTransferable::getUnoTunnelId()
3540 : {
3541 26 : return theSwTransferableUnoTunnelId::get().getSeq();
3542 : }
3543 :
3544 13 : sal_Int64 SwTransferable::getSomething( const Sequence< sal_Int8 >& rId ) throw( RuntimeException, std::exception )
3545 : {
3546 : sal_Int64 nRet;
3547 26 : if( ( rId.getLength() == 16 ) &&
3548 13 : ( 0 == memcmp( getUnoTunnelId().getConstArray(), rId.getConstArray(), 16 ) ) )
3549 : {
3550 13 : nRet = sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >( this ) );
3551 : }
3552 : else
3553 0 : nRet = TransferableHelper::getSomething(rId);
3554 13 : return nRet;
3555 : }
3556 :
3557 1135 : SwTransferable* SwTransferable::GetSwTransferable( const TransferableDataHelper& rData )
3558 : {
3559 1135 : SwTransferable* pSwTransferable = NULL;
3560 :
3561 1135 : uno::Reference<XUnoTunnel> xTunnel( rData.GetTransferable(), UNO_QUERY );
3562 1135 : if ( xTunnel.is() )
3563 : {
3564 3 : sal_Int64 nHandle = xTunnel->getSomething( getUnoTunnelId() );
3565 3 : if ( nHandle )
3566 3 : pSwTransferable = (SwTransferable*) (sal_IntPtr) nHandle;
3567 : }
3568 :
3569 1135 : return pSwTransferable;
3570 :
3571 : }
3572 :
3573 1 : SwTrnsfrDdeLink::SwTrnsfrDdeLink( SwTransferable& rTrans, SwWrtShell& rSh )
3574 : : rTrnsfr( rTrans ), pDocShell( 0 ),
3575 1 : bDelBookmrk( sal_False ), bInDisconnect( sal_False )
3576 : {
3577 : // we only end up here with table- or text selection
3578 1 : if( nsSelectionType::SEL_TBL_CELLS & rSh.GetSelectionType() )
3579 : {
3580 0 : SwFrmFmt* pFmt = rSh.GetTableFmt();
3581 0 : if( pFmt )
3582 0 : sName = pFmt->GetName();
3583 : }
3584 : else
3585 : {
3586 : // creating a temp. bookmark without undo
3587 1 : sal_Bool bUndo = rSh.DoesUndo();
3588 1 : rSh.DoUndo( sal_False );
3589 1 : sal_Bool bIsModified = rSh.IsModified();
3590 :
3591 : ::sw::mark::IMark* pMark = rSh.SetBookmark(
3592 : KeyCode(),
3593 : OUString(),
3594 : OUString(),
3595 1 : IDocumentMarkAccess::DDE_BOOKMARK);
3596 1 : if(pMark)
3597 : {
3598 1 : sName = pMark->GetName();
3599 1 : bDelBookmrk = sal_True;
3600 1 : if( !bIsModified )
3601 1 : rSh.ResetModified();
3602 : }
3603 : else
3604 0 : sName = "";
3605 1 : rSh.DoUndo( bUndo );
3606 : }
3607 :
3608 3 : if( !sName.isEmpty() &&
3609 2 : 0 != ( pDocShell = rSh.GetDoc()->GetDocShell() ) )
3610 : {
3611 : // then we create our "server" and connect to it
3612 1 : refObj = pDocShell->DdeCreateLinkSource( sName );
3613 1 : if( refObj.Is() )
3614 : {
3615 1 : refObj->AddConnectAdvise( this );
3616 : refObj->AddDataAdvise( this,
3617 : aEmptyOUStr,
3618 1 : ADVISEMODE_NODATA | ADVISEMODE_ONLYONCE );
3619 1 : nOldTimeOut = refObj->GetUpdateTimeout();
3620 1 : refObj->SetUpdateTimeout( 0 );
3621 : }
3622 : }
3623 1 : }
3624 :
3625 0 : SwTrnsfrDdeLink::~SwTrnsfrDdeLink()
3626 : {
3627 0 : if( refObj.Is() )
3628 0 : Disconnect( sal_True );
3629 0 : }
3630 :
3631 0 : ::sfx2::SvBaseLink::UpdateResult SwTrnsfrDdeLink::DataChanged( const OUString& ,
3632 : const uno::Any& )
3633 : {
3634 : // well, that's it with the link
3635 0 : if( !bInDisconnect )
3636 : {
3637 0 : if( FindDocShell() && pDocShell->GetView() )
3638 0 : rTrnsfr.RemoveDDELinkFormat( pDocShell->GetView()->GetEditWin() );
3639 0 : Disconnect( sal_False );
3640 : }
3641 0 : return SUCCESS;
3642 : }
3643 :
3644 0 : sal_Bool SwTrnsfrDdeLink::WriteData( SvStream& rStrm )
3645 : {
3646 0 : if( !refObj.Is() || !FindDocShell() )
3647 0 : return sal_False;
3648 :
3649 0 : rtl_TextEncoding eEncoding = DDE_TXT_ENCODING;
3650 : const OString aAppNm(OUStringToOString(
3651 0 : GetpApp()->GetAppName(), eEncoding));
3652 : const OString aTopic(OUStringToOString(
3653 0 : pDocShell->GetTitle(SFX_TITLE_FULLNAME), eEncoding));
3654 0 : const OString aName(OUStringToOString(sName, eEncoding));
3655 :
3656 0 : sal_Char* pMem = new sal_Char[ aAppNm.getLength() + aTopic.getLength() + aName.getLength() + 4 ];
3657 :
3658 0 : sal_Int32 nLen = aAppNm.getLength();
3659 0 : memcpy( pMem, aAppNm.getStr(), nLen );
3660 0 : pMem[ nLen++ ] = 0;
3661 0 : memcpy( pMem + nLen, aTopic.getStr(), aTopic.getLength() );
3662 0 : nLen = nLen + aTopic.getLength();
3663 0 : pMem[ nLen++ ] = 0;
3664 0 : memcpy( pMem + nLen, aName.getStr(), aName.getLength() );
3665 0 : nLen = nLen + aName.getLength();
3666 0 : pMem[ nLen++ ] = 0;
3667 0 : pMem[ nLen++ ] = 0;
3668 :
3669 0 : rStrm.Write( pMem, nLen );
3670 0 : delete[] pMem;
3671 :
3672 0 : IDocumentMarkAccess* const pMarkAccess = pDocShell->GetDoc()->getIDocumentMarkAccess();
3673 0 : IDocumentMarkAccess::const_iterator_t ppMark = pMarkAccess->findMark(sName);
3674 0 : if(ppMark != pMarkAccess->getAllMarksEnd()
3675 0 : && IDocumentMarkAccess::GetType(**ppMark) != IDocumentMarkAccess::BOOKMARK)
3676 : {
3677 : // the mark is still a DdeBookmark
3678 : // we replace it with a Bookmark, so it will get saved etc.
3679 0 : ::sw::mark::IMark* const pMark = ppMark->get();
3680 0 : SwServerObject* const pServerObject = dynamic_cast<SwServerObject *>(&refObj);
3681 :
3682 : // collecting state of old mark
3683 0 : SwPaM aPaM(pMark->GetMarkStart());
3684 0 : *aPaM.GetPoint() = pMark->GetMarkStart();
3685 0 : if(pMark->IsExpanded())
3686 : {
3687 0 : aPaM.SetMark();
3688 0 : *aPaM.GetMark() = pMark->GetMarkEnd();
3689 : }
3690 0 : OUString sMarkName = pMark->GetName();
3691 :
3692 : // remove mark
3693 0 : pServerObject->SetNoServer(); // this removes the connection between SwServerObject and mark
3694 : // N.B. ppMark was not loaded from file and cannot have xml:id
3695 0 : pMarkAccess->deleteMark(ppMark);
3696 :
3697 : // recreate as Bookmark
3698 : ::sw::mark::IMark* const pNewMark = pMarkAccess->makeMark(
3699 : aPaM,
3700 : sMarkName,
3701 0 : IDocumentMarkAccess::BOOKMARK);
3702 0 : pServerObject->SetDdeBookmark(*pNewMark);
3703 : }
3704 :
3705 0 : bDelBookmrk = false;
3706 0 : return true;
3707 : }
3708 :
3709 0 : void SwTrnsfrDdeLink::Disconnect( sal_Bool bRemoveDataAdvise )
3710 : {
3711 : // don't accept DataChanged anymore, when already in Disconnect!
3712 : // (DTOR from Bookmark sends a DataChanged!)
3713 0 : sal_Bool bOldDisconnect = bInDisconnect;
3714 0 : bInDisconnect = sal_True;
3715 :
3716 : // destroy the unused bookmark again (without Undo!)?
3717 0 : if( bDelBookmrk && refObj.Is() && FindDocShell() )
3718 : {
3719 0 : SwDoc* pDoc = pDocShell->GetDoc();
3720 0 : ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
3721 :
3722 : // #i58448#
3723 0 : Link aSavedOle2Link( pDoc->GetOle2Link() );
3724 0 : pDoc->SetOle2Link( Link() );
3725 :
3726 0 : sal_Bool bIsModified = pDoc->IsModified();
3727 :
3728 0 : IDocumentMarkAccess* const pMarkAccess = pDoc->getIDocumentMarkAccess();
3729 0 : pMarkAccess->deleteMark(pMarkAccess->findMark(sName));
3730 :
3731 0 : if( !bIsModified )
3732 0 : pDoc->ResetModified();
3733 : // #i58448#
3734 0 : pDoc->SetOle2Link( aSavedOle2Link );
3735 :
3736 0 : bDelBookmrk = sal_False;
3737 : }
3738 :
3739 0 : if( refObj.Is() )
3740 : {
3741 0 : refObj->SetUpdateTimeout( nOldTimeOut );
3742 0 : refObj->RemoveConnectAdvise( this );
3743 0 : if( bRemoveDataAdvise )
3744 : // in a DataChanged the SelectionObject must NEVER be deleted
3745 : // is already handled by the base class
3746 : // (ADVISEMODE_ONLYONCE!!!!)
3747 : // but always in normal Disconnect!
3748 0 : refObj->RemoveAllDataAdvise( this );
3749 0 : refObj.Clear();
3750 : }
3751 0 : bInDisconnect = bOldDisconnect;
3752 0 : }
3753 :
3754 0 : sal_Bool SwTrnsfrDdeLink::FindDocShell()
3755 : {
3756 0 : TypeId aType( TYPE( SwDocShell ) );
3757 0 : SfxObjectShell* pTmpSh = SfxObjectShell::GetFirst( &aType );
3758 0 : while( pTmpSh )
3759 : {
3760 0 : if( pTmpSh == pDocShell ) // that's what we want to have
3761 : {
3762 0 : if( pDocShell->GetDoc() )
3763 0 : return sal_True;
3764 0 : break; // the Doc is not there anymore, so leave!
3765 : }
3766 0 : pTmpSh = SfxObjectShell::GetNext( *pTmpSh, &aType );
3767 : }
3768 :
3769 0 : pDocShell = 0;
3770 0 : return sal_False;
3771 : }
3772 :
3773 1 : void SwTrnsfrDdeLink::Closed()
3774 : {
3775 1 : if( !bInDisconnect && refObj.Is() )
3776 : {
3777 1 : refObj->RemoveAllDataAdvise( this );
3778 1 : refObj->RemoveConnectAdvise( this );
3779 1 : refObj.Clear();
3780 : }
3781 112 : }
3782 :
3783 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
