sd/source/ui/view/sdview2.cxx

   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
  22 #include <vector>
  23 #include <com/sun/star/embed/XEmbedPersist.hpp>
  24 #include <tools/urlobj.hxx>
  25 #include <vcl/msgbox.hxx>
  26 #include <svx/svdetc.hxx>
  27 #include <svx/svdoole2.hxx>
  28 #include <svx/svdograf.hxx>
  29 #include <vcl/graph.hxx>
  30 #include <svx/xexch.hxx>
  31 #include <svx/svxdlg.hxx>
  32 #include <svx/dialogs.hrc>
  33 #include <sfx2/docfile.hxx>
  34 #include <sfx2/childwin.hxx>
  35 #include <svx/svdundo.hxx>
  36 #include <svx/svdpagv.hxx>
  37 #include <svl/urlbmk.hxx>
  38 #include <editeng/outliner.hxx>
  39 #include <svx/xflclit.hxx>
  40 #include <sot/formats.hxx>
  41 #include <editeng/editeng.hxx>
  42 #include <svx/svditer.hxx>
  43 #include <svx/obj3d.hxx>
  44 #include <svx/scene3d.hxx>
  45
  46 #include <sfx2/objsh.hxx>
  47 #include <svtools/embedtransfer.hxx>
  48
  49 #include "navigatr.hxx"
  50 #include "anminfo.hxx"
  51 #include "strings.hrc"
  52 #include "glob.hrc"
  53 #include "sdxfer.hxx"
  54 #include "sdresid.hxx"
  55 #include "sdmod.hxx"
  56 #include "DrawViewShell.hxx"
  57 #include "DrawDocShell.hxx"
  58 #include "fudraw.hxx"
  59 #include "drawdoc.hxx"
  60 #include "Window.hxx"
  61 #include "sdpage.hxx"
  62 #include "unoaprms.hxx"
  63 #include "drawview.hxx"
  64 #include "helpids.h"
  65 #include <vcl/svapp.hxx>
  66
  67 #include "slideshow.hxx"
  68 #include <boost/scoped_ptr.hpp>
  69
  70 namespace sd {
  71
  72 using namespace ::com::sun::star;
  73
  74 // - SdNavigatorDropEvent -
  75
  76 struct SdNavigatorDropEvent : public ExecuteDropEvent
  77 {
  78     DropTargetHelper&       mrTargetHelper;
  79     VclPtr< ::sd::Window>    mpTargetWindow;
  80     sal_uInt16                  mnPage;
  81     sal_uInt16                  mnLayer;
  82
  83     SdNavigatorDropEvent (
  84         const ExecuteDropEvent& rEvt,
  85         DropTargetHelper& rTargetHelper,
  86         ::sd::Window* pTargetWindow,
  87         sal_uInt16 nPage,
  88         sal_uInt16 nLayer )
  89         : ExecuteDropEvent( rEvt ),
  90           mrTargetHelper( rTargetHelper ),
  91           mpTargetWindow( pTargetWindow ),
  92           mnPage( nPage ),
  93           mnLayer( nLayer )
  94     {}
  95 };
  96
  97 ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable > View::CreateClipboardDataObject( View*, vcl::Window& )
  98 {
  99     // since SdTransferable::CopyToClipboard is called, this
 100     // dynamically created object ist destroyed automatically
 101     SdTransferable* pTransferable = new SdTransferable( &mrDoc, NULL, false );
 102     ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable > xRet( pTransferable );
 103
 104     SD_MOD()->pTransferClip = pTransferable;
 105
 106     mrDoc.CreatingDataObj( pTransferable );
 107     pTransferable->SetWorkDocument( static_cast<SdDrawDocument*>(GetMarkedObjModel()) );
 108     mrDoc.CreatingDataObj( NULL );
 109
 110     // #112978# need to use GetAllMarkedBoundRect instead of GetAllMarkedRect to get
 111     // fat lines correctly
 112     const Rectangle                 aMarkRect( GetAllMarkedBoundRect() );
 113     TransferableObjectDescriptor    aObjDesc;
 114     SdrOle2Obj*                     pSdrOleObj = NULL;
 115     SdrPageView*                    pPgView = GetSdrPageView();
 116     SdPage*                         pOldPage = pPgView ? static_cast<SdPage*>( pPgView->GetPage() ) : NULL;
 117     SdPage*                         pNewPage = const_cast<SdPage*>(static_cast<const SdPage*>( pTransferable->GetWorkDocument()->GetPage( 0 ) ));
 118
 119     if( pOldPage )
 120     {
 121         pNewPage->SetSize( pOldPage->GetSize() );
 122         pNewPage->SetLayoutName( pOldPage->GetLayoutName() );
 123     }
 124
 125     if( GetMarkedObjectCount() == 1 )
 126     {
 127         SdrObject* pObj = GetMarkedObjectByIndex(0);
 128
 129         if( pObj && pObj->ISA(SdrOle2Obj) && static_cast<SdrOle2Obj*>(pObj)->GetObjRef().is() )
 130         {
 131             // If object has no persistence it must be copied as part of the document
 132             try
 133             {
 134                 uno::Reference< embed::XEmbedPersist > xPersObj( static_cast<SdrOle2Obj*>(pObj)->GetObjRef(), uno::UNO_QUERY );
 135                 if ( xPersObj.is() && xPersObj->hasEntry() )
 136                      pSdrOleObj = static_cast<SdrOle2Obj*>(pObj);
 137             }
 138             catch( uno::Exception& )
 139             {}
 140         }
 141     }
 142
 143     if( pSdrOleObj )
 144         SvEmbedTransferHelper::FillTransferableObjectDescriptor( aObjDesc, pSdrOleObj->GetObjRef(), pSdrOleObj->GetGraphic(), pSdrOleObj->GetAspect() );
 145     else
 146         pTransferable->GetWorkDocument()->GetDocSh()->FillTransferableObjectDescriptor( aObjDesc );
 147
 148     if( mpDocSh )
 149         aObjDesc.maDisplayName = mpDocSh->GetMedium()->GetURLObject().GetURLNoPass();
 150
 151     aObjDesc.maSize = aMarkRect.GetSize();
 152
 153     pTransferable->SetStartPos( aMarkRect.TopLeft() );
 154     pTransferable->SetObjectDescriptor( aObjDesc );
 155     pTransferable->CopyToClipboard( mpViewSh->GetActiveWindow() );
 156
 157     return xRet;
 158 }
 159
 160 ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable > View::CreateDragDataObject( View* pWorkView, vcl::Window& rWindow, const Point& rDragPos )
 161 {
 162     SdTransferable* pTransferable = new SdTransferable( &mrDoc, pWorkView, false );
 163     ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable > xRet( pTransferable );
 164
 165     SD_MOD()->pTransferDrag = pTransferable;
 166
 167     TransferableObjectDescriptor    aObjDesc;
 168     OUString                        aDisplayName;
 169     SdrOle2Obj*                     pSdrOleObj = NULL;
 170
 171     if( GetMarkedObjectCount() == 1 )
 172     {
 173         SdrObject* pObj = GetMarkedObjectByIndex( 0 );
 174
 175         if( pObj && pObj->ISA( SdrOle2Obj ) && static_cast<SdrOle2Obj*>(pObj)->GetObjRef().is() )
 176         {
 177             // If object has no persistence it must be copied as part of the document
 178             try
 179             {
 180                 uno::Reference< embed::XEmbedPersist > xPersObj( static_cast<SdrOle2Obj*>(pObj)->GetObjRef(), uno::UNO_QUERY );
 181                 if ( xPersObj.is() && xPersObj->hasEntry() )
 182                      pSdrOleObj = static_cast<SdrOle2Obj*>(pObj);
 183             }
 184             catch( uno::Exception& )
 185             {}
 186         }
 187     }
 188
 189     if( mpDocSh )
 190         aDisplayName = mpDocSh->GetMedium()->GetURLObject().GetURLNoPass();
 191
 192     if( pSdrOleObj )
 193         SvEmbedTransferHelper::FillTransferableObjectDescriptor( aObjDesc, pSdrOleObj->GetObjRef(), pSdrOleObj->GetGraphic(), pSdrOleObj->GetAspect() );
 194     else if (mpDocSh)
 195         mpDocSh->FillTransferableObjectDescriptor( aObjDesc );
 196
 197     aObjDesc.maSize = GetAllMarkedRect().GetSize();
 198     aObjDesc.maDragStartPos = rDragPos;
 199     aObjDesc.maDisplayName = aDisplayName;
 200     aObjDesc.mbCanLink = false;
 201
 202     pTransferable->SetStartPos( rDragPos );
 203     pTransferable->SetObjectDescriptor( aObjDesc );
 204     pTransferable->StartDrag( &rWindow, DND_ACTION_COPYMOVE | DND_ACTION_LINK );
 205
 206     return xRet;
 207 }
 208
 209 ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable > View::CreateSelectionDataObject( View* pWorkView, vcl::Window& rWindow )
 210 {
 211     SdTransferable*                 pTransferable = new SdTransferable( &mrDoc, pWorkView, true );
 212     ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable > xRet( pTransferable );
 213     TransferableObjectDescriptor    aObjDesc;
 214     const Rectangle                 aMarkRect( GetAllMarkedRect() );
 215     OUString                        aDisplayName;
 216
 217     SD_MOD()->pTransferSelection = pTransferable;
 218
 219     if( mpDocSh )
 220     {
 221         aDisplayName = mpDocSh->GetMedium()->GetURLObject().GetURLNoPass();
 222         mpDocSh->FillTransferableObjectDescriptor( aObjDesc );
 223     }
 224
 225     aObjDesc.maSize = aMarkRect.GetSize();
 226
 227     pTransferable->SetStartPos( aMarkRect.TopLeft() );
 228     pTransferable->SetObjectDescriptor( aObjDesc );
 229     pTransferable->CopyToSelection( &rWindow );
 230
 231     return xRet;
 232 }
 233
 234 void View::UpdateSelectionClipboard( bool bForceDeselect )
 235 {
 236     if( mpViewSh && mpViewSh->GetActiveWindow() )
 237     {
 238         if( !bForceDeselect && GetMarkedObjectList().GetMarkCount() )
 239             CreateSelectionDataObject( this, *mpViewSh->GetActiveWindow() );
 240         else if( SD_MOD()->pTransferSelection && ( SD_MOD()->pTransferSelection->GetView() == this ) )
 241         {
 242             TransferableHelper::ClearSelection( mpViewSh->GetActiveWindow() );
 243             SD_MOD()->pTransferSelection = NULL;
 244         }
 245     }
 246 }
 247
 248 void View::DoCut(vcl::Window* )
 249 {
 250     const OutlinerView* pOLV = GetTextEditOutlinerView();
 251
 252     if( pOLV )
 253         const_cast<OutlinerView*>(pOLV)->Cut();
 254     else if( AreObjectsMarked() )
 255     {
 256         OUString aStr(SD_RESSTR(STR_UNDO_CUT));
 257
 258         DoCopy();
 259         BegUndo(aStr + " " + GetDescriptionOfMarkedObjects());
 260         DeleteMarked();
 261         EndUndo();
 262     }
 263 }
 264
 265 void View::DoCopy (vcl::Window* pWindow)
 266 {
 267     const OutlinerView* pOLV = GetTextEditOutlinerView();
 268
 269     if( pOLV )
 270         const_cast<OutlinerView*>(pOLV)->Copy();
 271     else if( AreObjectsMarked() )
 272     {
 273         BrkAction();
 274         CreateClipboardDataObject( this, *pWindow );
 275     }
 276 }
 277
 278 void View::DoPaste (vcl::Window* pWindow)
 279 {
 280     TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( mpViewSh->GetActiveWindow() ) );
 281     if( !aDataHelper.GetTransferable().is() )
 282         return; // empty clipboard?
 283
 284     const OutlinerView* pOLV = GetTextEditOutlinerView();
 285
 286     if( pOLV && EditEngine::HasValidData( aDataHelper.GetTransferable() ) )
 287     {
 288         const_cast< OutlinerView* >(pOLV)->PasteSpecial();
 289
 290         SdrObject*  pObj = GetTextEditObject();
 291         SdPage*     pPage = static_cast<SdPage*>( pObj ? pObj->GetPage() : NULL );
 292         ::Outliner* pOutliner = pOLV->GetOutliner();
 293
 294         if( pOutliner)
 295         {
 296             if( pObj && pPage && pPage->GetPresObjKind(pObj) == PRESOBJ_TITLE )
 297             {
 298                 // remove all hard linebreaks from the title
 299                 if( pOutliner && pOutliner->GetParagraphCount() > 1 )
 300                 {
 301                     bool bOldUpdateMode = pOutliner->GetUpdateMode();
 302
 303                     pOutliner->SetUpdateMode( false );
 304
 305                     const EditEngine& rEdit = pOutliner->GetEditEngine();
 306                     const sal_Int32 nParaCount = rEdit.GetParagraphCount();
 307
 308                     for( sal_Int32 nPara = nParaCount - 2; nPara >= 0; nPara-- )
 309                     {
 310                         const sal_Int32 nParaLen = rEdit.GetTextLen( nPara );
 311                         pOutliner->QuickDelete( ESelection( nPara, nParaLen, nPara+1, 0 ) );
 312                         pOutliner->QuickInsertLineBreak( ESelection( nPara, nParaLen, nPara, nParaLen ) );
 313                     }
 314
 315                     DBG_ASSERT( rEdit.GetParagraphCount() <= 1, "Titleobject contains hard line breaks" );
 316                     pOutliner->SetUpdateMode(bOldUpdateMode);
 317                 }
 318             }
 319
 320             if( !mrDoc.IsChanged() )
 321             {
 322                 if( pOutliner && pOutliner->IsModified() )
 323                     mrDoc.SetChanged( true );
 324             }
 325         }
 326     }
 327     else
 328     {
 329         Point       aPos;
 330         sal_Int8    nDnDAction = DND_ACTION_COPY;
 331
 332         if( pWindow )
 333             aPos = pWindow->PixelToLogic( Rectangle( aPos, pWindow->GetOutputSizePixel() ).Center() );
 334
 335         DrawViewShell* pDrViewSh = static_cast<DrawViewShell*>( mpDocSh->GetViewShell() );
 336
 337         if (pDrViewSh != NULL)
 338         {
 339             if( !InsertData( aDataHelper, aPos, nDnDAction, false ) )
 340             {
 341                 INetBookmark    aINetBookmark( aEmptyStr, aEmptyStr );
 342
 343                 if( ( aDataHelper.HasFormat( SotClipboardFormatId::NETSCAPE_BOOKMARK ) &&
 344                       aDataHelper.GetINetBookmark( SotClipboardFormatId::NETSCAPE_BOOKMARK, aINetBookmark ) ) ||
 345                     ( aDataHelper.HasFormat( SotClipboardFormatId::FILEGRPDESCRIPTOR ) &&
 346                       aDataHelper.GetINetBookmark( SotClipboardFormatId::FILEGRPDESCRIPTOR, aINetBookmark ) ) ||
 347                     ( aDataHelper.HasFormat( SotClipboardFormatId::UNIFORMRESOURCELOCATOR ) &&
 348                       aDataHelper.GetINetBookmark( SotClipboardFormatId::UNIFORMRESOURCELOCATOR, aINetBookmark ) ) )
 349                 {
 350                     pDrViewSh->InsertURLField( aINetBookmark.GetURL(), aINetBookmark.GetDescription(), aEmptyStr, NULL );
 351                 }
 352             }
 353         }
 354     }
 355 }
 356
 357 void View::StartDrag( const Point& rStartPos, vcl::Window* pWindow )
 358 {
 359     if( AreObjectsMarked() && IsAction() && mpViewSh && pWindow && !mpDragSrcMarkList )
 360     {
 361         BrkAction();
 362
 363         if( IsTextEdit() )
 364             SdrEndTextEdit();
 365
 366         DrawViewShell* pDrawViewShell = dynamic_cast< DrawViewShell* >( mpDocSh ? mpDocSh->GetViewShell() : 0 );
 367
 368         if( pDrawViewShell )
 369         {
 370             rtl::Reference<FuPoor> xFunction( pDrawViewShell->GetCurrentFunction() );
 371
 372             if( xFunction.is() && xFunction->ISA( FuDraw ) )
 373                 static_cast<FuDraw*>(xFunction.get())->ForcePointer( NULL );
 374         }
 375
 376         mpDragSrcMarkList = new SdrMarkList(GetMarkedObjectList());
 377         mnDragSrcPgNum = GetSdrPageView()->GetPage()->GetPageNum();
 378
 379         if( IsUndoEnabled() )
 380         {
 381             OUString aStr(SD_RESSTR(STR_UNDO_DRAGDROP));
 382             BegUndo(aStr + " " + mpDragSrcMarkList->GetMarkDescription());
 383         }
 384         CreateDragDataObject( this, *pWindow, rStartPos );
 385     }
 386 }
 387
 388 void View::DragFinished( sal_Int8 nDropAction )
 389 {
 390     const bool bUndo = IsUndoEnabled();
 391
 392     SdTransferable* pDragTransferable = SD_MOD()->pTransferDrag;
 393
 394     if( pDragTransferable )
 395         pDragTransferable->SetView( NULL );
 396
 397     if( ( nDropAction & DND_ACTION_MOVE ) &&
 398         pDragTransferable && !pDragTransferable->IsInternalMove() &&
 399         mpDragSrcMarkList && mpDragSrcMarkList->GetMarkCount() &&
 400         !IsPresObjSelected() )
 401     {
 402         mpDragSrcMarkList->ForceSort();
 403
 404         if( bUndo )
 405             BegUndo();
 406
 407         const size_t nAnz = mpDragSrcMarkList->GetMarkCount();
 408
 409         for( size_t nm = nAnz; nm>0; )
 410         {
 411             --nm;
 412             SdrMark* pM=mpDragSrcMarkList->GetMark(nm);
 413             if( bUndo )
 414                 AddUndo(mrDoc.GetSdrUndoFactory().CreateUndoDeleteObject(*pM->GetMarkedSdrObj()));
 415         }
 416
 417         mpDragSrcMarkList->GetMark(0)->GetMarkedSdrObj()->GetOrdNum();
 418
 419         for (size_t nm = nAnz; nm>0;)
 420         {
 421             --nm;
 422             SdrMark* pM=mpDragSrcMarkList->GetMark(nm);
 423             SdrObject* pObj=pM->GetMarkedSdrObj();
 424
 425             if( pObj && pObj->GetPage() )
 426             {
 427                 const size_t nOrdNum = pObj->GetOrdNumDirect();
 428 #ifdef DBG_UTIL
 429                 SdrObject* pChkObj =
 430 #endif
 431                     pObj->GetPage()->RemoveObject(nOrdNum);
 432                 DBG_ASSERT(pChkObj==pObj,"pChkObj!=pObj in RemoveObject()");
 433             }
 434         }
 435
 436         if( bUndo )
 437             EndUndo();
 438     }
 439
 440     if( pDragTransferable )
 441         pDragTransferable->SetInternalMove( false );
 442
 443     if( bUndo )
 444         EndUndo();
 445     mnDragSrcPgNum = SDRPAGE_NOTFOUND;
 446     delete mpDragSrcMarkList;
 447     mpDragSrcMarkList = NULL;
 448 }
 449
 450 sal_Int8 View::AcceptDrop( const AcceptDropEvent& rEvt, DropTargetHelper& rTargetHelper,
 451                              ::sd::Window*, sal_uInt16, sal_uInt16 nLayer )
 452 {
 453     OUString        aLayerName = GetActiveLayer();
 454     SdrPageView*    pPV = GetSdrPageView();
 455     sal_Int8        nDropAction = rEvt.mnAction;
 456     sal_Int8        nRet = DND_ACTION_NONE;
 457
 458     if( nLayer != SDRLAYER_NOTFOUND )
 459     {
 460         SdrLayerAdmin& rLayerAdmin = mrDoc.GetLayerAdmin();
 461         aLayerName = rLayerAdmin.GetLayerPerID(nLayer)->GetName();
 462     }
 463
 464     if( mbIsDropAllowed && !pPV->IsLayerLocked( aLayerName ) && pPV->IsLayerVisible( aLayerName ) )
 465     {
 466         const OutlinerView* pOLV = GetTextEditOutlinerView();
 467         bool                bIsInsideOutlinerView = false;
 468
 469         if( pOLV )
 470         {
 471             Rectangle aRect( pOLV->GetOutputArea() );
 472
 473             if (GetMarkedObjectCount() == 1)
 474             {
 475                 SdrMark* pMark = GetSdrMarkByIndex(0);
 476                 SdrObject* pObj = pMark->GetMarkedSdrObj();
 477                 aRect.Union( pObj->GetLogicRect() );
 478             }
 479
 480             if( aRect.IsInside( pOLV->GetWindow()->PixelToLogic( rEvt.maPosPixel ) ) )
 481             {
 482                 bIsInsideOutlinerView = true;
 483             }
 484         }
 485
 486         if( !bIsInsideOutlinerView )
 487         {
 488             SdTransferable* pDragTransferable = SD_MOD()->pTransferDrag;
 489
 490             if(pDragTransferable && (nDropAction & DND_ACTION_LINK))
 491             {
 492                 // suppress own data when it's intention is to use it as fill information
 493                 pDragTransferable = 0;
 494             }
 495
 496             if( pDragTransferable )
 497             {
 498                 const View* pSourceView = pDragTransferable->GetView();
 499
 500                 if( pDragTransferable->IsPageTransferable() )
 501                 {
 502                     nRet = DND_ACTION_COPY;
 503                 }
 504                 else if( pSourceView )
 505                 {
 506                     if( !( nDropAction & DND_ACTION_LINK ) ||
 507                         !pSourceView->GetDocSh()->GetMedium()->GetName().isEmpty() )
 508                     {
 509                         nRet = nDropAction;
 510                     }
 511                 }
 512             }
 513             else
 514             {
 515                 const bool  bDrawing = rTargetHelper.IsDropFormatSupported( SotClipboardFormatId::DRAWING );
 516                 const bool  bGraphic = rTargetHelper.IsDropFormatSupported( SotClipboardFormatId::SVXB );
 517                 const bool  bMtf = rTargetHelper.IsDropFormatSupported( SotClipboardFormatId::GDIMETAFILE );
 518                 const bool  bBitmap = rTargetHelper.IsDropFormatSupported( SotClipboardFormatId::BITMAP );
 519                 bool        bBookmark = rTargetHelper.IsDropFormatSupported( SotClipboardFormatId::NETSCAPE_BOOKMARK );
 520                 bool        bXFillExchange = rTargetHelper.IsDropFormatSupported( SotClipboardFormatId::XFA );
 521
 522                 // check handle insert
 523                 if( !nRet && ( (bXFillExchange && ( SDRDRAG_GRADIENT == GetDragMode() )) || ( SDRDRAG_TRANSPARENCE == GetDragMode() ) ) )
 524                 {
 525                     const SdrHdlList& rHdlList = GetHdlList();
 526
 527                     for( size_t n = 0; n < rHdlList.GetHdlCount(); ++n )
 528                     {
 529                         SdrHdl* pIAOHandle = rHdlList.GetHdl( n );
 530
 531                         if( pIAOHandle && ( HDL_COLR == pIAOHandle->GetKind() ) )
 532                         {
 533                             if(pIAOHandle->getOverlayObjectList().isHitPixel(rEvt.maPosPixel))
 534                             {
 535                                 nRet = nDropAction;
 536                                 static_cast< SdrHdlColor* >( pIAOHandle )->SetSize( SDR_HANDLE_COLOR_SIZE_SELECTED );
 537                             }
 538                             else
 539                             {
 540                                 static_cast< SdrHdlColor* >( pIAOHandle )->SetSize( SDR_HANDLE_COLOR_SIZE_NORMAL );
 541                             }
 542                         }
 543                     }
 544                 }
 545
 546                 // check object insert
 547                 if( !nRet && ( bXFillExchange || ( ( bDrawing || bGraphic || bMtf || bBitmap || bBookmark ) && ( nDropAction & DND_ACTION_LINK ) ) ) )
 548                 {
 549                     SdrObject*      pPickObj = NULL;
 550                     SdrPageView*    pPageView = NULL;
 551                     ::sd::Window* pWindow = mpViewSh->GetActiveWindow();
 552                     Point           aPos( pWindow->PixelToLogic( rEvt.maPosPixel ) );
 553                     const bool      bHasPickObj = PickObj( aPos, getHitTolLog(), pPickObj, pPageView );
 554                     bool            bIsPresTarget = false;
 555
 556                     if( bHasPickObj && pPickObj && ( pPickObj->IsEmptyPresObj() || pPickObj->GetUserCall() ) )
 557                     {
 558                         SdPage* pPage = static_cast<SdPage*>( pPickObj->GetPage() );
 559
 560                         if( pPage && pPage->IsMasterPage() )
 561                             bIsPresTarget = pPage->IsPresObj( pPickObj );
 562                     }
 563
 564                     if( bHasPickObj && !bIsPresTarget &&
 565                         ( bGraphic || bMtf || bBitmap || bXFillExchange ) )
 566                     {
 567                         if( mpDropMarkerObj != pPickObj )
 568                         {
 569                             mpDropMarkerObj = pPickObj;
 570                             ImplClearDrawDropMarker();
 571
 572                             if(mpDropMarkerObj)
 573                             {
 574                                 mpDropMarker = new SdrDropMarkerOverlay(*this, *mpDropMarkerObj);
 575                             }
 576                         }
 577
 578                         nRet = nDropAction;
 579                     }
 580                     else
 581                         bXFillExchange = false;
 582                 }
 583
 584                 // check normal insert
 585                 if( !nRet )
 586                 {
 587                     const bool  bSBAFormat = rTargetHelper.IsDropFormatSupported( SotClipboardFormatId::SVX_FORMFIELDEXCH );
 588                     const bool  bEditEngine = rTargetHelper.IsDropFormatSupported( SotClipboardFormatId::EDITENGINE );
 589                     const bool  bString = rTargetHelper.IsDropFormatSupported( SotClipboardFormatId::STRING );
 590                     const bool  bRTF = rTargetHelper.IsDropFormatSupported( SotClipboardFormatId::RTF );
 591                     const bool  bFile = rTargetHelper.IsDropFormatSupported( SotClipboardFormatId::SIMPLE_FILE );
 592                     const bool  bFileList = rTargetHelper.IsDropFormatSupported( SotClipboardFormatId::FILE_LIST );
 593
 594                     if( mpDropMarker )
 595                     {
 596                         ImplClearDrawDropMarker();
 597                         mpDropMarkerObj = NULL;
 598                     }
 599
 600                     if( bBookmark && bFile && ( nDropAction & DND_ACTION_MOVE ) && mpViewSh && SlideShow::IsRunning(mpViewSh->GetViewShellBase()) )
 601                         bBookmark = false;
 602
 603                     if( bDrawing || bGraphic || bMtf || bBitmap || bBookmark || bFile || bFileList || bXFillExchange || bSBAFormat || bEditEngine || bString || bRTF )
 604                         nRet = nDropAction;
 605
 606                     // For entries from the navigator, change action copy.
 607                     if (bBookmark
 608                         && rTargetHelper.IsDropFormatSupported(
 609                             SdPageObjsTLB::SdPageObjsTransferable::GetListBoxDropFormatId())
 610                         && (nDropAction & DND_ACTION_MOVE)!=0)
 611                     {
 612                         nRet = DND_ACTION_COPY;
 613                     }
 614                 }
 615             }
 616         }
 617     }
 618
 619     // destroy drop marker if this is a leaving event
 620     if( rEvt.mbLeaving && mpDropMarker )
 621     {
 622         ImplClearDrawDropMarker();
 623         mpDropMarkerObj = NULL;
 624     }
 625
 626     return nRet;
 627 }
 628
 629 sal_Int8 View::ExecuteDrop( const ExecuteDropEvent& rEvt, DropTargetHelper& rTargetHelper,
 630                               ::sd::Window* pTargetWindow, sal_uInt16 nPage, sal_uInt16 nLayer )
 631 {
 632     SdrPageView*    pPV = GetSdrPageView();
 633     OUString        aActiveLayer = GetActiveLayer();
 634     sal_Int8        nDropAction = rEvt.mnAction;
 635     sal_Int8        nRet = DND_ACTION_NONE;
 636
 637     // destroy drop marker if it is shown
 638     if( mpDropMarker )
 639     {
 640         ImplClearDrawDropMarker();
 641         mpDropMarkerObj = NULL;
 642     }
 643
 644     if( !pPV->IsLayerLocked( aActiveLayer ) )
 645     {
 646         const OutlinerView* pOLV = GetTextEditOutlinerView();
 647         bool                bIsInsideOutlinerView = false;
 648
 649         if( pOLV )
 650         {
 651             Rectangle aRect( pOLV->GetOutputArea() );
 652
 653             if( GetMarkedObjectCount() == 1 )
 654             {
 655                 SdrMark* pMark = GetSdrMarkByIndex(0);
 656                 SdrObject* pObj = pMark->GetMarkedSdrObj();
 657                 aRect.Union( pObj->GetLogicRect() );
 658             }
 659
 660             Point aPos( pOLV->GetWindow()->PixelToLogic( rEvt.maPosPixel ) );
 661
 662             if( aRect.IsInside( aPos ) )
 663             {
 664                 bIsInsideOutlinerView = true;
 665             }
 666         }
 667
 668         if( !bIsInsideOutlinerView )
 669         {
 670             Point                   aPos;
 671             TransferableDataHelper  aDataHelper( rEvt.maDropEvent.Transferable );
 672
 673             if( pTargetWindow )
 674                 aPos = pTargetWindow->PixelToLogic( rEvt.maPosPixel );
 675
 676             // handle insert?
 677             if( (!nRet && ( SDRDRAG_GRADIENT == GetDragMode() )) || (( SDRDRAG_TRANSPARENCE == GetDragMode() ) && aDataHelper.HasFormat( SotClipboardFormatId::XFA )) )
 678             {
 679                 const SdrHdlList& rHdlList = GetHdlList();
 680
 681                 for( size_t n = 0; !nRet && n < rHdlList.GetHdlCount(); ++n )
 682                 {
 683                     SdrHdl* pIAOHandle = rHdlList.GetHdl( n );
 684
 685                     if( pIAOHandle && ( HDL_COLR == pIAOHandle->GetKind() ) )
 686                     {
 687                         if(pIAOHandle->getOverlayObjectList().isHitPixel(rEvt.maPosPixel))
 688                         {
 689                             ::tools::SvRef<SotStorageStream> xStm;
 690
 691                             if( aDataHelper.GetSotStorageStream( SotClipboardFormatId::XFA, xStm ) && xStm.Is() )
 692                             {
 693                                 XFillExchangeData aFillData( XFillAttrSetItem( &mrDoc.GetPool() ) );
 694
 695                                 ReadXFillExchangeData( *xStm, aFillData );
 696                                 const Color aColor( static_cast<const XFillColorItem&>( aFillData.GetXFillAttrSetItem()->GetItemSet().Get( XATTR_FILLCOLOR ) ).GetColorValue() );
 697                                 static_cast< SdrHdlColor* >( pIAOHandle )->SetColor( aColor, true );
 698                                 nRet = nDropAction;
 699                             }
 700                         }
 701                     }
 702                 }
 703             }
 704
 705             // standard insert?
 706             if( !nRet && InsertData( aDataHelper, aPos, nDropAction, true, SotClipboardFormatId::NONE, nPage, nLayer ) )
 707                 nRet = nDropAction;
 708
 709             // special insert?
 710             if( !nRet && mpViewSh )
 711             {
 712                 OUString        aTmpString1, aTmpString2;
 713                 INetBookmark    aINetBookmark( aTmpString1, aTmpString2 );
 714
 715                 // insert bookmark
 716                 if( aDataHelper.HasFormat( SotClipboardFormatId::NETSCAPE_BOOKMARK ) &&
 717                     aDataHelper.GetINetBookmark( SotClipboardFormatId::NETSCAPE_BOOKMARK, aINetBookmark ) )
 718                 {
 719                     SdPageObjsTLB::SdPageObjsTransferable* pPageObjsTransferable = SdPageObjsTLB::SdPageObjsTransferable::getImplementation( aDataHelper.GetXTransferable() );
 720
 721                     if( pPageObjsTransferable &&
 722                         ( NAVIGATOR_DRAGTYPE_LINK == pPageObjsTransferable->GetDragType() ||
 723                           NAVIGATOR_DRAGTYPE_EMBEDDED == pPageObjsTransferable->GetDragType() ) )
 724                     {
 725                         // insert bookmark from own navigator (handled async. due to possible message box )
 726                         Application::PostUserEvent( LINK( this, View, ExecuteNavigatorDrop ),
 727                                                     new SdNavigatorDropEvent( rEvt, rTargetHelper, pTargetWindow,
 728                                                                               nPage, nLayer ) );
 729                         nRet = nDropAction;
 730                     }
 731                     else
 732                     {
 733                         SdrObject*      pPickObj = NULL;
 734                         SdrPageView*    pPageView = NULL;
 735
 736                         if( PickObj( aPos, getHitTolLog(), pPickObj, pPageView ) )
 737                         {
 738                             // insert as clip action => jump
 739                             OUString       aBookmark( aINetBookmark.GetURL() );
 740                             SdAnimationInfo*    pInfo = mrDoc.GetAnimationInfo( pPickObj );
 741
 742                             if( !aBookmark.isEmpty() )
 743                             {
 744                                 bool bCreated = false;
 745
 746                                 presentation::ClickAction eClickAction = presentation::ClickAction_DOCUMENT;
 747
 748                                 sal_Int32 nIndex = aBookmark.indexOf( (sal_Unicode)'#' );
 749                                 if( nIndex != -1 )
 750                                 {
 751                                     const OUString aDocName( aBookmark.copy( 0, nIndex ) );
 752
 753                                     if (mpDocSh->GetMedium()->GetName() == aDocName || aDocName.equals(mpDocSh->GetName()))
 754                                     {
 755                                         // internal jump, only use the part after and including '#'
 756                                         eClickAction = presentation::ClickAction_BOOKMARK;
 757                                         aBookmark = aBookmark.copy( nIndex+1 );
 758                                     }
 759                                 }
 760
 761                                 if( !pInfo )
 762                                 {
 763                                     pInfo = SdDrawDocument::GetShapeUserData( *pPickObj, true );
 764                                     bCreated = true;
 765                                 }
 766
 767                                 // create undo action with old and new sizes
 768                                 SdAnimationPrmsUndoAction* pAction = new SdAnimationPrmsUndoAction(&mrDoc, pPickObj, bCreated);
 769                                 pAction->SetActive(pInfo->mbActive, pInfo->mbActive);
 770                                 pAction->SetEffect(pInfo->meEffect, pInfo->meEffect);
 771                                 pAction->SetTextEffect(pInfo->meTextEffect, pInfo->meTextEffect);
 772                                 pAction->SetSpeed(pInfo->meSpeed, pInfo->meSpeed);
 773                                 pAction->SetDim(pInfo->mbDimPrevious, pInfo->mbDimPrevious);
 774                                 pAction->SetDimColor(pInfo->maDimColor, pInfo->maDimColor);
 775                                 pAction->SetDimHide(pInfo->mbDimHide, pInfo->mbDimHide);
 776                                 pAction->SetSoundOn(pInfo->mbSoundOn, pInfo->mbSoundOn);
 777                                 pAction->SetSound(pInfo->maSoundFile, pInfo->maSoundFile);
 778                                 pAction->SetPlayFull(pInfo->mbPlayFull, pInfo->mbPlayFull);
 779                                 pAction->SetPathObj(pInfo->mpPathObj, pInfo->mpPathObj);
 780                                 pAction->SetClickAction(pInfo->meClickAction, eClickAction);
 781                                 pAction->SetBookmark(pInfo->GetBookmark(), aBookmark);
 782                                 pAction->SetVerb(pInfo->mnVerb, pInfo->mnVerb);
 783                                 pAction->SetSecondEffect(pInfo->meSecondEffect, pInfo->meSecondEffect);
 784                                 pAction->SetSecondSpeed(pInfo->meSecondSpeed, pInfo->meSecondSpeed);
 785                                 pAction->SetSecondSoundOn(pInfo->mbSecondSoundOn, pInfo->mbSecondSoundOn);
 786                                 pAction->SetSecondPlayFull(pInfo->mbSecondPlayFull, pInfo->mbSecondPlayFull);
 787
 788                                 OUString aString(SdResId(STR_UNDO_ANIMATION));
 789                                 pAction->SetComment(aString);
 790                                 mpDocSh->GetUndoManager()->AddUndoAction(pAction);
 791                                 pInfo->meClickAction = eClickAction;
 792                                 pInfo->SetBookmark( aBookmark );
 793                                 mrDoc.SetChanged();
 794
 795                                 nRet = nDropAction;
 796                             }
 797                         }
 798                         else if( mpViewSh->ISA( DrawViewShell ) )
 799                         {
 800                             // insert as normal URL button
 801                             static_cast<DrawViewShell*>( mpViewSh )->InsertURLButton( aINetBookmark.GetURL(), aINetBookmark.GetDescription(), OUString(), &aPos );
 802                             nRet = nDropAction;
 803                         }
 804                     }
 805                 }
 806             }
 807         }
 808     }
 809
 810     return nRet;
 811 }
 812
 813 IMPL_LINK( View, ExecuteNavigatorDrop, SdNavigatorDropEvent*, pSdNavigatorDropEvent )
 814 {
 815     TransferableDataHelper                  aDataHelper( pSdNavigatorDropEvent->maDropEvent.Transferable );
 816     SdPageObjsTLB::SdPageObjsTransferable*  pPageObjsTransferable = SdPageObjsTLB::SdPageObjsTransferable::getImplementation( aDataHelper.GetXTransferable() );
 817     INetBookmark                            aINetBookmark;
 818
 819     if( pPageObjsTransferable && aDataHelper.GetINetBookmark( SotClipboardFormatId::NETSCAPE_BOOKMARK, aINetBookmark ) )
 820     {
 821         Point   aPos;
 822         OUString  aBookmark;
 823         SdPage* pPage = static_cast<SdPage*>( GetSdrPageView()->GetPage() );
 824         sal_uInt16  nPgPos = 0xFFFF;
 825
 826         if( pSdNavigatorDropEvent->mpTargetWindow )
 827             aPos = pSdNavigatorDropEvent->mpTargetWindow->PixelToLogic( pSdNavigatorDropEvent->maPosPixel );
 828
 829         const OUString aURL( aINetBookmark.GetURL() );
 830         sal_Int32 nIndex = aURL.indexOf( (sal_Unicode)'#' );
 831         if( nIndex != -1 )
 832             aBookmark = aURL.copy( nIndex+1 );
 833
 834         std::vector<OUString> aExchangeList;
 835         std::vector<OUString> aBookmarkList(1,aBookmark);
 836
 837         if( !pPage->IsMasterPage() )
 838         {
 839             if( pPage->GetPageKind() == PK_STANDARD )
 840                 nPgPos = pPage->GetPageNum() + 2;
 841             else if( pPage->GetPageKind() == PK_NOTES )
 842                 nPgPos = pPage->GetPageNum() + 1;
 843         }
 844
 845         /* In order t ensure unique page names, we test the ones we want to
 846            insert. If necessary. we put them into and replacement list (bNameOK
 847            == sal_False -> User canceled).  */
 848         bool    bLink = pPageObjsTransferable->GetDragType() == NAVIGATOR_DRAGTYPE_LINK;
 849         bool    bNameOK = GetExchangeList( aExchangeList, aBookmarkList, 2 );
 850         bool    bReplace = false;
 851
 852         /* Since we don't know the type (page or object), we fill a list with
 853            pages and objects.
 854            Of course we have problems if there are pages and objects with the
 855            same name!!! */
 856         if( bNameOK )
 857         {
 858             mrDoc.InsertBookmark( aBookmarkList, aExchangeList,
 859                                   bLink, bReplace, nPgPos, false,
 860                                   &pPageObjsTransferable->GetDocShell(),
 861                                   true, &aPos );
 862         }
 863     }
 864
 865     delete pSdNavigatorDropEvent;
 866
 867     return 0;
 868 }
 869
 870 bool View::GetExchangeList (std::vector<OUString> &rExchangeList,
 871                             std::vector<OUString> &rBookmarkList,
 872                             const sal_uInt16 nType)
 873 {
 874     assert(rExchangeList.empty());
 875
 876     bool bListIdentical = true; ///< Bookmark list and exchange list are identical
 877     bool bNameOK = true;        ///< name is unique
 878
 879     std::vector<OUString>::const_iterator pIter;
 880     for ( pIter = rBookmarkList.begin(); bNameOK && pIter != rBookmarkList.end(); ++pIter )
 881     {
 882         OUString aNewName = *pIter;
 883
 884         if( nType == 0  || nType == 2 )
 885             bNameOK = mpDocSh->CheckPageName(mpViewSh->GetActiveWindow(), aNewName);
 886
 887         if( bNameOK && ( nType == 1  || nType == 2 ) )
 888         {
 889             if( mrDoc.GetObj( aNewName ) )
 890             {
 891                 OUString aTitle(SD_RESSTR(STR_TITLE_NAMEGROUP));
 892                 OUString aDesc(SD_RESSTR(STR_DESC_NAMEGROUP));
 893
 894                 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 895                 boost::scoped_ptr<AbstractSvxNameDialog> pDlg;
 896
 897                 if (pFact)
 898                     pDlg.reset(pFact->CreateSvxNameDialog( mpViewSh->GetActiveWindow(), aNewName, aDesc ));
 899
 900                 if( pDlg )
 901                 {
 902                     pDlg->SetEditHelpId( HID_SD_NAMEDIALOG_OBJECT );
 903
 904                     bNameOK = false;
 905                     pDlg->SetText( aTitle );
 906
 907                     while( !bNameOK && pDlg->Execute() == RET_OK )
 908                     {
 909                         pDlg->GetName( aNewName );
 910
 911                         if( !mrDoc.GetObj( aNewName ) )
 912                             bNameOK = true;
 913                     }
 914                 }
 915             }
 916         }
 917
 918         bListIdentical = pIter->equals(aNewName);
 919
 920         rExchangeList.push_back(aNewName);
 921     }
 922
 923     // Exchange list is identical to bookmark list
 924     if( !rExchangeList.empty() && bListIdentical )
 925         rExchangeList.clear();
 926
 927     return bNameOK;
 928 }
 929
 930 typedef std::vector< SdrObject* > SdrObjectVector;
 931
 932 void ImplProcessObjectList(SdrObject* pObj, SdrObjectVector& rVector )
 933 {
 934     bool bIsGroup(pObj->IsGroupObject());
 935     if(bIsGroup && pObj->ISA(E3dObject) && !pObj->ISA(E3dScene))
 936         bIsGroup = false;
 937
 938     rVector.push_back( pObj );
 939
 940     if(bIsGroup)
 941     {
 942         SdrObjList* pObjList = pObj->GetSubList();
 943         for( size_t a = 0; a < pObjList->GetObjCount(); ++a)
 944             ImplProcessObjectList(pObjList->GetObj(a), rVector);
 945     }
 946 }
 947
 948 SdrModel* View::GetMarkedObjModel() const
 949 {
 950     return FmFormView::GetMarkedObjModel();;
 951 }
 952
 953 bool View::Paste(
 954     const SdrModel& rMod, const Point& rPos, SdrObjList* pLst, SdrInsertFlags nOptions,
 955     const OUString& rSrcShellID, const OUString& rDestShellID )
 956 {
 957     return FmFormView::Paste(rMod, rPos, pLst, nOptions, rSrcShellID, rDestShellID);
 958 }
 959
 960 } // end of namespace sd
 961
 962 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */