vcl/aqua/source/dtrans/DropTarget.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: DropTarget.cxx,v $
  10  * $Revision: 1.5 $
  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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_vcl.hxx"
  33 #include <com/sun/star/datatransfer/dnd/DNDConstants.hpp>
  34 #include <com/sun/star/datatransfer/XTransferable.hpp>
  35 #include <com/sun/star/datatransfer/dnd/DropTargetDragEnterEvent.hpp>
  36 #include <rtl/unload.h>
  37
  38 #ifndef COMPHELPER_MAKESEQUENCE_HXX_INCLUDED
  39 #include "comphelper/makesequence.hxx"
  40 #endif
  41 #include <cppuhelper/interfacecontainer.hxx>
  42
  43 #include "aqua_clipboard.hxx"
  44 #include "DropTarget.hxx"
  45 #include "DragActionConversion.hxx"
  46
  47 #include "DragSource.hxx"
  48
  49 #include <rtl/ustring.h>
  50 #include <stdio.h>
  51
  52 #include <premac.h>
  53 #include <Carbon/Carbon.h>
  54 #include <postmac.h>
  55
  56
  57 using namespace rtl;
  58 using namespace cppu;
  59 using namespace osl;
  60 using namespace com::sun::star::datatransfer;
  61 using namespace com::sun::star::datatransfer::dnd;
  62 using namespace com::sun::star::datatransfer::dnd::DNDConstants;
  63 using namespace com::sun::star::datatransfer::clipboard;
  64 using namespace com::sun::star::lang;
  65 using namespace com::sun::star::uno;
  66 using namespace comphelper;
  67
  68 OUString dropTarget_getImplementationName()
  69 {
  70   return OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.datatransfer.dnd.OleDropTarget_V1"));
  71 }
  72
  73
  74 Sequence<OUString> dropTarget_getSupportedServiceNames()
  75 {
  76   return makeSequence(OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.datatransfer.dnd.OleDropTarget")));
  77 }
  78
  79
  80 namespace /* private */
  81 {
  82   // Cocoa's coordinate system has its origin lower-left, VCL's
  83   // coordinate system upper-left hence we need to transform
  84   // coordinates
  85
  86   inline void CocoaToVCL(NSPoint& rPoint, const NSRect& bounds)
  87   {
  88     rPoint.y = bounds.size.height - rPoint.y;
  89   }
  90
  91   inline void CocoaToVCL(NSRect& rRect, const NSRect& bounds)
  92   {
  93     rRect.origin.y = bounds.size.height - (rRect.origin.y + rRect.size.height);
  94   }
  95 }
  96
  97
  98 @implementation DropTargetHelper
  99
 100
 101 -(DropTargetHelper*)initWithDropTarget:(DropTarget*)pdt
 102 {
 103   self = [super init];
 104
 105   if (self)
 106     {
 107       mDropTarget = pdt;
 108     }
 109
 110   return self;
 111 }
 112
 113
 114 -(NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender
 115 {
 116   return mDropTarget->draggingEntered(sender);
 117 }
 118
 119
 120 -(NSDragOperation)draggingUpdated:(id <NSDraggingInfo>)sender
 121 {
 122   return mDropTarget->draggingUpdated(sender);
 123 }
 124
 125
 126 -(void)draggingExited:(id <NSDraggingInfo>)sender
 127 {
 128   mDropTarget->draggingExited(sender);
 129 }
 130
 131
 132 -(MacOSBOOL)prepareForDragOperation:(id <NSDraggingInfo>)sender
 133 {
 134   return mDropTarget->prepareForDragOperation(sender);
 135 }
 136
 137
 138 -(MacOSBOOL)performDragOperation:(id <NSDraggingInfo>)sender
 139 {
 140   return mDropTarget->performDragOperation(sender);
 141 }
 142
 143
 144 -(void)concludeDragOperation:(id <NSDraggingInfo>)sender
 145 {
 146   mDropTarget->concludeDragOperation(sender);
 147 }
 148
 149
 150 @end
 151
 152
 153 DropTarget::DropTarget() :
 154   WeakComponentImplHelper5<XInitialization, XDropTarget, XDropTargetDragContext, XDropTargetDropContext, XServiceInfo>(m_aMutex),
 155   mDropTargetHelper(nil),
 156   mbActive(false),
 157   mDragSourceSupportedActions(DNDConstants::ACTION_NONE),
 158   mSelectedDropAction(DNDConstants::ACTION_NONE),
 159   mDefaultActions(DNDConstants::ACTION_COPY_OR_MOVE | DNDConstants::ACTION_LINK | DNDConstants::ACTION_DEFAULT)
 160 {
 161   mDataFlavorMapper = DataFlavorMapperPtr_t(new DataFlavorMapper());
 162 }
 163
 164
 165 DropTarget::~DropTarget()
 166 {
 167   [(id <DraggingDestinationHandler>)mView unregisterDraggingDestinationHandler:mDropTargetHelper];
 168   [mDropTargetHelper release];
 169 }
 170
 171
 172 sal_Int8 DropTarget::determineDropAction(sal_Int8 dropActions, id sender) const
 173 {
 174   sal_Int8 dropAct = dropActions;
 175   bool srcAndDestEqual = false;
 176
 177   if ([sender draggingSource] != nil)
 178     {
 179       // Internal DnD
 180       NSView* destView = [[sender draggingDestinationWindow] contentView];
 181       srcAndDestEqual = (DragSource::g_DragSourceView == destView);
 182     }
 183
 184   // If ACTION_DEFAULT is set this means NSDragOperationGeneric
 185   // has been set and we map this to ACTION_MOVE or ACTION_COPY
 186   // depending on whether or not source and dest are equal,
 187   // this hopefully satisfies all parties
 188   if( (dropActions == DNDConstants::ACTION_DEFAULT)
 189   || ((dropActions == mDragSourceSupportedActions)
 190      && !(~mDragSourceSupportedActions & DNDConstants::ACTION_COPY_OR_MOVE ) ) )
 191     {
 192       dropAct = srcAndDestEqual ? DNDConstants::ACTION_MOVE :
 193         DNDConstants::ACTION_COPY;
 194     }
 195      // if more than one drop actions have been specified
 196      // set ACTION_DEFAULT in order to let the drop target
 197      // decide which one to use
 198   else if (dropActions != DNDConstants::ACTION_NONE &&
 199            dropActions != DNDConstants::ACTION_MOVE &&
 200            dropActions != DNDConstants::ACTION_COPY &&
 201            dropActions != DNDConstants::ACTION_LINK)
 202     {
 203       if (srcAndDestEqual)
 204         {
 205           dropAct = dropActions;
 206         }
 207       else // source and destination are different
 208         {
 209           if (dropActions & DNDConstants::ACTION_COPY)
 210             dropAct = DNDConstants::ACTION_COPY;
 211           else if (dropActions & DNDConstants::ACTION_MOVE)
 212             dropAct = DNDConstants::ACTION_MOVE;
 213           else if (dropActions & DNDConstants::ACTION_LINK)
 214             dropAct = DNDConstants::ACTION_LINK;
 215         }
 216
 217       dropAct |= DNDConstants::ACTION_DEFAULT;
 218     }
 219
 220   return dropAct;
 221 }
 222
 223
 224 NSDragOperation DropTarget::draggingEntered(id sender)
 225 {
 226   // Initially when DnD will be started no modifier key can be pressed yet
 227   // thus we are getting all actions that the drag source supports, we save
 228   // this value because later the system masks the drag source actions if
 229   // a modifier key will be pressed
 230   mDragSourceSupportedActions = SystemToOfficeDragActions([sender draggingSourceOperationMask]);
 231
 232   // Only if the drop target is really interessted in the drag actions
 233   // supported by the source
 234   if (mDragSourceSupportedActions & mDefaultActions)
 235     {
 236       sal_Int8 currentAction = determineDropAction(mDragSourceSupportedActions, sender);
 237
 238       NSRect bounds = [mView bounds];
 239       NSPoint dragLocation = [sender draggedImageLocation];
 240
 241       CocoaToVCL(dragLocation, bounds);
 242
 243       sal_Int32 posX = static_cast<sal_Int32>(dragLocation.x);
 244       sal_Int32 posY = static_cast<sal_Int32>(dragLocation.y);
 245
 246       NSPasteboard* dragPboard = [sender draggingPasteboard];
 247       mXCurrentDragClipboard = new AquaClipboard(dragPboard, false);
 248
 249       Reference<XTransferable> xTransferable = DragSource::g_XTransferable.is() ?
 250         DragSource::g_XTransferable : mXCurrentDragClipboard->getContents();
 251
 252       DropTargetDragEnterEvent dtdee(static_cast<OWeakObject*>(this),
 253                                      0,
 254                                      this,
 255                                      currentAction,
 256                                      posX,
 257                                      posY,
 258                                      mDragSourceSupportedActions,
 259                                      xTransferable->getTransferDataFlavors());
 260
 261       fire_dragEnter(dtdee);
 262     }
 263
 264   return OfficeToSystemDragActions(mSelectedDropAction);
 265 }
 266
 267
 268 NSDragOperation DropTarget::draggingUpdated(id sender)
 269 {
 270   sal_Int8 currentDragSourceActions =
 271     SystemToOfficeDragActions([sender draggingSourceOperationMask]);
 272   NSDragOperation dragOp = NSDragOperationNone;
 273
 274   if (currentDragSourceActions & mDefaultActions)
 275     {
 276       sal_Int8 currentAction = determineDropAction(currentDragSourceActions, sender);
 277       NSRect bounds = [mView bounds];
 278       NSPoint dragLocation = [sender draggedImageLocation];
 279
 280       CocoaToVCL(dragLocation, bounds);
 281
 282       sal_Int32 posX = static_cast<sal_Int32>(dragLocation.x);
 283       sal_Int32 posY = static_cast<sal_Int32>(dragLocation.y);
 284
 285       DropTargetDragEvent dtde(static_cast<OWeakObject*>(this),
 286                                0,
 287                                this,
 288                                currentAction,
 289                                posX,
 290                                posY,
 291                                mDragSourceSupportedActions);
 292
 293       fire_dragOver(dtde);
 294
 295       // drag over callbacks likely have rendered something
 296       [mView setNeedsDisplay: TRUE];
 297
 298       dragOp = OfficeToSystemDragActions(mSelectedDropAction);
 299
 300       //NSLog(@"Drag update: Source actions: %x proposed action %x selected action %x", mDragSourceSupportedActions, currentAction, mSelectedDropAction);
 301     }
 302
 303   // Weird but it appears as if there is no method in Cocoa
 304   // to create a kThemeCopyArrowCursor hence we have to use
 305   // Carbon to do it
 306   if (dragOp == NSDragOperationNone)
 307     SetThemeCursor(kThemeNotAllowedCursor);
 308   else if (dragOp == NSDragOperationCopy)
 309     SetThemeCursor(kThemeCopyArrowCursor);
 310   else
 311     SetThemeCursor(kThemeArrowCursor);
 312
 313   return dragOp;
 314 }
 315
 316
 317   void DropTarget::draggingExited(id sender)
 318   {
 319     DropTargetEvent dte(static_cast<OWeakObject*>(this), 0);
 320     fire_dragExit(dte);
 321     mDragSourceSupportedActions = DNDConstants::ACTION_NONE;
 322     mSelectedDropAction = DNDConstants::ACTION_NONE;
 323     SetThemeCursor(kThemeArrowCursor);
 324   }
 325
 326
 327   MacOSBOOL DropTarget::prepareForDragOperation(id sender)
 328   {
 329     return 1;
 330   }
 331
 332
 333 MacOSBOOL DropTarget::performDragOperation(id sender)
 334 {
 335   bool bSuccess = false;
 336
 337   if (mSelectedDropAction != DNDConstants::ACTION_NONE)
 338     {
 339       Reference<XTransferable> xTransferable = DragSource::g_XTransferable;
 340
 341       if (!DragSource::g_XTransferable.is())
 342         {
 343           xTransferable = mXCurrentDragClipboard->getContents();
 344         }
 345
 346       NSRect bounds = [mView bounds];
 347       NSPoint dragLocation = [sender draggedImageLocation];
 348
 349       CocoaToVCL(dragLocation, bounds);
 350
 351       sal_Int32 posX = static_cast<sal_Int32>(dragLocation.x);
 352       sal_Int32 posY = static_cast<sal_Int32>(dragLocation.y);
 353
 354       DropTargetDropEvent dtde(static_cast<OWeakObject*>(this),
 355                                0,
 356                                this,
 357                                mSelectedDropAction,
 358                                posX,
 359                                posY,
 360                                mDragSourceSupportedActions,
 361                                xTransferable);
 362
 363       fire_drop(dtde);
 364
 365       bSuccess = true;
 366     }
 367
 368   return bSuccess;
 369 }
 370
 371
 372   void DropTarget::concludeDragOperation(id sender)
 373   {
 374     mDragSourceSupportedActions = DNDConstants::ACTION_NONE;
 375     mSelectedDropAction = DNDConstants::ACTION_NONE;
 376     mXCurrentDragClipboard = Reference<XClipboard>();
 377     SetThemeCursor(kThemeArrowCursor);
 378   }
 379
 380
 381   // called from WeakComponentImplHelperX::dispose
 382   // WeakComponentImplHelper calls disposing before it destroys
 383   // itself.
 384   void SAL_CALL DropTarget::disposing()
 385   {
 386   }
 387
 388
 389   void SAL_CALL DropTarget::initialize(const Sequence< Any >& aArguments)
 390     throw(Exception)
 391   {
 392     if (aArguments.getLength() < 2)
 393       {
 394         throw RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM("DropTarget::initialize: Cannot install window event handler")),
 395                                static_cast<OWeakObject*>(this));
 396       }
 397
 398     Any pNSView = aArguments[0];
 399     sal_uInt64 tmp = 0;
 400     pNSView >>= tmp;
 401     mView = (id)tmp;
 402
 403     mDropTargetHelper = [[DropTargetHelper alloc] initWithDropTarget: this];
 404
 405     [(id <DraggingDestinationHandler>)mView registerDraggingDestinationHandler:mDropTargetHelper];
 406     [mView registerForDraggedTypes: mDataFlavorMapper->getAllSupportedPboardTypes()];
 407
 408     id wnd = [mView window];
 409     NSWindow* parentWnd = [wnd parentWindow];
 410     unsigned int topWndStyle = (NSTitledWindowMask | NSClosableWindowMask | NSResizableWindowMask);
 411     unsigned int wndStyles = [wnd styleMask] & topWndStyle;
 412
 413     if (parentWnd == nil && (wndStyles == topWndStyle))
 414       {
 415         [wnd registerDraggingDestinationHandler:mDropTargetHelper];
 416         [wnd registerForDraggedTypes: [NSArray arrayWithObjects: NSFilenamesPboardType, nil]];
 417       }
 418   }
 419
 420
 421   void SAL_CALL DropTarget::addDropTargetListener(const Reference<XDropTargetListener>& dtl)
 422     throw(RuntimeException)
 423   {
 424     rBHelper.addListener(::getCppuType(&dtl), dtl);
 425   }
 426
 427
 428   void SAL_CALL DropTarget::removeDropTargetListener(const Reference<XDropTargetListener>& dtl)
 429     throw(RuntimeException)
 430   {
 431     rBHelper.removeListener(::getCppuType(&dtl), dtl);
 432   }
 433
 434
 435   sal_Bool SAL_CALL DropTarget::isActive(  ) throw(RuntimeException)
 436   {
 437     return mbActive;
 438   }
 439
 440
 441   void SAL_CALL DropTarget::setActive(sal_Bool active) throw(RuntimeException)
 442   {
 443     mbActive = active;
 444   }
 445
 446
 447   sal_Int8 SAL_CALL DropTarget::getDefaultActions() throw(RuntimeException)
 448   {
 449     return mDefaultActions;
 450   }
 451
 452
 453   void SAL_CALL DropTarget::setDefaultActions(sal_Int8 actions) throw(RuntimeException)
 454   {
 455     OSL_ENSURE( actions < 8, "No valid default actions");
 456     mDefaultActions= actions;
 457   }
 458
 459
 460   // XDropTargetDragContext
 461
 462   void SAL_CALL DropTarget::acceptDrag(sal_Int8 dragOperation) throw (RuntimeException)
 463   {
 464     mSelectedDropAction = dragOperation;
 465   }
 466
 467
 468   void SAL_CALL DropTarget::rejectDrag() throw (RuntimeException)
 469   {
 470     mSelectedDropAction = DNDConstants::ACTION_NONE;
 471   }
 472
 473
 474   //XDropTargetDropContext
 475
 476   void SAL_CALL DropTarget::acceptDrop(sal_Int8 dropOperation) throw( RuntimeException)
 477   {
 478     mSelectedDropAction = dropOperation;
 479   }
 480
 481
 482   void SAL_CALL DropTarget::rejectDrop() throw (RuntimeException)
 483   {
 484     mSelectedDropAction = DNDConstants::ACTION_NONE;
 485   }
 486
 487
 488   void SAL_CALL DropTarget::dropComplete(sal_Bool success) throw (RuntimeException)
 489   {
 490     // Reset the internal transferable used as shortcut in case this is
 491     // an internal D&D operation
 492     DragSource::g_XTransferable = Reference<XTransferable>();
 493     DragSource::g_DropSuccessSet = true;
 494     DragSource::g_DropSuccess = success;
 495   }
 496
 497
 498   void DropTarget::fire_drop( const DropTargetDropEvent& dte)
 499   {
 500     OInterfaceContainerHelper* pContainer= rBHelper.getContainer( getCppuType( (Reference<XDropTargetListener>* )0 ) );
 501     if( pContainer)
 502       {
 503         OInterfaceIteratorHelper iter( *pContainer);
 504         while( iter.hasMoreElements())
 505           {
 506             Reference<XDropTargetListener> listener( static_cast<XDropTargetListener*>( iter.next()));
 507
 508             try { listener->drop( dte); }
 509             catch(RuntimeException&) {}
 510           }
 511       }
 512   }
 513
 514
 515   void DropTarget::fire_dragEnter(const DropTargetDragEnterEvent& e)
 516   {
 517     OInterfaceContainerHelper* pContainer= rBHelper.getContainer( getCppuType( (Reference<XDropTargetListener>* )0 ) );
 518     if( pContainer)
 519       {
 520         OInterfaceIteratorHelper iter( *pContainer);
 521         while( iter.hasMoreElements())
 522           {
 523             Reference<XDropTargetListener> listener( static_cast<XDropTargetListener*>( iter.next()));
 524
 525             try { listener->dragEnter( e); }
 526             catch (RuntimeException&) {}
 527           }
 528       }
 529   }
 530
 531
 532   void DropTarget::fire_dragExit(const DropTargetEvent& dte)
 533   {
 534     OInterfaceContainerHelper* pContainer= rBHelper.getContainer( getCppuType( (Reference<XDropTargetListener>* )0 ) );
 535
 536     if( pContainer)
 537       {
 538         OInterfaceIteratorHelper iter( *pContainer);
 539         while( iter.hasMoreElements())
 540           {
 541             Reference<XDropTargetListener> listener( static_cast<XDropTargetListener*>( iter.next()));
 542
 543             try { listener->dragExit( dte); }
 544             catch (RuntimeException&) {}
 545           }
 546       }
 547   }
 548
 549
 550   void DropTarget::fire_dragOver(const DropTargetDragEvent& dtde)
 551   {
 552     OInterfaceContainerHelper* pContainer= rBHelper.getContainer( getCppuType( (Reference<XDropTargetListener>* )0 ) );
 553     if( pContainer)
 554       {
 555         OInterfaceIteratorHelper iter( *pContainer );
 556         while( iter.hasMoreElements())
 557           {
 558             Reference<XDropTargetListener> listener( static_cast<XDropTargetListener*>( iter.next()));
 559
 560             try { listener->dragOver( dtde); }
 561             catch (RuntimeException&) {}
 562           }
 563       }
 564   }
 565
 566
 567   void DropTarget::fire_dropActionChanged(const DropTargetDragEvent& dtde)
 568   {
 569     OInterfaceContainerHelper* pContainer= rBHelper.getContainer( getCppuType( (Reference<XDropTargetListener>* )0 ) );
 570     if( pContainer)
 571       {
 572         OInterfaceIteratorHelper iter( *pContainer);
 573         while( iter.hasMoreElements())
 574           {
 575             Reference<XDropTargetListener> listener( static_cast<XDropTargetListener*>( iter.next()));
 576
 577             try { listener->dropActionChanged( dtde); }
 578             catch (RuntimeException&) {}
 579           }
 580       }
 581   }
 582
 583
 584   // XServiceInfo
 585
 586   OUString SAL_CALL DropTarget::getImplementationName() throw (RuntimeException)
 587   {
 588     return dropTarget_getImplementationName();
 589   }
 590
 591
 592   sal_Bool SAL_CALL DropTarget::supportsService( const OUString& ServiceName ) throw (RuntimeException)
 593   {
 594     return ServiceName.equals(OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.datatransfer.dnd.OleDropTarget")));
 595   }
 596
 597
 598   Sequence< OUString > SAL_CALL DropTarget::getSupportedServiceNames(  ) throw (RuntimeException)
 599   {
 600     return dropTarget_getSupportedServiceNames();
 601   }
 602