svtools/source/misc/transfer2.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 <osl/mutex.hxx>
  21 #include <unotools/ucbstreamhelper.hxx>
  22 #include <sot/exchange.hxx>
  23 #include <sot/storage.hxx>
  24 #include <vcl/bitmap.hxx>
  25 #include <vcl/gdimtf.hxx>
  26 #include <vcl/graph.hxx>
  27 #include <vcl/svapp.hxx>
  28 #include <vcl/window.hxx>
  29 #include <comphelper/processfactory.hxx>
  30 #include <com/sun/star/datatransfer/dnd/XDropTargetDragContext.hpp>
  31 #include <svl/urlbmk.hxx>
  32 #include <svtools/inetimg.hxx>
  33 #include <svtools/imap.hxx>
  34 #include <svtools/transfer.hxx>
  35
  36
  37 // - Namespaces -
  38
  39
  40 using namespace ::com::sun::star::uno;
  41 using namespace ::com::sun::star::lang;
  42 using namespace ::com::sun::star::io;
  43 using namespace ::com::sun::star::datatransfer;
  44 using namespace ::com::sun::star::datatransfer::clipboard;
  45 using namespace ::com::sun::star::datatransfer::dnd;
  46
  47
  48 // - DragSourceHelper::DragGestureListener -
  49
  50
  51 DragSourceHelper::DragGestureListener::DragGestureListener( DragSourceHelper& rDragSourceHelper ) :
  52     mrParent( rDragSourceHelper )
  53 {
  54 }
  55
  56
  57
  58 DragSourceHelper::DragGestureListener::~DragGestureListener()
  59 {
  60 }
  61
  62
  63
  64 void SAL_CALL DragSourceHelper::DragGestureListener::disposing( const EventObject& ) throw( RuntimeException, std::exception )
  65 {
  66 }
  67
  68
  69
  70 void SAL_CALL DragSourceHelper::DragGestureListener::dragGestureRecognized( const DragGestureEvent& rDGE ) throw( RuntimeException, std::exception )
  71 {
  72     const SolarMutexGuard aGuard;
  73
  74     const Point aPtPixel( rDGE.DragOriginX, rDGE.DragOriginY );
  75     mrParent.StartDrag( rDGE.DragAction, aPtPixel );
  76 }
  77
  78
  79 // - DragSourceHelper -
  80
  81
  82 DragSourceHelper::DragSourceHelper( vcl::Window* pWindow ) :
  83     mxDragGestureRecognizer( pWindow->GetDragGestureRecognizer() )
  84 {
  85     if( mxDragGestureRecognizer.is() )
  86     {
  87         mxDragGestureListener = new DragSourceHelper::DragGestureListener( *this );
  88         mxDragGestureRecognizer->addDragGestureListener( mxDragGestureListener );
  89     }
  90 }
  91
  92
  93
  94 DragSourceHelper::~DragSourceHelper()
  95 {
  96     if( mxDragGestureRecognizer.is()  )
  97         mxDragGestureRecognizer->removeDragGestureListener( mxDragGestureListener );
  98 }
  99
 100
 101
 102 void DragSourceHelper::StartDrag( sal_Int8, const Point& )
 103 {
 104 }
 105
 106
 107 // - DropTargetHelper::DropTargetListener -
 108
 109
 110 DropTargetHelper::DropTargetListener::DropTargetListener( DropTargetHelper& rDropTargetHelper ) :
 111     mrParent( rDropTargetHelper ),
 112     mpLastDragOverEvent( NULL )
 113 {
 114 }
 115
 116
 117
 118 DropTargetHelper::DropTargetListener::~DropTargetListener()
 119 {
 120     delete mpLastDragOverEvent;
 121 }
 122
 123
 124
 125 void SAL_CALL DropTargetHelper::DropTargetListener::disposing( const EventObject& ) throw( RuntimeException, std::exception )
 126 {
 127 }
 128
 129
 130
 131 void SAL_CALL DropTargetHelper::DropTargetListener::drop( const DropTargetDropEvent& rDTDE ) throw( RuntimeException, std::exception )
 132 {
 133     const SolarMutexGuard aGuard;
 134
 135     try
 136     {
 137         AcceptDropEvent  aAcceptEvent;
 138         ExecuteDropEvent aExecuteEvt( rDTDE.DropAction & ~DNDConstants::ACTION_DEFAULT, Point( rDTDE.LocationX, rDTDE.LocationY ), rDTDE );
 139
 140         aExecuteEvt.mbDefault = ( ( rDTDE.DropAction & DNDConstants::ACTION_DEFAULT ) != 0 );
 141
 142         // in case of a default action, call ::AcceptDrop first and use the returned
 143         // accepted action as the execute action in the call to ::ExecuteDrop
 144         aAcceptEvent.mnAction = aExecuteEvt.mnAction;
 145         aAcceptEvent.maPosPixel = aExecuteEvt.maPosPixel;
 146         (DropTargetEvent&)( aAcceptEvent.maDragEvent ) = (DropTargetEvent&) rDTDE;
 147         ( (DropTargetDragEvent&)( aAcceptEvent.maDragEvent ) ).DropAction = rDTDE.DropAction;
 148         ( (DropTargetDragEvent&)( aAcceptEvent.maDragEvent ) ).LocationX = rDTDE.LocationX;
 149         ( (DropTargetDragEvent&)( aAcceptEvent.maDragEvent ) ).LocationY = rDTDE.LocationY;
 150         ( (DropTargetDragEvent&)( aAcceptEvent.maDragEvent ) ).SourceActions = rDTDE.SourceActions;
 151         aAcceptEvent.mbLeaving = false;
 152         aAcceptEvent.mbDefault = aExecuteEvt.mbDefault;
 153
 154         sal_Int8 nRet = mrParent.AcceptDrop( aAcceptEvent );
 155
 156         if( DNDConstants::ACTION_NONE != nRet )
 157         {
 158             rDTDE.Context->acceptDrop( nRet );
 159
 160             if( aExecuteEvt.mbDefault )
 161                 aExecuteEvt.mnAction = nRet;
 162
 163             nRet = mrParent.ExecuteDrop( aExecuteEvt );
 164         }
 165
 166         rDTDE.Context->dropComplete( DNDConstants::ACTION_NONE != nRet );
 167
 168         if( mpLastDragOverEvent )
 169         {
 170             delete mpLastDragOverEvent;
 171             mpLastDragOverEvent = NULL;
 172         }
 173     }
 174     catch( const ::com::sun::star::uno::Exception& )
 175     {
 176     }
 177 }
 178
 179
 180
 181 void SAL_CALL DropTargetHelper::DropTargetListener::dragEnter( const DropTargetDragEnterEvent& rDTDEE ) throw( RuntimeException, std::exception )
 182 {
 183     const SolarMutexGuard aGuard;
 184
 185     try
 186     {
 187         mrParent.ImplBeginDrag( rDTDEE.SupportedDataFlavors );
 188     }
 189     catch( const ::com::sun::star::uno::Exception& )
 190     {
 191     }
 192
 193     dragOver( rDTDEE );
 194 }
 195
 196
 197
 198 void SAL_CALL DropTargetHelper::DropTargetListener::dragOver( const DropTargetDragEvent& rDTDE ) throw( RuntimeException, std::exception )
 199 {
 200     const SolarMutexGuard aGuard;
 201
 202     try
 203     {
 204         if( mpLastDragOverEvent )
 205             delete mpLastDragOverEvent;
 206
 207         mpLastDragOverEvent = new AcceptDropEvent( rDTDE.DropAction & ~DNDConstants::ACTION_DEFAULT, Point( rDTDE.LocationX, rDTDE.LocationY ), rDTDE );
 208         mpLastDragOverEvent->mbDefault = ( ( rDTDE.DropAction & DNDConstants::ACTION_DEFAULT ) != 0 );
 209
 210         const sal_Int8 nRet = mrParent.AcceptDrop( *mpLastDragOverEvent );
 211
 212         if( DNDConstants::ACTION_NONE == nRet )
 213             rDTDE.Context->rejectDrag();
 214         else
 215             rDTDE.Context->acceptDrag( nRet );
 216     }
 217     catch( const ::com::sun::star::uno::Exception& )
 218     {
 219     }
 220 }
 221
 222
 223
 224 void SAL_CALL DropTargetHelper::DropTargetListener::dragExit( const DropTargetEvent& ) throw( RuntimeException, std::exception )
 225 {
 226     const SolarMutexGuard aGuard;
 227
 228     try
 229     {
 230         if( mpLastDragOverEvent )
 231         {
 232             mpLastDragOverEvent->mbLeaving = true;
 233             mrParent.AcceptDrop( *mpLastDragOverEvent );
 234             delete mpLastDragOverEvent;
 235             mpLastDragOverEvent = NULL;
 236         }
 237
 238         mrParent.ImplEndDrag();
 239     }
 240     catch( const ::com::sun::star::uno::Exception& )
 241     {
 242     }
 243 }
 244
 245
 246
 247
 248 void SAL_CALL DropTargetHelper::DropTargetListener::dropActionChanged( const DropTargetDragEvent& ) throw( RuntimeException, std::exception )
 249 {
 250 }
 251
 252
 253 // - DropTargetHelper -
 254
 255
 256 DropTargetHelper::DropTargetHelper( vcl::Window* pWindow ) :
 257     mxDropTarget( pWindow->GetDropTarget() ),
 258     mpFormats( new DataFlavorExVector )
 259 {
 260     ImplConstruct();
 261 }
 262
 263
 264
 265 DropTargetHelper::DropTargetHelper( const Reference< XDropTarget >& rxDropTarget ) :
 266     mxDropTarget( rxDropTarget ),
 267     mpFormats( new DataFlavorExVector )
 268 {
 269     ImplConstruct();
 270 }
 271
 272
 273
 274 DropTargetHelper::~DropTargetHelper()
 275 {
 276     if( mxDropTarget.is() )
 277         mxDropTarget->removeDropTargetListener( mxDropTargetListener );
 278
 279     delete mpFormats;
 280 }
 281
 282
 283
 284 void DropTargetHelper::ImplConstruct()
 285 {
 286     if( mxDropTarget.is() )
 287     {
 288         mxDropTargetListener = new DropTargetHelper::DropTargetListener( *this );
 289         mxDropTarget->addDropTargetListener( mxDropTargetListener );
 290         mxDropTarget->setActive( sal_True );
 291     }
 292 }
 293
 294
 295
 296 void DropTargetHelper::ImplBeginDrag( const Sequence< DataFlavor >& rSupportedDataFlavors )
 297 {
 298     mpFormats->clear();
 299     TransferableDataHelper::FillDataFlavorExVector( rSupportedDataFlavors, *mpFormats );
 300 }
 301
 302
 303
 304 void DropTargetHelper::ImplEndDrag()
 305 {
 306     mpFormats->clear();
 307 }
 308
 309
 310
 311 sal_Int8 DropTargetHelper::AcceptDrop( const AcceptDropEvent& )
 312 {
 313     return( DNDConstants::ACTION_NONE );
 314 }
 315
 316
 317
 318 sal_Int8 DropTargetHelper::ExecuteDrop( const ExecuteDropEvent& )
 319 {
 320     return( DNDConstants::ACTION_NONE );
 321 }
 322
 323
 324
 325 bool DropTargetHelper::IsDropFormatSupported( SotClipboardFormatId nFormat )
 326 {
 327     DataFlavorExVector::iterator    aIter( mpFormats->begin() ), aEnd( mpFormats->end() );
 328     bool                            bRet = false;
 329
 330     while( aIter != aEnd )
 331     {
 332         if( nFormat == (*aIter++).mnSotId )
 333         {
 334             bRet = true;
 335             aIter = aEnd;
 336         }
 337     }
 338
 339     return bRet;
 340 }
 341
 342
 343
 344 bool DropTargetHelper::IsDropFormatSupported( const DataFlavor& rFlavor )
 345 {
 346     DataFlavorExVector::iterator    aIter( mpFormats->begin() ), aEnd( mpFormats->end() );
 347     bool                            bRet = false;
 348
 349     while( aIter != aEnd )
 350     {
 351         if( TransferableDataHelper::IsEqual( rFlavor, *aIter++ ) )
 352         {
 353             bRet = true;
 354             aIter = aEnd;
 355         }
 356     }
 357
 358     return bRet;
 359 }
 360
 361
 362 // TransferDataContainer
 363
 364
 365 struct TDataCntnrEntry_Impl
 366 {
 367     ::com::sun::star::uno::Any aAny;
 368     SotClipboardFormatId nId;
 369 };
 370
 371
 372
 373 typedef ::std::list< TDataCntnrEntry_Impl > TDataCntnrEntryList;
 374
 375
 376
 377 struct TransferDataContainer_Impl
 378 {
 379     TDataCntnrEntryList aFmtList;
 380     Link<> aFinshedLnk;
 381     INetBookmark* pBookmk;
 382     Graphic* pGrf;
 383
 384     TransferDataContainer_Impl()
 385         : pBookmk( 0 ), pGrf( 0 )
 386     {
 387     }
 388
 389     ~TransferDataContainer_Impl()
 390     {
 391         delete pBookmk;
 392         delete pGrf;
 393     }
 394 };
 395
 396
 397
 398 TransferDataContainer::TransferDataContainer()
 399     : pImpl( new TransferDataContainer_Impl )
 400 {
 401 }
 402
 403
 404
 405 TransferDataContainer::~TransferDataContainer()
 406 {
 407     delete pImpl;
 408 }
 409
 410
 411
 412 void TransferDataContainer::AddSupportedFormats()
 413 {
 414 }
 415
 416
 417
 418 bool TransferDataContainer::GetData(
 419     const css::datatransfer::DataFlavor& rFlavor, const OUString& /*rDestDoc*/ )
 420 {
 421     TDataCntnrEntryList::iterator   aIter( pImpl->aFmtList.begin() ),
 422                                     aEnd( pImpl->aFmtList.end() );
 423     bool bFnd = false;
 424     SotClipboardFormatId nFmtId = SotExchange::GetFormat( rFlavor );
 425
 426     // test first the list
 427     for( ; aIter != aEnd; ++aIter )
 428     {
 429         TDataCntnrEntry_Impl& rEntry = (TDataCntnrEntry_Impl&)*aIter;
 430         if( nFmtId == rEntry.nId )
 431         {
 432             bFnd = SetAny( rEntry.aAny, rFlavor );
 433             break;
 434         }
 435     }
 436
 437     // test second the bookmark pointer
 438     if( !bFnd )
 439         switch( nFmtId )
 440         {
 441          case SotClipboardFormatId::STRING:
 442          case SotClipboardFormatId::SOLK:
 443          case SotClipboardFormatId::NETSCAPE_BOOKMARK:
 444          case SotClipboardFormatId::FILECONTENT:
 445          case SotClipboardFormatId::FILEGRPDESCRIPTOR:
 446          case SotClipboardFormatId::UNIFORMRESOURCELOCATOR:
 447             if( pImpl->pBookmk )
 448                 bFnd = SetINetBookmark( *pImpl->pBookmk, rFlavor );
 449             break;
 450
 451         case SotClipboardFormatId::SVXB:
 452         case SotClipboardFormatId::PNG:
 453         case SotClipboardFormatId::BITMAP:
 454         case SotClipboardFormatId::GDIMETAFILE:
 455             if( pImpl->pGrf )
 456                 bFnd = SetGraphic( *pImpl->pGrf, rFlavor );
 457             break;
 458         default: break;
 459         }
 460
 461     return bFnd;
 462 }
 463
 464
 465
 466 void TransferDataContainer::CopyINetBookmark( const INetBookmark& rBkmk )
 467 {
 468     if( !pImpl->pBookmk )
 469         pImpl->pBookmk = new INetBookmark( rBkmk );
 470     else
 471         *pImpl->pBookmk = rBkmk;
 472
 473      AddFormat( SotClipboardFormatId::STRING );
 474      AddFormat( SotClipboardFormatId::SOLK );
 475      AddFormat( SotClipboardFormatId::NETSCAPE_BOOKMARK );
 476      AddFormat( SotClipboardFormatId::FILECONTENT );
 477      AddFormat( SotClipboardFormatId::FILEGRPDESCRIPTOR );
 478      AddFormat( SotClipboardFormatId::UNIFORMRESOURCELOCATOR );
 479 }
 480
 481
 482
 483 void TransferDataContainer::CopyAnyData( SotClipboardFormatId nFormatId,
 484                                         const sal_Char* pData, sal_uLong nLen )
 485 {
 486     if( nLen )
 487     {
 488         TDataCntnrEntry_Impl aEntry;
 489         aEntry.nId = nFormatId;
 490
 491         Sequence< sal_Int8 > aSeq( nLen  );
 492         memcpy( aSeq.getArray(), pData, nLen );
 493         aEntry.aAny <<= aSeq;
 494         pImpl->aFmtList.push_back( aEntry );
 495          AddFormat( nFormatId );
 496     }
 497 }
 498
 499
 500
 501 void TransferDataContainer::CopyByteString( SotClipboardFormatId nFormatId,
 502                                             const OString& rStr )
 503 {
 504     CopyAnyData( nFormatId, rStr.getStr(), rStr.getLength() );
 505 }
 506
 507
 508
 509 void TransferDataContainer::CopyINetImage( const INetImage& rINtImg )
 510 {
 511     SvMemoryStream aMemStm( 1024, 1024 );
 512     aMemStm.SetVersion( SOFFICE_FILEFORMAT_50 );
 513     rINtImg.Write( aMemStm, SotClipboardFormatId::INET_IMAGE );
 514     CopyAnyData( SotClipboardFormatId::INET_IMAGE, static_cast<sal_Char const *>(aMemStm.GetData()),
 515                     aMemStm.Seek( STREAM_SEEK_TO_END ) );
 516 }
 517
 518
 519
 520 void TransferDataContainer::CopyImageMap( const ImageMap& rImgMap )
 521 {
 522     SvMemoryStream aMemStm( 8192, 8192 );
 523     aMemStm.SetVersion( SOFFICE_FILEFORMAT_50 );
 524     rImgMap.Write( aMemStm, OUString() );
 525     CopyAnyData( SotClipboardFormatId::SVIM, static_cast<sal_Char const *>(aMemStm.GetData()),
 526                     aMemStm.Seek( STREAM_SEEK_TO_END ) );
 527 }
 528
 529
 530
 531 void TransferDataContainer::CopyGraphic( const Graphic& rGrf )
 532 {
 533     GraphicType nType = rGrf.GetType();
 534     if( GRAPHIC_NONE != nType )
 535     {
 536         if( !pImpl->pGrf )
 537             pImpl->pGrf = new Graphic( rGrf );
 538         else
 539             *pImpl->pGrf = rGrf;
 540
 541         AddFormat( SotClipboardFormatId::SVXB );
 542
 543         if( GRAPHIC_BITMAP == nType )
 544         {
 545             AddFormat( SotClipboardFormatId::PNG );
 546             AddFormat( SotClipboardFormatId::BITMAP );
 547         }
 548         else if( GRAPHIC_GDIMETAFILE == nType )
 549         {
 550             AddFormat( SotClipboardFormatId::GDIMETAFILE );
 551         }
 552     }
 553 }
 554
 555
 556
 557 void TransferDataContainer::CopyString( SotClipboardFormatId nFmt, const OUString& rStr )
 558 {
 559     if( !rStr.isEmpty() )
 560     {
 561         TDataCntnrEntry_Impl aEntry;
 562         aEntry.nId = nFmt;
 563         OUString aStr( rStr );
 564         aEntry.aAny <<= aStr;
 565         pImpl->aFmtList.push_back( aEntry );
 566          AddFormat( aEntry.nId );
 567     }
 568 }
 569
 570
 571
 572 void TransferDataContainer::CopyString( const OUString& rStr )
 573 {
 574     CopyString( SotClipboardFormatId::STRING, rStr );
 575 }
 576
 577
 578
 579 void TransferDataContainer::CopyAny( SotClipboardFormatId nFmt,
 580                                     const ::com::sun::star::uno::Any& rAny )
 581 {
 582     TDataCntnrEntry_Impl aEntry;
 583     aEntry.nId = nFmt;
 584     aEntry.aAny = rAny;
 585     pImpl->aFmtList.push_back( aEntry );
 586     AddFormat( aEntry.nId );
 587 }
 588
 589
 590
 591 bool TransferDataContainer::HasAnyData() const
 592 {
 593     return pImpl->aFmtList.begin() != pImpl->aFmtList.end() ||
 594             0 != pImpl->pBookmk;
 595 }
 596
 597
 598
 599 void TransferDataContainer::StartDrag(
 600         vcl::Window* pWindow, sal_Int8 nDragSourceActions,
 601         const Link<>& rLnk, sal_Int32 nDragPointer, sal_Int32 nDragImage )
 602 {
 603     pImpl->aFinshedLnk = rLnk;
 604     TransferableHelper::StartDrag( pWindow, nDragSourceActions,
 605                                     nDragPointer, nDragImage );
 606 }
 607
 608
 609
 610 void TransferDataContainer::DragFinished( sal_Int8 nDropAction )
 611 {
 612     if( pImpl->aFinshedLnk.IsSet() )
 613         pImpl->aFinshedLnk.Call( &nDropAction );
 614 }
 615
 616 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */