?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 5.0.4.1
[LibreOffice.git] / sd / source / ui / view / sdview3.cxx
bloba02ec4e709bd049f932b44c791ce7095f407d3da
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 "View.hxx"
21 #include <com/sun/star/embed/XEmbedObjectClipboardCreator.hpp>
22 #include <com/sun/star/embed/NoVisualAreaSizeException.hpp>
23 #include <com/sun/star/embed/MSOLEObjectSystemCreator.hpp>
24 #include <com/sun/star/lang/XComponent.hpp>
25 #include <sot/filelist.hxx>
26 #include <unotools/pathoptions.hxx>
27 #include <editeng/editdata.hxx>
28 #include <svl/urlbmk.hxx>
29 #include <svx/xexch.hxx>
30 #include <svx/xflclit.hxx>
31 #include <svx/xlnclit.hxx>
32 #include <svx/svdpagv.hxx>
33 #include <editeng/eeitem.hxx>
34 #include <editeng/colritem.hxx>
35 #include <sfx2/docfile.hxx>
36 #include <svx/svditer.hxx>
37 #include <svx/svdogrp.hxx>
38 #include <svx/svdoole2.hxx>
39 #include <svx/svdograf.hxx>
40 #include <svx/svdetc.hxx>
41 #include <svx/svdundo.hxx>
42 #include <sfx2/app.hxx>
43 #include <svl/itempool.hxx>
44 #include <comphelper/classids.hxx>
45 #include <svx/fmmodel.hxx>
46 #include <sot/formats.hxx>
47 #include <editeng/outliner.hxx>
48 #include <editeng/editeng.hxx>
49 #include <svx/obj3d.hxx>
50 #include <svx/e3dundo.hxx>
51 #include <svx/unomodel.hxx>
52 #include <unotools/streamwrap.hxx>
53 #include <vcl/metaact.hxx>
54 #include <svx/svxids.hrc>
55 #include <toolkit/helper/vclunohelper.hxx>
56 #include <svtools/embedhlp.hxx>
57 #include "DrawDocShell.hxx"
58 #include "fupoor.hxx"
59 #include "tablefunction.hxx"
60 #include "Window.hxx"
61 #include "sdxfer.hxx"
62 #include "sdpage.hxx"
63 #include "DrawViewShell.hxx"
64 #include "drawdoc.hxx"
65 #include "sdresid.hxx"
66 #include "strings.hrc"
67 #include "imapinfo.hxx"
68 #include "SlideSorterViewShell.hxx"
69 #include "strmname.h"
70 #include "unomodel.hxx"
71 #include "ViewClipboard.hxx"
72 #include <sfx2/ipclient.hxx>
73 #include <comphelper/storagehelper.hxx>
74 #include <comphelper/processfactory.hxx>
75 #include <tools/stream.hxx>
76 #include <vcl/cvtgrf.hxx>
77 #include <svx/sdrhittesthelper.hxx>
78 #include <svx/xbtmpit.hxx>
79 #include <boost/scoped_ptr.hpp>
80
81 // - Namespaces -
82
83 using namespace ::com::sun::star;
84 using namespace ::com::sun::star::lang;
85 using namespace ::com::sun::star::uno;
86 using namespace ::com::sun::star::io;
87 using namespace ::com::sun::star::datatransfer;
88 using namespace ::com::sun::star::datatransfer::clipboard;
89
90 namespace sd {
91
92 #define CHECK_FORMAT_TRANS( _def_Type ) ( ( nFormat == (_def_Type) || nFormat == SotClipboardFormatId::NONE ) && aDataHelper.HasFormat( _def_Type ) )
93
94 /*************************************************************************
95 |*
96 |* Paste
97 |*
98 \************************************************************************/
99
100 struct ImpRememberOrigAndClone
101 {
102 SdrObject* pOrig;
103 SdrObject* pClone;
104 };
105
106 SdrObject* ImpGetClone(std::vector<ImpRememberOrigAndClone*>& aConnectorContainer, SdrObject* pConnObj)
107 {
108 for(sal_uInt32 a(0); a < aConnectorContainer.size(); a++)
109 {
110 if(pConnObj == aConnectorContainer[a]->pOrig)
111 return aConnectorContainer[a]->pClone;
112 }
113 return 0L;
114 }
115
116 // restrict movement to WorkArea
117 void ImpCheckInsertPos(Point& rPos, const Size& rSize, const Rectangle& rWorkArea)
118 {
119 if(!rWorkArea.IsEmpty())
120 {
121 Rectangle aMarkRect(Point(rPos.X() - (rSize.Width() / 2), rPos.Y() - (rSize.Height() / 2)), rSize);
122
123 if(!aMarkRect.IsInside(rWorkArea))
124 {
125 if(aMarkRect.Left() < rWorkArea.Left())
126 {
127 rPos.X() += rWorkArea.Left() - aMarkRect.Left();
128 }
129
130 if(aMarkRect.Right() > rWorkArea.Right())
131 {
132 rPos.X() -= aMarkRect.Right() - rWorkArea.Right();
133 }
134
135 if(aMarkRect.Top() < rWorkArea.Top())
136 {
137 rPos.Y() += rWorkArea.Top() - aMarkRect.Top();
138 }
139
140 if(aMarkRect.Bottom() > rWorkArea.Bottom())
141 {
142 rPos.Y() -= aMarkRect.Bottom() - rWorkArea.Bottom();
143 }
144 }
145 }
146 }
147
148 bool View::InsertMetaFile( TransferableDataHelper& rDataHelper, const Point& rPos, ImageMap* pImageMap, bool bOptimize )
149 {
150 GDIMetaFile aMtf;
151
152 if( !rDataHelper.GetGDIMetaFile( SotClipboardFormatId::GDIMETAFILE, aMtf ) )
153 return false;
154
155 bool bVector = false;
156 Graphic aGraphic;
157
158 // check if metafile only contains a pixel image, if so insert a bitmap instead
159 if( bOptimize )
160 {
161 MetaAction* pAction = aMtf.FirstAction();
162 while( pAction && !bVector )
163 {
164 switch( pAction->GetType() )
165 {
166 case MetaActionType::POINT:
167 case MetaActionType::LINE:
168 case MetaActionType::RECT:
169 case MetaActionType::ROUNDRECT:
170 case MetaActionType::ELLIPSE:
171 case MetaActionType::ARC:
172 case MetaActionType::PIE:
173 case MetaActionType::CHORD:
174 case MetaActionType::POLYLINE:
175 case MetaActionType::POLYGON:
176 case MetaActionType::POLYPOLYGON:
177 case MetaActionType::TEXT:
178 case MetaActionType::TEXTARRAY:
179 case MetaActionType::STRETCHTEXT:
180 case MetaActionType::TEXTRECT:
181 case MetaActionType::GRADIENT:
182 case MetaActionType::HATCH:
183 case MetaActionType::WALLPAPER:
184 case MetaActionType::EPS:
185 case MetaActionType::TEXTLINE:
186 case MetaActionType::FLOATTRANSPARENT:
187 case MetaActionType::GRADIENTEX:
188 case MetaActionType::BMPSCALEPART:
189 case MetaActionType::BMPEXSCALEPART:
190 bVector = true;
191 break;
192 case MetaActionType::BMP:
193 case MetaActionType::BMPSCALE:
194 case MetaActionType::BMPEX:
195 case MetaActionType::BMPEXSCALE:
196 if( aGraphic.GetType() != GRAPHIC_NONE )
197 {
198 bVector = true;
199 }
200 else switch( pAction->GetType() )
201 {
202 case MetaActionType::BMP:
203 {
204 MetaBmpAction* pBmpAction = dynamic_cast< MetaBmpAction* >( pAction );
205 if( pBmpAction )
206 aGraphic = Graphic( pBmpAction->GetBitmap() );
207 }
208 break;
209 case MetaActionType::BMPSCALE:
210 {
211 MetaBmpScaleAction* pBmpScaleAction = dynamic_cast< MetaBmpScaleAction* >( pAction );
212 if( pBmpScaleAction )
213 aGraphic = Graphic( pBmpScaleAction->GetBitmap() );
214 }
215 break;
216 case MetaActionType::BMPEX:
217 {
218 MetaBmpExAction* pBmpExAction = dynamic_cast< MetaBmpExAction* >( pAction );
219 if( pBmpExAction )
220 aGraphic = Graphic( pBmpExAction->GetBitmapEx() );
221 }
222 break;
223 case MetaActionType::BMPEXSCALE:
224 {
225 MetaBmpExScaleAction* pBmpExScaleAction = dynamic_cast< MetaBmpExScaleAction* >( pAction );
226 if( pBmpExScaleAction )
227 aGraphic = Graphic( pBmpExScaleAction->GetBitmapEx() );
228 }
229 break;
230 default: break;
231 }
232 default: break;
233 }
234
235 pAction = aMtf.NextAction();
236 }
237 }
238
239 // it is not a vector metafile but it also has no graphic?
240 if( !bVector && (aGraphic.GetType() == GRAPHIC_NONE) )
241 bVector = true;
242
243 // restrict movement to WorkArea
244 Point aInsertPos( rPos );
245 Size aImageSize;
246 aImageSize = bVector ? aMtf.GetPrefSize() : aGraphic.GetSizePixel();
247 ImpCheckInsertPos(aInsertPos, aImageSize, GetWorkArea());
248
249 if( bVector )
250 aGraphic = Graphic( aMtf );
251
252 aGraphic.SetPrefMapMode( aMtf.GetPrefMapMode() );
253 aGraphic.SetPrefSize( aMtf.GetPrefSize() );
254 InsertGraphic( aGraphic, mnAction, aInsertPos, NULL, pImageMap );
255
256 return true;
257 }
258
259 bool View::InsertData( const TransferableDataHelper& rDataHelper,
260 const Point& rPos, sal_Int8& rDnDAction, bool bDrag,
261 SotClipboardFormatId nFormat, sal_uInt16 nPage, sal_uInt16 nLayer )
262 {
263 maDropPos = rPos;
264 mnAction = rDnDAction;
265 mbIsDropAllowed = false;
266
267 TransferableDataHelper aDataHelper( rDataHelper );
268 SdrObject* pPickObj = NULL;
269 SdPage* pPage = NULL;
270 boost::scoped_ptr<ImageMap> pImageMap;
271 bool bReturn = false;
272 bool bLink = ( ( mnAction & DND_ACTION_LINK ) != 0 );
273 bool bCopy = ( ( ( mnAction & DND_ACTION_COPY ) != 0 ) || bLink );
274 SdrInsertFlags nPasteOptions = SdrInsertFlags::SETDEFLAYER;
275
276 if (mpViewSh != NULL)
277 {
278 OSL_ASSERT (mpViewSh->GetViewShell()!=NULL);
279 SfxInPlaceClient* pIpClient = mpViewSh->GetViewShell()->GetIPClient();
280 if( mpViewSh->ISA(::sd::slidesorter::SlideSorterViewShell)
281 || (pIpClient!=NULL && pIpClient->IsObjectInPlaceActive()))
282 nPasteOptions |= SdrInsertFlags::DONTMARK;
283 }
284
285 if( bDrag )
286 {
287 SdrPageView* pPV = NULL;
288 PickObj( rPos, getHitTolLog(), pPickObj, pPV );
289 }
290
291 if( nPage != SDRPAGE_NOTFOUND )
292 pPage = static_cast<SdPage*>( mrDoc.GetPage( nPage ) );
293
294 SdTransferable* pOwnData = NULL;
295 SdTransferable* pImplementation = SdTransferable::getImplementation( aDataHelper.GetTransferable() );
296
297 if(pImplementation && (rDnDAction & DND_ACTION_LINK))
298 {
299 // suppress own data when it's intention is to use it as fill information
300 pImplementation = 0;
301 }
302
303 // try to get own transfer data
304 if( pImplementation )
305 {
306 if( SD_MOD()->pTransferClip == pImplementation )
307 pOwnData = SD_MOD()->pTransferClip;
308 else if( SD_MOD()->pTransferDrag == pImplementation )
309 pOwnData = SD_MOD()->pTransferDrag;
310 else if( SD_MOD()->pTransferSelection == pImplementation )
311 pOwnData = SD_MOD()->pTransferSelection;
312 }
313
314 // ImageMap?
315 if( !pOwnData && aDataHelper.HasFormat( SotClipboardFormatId::SVIM ) )
316 {
317 ::tools::SvRef<SotStorageStream> xStm;
318
319 if( aDataHelper.GetSotStorageStream( SotClipboardFormatId::SVIM, xStm ) )
320 {
321 pImageMap.reset(new ImageMap);
322 // mba: clipboard always must contain absolute URLs (could be from alien source)
323 pImageMap->Read( *xStm, OUString() );
324 }
325 }
326
327 bool bTable = false;
328 // check special cases for pasting table formats as RTL
329 if( !bLink && (nFormat == SotClipboardFormatId::NONE || (nFormat == SotClipboardFormatId::RTF)) )
330 {
331 // if the objekt supports rtf and there is a table involved, default is to create a table
332 if( aDataHelper.HasFormat( SotClipboardFormatId::RTF ) && ! aDataHelper.HasFormat( SotClipboardFormatId::DRAWING ) )
333 {
334 ::tools::SvRef<SotStorageStream> xStm;
335
336 if( aDataHelper.GetSotStorageStream( SotClipboardFormatId::RTF, xStm ) )
337 {
338 xStm->Seek( 0 );
339
340 OString aLine;
341 while (xStm->ReadLine(aLine))
342 {
343 sal_Int32 x = aLine.indexOf( "\\trowd" );
344 if (x != -1)
345 {
346 bTable = true;
347 nFormat = SotClipboardFormatId::RTF;
348 break;
349 }
350 }
351 }
352 }
353 }
354
355 // Changed the whole decision tree to be dependent of bReturn as a flag that
356 // the work was done; this allows to check multiple formats and not just fail
357 // when a CHECK_FORMAT_TRANS(*format*) detected format does not work. This is
358 // e.g. necessary for SotClipboardFormatId::BITMAP
359 if( pOwnData && nFormat == SotClipboardFormatId::NONE )
360 {
361 const View* pSourceView = pOwnData->GetView();
362
363 if( pOwnData->GetDocShell() && pOwnData->IsPageTransferable() && ISA( View ) )
364 {
365 mpClipboard->HandlePageDrop (*pOwnData);
366 bReturn = true;
367 }
368 else if( pSourceView )
369 {
370 if( pSourceView == this )
371 {
372 // same view
373 if( nLayer != SDRLAYER_NOTFOUND )
374 {
375 // drop on layer tab bar
376 SdrLayerAdmin& rLayerAdmin = mrDoc.GetLayerAdmin();
377 SdrLayer* pLayer = rLayerAdmin.GetLayerPerID( nLayer );
378 SdrPageView* pPV = GetSdrPageView();
379 OUString aLayer = pLayer->GetName();
380
381 if( !pPV->IsLayerLocked( aLayer ) )
382 {
383 pOwnData->SetInternalMove( true );
384 SortMarkedObjects();
385
386 for( size_t nM = 0; nM < GetMarkedObjectCount(); ++nM )
387 {
388 SdrMark* pM = GetSdrMarkByIndex( nM );
389 SdrObject* pO = pM->GetMarkedSdrObj();
390
391 if( pO )
392 {
393 // #i11702#
394 if( IsUndoEnabled() )
395 {
396 BegUndo(SD_RESSTR(STR_MODIFYLAYER));
397 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoObjectLayerChange(*pO, pO->GetLayer(), (SdrLayerID)nLayer));
398 EndUndo();
399 }
400
401 pO->SetLayer( (SdrLayerID) nLayer );
402 }
403 }
404
405 bReturn = true;
406 }
407 }
408 else
409 {
410 SdrPageView* pPV = GetSdrPageView();
411 bool bDropOnTabBar = true;
412
413 if( !pPage && pPV->GetPage()->GetPageNum() != mnDragSrcPgNum )
414 {
415 pPage = static_cast<SdPage*>( pPV->GetPage() );
416 bDropOnTabBar = false;
417 }
418
419 if( pPage )
420 {
421 // drop on other page
422 OUString aActiveLayer = GetActiveLayer();
423
424 if( !pPV->IsLayerLocked( aActiveLayer ) )
425 {
426 if( !IsPresObjSelected() )
427 {
428 SdrMarkList* pMarkList;
429
430 if( (mnDragSrcPgNum != SDRPAGE_NOTFOUND) && (mnDragSrcPgNum != pPV->GetPage()->GetPageNum()) )
431 {
432 pMarkList = mpDragSrcMarkList;
433 }
434 else
435 {
436 // actual mark list is used
437 pMarkList = new SdrMarkList( GetMarkedObjectList());
438 }
439
440 pMarkList->ForceSort();
441
442 // stuff to remember originals and clones
443 std::vector<ImpRememberOrigAndClone*> aConnectorContainer;
444 size_t nConnectorCount = 0;
445 Point aCurPos;
446
447 // calculate real position of current
448 // source objects, if necessary (#103207)
449 if( pOwnData == SD_MOD()->pTransferSelection )
450 {
451 Rectangle aCurBoundRect;
452
453 if( pMarkList->TakeBoundRect( pPV, aCurBoundRect ) )
454 aCurPos = aCurBoundRect.TopLeft();
455 else
456 aCurPos = pOwnData->GetStartPos();
457 }
458 else
459 aCurPos = pOwnData->GetStartPos();
460
461 const Size aVector( maDropPos.X() - aCurPos.X(), maDropPos.Y() - aCurPos.Y() );
462
463 for(size_t a = 0; a < pMarkList->GetMarkCount(); ++a)
464 {
465 SdrMark* pM = pMarkList->GetMark(a);
466 SdrObject* pObj = pM->GetMarkedSdrObj()->Clone();
467
468 if(pObj)
469 {
470 if(!bDropOnTabBar)
471 {
472 // do a NbcMove(...) instead of setting SnapRects here
473 pObj->NbcMove(aVector);
474 }
475
476 pPage->InsertObject(pObj);
477
478 if( IsUndoEnabled() )
479 {
480 BegUndo(SD_RESSTR(STR_UNDO_DRAGDROP));
481 AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoNewObject(*pObj));
482 EndUndo();
483 }
484
485 ImpRememberOrigAndClone* pRem = new ImpRememberOrigAndClone;
486 pRem->pOrig = pM->GetMarkedSdrObj();
487 pRem->pClone = pObj;
488 aConnectorContainer.push_back(pRem);
489
490 if(pObj->ISA(SdrEdgeObj))
491 nConnectorCount++;
492 }
493 }
494
495 // try to re-establish connections at clones
496 if(nConnectorCount)
497 {
498 for(size_t a = 0; a < aConnectorContainer.size(); ++a)
499 {
500 ImpRememberOrigAndClone* pRem = aConnectorContainer[a];
501
502 if(pRem->pClone->ISA(SdrEdgeObj))
503 {
504 SdrEdgeObj* pOrigEdge = static_cast<SdrEdgeObj*>(pRem->pOrig);
505 SdrEdgeObj* pCloneEdge = static_cast<SdrEdgeObj*>(pRem->pClone);
506
507 // test first connection
508 SdrObjConnection& rConn0 = pOrigEdge->GetConnection(false);
509 SdrObject* pConnObj = rConn0.GetObject();
510 if(pConnObj)
511 {
512 SdrObject* pConnClone = ImpGetClone(aConnectorContainer, pConnObj);
513 if(pConnClone)
514 {
515 // if dest obj was cloned, too, re-establish connection
516 pCloneEdge->ConnectToNode(false, pConnClone);
517 pCloneEdge->GetConnection(false).SetConnectorId(rConn0.GetConnectorId());
518 }
519 else
520 {
521 // set position of connection point of original connected object
522 const SdrGluePointList* pGlueList = pConnObj->GetGluePointList();
523 if(pGlueList)
524 {
525 sal_uInt16 nInd = pGlueList->FindGluePoint(rConn0.GetConnectorId());
526
527 if(SDRGLUEPOINT_NOTFOUND != nInd)
528 {
529 const SdrGluePoint& rGluePoint = (*pGlueList)[nInd];
530 Point aPosition = rGluePoint.GetAbsolutePos(*pConnObj);
531 aPosition.X() += aVector.A();
532 aPosition.Y() += aVector.B();
533 pCloneEdge->SetTailPoint(false, aPosition);
534 }
535 }
536 }
537 }
538
539 // test second connection
540 SdrObjConnection& rConn1 = pOrigEdge->GetConnection(true);
541 pConnObj = rConn1.GetObject();
542 if(pConnObj)
543 {
544 SdrObject* pConnClone = ImpGetClone(aConnectorContainer, pConnObj);
545 if(pConnClone)
546 {
547 // if dest obj was cloned, too, re-establish connection
548 pCloneEdge->ConnectToNode(true, pConnClone);
549 pCloneEdge->GetConnection(true).SetConnectorId(rConn1.GetConnectorId());
550 }
551 else
552 {
553 // set position of connection point of original connected object
554 const SdrGluePointList* pGlueList = pConnObj->GetGluePointList();
555 if(pGlueList)
556 {
557 sal_uInt16 nInd = pGlueList->FindGluePoint(rConn1.GetConnectorId());
558
559 if(SDRGLUEPOINT_NOTFOUND != nInd)
560 {
561 const SdrGluePoint& rGluePoint = (*pGlueList)[nInd];
562 Point aPosition = rGluePoint.GetAbsolutePos(*pConnObj);
563 aPosition.X() += aVector.A();
564 aPosition.Y() += aVector.B();
565 pCloneEdge->SetTailPoint(true, aPosition);
566 }
567 }
568 }
569 }
570 }
571 }
572 }
573
574 // cleanup remember classes
575 for(size_t a = 0; a < aConnectorContainer.size(); ++a)
576 delete aConnectorContainer[a];
577
578 if( pMarkList != mpDragSrcMarkList )
579 delete pMarkList;
580
581 bReturn = true;
582 }
583 else
584 {
585 maDropErrorIdle.Start();
586 bReturn = false;
587 }
588 }
589 }
590 else
591 {
592 pOwnData->SetInternalMove( true );
593 MoveAllMarked( Size( maDropPos.X() - pOwnData->GetStartPos().X(),
594 maDropPos.Y() - pOwnData->GetStartPos().Y() ), bCopy );
595 bReturn = true;
596 }
597 }
598 }
599 else
600 {
601 // different views
602 if( !pSourceView->IsPresObjSelected() )
603 {
604 // model is owned by from AllocModel() created DocShell
605 SdDrawDocument* pSourceDoc = static_cast<SdDrawDocument*>( pSourceView->GetModel() );
606 pSourceDoc->CreatingDataObj( pOwnData );
607 SdDrawDocument* pModel = static_cast<SdDrawDocument*>( pSourceView->GetMarkedObjModel() );
608 bReturn = Paste(*pModel, maDropPos, pPage, nPasteOptions, OUString(), OUString());
609
610 if( !pPage )
611 pPage = static_cast<SdPage*>( GetSdrPageView()->GetPage() );
612
613 OUString aLayout = pPage->GetLayoutName();
614 sal_Int32 nPos = aLayout.indexOf(SD_LT_SEPARATOR);
615 if (nPos != -1)
616 aLayout = aLayout.copy(0, nPos);
617 pPage->SetPresentationLayout( aLayout, false, false );
618 pSourceDoc->CreatingDataObj( NULL );
619 }
620 else
621 {
622 maDropErrorIdle.Start();
623 bReturn = false;
624 }
625 }
626 }
627 else
628 {
629 SdDrawDocument* pWorkModel = const_cast<SdDrawDocument*>(pOwnData->GetWorkDocument());
630 SdPage* pWorkPage = pWorkModel->GetSdPage( 0, PK_STANDARD );
631
632 pWorkPage->SetRectsDirty();
633
634 // #i120393# Clipboard data uses full object geometry range
635 const Size aSize( pWorkPage->GetAllObjBoundRect().GetSize() );
636
637 maDropPos.X() = pOwnData->GetStartPos().X() + ( aSize.Width() >> 1 );
638 maDropPos.Y() = pOwnData->GetStartPos().Y() + ( aSize.Height() >> 1 );
639
640 // delete pages, that are not of any interest for us
641 for( long i = ( pWorkModel->GetPageCount() - 1 ); i >= 0; i-- )
642 {
643 SdPage* pP = static_cast< SdPage* >( pWorkModel->GetPage( (sal_uInt16) i ) );
644
645 if( pP->GetPageKind() != PK_STANDARD )
646 pWorkModel->DeletePage( (sal_uInt16) i );
647 }
648
649 bReturn = Paste(*pWorkModel, maDropPos, pPage, nPasteOptions, OUString(), OUString());
650
651 if( !pPage )
652 pPage = static_cast<SdPage*>( GetSdrPageView()->GetPage() );
653
654 OUString aLayout = pPage->GetLayoutName();
655 sal_Int32 nPos = aLayout.indexOf(SD_LT_SEPARATOR);
656 if (nPos != -1)
657 aLayout = aLayout.copy(0, nPos);
658 pPage->SetPresentationLayout( aLayout, false, false );
659 }
660 }
661
662 if(!bReturn && CHECK_FORMAT_TRANS( SotClipboardFormatId::DRAWING ))
663 {
664 ::tools::SvRef<SotStorageStream> xStm;
665
666 if( aDataHelper.GetSotStorageStream( SotClipboardFormatId::DRAWING, xStm ) )
667 {
668 DrawDocShellRef xShell = new DrawDocShell(SfxObjectCreateMode::INTERNAL);
669 xShell->DoInitNew(0);
670
671 SdDrawDocument* pModel = xShell->GetDoc();
672 pModel->InsertPage(pModel->AllocPage(false));
673
674 Reference< XComponent > xComponent( xShell->GetModel(), UNO_QUERY );
675 xStm->Seek( 0 );
676
677 com::sun::star::uno::Reference< com::sun::star::io::XInputStream > xInputStream( new utl::OInputStreamWrapper( *xStm ) );
678 bReturn = SvxDrawingLayerImport( pModel, xInputStream, xComponent, "com.sun.star.comp.Impress.XMLOasisImporter" );
679
680 if( pModel->GetPageCount() == 0 )
681 {
682 OSL_FAIL("empty or invalid drawing xml document on clipboard!" );
683 }
684 else
685 {
686 bool bChanged = false;
687
688 if( bReturn )
689 {
690 if( pModel->GetSdPage( 0, PK_STANDARD )->GetObjCount() == 1 )
691 {
692 // only one object
693 SdrObject* pObj = pModel->GetSdPage( 0, PK_STANDARD )->GetObj( 0 );
694 SdrObject* pPickObj2 = NULL;
695 SdrPageView* pPV = NULL;
696 PickObj( rPos, getHitTolLog(), pPickObj2, pPV );
697
698 if( ( mnAction & DND_ACTION_MOVE ) && pPickObj2 && pObj )
699 {
700 // replace object
701 SdrObject* pNewObj = pObj->Clone();
702 Rectangle aPickObjRect( pPickObj2->GetCurrentBoundRect() );
703 Size aPickObjSize( aPickObjRect.GetSize() );
704 Point aVec( aPickObjRect.TopLeft() );
705 Rectangle aObjRect( pNewObj->GetCurrentBoundRect() );
706 Size aObjSize( aObjRect.GetSize() );
707
708 Fraction aScaleWidth( aPickObjSize.Width(), aObjSize.Width() );
709 Fraction aScaleHeight( aPickObjSize.Height(), aObjSize.Height() );
710 pNewObj->NbcResize( aObjRect.TopLeft(), aScaleWidth, aScaleHeight );
711
712 aVec -= aObjRect.TopLeft();
713 pNewObj->NbcMove( Size( aVec.X(), aVec.Y() ) );
714
715 const bool bUndo = IsUndoEnabled();
716
717 if( bUndo )
718 BegUndo(SD_RESSTR(STR_UNDO_DRAGDROP));
719 pNewObj->NbcSetLayer( pPickObj->GetLayer() );
720 SdrPage* pWorkPage = GetSdrPageView()->GetPage();
721 pWorkPage->InsertObject( pNewObj );
722 if( bUndo )
723 {
724 AddUndo( mrDoc.GetSdrUndoFactory().CreateUndoNewObject( *pNewObj ) );
725 AddUndo( mrDoc.GetSdrUndoFactory().CreateUndoDeleteObject( *pPickObj2 ) );
726 }
727 pWorkPage->RemoveObject( pPickObj2->GetOrdNum() );
728
729 if( bUndo )
730 {
731 EndUndo();
732 }
733 else
734 {
735 SdrObject::Free(pPickObj2 );
736 }
737 bChanged = true;
738 mnAction = DND_ACTION_COPY;
739 }
740 else if( ( mnAction & DND_ACTION_LINK ) && pPickObj && pObj && !pPickObj->ISA( SdrGrafObj ) && !pPickObj->ISA( SdrOle2Obj ) )
741 {
742 SfxItemSet aSet( mrDoc.GetPool() );
743
744 // set new attributes to object
745 const bool bUndo = IsUndoEnabled();
746 if( bUndo )
747 {
748 BegUndo( SD_RESSTR(STR_UNDO_DRAGDROP) );
749 AddUndo( mrDoc.GetSdrUndoFactory().CreateUndoAttrObject( *pPickObj ) );
750 }
751
752 aSet.Put( pObj->GetMergedItemSet() );
753
754 /* Do not take over corner radius. There are
755 gradients (rectangles) in the gallery with corner
756 radius of 0. We should not use that on the
757 object. */
758 aSet.ClearItem( SDRATTR_ECKENRADIUS );
759
760 const SdrGrafObj* pSdrGrafObj = dynamic_cast< const SdrGrafObj* >(pObj);
761
762 if(pSdrGrafObj)
763 {
764 // If we have a graphic as source object, use it's graphic
765 // content as fill style
766 aSet.Put(XFillStyleItem(drawing::FillStyle_BITMAP));
767 aSet.Put(XFillBitmapItem(&mrDoc.GetPool(), pSdrGrafObj->GetGraphic()));
768 }
769
770 pPickObj->SetMergedItemSetAndBroadcast( aSet );
771
772 if( pPickObj->ISA( E3dObject ) && pObj->ISA( E3dObject ) )
773 {
774 // handle 3D attribute in addition
775 SfxItemSet aNewSet( mrDoc.GetPool(), SID_ATTR_3D_START, SID_ATTR_3D_END, 0 );
776 SfxItemSet aOldSet( mrDoc.GetPool(), SID_ATTR_3D_START, SID_ATTR_3D_END, 0 );
777
778 aOldSet.Put(pPickObj->GetMergedItemSet());
779 aNewSet.Put( pObj->GetMergedItemSet() );
780
781 if( bUndo )
782 AddUndo( new E3dAttributesUndoAction( mrDoc, static_cast<E3dObject*>(pPickObj), aNewSet, aOldSet ) );
783 pPickObj->SetMergedItemSetAndBroadcast( aNewSet );
784 }
785
786 if( bUndo )
787 EndUndo();
788 bChanged = true;
789 }
790 }
791 }
792
793 if( !bChanged )
794 {
795 SdrPage* pWorkPage = pModel->GetSdPage( 0, PK_STANDARD );
796
797 pWorkPage->SetRectsDirty();
798
799 if( pOwnData )
800 {
801 // #i120393# Clipboard data uses full object geometry range
802 const Size aSize( pWorkPage->GetAllObjBoundRect().GetSize() );
803
804 maDropPos.X() = pOwnData->GetStartPos().X() + ( aSize.Width() >> 1 );
805 maDropPos.Y() = pOwnData->GetStartPos().Y() + ( aSize.Height() >> 1 );
806 }
807
808 bReturn = Paste(*pModel, maDropPos, pPage, nPasteOptions, OUString(), OUString());
809 }
810
811 xShell->DoClose();
812 }
813 }
814 }
815
816 if(!bReturn && CHECK_FORMAT_TRANS(SotClipboardFormatId::SBA_FIELDDATAEXCHANGE))
817 {
818 OUString aOUString;
819
820 if( aDataHelper.GetString( SotClipboardFormatId::SBA_FIELDDATAEXCHANGE, aOUString ) )
821 {
822 SdrObject* pObj = CreateFieldControl( aOUString );
823
824 if( pObj )
825 {
826 Rectangle aRect( pObj->GetLogicRect() );
827 Size aSize( aRect.GetSize() );
828
829 maDropPos.X() -= ( aSize.Width() >> 1 );
830 maDropPos.Y() -= ( aSize.Height() >> 1 );
831
832 aRect.SetPos( maDropPos );
833 pObj->SetLogicRect( aRect );
834 InsertObjectAtView( pObj, *GetSdrPageView(), SdrInsertFlags::SETDEFLAYER );
835 bReturn = true;
836 }
837 }
838 }
839
840 if(!bReturn &&
841 !bLink &&
842 (CHECK_FORMAT_TRANS(SotClipboardFormatId::EMBED_SOURCE) || CHECK_FORMAT_TRANS(SotClipboardFormatId::EMBEDDED_OBJ)) &&
843 aDataHelper.HasFormat(SotClipboardFormatId::OBJECTDESCRIPTOR))
844 {
845 //TODO/LATER: is it possible that this format is binary?! (from old versions of SO)
846 uno::Reference < io::XInputStream > xStm;
847 TransferableObjectDescriptor aObjDesc;
848
849 if (aDataHelper.GetTransferableObjectDescriptor(SotClipboardFormatId::OBJECTDESCRIPTOR, aObjDesc))
850 {
851 OUString aDocShellID = SfxObjectShell::CreateShellID(mrDoc.GetDocSh());
852 xStm = aDataHelper.GetInputStream(nFormat != SotClipboardFormatId::NONE ? nFormat : SotClipboardFormatId::EMBED_SOURCE, aDocShellID);
853 if (!xStm.is())
854 xStm = aDataHelper.GetInputStream(SotClipboardFormatId::EMBEDDED_OBJ, aDocShellID);
855 }
856
857 if (xStm.is())
858 {
859 if( mrDoc.GetDocSh() && ( mrDoc.GetDocSh()->GetClassName() == aObjDesc.maClassName ) )
860 {
861 uno::Reference < embed::XStorage > xStore( ::comphelper::OStorageHelper::GetStorageFromInputStream( xStm ) );
862 ::sd::DrawDocShellRef xDocShRef( new ::sd::DrawDocShell( SfxObjectCreateMode::EMBEDDED, true, mrDoc.GetDocumentType() ) );
863
864 // mba: BaseURL doesn't make sense for clipboard functionality
865 SfxMedium *pMedium = new SfxMedium( xStore, OUString() );
866 if( xDocShRef->DoLoad( pMedium ) )
867 {
868 SdDrawDocument* pModel = xDocShRef->GetDoc();
869 SdPage* pWorkPage = pModel->GetSdPage( 0, PK_STANDARD );
870
871 pWorkPage->SetRectsDirty();
872
873 if( pOwnData )
874 {
875 // #i120393# Clipboard data uses full object geometry range
876 const Size aSize( pWorkPage->GetAllObjBoundRect().GetSize() );
877
878 maDropPos.X() = pOwnData->GetStartPos().X() + ( aSize.Width() >> 1 );
879 maDropPos.Y() = pOwnData->GetStartPos().Y() + ( aSize.Height() >> 1 );
880 }
881
882 // delete pages, that are not of any interest for us
883 for( long i = ( pModel->GetPageCount() - 1 ); i >= 0; i-- )
884 {
885 SdPage* pP = static_cast< SdPage* >( pModel->GetPage( (sal_uInt16) i ) );
886
887 if( pP->GetPageKind() != PK_STANDARD )
888 pModel->DeletePage( (sal_uInt16) i );
889 }
890
891 bReturn = Paste(*pModel, maDropPos, pPage, nPasteOptions, OUString(), OUString());
892
893 if( !pPage )
894 pPage = static_cast<SdPage*>(GetSdrPageView()->GetPage());
895
896 OUString aLayout = pPage->GetLayoutName();
897 sal_Int32 nPos = aLayout.indexOf(SD_LT_SEPARATOR);
898 if (nPos != -1)
899 aLayout = aLayout.copy(0, nPos);
900 pPage->SetPresentationLayout( aLayout, false, false );
901 }
902
903 xDocShRef->DoClose();
904 xDocShRef.Clear();
905
906 }
907 else
908 {
909 OUString aName;
910 uno::Reference < embed::XEmbeddedObject > xObj = mpDocSh->GetEmbeddedObjectContainer().InsertEmbeddedObject( xStm, aName );
911 if ( xObj.is() )
912 {
913 svt::EmbeddedObjectRef aObjRef( xObj, aObjDesc.mnViewAspect );
914
915 // try to get the replacement image from the clipboard
916 Graphic aGraphic;
917 SotClipboardFormatId nGrFormat = SotClipboardFormatId::NONE;
918
919 // insert replacement image ( if there is one ) into the object helper
920 if ( nGrFormat != SotClipboardFormatId::NONE )
921 {
922 datatransfer::DataFlavor aDataFlavor;
923 SotExchange::GetFormatDataFlavor( nGrFormat, aDataFlavor );
924 aObjRef.SetGraphic( aGraphic, aDataFlavor.MimeType );
925 }
926
927 Size aSize;
928 if ( aObjDesc.mnViewAspect == embed::Aspects::MSOLE_ICON )
929 {
930 if( aObjDesc.maSize.Width() && aObjDesc.maSize.Height() )
931 aSize = aObjDesc.maSize;
932 else
933 {
934 MapMode aMapMode( MAP_100TH_MM );
935 aSize = aObjRef.GetSize( &aMapMode );
936 }
937 }
938 else
939 {
940 awt::Size aSz;
941 MapUnit aMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( aObjDesc.mnViewAspect ) );
942 if( aObjDesc.maSize.Width() && aObjDesc.maSize.Height() )
943 {
944 Size aTmp( OutputDevice::LogicToLogic( aObjDesc.maSize, MAP_100TH_MM, aMapUnit ) );
945 aSz.Width = aTmp.Width();
946 aSz.Height = aTmp.Height();
947 xObj->setVisualAreaSize( aObjDesc.mnViewAspect, aSz );
948 }
949
950 try
951 {
952 aSz = xObj->getVisualAreaSize( aObjDesc.mnViewAspect );
953 }
954 catch( embed::NoVisualAreaSizeException& )
955 {
956 // if the size still was not set the default size will be set later
957 }
958
959 aSize = Size( aSz.Width, aSz.Height );
960
961 if( !aSize.Width() || !aSize.Height() )
962 {
963 aSize.Width() = 14100;
964 aSize.Height() = 10000;
965 aSize = OutputDevice::LogicToLogic( Size(14100, 10000), MAP_100TH_MM, aMapUnit );
966 aSz.Width = aSize.Width();
967 aSz.Height = aSize.Height();
968 xObj->setVisualAreaSize( aObjDesc.mnViewAspect, aSz );
969 }
970
971 aSize = OutputDevice::LogicToLogic( aSize, aMapUnit, MAP_100TH_MM );
972 }
973
974 Size aMaxSize( mrDoc.GetMaxObjSize() );
975
976 maDropPos.X() -= std::min( aSize.Width(), aMaxSize.Width() ) >> 1;
977 maDropPos.Y() -= std::min( aSize.Height(), aMaxSize.Height() ) >> 1;
978
979 Rectangle aRect( maDropPos, aSize );
980 SdrOle2Obj* pObj = new SdrOle2Obj( aObjRef, aName, aRect );
981 SdrPageView* pPV = GetSdrPageView();
982 SdrInsertFlags nOptions = SdrInsertFlags::SETDEFLAYER;
983
984 if (mpViewSh!=NULL)
985 {
986 OSL_ASSERT (mpViewSh->GetViewShell()!=NULL);
987 SfxInPlaceClient* pIpClient
988 = mpViewSh->GetViewShell()->GetIPClient();
989 if (pIpClient!=NULL && pIpClient->IsObjectInPlaceActive())
990 nOptions |= SdrInsertFlags::DONTMARK;
991 }
992
993 InsertObjectAtView( pObj, *pPV, nOptions );
994
995 if( pImageMap )
996 pObj->AppendUserData( new SdIMapInfo( *pImageMap ) );
997
998 if (pObj->IsChart())
999 {
1000 bool bDisableDataTableDialog = false;
1001 svt::EmbeddedObjectRef::TryRunningState( xObj );
1002 uno::Reference< beans::XPropertySet > xProps( xObj->getComponent(), uno::UNO_QUERY );
1003 if ( xProps.is() &&
1004 ( xProps->getPropertyValue( "DisableDataTableDialog" ) >>= bDisableDataTableDialog ) &&
1005 bDisableDataTableDialog )
1006 {
1007 xProps->setPropertyValue( "DisableDataTableDialog" , uno::makeAny( sal_False ) );
1008 xProps->setPropertyValue( "DisableComplexChartTypes" , uno::makeAny( sal_False ) );
1009 uno::Reference< util::XModifiable > xModifiable( xProps, uno::UNO_QUERY );
1010 if ( xModifiable.is() )
1011 {
1012 xModifiable->setModified( sal_True );
1013 }
1014 }
1015 }
1016
1017 bReturn = true;
1018 }
1019 }
1020 }
1021 }
1022
1023 if(!bReturn &&
1024 !bLink &&
1025 (CHECK_FORMAT_TRANS(SotClipboardFormatId::EMBEDDED_OBJ_OLE) || CHECK_FORMAT_TRANS(SotClipboardFormatId::EMBED_SOURCE_OLE)) &&
1026 aDataHelper.HasFormat(SotClipboardFormatId::OBJECTDESCRIPTOR_OLE))
1027 {
1028 // online insert ole if format is forced or no gdi metafile is available
1029 if( (nFormat != SotClipboardFormatId::NONE) || !aDataHelper.HasFormat( SotClipboardFormatId::GDIMETAFILE ) )
1030 {
1031 uno::Reference < io::XInputStream > xStm;
1032 TransferableObjectDescriptor aObjDesc;
1033
1034 if ( aDataHelper.GetTransferableObjectDescriptor( SotClipboardFormatId::OBJECTDESCRIPTOR_OLE, aObjDesc ) )
1035 {
1036 uno::Reference < embed::XEmbeddedObject > xObj;
1037 OUString aName;
1038
1039 xStm = aDataHelper.GetInputStream(nFormat != SotClipboardFormatId::NONE ? nFormat : SotClipboardFormatId::EMBED_SOURCE_OLE, OUString());
1040 if (!xStm.is())
1041 xStm = aDataHelper.GetInputStream(SotClipboardFormatId::EMBEDDED_OBJ_OLE, OUString());
1042
1043 if (xStm.is())
1044 {
1045 xObj = mpDocSh->GetEmbeddedObjectContainer().InsertEmbeddedObject( xStm, aName );
1046 }
1047 else
1048 {
1049 try
1050 {
1051 uno::Reference< embed::XStorage > xTmpStor = ::comphelper::OStorageHelper::GetTemporaryStorage();
1052 uno::Reference < embed::XEmbedObjectClipboardCreator > xClipboardCreator =
1053 embed::MSOLEObjectSystemCreator::create( ::comphelper::getProcessComponentContext() );
1054
1055 embed::InsertedObjectInfo aInfo = xClipboardCreator->createInstanceInitFromClipboard(
1056 xTmpStor,
1057 "DummyName" ,
1058 uno::Sequence< beans::PropertyValue >() );
1059
1060 // TODO/LATER: in future InsertedObjectInfo will be used to get container related information
1061 // for example whether the object should be an iconified one
1062 xObj = aInfo.Object;
1063 if ( xObj.is() )
1064 mpDocSh->GetEmbeddedObjectContainer().InsertEmbeddedObject( xObj, aName );
1065 }
1066 catch( uno::Exception& )
1067 {}
1068 }
1069
1070 if ( xObj.is() )
1071 {
1072 svt::EmbeddedObjectRef aObjRef( xObj, aObjDesc.mnViewAspect );
1073
1074 // try to get the replacement image from the clipboard
1075 Graphic aGraphic;
1076 SotClipboardFormatId nGrFormat = SotClipboardFormatId::NONE;
1077
1078 // (wg. Selection Manager bei Trustet Solaris)
1079 #ifndef SOLARIS
1080 if( aDataHelper.GetGraphic( SotClipboardFormatId::SVXB, aGraphic ) )
1081 nGrFormat = SotClipboardFormatId::SVXB;
1082 else if( aDataHelper.GetGraphic( SotClipboardFormatId::GDIMETAFILE, aGraphic ) )
1083 nGrFormat = SotClipboardFormatId::GDIMETAFILE;
1084 else if( aDataHelper.GetGraphic( SotClipboardFormatId::BITMAP, aGraphic ) )
1085 nGrFormat = SotClipboardFormatId::BITMAP;
1086 #endif
1087
1088 // insert replacement image ( if there is one ) into the object helper
1089 if ( nGrFormat != SotClipboardFormatId::NONE )
1090 {
1091 datatransfer::DataFlavor aDataFlavor;
1092 SotExchange::GetFormatDataFlavor( nGrFormat, aDataFlavor );
1093 aObjRef.SetGraphic( aGraphic, aDataFlavor.MimeType );
1094 }
1095
1096 Size aSize;
1097 if ( aObjDesc.mnViewAspect == embed::Aspects::MSOLE_ICON )
1098 {
1099 if( aObjDesc.maSize.Width() && aObjDesc.maSize.Height() )
1100 aSize = aObjDesc.maSize;
1101 else
1102 {
1103 MapMode aMapMode( MAP_100TH_MM );
1104 aSize = aObjRef.GetSize( &aMapMode );
1105 }
1106 }
1107 else
1108 {
1109 MapUnit aMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( aObjDesc.mnViewAspect ) );
1110
1111 awt::Size aSz;
1112 try{
1113 aSz = xObj->getVisualAreaSize( aObjDesc.mnViewAspect );
1114 }
1115 catch( embed::NoVisualAreaSizeException& )
1116 {
1117 // the default size will be set later
1118 }
1119
1120 if( aObjDesc.maSize.Width() && aObjDesc.maSize.Height() )
1121 {
1122 Size aTmp( OutputDevice::LogicToLogic( aObjDesc.maSize, MAP_100TH_MM, aMapUnit ) );
1123 if ( aSz.Width != aTmp.Width() || aSz.Height != aTmp.Height() )
1124 {
1125 aSz.Width = aTmp.Width();
1126 aSz.Height = aTmp.Height();
1127 xObj->setVisualAreaSize( aObjDesc.mnViewAspect, aSz );
1128 }
1129 }
1130
1131 aSize = Size( aSz.Width, aSz.Height );
1132
1133 if( !aSize.Width() || !aSize.Height() )
1134 {
1135 aSize = OutputDevice::LogicToLogic( Size(14100, 10000), MAP_100TH_MM, aMapUnit );
1136 aSz.Width = aSize.Width();
1137 aSz.Height = aSize.Height();
1138 xObj->setVisualAreaSize( aObjDesc.mnViewAspect, aSz );
1139 }
1140
1141 aSize = OutputDevice::LogicToLogic( aSize, aMapUnit, MAP_100TH_MM );
1142 }
1143
1144 Size aMaxSize( mrDoc.GetMaxObjSize() );
1145
1146 maDropPos.X() -= std::min( aSize.Width(), aMaxSize.Width() ) >> 1;
1147 maDropPos.Y() -= std::min( aSize.Height(), aMaxSize.Height() ) >> 1;
1148
1149 Rectangle aRect( maDropPos, aSize );
1150 SdrOle2Obj* pObj = new SdrOle2Obj( aObjRef, aName, aRect );
1151 SdrPageView* pPV = GetSdrPageView();
1152 SdrInsertFlags nOptions = SdrInsertFlags::SETDEFLAYER;
1153
1154 if (mpViewSh!=NULL)
1155 {
1156 OSL_ASSERT (mpViewSh->GetViewShell()!=NULL);
1157 SfxInPlaceClient* pIpClient
1158 = mpViewSh->GetViewShell()->GetIPClient();
1159 if (pIpClient!=NULL && pIpClient->IsObjectInPlaceActive())
1160 nOptions |= SdrInsertFlags::DONTMARK;
1161 }
1162
1163 InsertObjectAtView( pObj, *pPV, nOptions );
1164
1165 if( pImageMap )
1166 pObj->AppendUserData( new SdIMapInfo( *pImageMap ) );
1167
1168 // let the object stay in loaded state after insertion
1169 pObj->Unload();
1170 bReturn = true;
1171 }
1172 }
1173 }
1174
1175 if( !bReturn && aDataHelper.HasFormat( SotClipboardFormatId::GDIMETAFILE ) )
1176 {
1177 // if no object was inserted, insert a picture
1178 InsertMetaFile( aDataHelper, rPos, pImageMap.get(), true );
1179 bReturn = true;
1180 }
1181 }
1182
1183 if(!bReturn && (!bLink || pPickObj) && CHECK_FORMAT_TRANS(SotClipboardFormatId::SVXB))
1184 {
1185 ::tools::SvRef<SotStorageStream> xStm;
1186
1187 if( aDataHelper.GetSotStorageStream( SotClipboardFormatId::SVXB, xStm ) )
1188 {
1189 Point aInsertPos( rPos );
1190 Graphic aGraphic;
1191
1192 ReadGraphic( *xStm, aGraphic );
1193
1194 if( pOwnData && pOwnData->GetWorkDocument() )
1195 {
1196 const SdDrawDocument* pWorkModel = pOwnData->GetWorkDocument();
1197 SdrPage* pWorkPage = const_cast<SdrPage*>( ( pWorkModel->GetPageCount() > 1 ) ?
1198 pWorkModel->GetSdPage( 0, PK_STANDARD ) :
1199 pWorkModel->GetPage( 0 ) );
1200
1201 pWorkPage->SetRectsDirty();
1202
1203 // #i120393# Clipboard data uses full object geometry range
1204 const Size aSize( pWorkPage->GetAllObjBoundRect().GetSize() );
1205
1206 aInsertPos.X() = pOwnData->GetStartPos().X() + ( aSize.Width() >> 1 );
1207 aInsertPos.Y() = pOwnData->GetStartPos().Y() + ( aSize.Height() >> 1 );
1208 }
1209
1210 // restrict movement to WorkArea
1211 Size aImageMapSize = OutputDevice::LogicToLogic(aGraphic.GetPrefSize(),
1212 aGraphic.GetPrefMapMode(), MapMode(MAP_100TH_MM));
1213
1214 ImpCheckInsertPos(aInsertPos, aImageMapSize, GetWorkArea());
1215
1216 InsertGraphic( aGraphic, mnAction, aInsertPos, NULL, pImageMap.get() );
1217 bReturn = true;
1218 }
1219 }
1220
1221 if(!bReturn && (!bLink || pPickObj) && CHECK_FORMAT_TRANS(SotClipboardFormatId::GDIMETAFILE))
1222 {
1223 Point aInsertPos( rPos );
1224
1225 if( pOwnData && pOwnData->GetWorkDocument() )
1226
1227 {
1228 const SdDrawDocument* pWorkModel = pOwnData->GetWorkDocument();
1229 SdrPage* pWorkPage = const_cast<SdrPage*>( ( pWorkModel->GetPageCount() > 1 ) ?
1230 pWorkModel->GetSdPage( 0, PK_STANDARD ) :
1231 pWorkModel->GetPage( 0 ) );
1232
1233 pWorkPage->SetRectsDirty();
1234
1235 // #i120393# Clipboard data uses full object geometry range
1236 const Size aSize( pWorkPage->GetAllObjBoundRect().GetSize() );
1237
1238 aInsertPos.X() = pOwnData->GetStartPos().X() + ( aSize.Width() >> 1 );
1239 aInsertPos.Y() = pOwnData->GetStartPos().Y() + ( aSize.Height() >> 1 );
1240 }
1241
1242 bReturn = InsertMetaFile( aDataHelper, aInsertPos, pImageMap.get(), nFormat == SotClipboardFormatId::NONE );
1243 }
1244
1245 if(!bReturn && (!bLink || pPickObj) && CHECK_FORMAT_TRANS(SotClipboardFormatId::BITMAP))
1246 {
1247 BitmapEx aBmpEx;
1248
1249 // get basic Bitmap data
1250 aDataHelper.GetBitmapEx(SotClipboardFormatId::BITMAP, aBmpEx);
1251
1252 if(aBmpEx.IsEmpty())
1253 {
1254 // if this did not work, try to get graphic formats and convert these to bitmap
1255 Graphic aGraphic;
1256
1257 if(aDataHelper.GetGraphic(SotClipboardFormatId::GDIMETAFILE, aGraphic))
1258 {
1259 aBmpEx = aGraphic.GetBitmapEx();
1260 }
1261 else if(aDataHelper.GetGraphic(SotClipboardFormatId::SVXB, aGraphic))
1262 {
1263 aBmpEx = aGraphic.GetBitmapEx();
1264 }
1265 else if(aDataHelper.GetGraphic(SotClipboardFormatId::BITMAP, aGraphic))
1266 {
1267 aBmpEx = aGraphic.GetBitmapEx();
1268 }
1269 }
1270
1271 if(!aBmpEx.IsEmpty())
1272 {
1273 Point aInsertPos( rPos );
1274
1275 if( pOwnData && pOwnData->GetWorkDocument() )
1276 {
1277 const SdDrawDocument* pWorkModel = pOwnData->GetWorkDocument();
1278 SdrPage* pWorkPage = const_cast<SdrPage*>( ( pWorkModel->GetPageCount() > 1 ) ?
1279 pWorkModel->GetSdPage( 0, PK_STANDARD ) :
1280 pWorkModel->GetPage( 0 ) );
1281
1282 pWorkPage->SetRectsDirty();
1283
1284 // #i120393# Clipboard data uses full object geometry range
1285 const Size aSize( pWorkPage->GetAllObjBoundRect().GetSize() );
1286
1287 aInsertPos.X() = pOwnData->GetStartPos().X() + ( aSize.Width() >> 1 );
1288 aInsertPos.Y() = pOwnData->GetStartPos().Y() + ( aSize.Height() >> 1 );
1289 }
1290
1291 // restrict movement to WorkArea
1292 Size aImageMapSize(aBmpEx.GetPrefSize());
1293 ImpCheckInsertPos(aInsertPos, aImageMapSize, GetWorkArea());
1294
1295 InsertGraphic( aBmpEx, mnAction, aInsertPos, NULL, pImageMap.get() );
1296 bReturn = true;
1297 }
1298 }
1299
1300 if(!bReturn && pPickObj && CHECK_FORMAT_TRANS( SotClipboardFormatId::XFA ) )
1301 {
1302 ::tools::SvRef<SotStorageStream> xStm;
1303
1304 if( aDataHelper.GetSotStorageStream( SotClipboardFormatId::XFA, xStm ) )
1305 {
1306 XFillExchangeData aFillData( XFillAttrSetItem( &mrDoc.GetPool() ) );
1307
1308 ReadXFillExchangeData( *xStm, aFillData );
1309
1310 if( IsUndoEnabled() )
1311 {
1312 BegUndo( SD_RESSTR(STR_UNDO_DRAGDROP) );
1313 AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoAttrObject( *pPickObj ) );
1314 EndUndo();
1315 }
1316
1317 XFillAttrSetItem* pSetItem = aFillData.GetXFillAttrSetItem();
1318 SfxItemSet rSet = pSetItem->GetItemSet();
1319 drawing::FillStyle eFill = static_cast<const XFillStyleItem&>( rSet.Get( XATTR_FILLSTYLE ) ).GetValue();
1320
1321 if( eFill == drawing::FillStyle_SOLID || eFill == drawing::FillStyle_NONE )
1322 {
1323 const XFillColorItem& rColItem = static_cast<const XFillColorItem&>( rSet.Get( XATTR_FILLCOLOR ) );
1324 Color aColor( rColItem.GetColorValue() );
1325 OUString aName( rColItem.GetName() );
1326 SfxItemSet aSet( mrDoc.GetPool() );
1327 bool bClosed = pPickObj->IsClosedObj();
1328 ::sd::Window* pWin = mpViewSh->GetActiveWindow();
1329 sal_uInt16 nHitLog = (sal_uInt16) pWin->PixelToLogic(
1330 Size(FuPoor::HITPIX, 0 ) ).Width();
1331 const long n2HitLog = nHitLog << 1;
1332 Point aHitPosR( rPos );
1333 Point aHitPosL( rPos );
1334 Point aHitPosT( rPos );
1335 Point aHitPosB( rPos );
1336 const SetOfByte* pVisiLayer = &GetSdrPageView()->GetVisibleLayers();
1337
1338 aHitPosR.X() += n2HitLog;
1339 aHitPosL.X() -= n2HitLog;
1340 aHitPosT.Y() += n2HitLog;
1341 aHitPosB.Y() -= n2HitLog;
1342
1343 if( bClosed &&
1344 SdrObjectPrimitiveHit(*pPickObj, aHitPosR, nHitLog, *GetSdrPageView(), pVisiLayer, false) &&
1345 SdrObjectPrimitiveHit(*pPickObj, aHitPosL, nHitLog, *GetSdrPageView(), pVisiLayer, false) &&
1346 SdrObjectPrimitiveHit(*pPickObj, aHitPosT, nHitLog, *GetSdrPageView(), pVisiLayer, false) &&
1347 SdrObjectPrimitiveHit(*pPickObj, aHitPosB, nHitLog, *GetSdrPageView(), pVisiLayer, false) )
1348 {
1349 // area fill
1350 if(eFill == drawing::FillStyle_SOLID )
1351 aSet.Put(XFillColorItem(aName, aColor));
1352
1353 aSet.Put( XFillStyleItem( eFill ) );
1354 }
1355 else
1356 aSet.Put( XLineColorItem( aName, aColor ) );
1357
1358 // add text color
1359 pPickObj->SetMergedItemSetAndBroadcast( aSet );
1360 }
1361 bReturn = true;
1362 }
1363 }
1364
1365 if(!bReturn && !bLink && CHECK_FORMAT_TRANS(SotClipboardFormatId::HTML))
1366 {
1367 ::tools::SvRef<SotStorageStream> xStm;
1368
1369 if( aDataHelper.GetSotStorageStream( SotClipboardFormatId::HTML, xStm ) )
1370 {
1371 xStm->Seek( 0 );
1372 // mba: clipboard always must contain absolute URLs (could be from alien source)
1373 bReturn = SdrView::Paste( *xStm, OUString(), EE_FORMAT_HTML, maDropPos, pPage, nPasteOptions );
1374 }
1375 }
1376
1377 if(!bReturn && !bLink && CHECK_FORMAT_TRANS(SotClipboardFormatId::EDITENGINE))
1378 {
1379 ::tools::SvRef<SotStorageStream> xStm;
1380
1381 if( aDataHelper.GetSotStorageStream( SotClipboardFormatId::EDITENGINE, xStm ) )
1382 {
1383 OutlinerView* pOLV = GetTextEditOutlinerView();
1384
1385 xStm->Seek( 0 );
1386
1387 if( pOLV )
1388 {
1389 Rectangle aRect( pOLV->GetOutputArea() );
1390 Point aPos( pOLV->GetWindow()->PixelToLogic( maDropPos ) );
1391
1392 if( aRect.IsInside( aPos ) || ( !bDrag && IsTextEdit() ) )
1393 {
1394 // mba: clipboard always must contain absolute URLs (could be from alien source)
1395 pOLV->Read( *xStm, OUString(), EE_FORMAT_BIN, false, mpDocSh->GetHeaderAttributes() );
1396 bReturn = true;
1397 }
1398 }
1399
1400 if( !bReturn )
1401 // mba: clipboard always must contain absolute URLs (could be from alien source)
1402 bReturn = SdrView::Paste( *xStm, OUString(), EE_FORMAT_BIN, maDropPos, pPage, nPasteOptions );
1403 }
1404 }
1405
1406 if(!bReturn && !bLink && CHECK_FORMAT_TRANS(SotClipboardFormatId::RTF))
1407 {
1408 ::tools::SvRef<SotStorageStream> xStm;
1409
1410 if( aDataHelper.GetSotStorageStream( SotClipboardFormatId::RTF, xStm ) )
1411 {
1412 xStm->Seek( 0 );
1413
1414 if( bTable )
1415 {
1416 bReturn = PasteRTFTable( xStm, pPage, nPasteOptions );
1417 }
1418 else
1419 {
1420 OutlinerView* pOLV = GetTextEditOutlinerView();
1421
1422 if( pOLV )
1423 {
1424 Rectangle aRect( pOLV->GetOutputArea() );
1425 Point aPos( pOLV->GetWindow()->PixelToLogic( maDropPos ) );
1426
1427 if( aRect.IsInside( aPos ) || ( !bDrag && IsTextEdit() ) )
1428 {
1429 // mba: clipboard always must contain absolute URLs (could be from alien source)
1430 pOLV->Read( *xStm, OUString(), EE_FORMAT_RTF, false, mpDocSh->GetHeaderAttributes() );
1431 bReturn = true;
1432 }
1433 }
1434
1435 if( !bReturn )
1436 // mba: clipboard always must contain absolute URLs (could be from alien source)
1437 bReturn = SdrView::Paste( *xStm, OUString(), EE_FORMAT_RTF, maDropPos, pPage, nPasteOptions );
1438 }
1439 }
1440 }
1441
1442 if(!bReturn && CHECK_FORMAT_TRANS(SotClipboardFormatId::FILE_LIST))
1443 {
1444 FileList aDropFileList;
1445
1446 if( aDataHelper.GetFileList( SotClipboardFormatId::FILE_LIST, aDropFileList ) )
1447 {
1448 maDropFileVector.clear();
1449
1450 for( sal_uLong i = 0, nCount = aDropFileList.Count(); i < nCount; i++ )
1451 maDropFileVector.push_back( aDropFileList.GetFile( i ) );
1452
1453 maDropInsertFileIdle.Start();
1454 }
1455
1456 bReturn = true;
1457 }
1458
1459 if(!bReturn && CHECK_FORMAT_TRANS(SotClipboardFormatId::SIMPLE_FILE))
1460 {
1461 OUString aDropFile;
1462
1463 if( aDataHelper.GetString( SotClipboardFormatId::SIMPLE_FILE, aDropFile ) )
1464 {
1465 maDropFileVector.clear();
1466 maDropFileVector.push_back( aDropFile );
1467 maDropInsertFileIdle.Start();
1468 }
1469
1470 bReturn = true;
1471 }
1472
1473 if(!bReturn && !bLink && CHECK_FORMAT_TRANS(SotClipboardFormatId::STRING))
1474 {
1475 if( ( SotClipboardFormatId::STRING == nFormat ) ||
1476 ( !aDataHelper.HasFormat( SotClipboardFormatId::SOLK ) &&
1477 !aDataHelper.HasFormat( SotClipboardFormatId::NETSCAPE_BOOKMARK ) &&
1478 !aDataHelper.HasFormat( SotClipboardFormatId::FILENAME ) ) )
1479 {
1480 OUString aOUString;
1481
1482 if( aDataHelper.GetString( SotClipboardFormatId::STRING, aOUString ) )
1483 {
1484 OutlinerView* pOLV = GetTextEditOutlinerView();
1485
1486 if( pOLV )
1487 {
1488 pOLV->InsertText( aOUString );
1489 bReturn = true;
1490 }
1491
1492 if( !bReturn )
1493 bReturn = SdrView::Paste( aOUString, maDropPos, pPage, nPasteOptions );
1494 }
1495 }
1496 }
1497
1498 MarkListHasChanged();
1499 mbIsDropAllowed = true;
1500 rDnDAction = mnAction;
1501
1502 return bReturn;
1503 }
1504
1505 bool View::PasteRTFTable( ::tools::SvRef<SotStorageStream> xStm, SdrPage* pPage, SdrInsertFlags nPasteOptions )
1506 {
1507 boost::scoped_ptr<SdDrawDocument> pModel(new SdDrawDocument( DOCUMENT_TYPE_IMPRESS, mpDocSh ));
1508 pModel->NewOrLoadCompleted(NEW_DOC);
1509 pModel->GetItemPool().SetDefaultMetric(SFX_MAPUNIT_100TH_MM);
1510 pModel->InsertPage(pModel->AllocPage(false));
1511
1512 Reference< XComponent > xComponent( new SdXImpressDocument( pModel.get(), true ) );
1513 pModel->setUnoModel( Reference< XInterface >::query( xComponent ) );
1514
1515 CreateTableFromRTF( *xStm, pModel.get() );
1516 bool bRet = Paste(*pModel, maDropPos, pPage, nPasteOptions, OUString(), OUString());
1517
1518 xComponent->dispose();
1519 xComponent.clear();
1520
1521 return bRet;
1522 }
1523
1524 } // end of namespace sd
1525
1526 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE