sd/source/ui/slidesorter/controller/SlsClipboard.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: SlsClipboard.cxx,v $
  10  * $Revision: 1.27 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "precompiled_sd.hxx"
  32
  33 #include "controller/SlsClipboard.hxx"
  34
  35 #include "SlideSorterViewShell.hxx"
  36 #include "SlideSorter.hxx"
  37 #include "model/SlideSorterModel.hxx"
  38 #include "model/SlsPageDescriptor.hxx"
  39 #include "model/SlsPageEnumerationProvider.hxx"
  40 #include "view/SlideSorterView.hxx"
  41 #include "view/SlsViewOverlay.hxx"
  42 #include "view/SlsPageObject.hxx"
  43 #include "controller/SlideSorterController.hxx"
  44 #include "controller/SlsPageSelector.hxx"
  45 #include "controller/SlsSelectionFunction.hxx"
  46 #include "controller/SlsCurrentSlideManager.hxx"
  47 #include "controller/SlsScrollBarManager.hxx"
  48 #include "controller/SlsFocusManager.hxx"
  49 #include "controller/SlsSelectionManager.hxx"
  50 #include "SlsTransferable.hxx"
  51
  52 #include "ViewShellBase.hxx"
  53 #include "DrawViewShell.hxx"
  54 #include "Window.hxx"
  55 #include "fupoor.hxx"
  56 #include "fuslhide.hxx"
  57 #include "fuzoom.hxx"
  58 #include "fucushow.hxx"
  59 #include "fusldlg.hxx"
  60 #include "fuexpand.hxx"
  61 #include "fusumry.hxx"
  62 #include "app.hrc"
  63 #include "glob.hrc"
  64 #include "strings.hrc"
  65 #include "sdresid.hxx"
  66 #include "sdxfer.hxx"
  67 #include "sdmod.hxx"
  68 #include "sddll.hxx"
  69 #include "ins_paste.hxx"
  70 #include "drawdoc.hxx"
  71 #include "DrawDocShell.hxx"
  72 #include "sdpage.hxx"
  73
  74 #include <com/sun/star/datatransfer/dnd/DNDConstants.hpp>
  75 #include <sfx2/request.hxx>
  76 #include <sfx2/viewfrm.hxx>
  77 #include <sfx2/bindings.hxx>
  78 #include <sfx2/docfile.hxx>
  79 #include <svx/svxids.hrc>
  80 #include <vcl/msgbox.hxx>
  81 #include <tools/urlobj.hxx>
  82 #include <rtl/ustring.hxx>
  83 #include <vos/mutex.hxx>
  84 #include <vcl/svapp.hxx>
  85
  86 namespace sd { namespace slidesorter { namespace controller {
  87
  88
  89 Clipboard::Clipboard (SlideSorter& rSlideSorter)
  90     : ViewClipboard(rSlideSorter.GetView()),
  91       mrSlideSorter(rSlideSorter),
  92       mrController(mrSlideSorter.GetController()),
  93       maPagesToRemove(),
  94       maPagesToSelect(),
  95       mbUpdateSelectionPending(false)
  96 {
  97 }
  98
  99
 100
 101
 102 Clipboard::~Clipboard (void)
 103 {
 104 }
 105
 106
 107
 108
 109 /** With the current implementation the forwarded calls to the current
 110     function will come back eventually to call the local Do(Cut|Copy|Paste)
 111     methods.  A shortcut is possible but would be an unclean hack.
 112 */
 113 void Clipboard::HandleSlotCall (SfxRequest& rRequest)
 114 {
 115     ViewShell* pViewShell = mrSlideSorter.GetViewShell();
 116     FunctionReference xFunc;
 117     if (pViewShell != NULL)
 118         xFunc = pViewShell->GetCurrentFunction();
 119     switch (rRequest.GetSlot())
 120     {
 121         case SID_CUT:
 122             if (mrSlideSorter.GetModel().GetEditMode() != EM_MASTERPAGE)
 123             {
 124                 if(xFunc.is())
 125                     xFunc->DoCut();
 126                 else
 127                     DoCut();
 128             }
 129             rRequest.Done();
 130             break;
 131
 132         case SID_COPY:
 133             if (mrSlideSorter.GetModel().GetEditMode() != EM_MASTERPAGE)
 134             {
 135                 if(xFunc.is())
 136                     xFunc->DoCopy();
 137                 else
 138                     DoCopy();
 139             }
 140             rRequest.Done();
 141             break;
 142
 143         case SID_PASTE:
 144             // Prevent redraws while inserting pages from the clipboard
 145             // because the intermediate inconsistent state might lead to
 146             // a crash.
 147             if (mrSlideSorter.GetModel().GetEditMode() != EM_MASTERPAGE)
 148             {
 149                 mrSlideSorter.GetView().LockRedraw (TRUE);
 150                 if(xFunc.is())
 151                     xFunc->DoPaste();
 152                 else
 153                     DoPaste();
 154                 mrController.GetSelectionManager()->MakeSelectionVisible();
 155                 mrSlideSorter.GetView().LockRedraw(FALSE);
 156             }
 157             rRequest.Done();
 158             break;
 159
 160         case SID_DELETE:
 161             DoDelete();
 162             rRequest.Done();
 163             break;
 164     }
 165 }
 166
 167
 168
 169
 170 void Clipboard::DoCut (::Window* pWindow)
 171 {
 172     if (mrSlideSorter.GetModel().GetPageCount() > 1)
 173     {
 174         DoCopy(pWindow);
 175         DoDelete(pWindow);
 176     }
 177 }
 178
 179
 180
 181
 182 void Clipboard::DoDelete (::Window* )
 183 {
 184     if (mrSlideSorter.GetModel().GetPageCount() > 1)
 185     {
 186         mrController.GetSelectionManager()->DeleteSelectedPages();
 187     }
 188 }
 189
 190
 191
 192
 193 void Clipboard::DoCopy (::Window* pWindow )
 194 {
 195     CreateSlideTransferable( pWindow, FALSE );
 196 }
 197
 198
 199
 200
 201 void Clipboard::DoPaste (::Window* pWindow)
 202 {
 203     SdTransferable* pClipTransferable = SD_MOD()->pTransferClip;
 204
 205     if (pClipTransferable!=NULL && pClipTransferable->IsPageTransferable())
 206     {
 207         sal_Int32 nInsertPosition = GetInsertionPosition(pWindow);
 208
 209         if (nInsertPosition >= 0)
 210         {
 211             // Paste the pages from the clipboard.
 212             sal_Int32 nInsertPageCount = PasteTransferable(nInsertPosition);
 213             // Select the pasted pages and make the first of them the
 214             // current page.
 215             mrSlideSorter.GetView().GetWindow()->GrabFocus();
 216             SelectPageRange(nInsertPosition, nInsertPageCount);
 217         }
 218     }
 219 }
 220
 221
 222
 223
 224 sal_Int32 Clipboard::GetInsertionPosition (::Window* pWindow)
 225 {
 226     sal_Int32 nInsertPosition = -1;
 227
 228     // Determine the insertion position:
 229     // a) When the insertion indicator is visible, then at that position.
 230     // b) When the focus indicator is visible, then before or after the
 231     // focused page, depending on user input to a dialog.
 232     // c) When there is a selection but no focus, then after the
 233     // selection.
 234     // d) After the last page when there is no selection and no focus.
 235
 236     view::InsertionIndicatorOverlay& rInsertionIndicatorOverlay (
 237         mrSlideSorter.GetView().GetOverlay().GetInsertionIndicatorOverlay());
 238     if (rInsertionIndicatorOverlay.isVisible())
 239     {
 240         nInsertPosition = rInsertionIndicatorOverlay.GetInsertionPageIndex();
 241     }
 242     else if (mrController.GetFocusManager().IsFocusShowing())
 243     {
 244         SdInsertPasteDlg aDialog (pWindow);
 245         if (aDialog.Execute() == RET_OK)
 246         {
 247             nInsertPosition = mrController.GetFocusManager().GetFocusedPageIndex();
 248             if ( ! aDialog.IsInsertBefore())
 249                 nInsertPosition ++;
 250         }
 251     }
 252     else
 253     {
 254         nInsertPosition = mrController.GetSelectionManager()->GetInsertionPosition();
 255     }
 256
 257     return nInsertPosition;
 258 }
 259
 260
 261
 262
 263 sal_Int32 Clipboard::PasteTransferable (sal_Int32 nInsertPosition)
 264 {
 265     SdTransferable* pClipTransferable = SD_MOD()->pTransferClip;
 266     bool bMergeMasterPages = !pClipTransferable->HasSourceDoc (
 267         mrSlideSorter.GetModel().GetDocument());
 268     USHORT nInsertIndex ((USHORT)(nInsertPosition * 2 + 1));
 269     sal_Int32 nInsertPageCount (0);
 270     if (pClipTransferable->HasPageBookmarks())
 271     {
 272         const List& rBookmarkList = pClipTransferable->GetPageBookmarks();
 273         const ::vos::OGuard aGuard (Application::GetSolarMutex());
 274
 275         nInsertPageCount = (USHORT) rBookmarkList.Count();
 276         mrSlideSorter.GetModel().GetDocument()->InsertBookmarkAsPage(
 277             const_cast<List*>(&rBookmarkList),
 278             NULL,
 279             FALSE,
 280             FALSE,
 281             nInsertIndex,
 282             FALSE,
 283             pClipTransferable->GetPageDocShell(),
 284             TRUE,
 285             bMergeMasterPages,
 286             FALSE);
 287     }
 288     else
 289     {
 290         SfxObjectShell* pShell = pClipTransferable->GetDocShell();
 291         DrawDocShell* pDataDocSh = (DrawDocShell*)pShell;
 292         SdDrawDocument* pDataDoc = pDataDocSh->GetDoc();
 293
 294         if (pDataDoc!=NULL
 295             && pDataDoc->GetSdPageCount(PK_STANDARD))
 296         {
 297             const ::vos::OGuard aGuard (Application::GetSolarMutex());
 298
 299             bMergeMasterPages = (pDataDoc != mrSlideSorter.GetModel().GetDocument());
 300             nInsertPageCount = pDataDoc->GetSdPageCount( PK_STANDARD );
 301             mrSlideSorter.GetModel().GetDocument()->InsertBookmarkAsPage(
 302                 NULL,
 303                 NULL,
 304                 FALSE,
 305                 FALSE,
 306                 nInsertIndex,
 307                 FALSE,
 308                 pDataDocSh,
 309                 TRUE,
 310                 bMergeMasterPages,
 311                 FALSE);
 312         }
 313     }
 314     mrController.HandleModelChange();
 315     return nInsertPageCount;
 316 }
 317
 318
 319
 320
 321 void Clipboard::SelectPageRange (sal_Int32 nFirstIndex, sal_Int32 nPageCount)
 322 {
 323     // Select the newly inserted pages.  That are the nInsertPageCount pages
 324     // after the nInsertIndex position.
 325     PageSelector& rSelector (mrController.GetPageSelector());
 326     rSelector.DeselectAllPages();
 327     for (USHORT i=0; i<nPageCount; i++)
 328     {
 329         model::SharedPageDescriptor pDescriptor (
 330             mrSlideSorter.GetModel().GetPageDescriptor(nFirstIndex + i));
 331         if (pDescriptor.get() != NULL)
 332         {
 333             rSelector.SelectPage(pDescriptor);
 334             // The first page of the new selection is made the current page.
 335             if (i == 0)
 336             {
 337                 mrController.GetCurrentSlideManager()->SwitchCurrentSlide(pDescriptor);
 338                 mrController.GetFocusManager().SetFocusedPage(pDescriptor);
 339             }
 340         }
 341     }
 342 }
 343
 344
 345
 346
 347 void Clipboard::CreateSlideTransferable (
 348     ::Window* pWindow,
 349     bool bDrag)
 350 {
 351     List aBookmarkList;
 352
 353     // Insert all selected pages into a bookmark list and remember them in
 354     // maPagesToRemove for possible later removal.
 355     model::PageEnumeration aSelectedPages
 356         (model::PageEnumerationProvider::CreateSelectedPagesEnumeration(
 357             mrSlideSorter.GetModel()));
 358     while (aSelectedPages.HasMoreElements())
 359     {
 360         model::SharedPageDescriptor pDescriptor (aSelectedPages.GetNextElement());
 361         aBookmarkList.Insert (
 362             new String(pDescriptor->GetPage()->GetName()),
 363             LIST_APPEND);
 364         maPagesToRemove.push_back (pDescriptor->GetPage());
 365     }
 366
 367     if (aBookmarkList.Count() > 0)
 368     {
 369         mrSlideSorter.GetView().BrkAction();
 370         SdDrawDocument* pDocument = mrSlideSorter.GetModel().GetDocument();
 371         SdTransferable* pTransferable = new Transferable (
 372             pDocument,
 373             NULL,
 374             FALSE,
 375             dynamic_cast<SlideSorterViewShell*>(mrSlideSorter.GetViewShell()));
 376
 377         if (bDrag)
 378             SD_MOD()->pTransferDrag = pTransferable;
 379         else
 380             SD_MOD()->pTransferClip = pTransferable;
 381
 382         pDocument->CreatingDataObj (pTransferable);
 383         pTransferable->SetWorkDocument( dynamic_cast<SdDrawDocument*>(pDocument->AllocModel()) );
 384         pDocument->CreatingDataObj (NULL);
 385         TransferableObjectDescriptor aObjDesc;
 386         pTransferable->GetWorkDocument()->GetDocSh()
 387             ->FillTransferableObjectDescriptor (aObjDesc);
 388
 389         if (pDocument->GetDocSh() != NULL)
 390             aObjDesc.maDisplayName = pDocument->GetDocSh()
 391                 ->GetMedium()->GetURLObject().GetURLNoPass();
 392
 393         ::Window* pActionWindow = pWindow;
 394         if (pActionWindow == NULL)
 395         {
 396             ViewShell* pViewShell = mrSlideSorter.GetViewShell();
 397             if (pViewShell != NULL)
 398                 pActionWindow = pViewShell->GetActiveWindow();
 399         }
 400
 401         pTransferable->SetStartPos (pActionWindow->PixelToLogic(
 402             pActionWindow->GetPointerPosPixel()));
 403         pTransferable->SetObjectDescriptor (aObjDesc);
 404         pTransferable->SetPageBookmarks (aBookmarkList, !bDrag);
 405
 406         for (void* p=aBookmarkList.First(); p!=NULL; p=aBookmarkList.Next())
 407             delete static_cast<String*>(p);
 408
 409         if (bDrag)
 410         {
 411             pTransferable->SetView (&mrSlideSorter.GetView());
 412             sal_Int8 nDragSourceActions (DND_ACTION_COPY);
 413             // The move action is available only when not all pages would be
 414             // moved.  Otherwise an empty document would remain.  Crash.
 415             sal_Int32 nRemainingPages = mrSlideSorter.GetModel().GetPageCount() - aBookmarkList.Count();
 416             if (nRemainingPages > 0)
 417                 nDragSourceActions |= DND_ACTION_MOVE;
 418             pTransferable->StartDrag (pActionWindow, nDragSourceActions);
 419         }
 420         else
 421             pTransferable->CopyToClipboard (pActionWindow);
 422     }
 423 }
 424
 425
 426
 427
 428 void Clipboard::StartDrag (
 429     const Point&,
 430     ::Window* pWindow)
 431 {
 432     maPagesToRemove.clear();
 433     maPagesToSelect.clear();
 434     mbUpdateSelectionPending = false;
 435     CreateSlideTransferable (pWindow, TRUE);
 436 }
 437
 438
 439
 440
 441 void Clipboard::DragFinished (sal_Int8 nDropAction)
 442 {
 443     // Hide the substitution display and insertion indicator.
 444     mrSlideSorter.GetView().GetOverlay().GetSubstitutionOverlay().setVisible(false);
 445     mrSlideSorter.GetView().GetOverlay().GetInsertionIndicatorOverlay().setVisible(false);
 446
 447     SdTransferable* pDragTransferable = SD_MOD()->pTransferDrag;
 448
 449     if (pDragTransferable != NULL)
 450         pDragTransferable->SetView (NULL);
 451
 452     PageSelector& rSelector (mrController.GetPageSelector());
 453     if ((nDropAction & DND_ACTION_MOVE) != 0
 454         && ! maPagesToRemove.empty())
 455     {
 456         // Remove the pages that have been moved to another place (possibly
 457         // in the same document.)
 458         rSelector.DeselectAllPages();
 459         PageList::iterator aDraggedPage;
 460         for (aDraggedPage=maPagesToRemove.begin();
 461              aDraggedPage!=maPagesToRemove.end();
 462              aDraggedPage++)
 463         {
 464             rSelector.SelectPage (*aDraggedPage);
 465         }
 466         mrController.GetSelectionManager()->DeleteSelectedPages ();
 467     }
 468
 469     SelectPages();
 470 }
 471
 472
 473
 474
 475 void Clipboard::SelectPages (void)
 476 {
 477     PageSelector& rSelector (mrController.GetPageSelector());
 478
 479     // Select the dropped pages.
 480     PageList::iterator iPage;
 481     rSelector.DeselectAllPages();
 482     for (iPage=maPagesToSelect.begin(); iPage!=maPagesToSelect.end(); ++iPage)
 483     {
 484         rSelector.SelectPage(*iPage);
 485     }
 486 }
 487
 488
 489
 490
 491 sal_Int8 Clipboard::AcceptDrop (
 492     const AcceptDropEvent& rEvent,
 493     DropTargetHelper& rTargetHelper,
 494     ::sd::Window* pTargetWindow,
 495     USHORT nPage,
 496     USHORT nLayer)
 497 {
 498     sal_Int8 nResult = DND_ACTION_NONE;
 499
 500     switch (IsDropAccepted())
 501     {
 502         case DT_PAGE:
 503         {
 504             // Accept a drop.
 505             nResult = rEvent.mnAction;
 506
 507             // Use the copy action when the drop action is the default, i.e. not
 508             // explicitly set to move or link, and when the source and
 509             // target models are not the same.
 510             const SdTransferable* pDragTransferable = SD_MOD()->pTransferDrag;
 511             if (pDragTransferable != NULL
 512                 && pDragTransferable->IsPageTransferable()
 513                 && ((rEvent.maDragEvent.DropAction
 514                         & ::com::sun::star::datatransfer::dnd::DNDConstants::ACTION_DEFAULT) != 0)
 515                 && (mrSlideSorter.GetModel().GetDocument()->GetDocSh()
 516                     != pDragTransferable->GetPageDocShell()))
 517             {
 518                 nResult = DND_ACTION_COPY;
 519             }
 520
 521             // Show the insertion marker and the substitution for a drop.
 522             Point aPosition = pTargetWindow->PixelToLogic (rEvent.maPosPixel);
 523             view::ViewOverlay& rOverlay (mrSlideSorter.GetView().GetOverlay());
 524             rOverlay.GetInsertionIndicatorOverlay().SetPosition (aPosition);
 525             rOverlay.GetInsertionIndicatorOverlay().setVisible(true);
 526             rOverlay.GetSubstitutionOverlay().SetPosition (aPosition);
 527
 528             // Scroll the window when the mouse reaches the window border.
 529             mrController.GetScrollBarManager().AutoScroll (rEvent.maPosPixel);
 530         }
 531         break;
 532
 533         case DT_SHAPE:
 534             nResult = ExecuteOrAcceptShapeDrop(
 535                 DC_ACCEPT,
 536                 rEvent.maPosPixel,
 537                 &rEvent,
 538                 rTargetHelper,
 539                 pTargetWindow,
 540                 nPage,
 541                 nLayer);
 542             break;
 543         default:
 544             break;
 545     }
 546
 547     return nResult;
 548 }
 549
 550
 551
 552
 553 sal_Int8 Clipboard::ExecuteDrop (
 554     const ExecuteDropEvent& rEvent,
 555     DropTargetHelper& rTargetHelper,
 556     ::sd::Window* pTargetWindow,
 557     USHORT nPage,
 558     USHORT nLayer)
 559 {
 560     sal_Int8 nResult = DND_ACTION_NONE;
 561
 562     switch (IsDropAccepted())
 563     {
 564         case DT_PAGE:
 565         {
 566             const SdTransferable* pDragTransferable = SD_MOD()->pTransferDrag;
 567             const Point aEventModelPosition (
 568                 pTargetWindow->PixelToLogic (rEvent.maPosPixel));
 569             long int nXOffset = labs (pDragTransferable->GetStartPos().X()
 570                 - aEventModelPosition.X());
 571             long int nYOffset = labs (pDragTransferable->GetStartPos().Y()
 572                 - aEventModelPosition.Y());
 573             const bool bContinue =
 574                 ( pDragTransferable->GetView() != &mrSlideSorter.GetView() )
 575                 || ( nXOffset >= 2 && nYOffset >= 2 );
 576
 577             // Get insertion position and then turn off the insertion indicator.
 578             view::ViewOverlay& rOverlay (mrSlideSorter.GetView().GetOverlay());
 579             rOverlay.GetInsertionIndicatorOverlay().SetPosition(
 580                 aEventModelPosition);
 581             USHORT nIndex = DetermineInsertPosition (*pDragTransferable);
 582             OSL_TRACE ("Clipboard::AcceptDrop() called for index %d",
 583                 nIndex);
 584             rOverlay.GetInsertionIndicatorOverlay().setVisible(false);
 585
 586             if (bContinue)
 587             {
 588                 SlideSorterController::ModelChangeLock aModelChangeLock (mrController);
 589
 590                 if (pDragTransferable->GetView() == &mrSlideSorter.GetView()
 591                     && rEvent.mnAction == DND_ACTION_MOVE)
 592                 {
 593                     // We are asked to move pages inside one view.  For this we
 594                     // call MoveSelectedPages() which is faster than going the
 595                     // generic way.
 596
 597                     // Remember to select the moved pages afterwards.
 598                     maPagesToRemove.swap(maPagesToSelect);
 599                     maPagesToRemove.clear();
 600
 601                     USHORT nSdrModelIndex;
 602                     if (nIndex != SDRPAGE_NOTFOUND)
 603                         nSdrModelIndex = nIndex / 2 - 1;
 604                     else
 605                         nSdrModelIndex = SDRPAGE_NOTFOUND;
 606                     mrController.GetSelectionManager()->MoveSelectedPages(nSdrModelIndex);
 607                     mbUpdateSelectionPending = true;
 608                     nResult = DND_ACTION_NONE;
 609                 }
 610                 else
 611                 {
 612                     // Handle a general drop operation.
 613                     HandlePageDrop (*pDragTransferable);
 614                     nResult = rEvent.mnAction;
 615                 }
 616             }
 617         }
 618         break;
 619
 620         case DT_SHAPE:
 621             nResult = ExecuteOrAcceptShapeDrop(
 622                 DC_EXECUTE,
 623                 rEvent.maPosPixel,
 624                 &rEvent,
 625                 rTargetHelper,
 626                 pTargetWindow,
 627                 nPage,
 628                 nLayer);
 629             break;
 630         default:
 631             break;
 632     }
 633
 634     return nResult;
 635 }
 636
 637
 638
 639
 640 USHORT Clipboard::DetermineInsertPosition (const SdTransferable& )
 641 {
 642     USHORT nInsertPosition = SDRPAGE_NOTFOUND;
 643
 644     // Tell the model to move the dragged pages behind the one with the
 645     // index nInsertionIndex which first has to be transformed into an index
 646     // understandable by the document.
 647     view::InsertionIndicatorOverlay& rOverlay (
 648         mrSlideSorter.GetView().GetOverlay().GetInsertionIndicatorOverlay());
 649     sal_Int32 nInsertionIndex (rOverlay.GetInsertionPageIndex());
 650
 651     // The index returned by the overlay starts with 1 for the first slide.
 652     // This is now converted that to an SdModel index that also starts with 1.
 653     if (nInsertionIndex >= 0)
 654         nInsertPosition = (USHORT)nInsertionIndex * 2 + 1;
 655
 656     return nInsertPosition;
 657 }
 658
 659
 660
 661
 662 USHORT Clipboard::InsertSlides (
 663     const SdTransferable& rTransferable,
 664     USHORT nInsertPosition)
 665 {
 666     USHORT nInsertedPageCount = ViewClipboard::InsertSlides (
 667         rTransferable,
 668         nInsertPosition);
 669
 670     // Remember the inserted pages so that they can be selected when the
 671     // operation is finished.
 672     int nDocumentIndex = nInsertPosition / 2 - 1;
 673     for (USHORT i=1; i<=nInsertedPageCount; i++)
 674     {
 675         model::SharedPageDescriptor pDescriptor (
 676             mrSlideSorter.GetModel().GetPageDescriptor(nDocumentIndex + i));
 677         if (pDescriptor.get() != NULL)
 678             maPagesToSelect.push_back (pDescriptor->GetPage());
 679     }
 680
 681     mbUpdateSelectionPending |= (nInsertedPageCount>0);
 682
 683     return nInsertedPageCount;
 684 }
 685
 686
 687
 688
 689 Clipboard::DropType Clipboard::IsDropAccepted (void) const
 690 {
 691     DropType eResult (DT_NONE);
 692
 693     const SdTransferable* pDragTransferable = SD_MOD()->pTransferDrag;
 694     if (pDragTransferable != NULL)
 695     {
 696         if (pDragTransferable->IsPageTransferable())
 697         {
 698             if (mrSlideSorter.GetModel().GetEditMode() != EM_MASTERPAGE)
 699                 eResult = DT_PAGE;
 700         }
 701         else
 702         {
 703             eResult = DT_SHAPE;
 704         }
 705     }
 706
 707     return eResult;
 708 }
 709
 710
 711
 712
 713 sal_Int8 Clipboard::ExecuteOrAcceptShapeDrop (
 714     DropCommand eCommand,
 715     const Point& rPosition,
 716     const void* pDropEvent,
 717     DropTargetHelper& rTargetHelper,
 718     ::sd::Window* pTargetWindow,
 719     USHORT nPage,
 720     USHORT nLayer)
 721 {
 722     sal_Int8 nResult = 0;
 723
 724     // The dropping of a shape is accepted or executed only when there is
 725     // DrawViewShell available to which we can forward this call.  This has
 726     // technical reasons:  The actual code to accept or execute a shape drop
 727     // is implemented in the ViewShell class and uses the page view of the
 728     // main edit view.  This is not possible without a DrawViewShell.
 729     ::boost::shared_ptr<DrawViewShell> pDrawViewShell;
 730     if (mrSlideSorter.GetViewShell() != NULL)
 731         pDrawViewShell = ::boost::dynamic_pointer_cast<DrawViewShell>(
 732             mrSlideSorter.GetViewShell()->GetViewShellBase().GetMainViewShell());
 733     if (pDrawViewShell.get() != NULL
 734         && (pDrawViewShell->GetShellType() == ViewShell::ST_IMPRESS
 735             || pDrawViewShell->GetShellType() == ViewShell::ST_DRAW))
 736     {
 737         // The drop is only accepted or executed when it takes place over a
 738         // page object.  Therefore we replace a missing page number by the
 739         // number of the page under the mouse.
 740         if (nPage == SDRPAGE_NOTFOUND)
 741         {
 742             model::SharedPageDescriptor pDescriptor (
 743                 mrSlideSorter.GetModel().GetPageDescriptor(
 744                     mrSlideSorter.GetView().GetPageIndexAtPoint(rPosition)));
 745             if (pDescriptor.get() != NULL && pDescriptor->GetPage()!=NULL)
 746                 nPage = (pDescriptor->GetPage()->GetPageNum() - 1) / 2;
 747         }
 748
 749         // Now comes the code that is different for the Execute and Accept:
 750         // We simply forward the call to the AcceptDrop() or ExecuteDrop()
 751         // methods of the DrawViewShell in the center pane.
 752         if (nPage != SDRPAGE_NOTFOUND)
 753             switch (eCommand)
 754             {
 755                 case DC_ACCEPT:
 756                     nResult = pDrawViewShell->AcceptDrop(
 757                         *reinterpret_cast<const AcceptDropEvent*>(pDropEvent),
 758                         rTargetHelper,
 759                         pTargetWindow,
 760                         nPage,
 761                         nLayer);
 762                     break;
 763
 764                 case DC_EXECUTE:
 765                     nResult = pDrawViewShell->ExecuteDrop(
 766                         *reinterpret_cast<const ExecuteDropEvent*>(pDropEvent),
 767                         rTargetHelper,
 768                         pTargetWindow,
 769                         nPage,
 770                         nLayer);
 771                     break;
 772             }
 773     }
 774
 775     return nResult;
 776 }
 777
 778
 779
 780 } } } // end of namespace ::sd::slidesorter::controller
 781