vcl/source/window/dndlcon.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
  21 #include <dndlcon.hxx>
  22
  23 using namespace ::cppu;
  24 using namespace ::com::sun::star::uno;
  25 using namespace ::com::sun::star::datatransfer;
  26 using namespace ::com::sun::star::datatransfer::dnd;
  27
  28 //==================================================================================================
  29 //
  30 //==================================================================================================
  31
  32 DNDListenerContainer::DNDListenerContainer( sal_Int8 nDefaultActions )
  33     : WeakComponentImplHelper4< XDragGestureRecognizer, XDropTargetDragContext, XDropTargetDropContext, XDropTarget >(GetMutex())
  34 {
  35     m_bActive = sal_True;
  36     m_nDefaultActions = nDefaultActions;
  37 }
  38
  39 //==================================================================================================
  40 //
  41 //==================================================================================================
  42
  43 DNDListenerContainer::~DNDListenerContainer()
  44 {
  45 }
  46
  47 //==================================================================================================
  48 // DNDListenerContainer::addDragGestureListener
  49 //==================================================================================================
  50
  51 void SAL_CALL DNDListenerContainer::addDragGestureListener( const Reference< XDragGestureListener >& dgl )
  52     throw(RuntimeException)
  53 {
  54     rBHelper.addListener( getCppuType( ( const Reference< XDragGestureListener > * ) 0 ), dgl );
  55 }
  56
  57 //==================================================================================================
  58 // DNDListenerContainer::removeDragGestureListener
  59 //==================================================================================================
  60
  61 void SAL_CALL DNDListenerContainer::removeDragGestureListener( const Reference< XDragGestureListener >& dgl )
  62     throw(RuntimeException)
  63 {
  64     rBHelper.removeListener( getCppuType( ( const Reference< XDragGestureListener > * ) 0 ), dgl );
  65 }
  66
  67 //==================================================================================================
  68 // DNDListenerContainer::resetRecognizer
  69 //==================================================================================================
  70
  71 void SAL_CALL DNDListenerContainer::resetRecognizer(  )
  72     throw(RuntimeException)
  73 {
  74 }
  75
  76 //==================================================================================================
  77 // DNDListenerContainer::addDropTargetListener
  78 //==================================================================================================
  79
  80 void SAL_CALL DNDListenerContainer::addDropTargetListener( const Reference< XDropTargetListener >& dtl )
  81     throw(RuntimeException)
  82 {
  83     rBHelper.addListener( getCppuType( ( const Reference< XDropTargetListener > * ) 0 ), dtl );
  84 }
  85
  86 //==================================================================================================
  87 // DNDListenerContainer::removeDropTargetListener
  88 //==================================================================================================
  89
  90 void SAL_CALL DNDListenerContainer::removeDropTargetListener( const Reference< XDropTargetListener >& dtl )
  91     throw(RuntimeException)
  92 {
  93     rBHelper.removeListener( getCppuType( ( const Reference< XDropTargetListener > * ) 0 ), dtl );
  94 }
  95
  96 //==================================================================================================
  97 // DNDListenerContainer::isActive
  98 //==================================================================================================
  99
 100 sal_Bool SAL_CALL DNDListenerContainer::isActive(  )
 101     throw(RuntimeException)
 102 {
 103     return m_bActive;
 104 }
 105
 106 //==================================================================================================
 107 // DNDListenerContainer::setActive
 108 //==================================================================================================
 109
 110 void SAL_CALL DNDListenerContainer::setActive( sal_Bool active )
 111     throw(RuntimeException)
 112 {
 113     m_bActive = active;
 114 }
 115
 116 //==================================================================================================
 117 // DNDListenerContainer::getDefaultActions
 118 //==================================================================================================
 119
 120 sal_Int8 SAL_CALL DNDListenerContainer::getDefaultActions(  )
 121     throw(RuntimeException)
 122 {
 123     return m_nDefaultActions;
 124 }
 125
 126 //==================================================================================================
 127 // DNDListenerContainer::setDefaultActions
 128 //==================================================================================================
 129
 130 void SAL_CALL DNDListenerContainer::setDefaultActions( sal_Int8 actions )
 131     throw(RuntimeException)
 132 {
 133     m_nDefaultActions = actions;
 134 }
 135
 136 //==================================================================================================
 137 // DNDListenerContainer::fireDropEvent
 138 //==================================================================================================
 139
 140 sal_uInt32 DNDListenerContainer::fireDropEvent( const Reference< XDropTargetDropContext >& context,
 141     sal_Int8 dropAction, sal_Int32 locationX, sal_Int32 locationY, sal_Int8 sourceActions,
 142     const Reference< XTransferable >& transferable )
 143 {
 144     sal_uInt32 nRet = 0;
 145
 146     // fire DropTargetDropEvent on all XDropTargetListeners
 147     OInterfaceContainerHelper *pContainer = rBHelper.getContainer( getCppuType( ( Reference < XDropTargetListener > * ) 0) );
 148
 149     if( pContainer && m_bActive )
 150     {
 151         OInterfaceIteratorHelper aIterator( *pContainer );
 152
 153         // remember context to use in own context methods
 154         m_xDropTargetDropContext = context;
 155
 156         // do not construct the event before you are sure at least one listener is registered
 157         DropTargetDropEvent aEvent( static_cast < XDropTarget * > (this), 0,
 158             static_cast < XDropTargetDropContext * > (this), dropAction,
 159             locationX, locationY, sourceActions, transferable );
 160
 161         while (aIterator.hasMoreElements())
 162         {
 163             // FIXME: this can be simplified as soon as the Iterator has a remove method
 164             Reference< XInterface > xElement( aIterator.next() );
 165
 166             try
 167             {
 168                 // this may result in a runtime exception
 169                 Reference < XDropTargetListener > xListener( xElement, UNO_QUERY );
 170
 171                 if( xListener.is() )
 172                 {
 173                     // fire drop until the first one has accepted
 174                     if( m_xDropTargetDropContext.is() )
 175                         xListener->drop( aEvent );
 176                     else
 177                     {
 178                         DropTargetEvent aDTEvent( static_cast < XDropTarget * > (this), 0 );
 179                         xListener->dragExit( aDTEvent );
 180                     }
 181
 182                     nRet++;
 183                 }
 184             }
 185             catch (const RuntimeException&)
 186             {
 187                 pContainer->removeInterface( xElement );
 188             }
 189         }
 190
 191         // if context still valid, then reject drop
 192         if( m_xDropTargetDropContext.is() )
 193         {
 194             m_xDropTargetDropContext.clear();
 195
 196             try
 197             {
 198                 context->rejectDrop();
 199             }
 200             catch (const RuntimeException&)
 201             {
 202             }
 203         }
 204     }
 205
 206     return nRet;
 207 }
 208
 209 //==================================================================================================
 210 // DNDListenerContainer::fireDragExitEvent
 211 //==================================================================================================
 212
 213 sal_uInt32 DNDListenerContainer::fireDragExitEvent()
 214 {
 215     sal_uInt32 nRet = 0;
 216
 217     // fire DropTargetDropEvent on all XDropTargetListeners
 218     OInterfaceContainerHelper *pContainer = rBHelper.getContainer( getCppuType( ( Reference < XDropTargetListener > * ) 0) );
 219
 220     if( pContainer && m_bActive )
 221     {
 222         OInterfaceIteratorHelper aIterator( *pContainer );
 223
 224         // do not construct the event before you are sure at least one listener is registered
 225         DropTargetEvent aEvent( static_cast < XDropTarget * > (this), 0 );
 226
 227         while (aIterator.hasMoreElements())
 228         {
 229             // FIXME: this can be simplified as soon as the Iterator has a remove method
 230             Reference< XInterface > xElement( aIterator.next() );
 231
 232             try
 233             {
 234                 // this may result in a runtime exception
 235                 Reference < XDropTargetListener > xListener( xElement, UNO_QUERY );
 236
 237                 if( xListener.is() )
 238                 {
 239                        xListener->dragExit( aEvent );
 240                     nRet++;
 241                 }
 242             }
 243             catch (const RuntimeException&)
 244             {
 245                 pContainer->removeInterface( xElement );
 246             }
 247         }
 248     }
 249
 250     return nRet;
 251 }
 252
 253 //==================================================================================================
 254 // DNDListenerContainer::fireDragOverEvent
 255 //==================================================================================================
 256
 257 sal_uInt32 DNDListenerContainer::fireDragOverEvent( const Reference< XDropTargetDragContext >& context,
 258     sal_Int8 dropAction, sal_Int32 locationX, sal_Int32 locationY, sal_Int8 sourceActions )
 259 {
 260     sal_uInt32 nRet = 0;
 261
 262     // fire DropTargetDropEvent on all XDropTargetListeners
 263     OInterfaceContainerHelper *pContainer = rBHelper.getContainer( getCppuType( ( Reference < XDropTargetListener > * ) 0) );
 264
 265     if( pContainer && m_bActive )
 266     {
 267         OInterfaceIteratorHelper aIterator( *pContainer );
 268
 269         // remember context to use in own context methods
 270         m_xDropTargetDragContext = context;
 271
 272         // do not construct the event before you are sure at least one listener is registered
 273         DropTargetDragEvent aEvent( static_cast < XDropTarget * > (this), 0,
 274             static_cast < XDropTargetDragContext * > (this),
 275             dropAction, locationX, locationY, sourceActions );
 276
 277         while (aIterator.hasMoreElements())
 278         {
 279             // FIXME: this can be simplified as soon as the Iterator has a remove method
 280             Reference< XInterface > xElement( aIterator.next() );
 281
 282             try
 283             {
 284                 // this may result in a runtime exception
 285                 Reference < XDropTargetListener > xListener( xElement, UNO_QUERY );
 286
 287                 if( xListener.is() )
 288                 {
 289                     if( m_xDropTargetDragContext.is() )
 290                         xListener->dragOver( aEvent );
 291                       nRet++;
 292                 }
 293             }
 294             catch (const RuntimeException&)
 295             {
 296                 pContainer->removeInterface( xElement );
 297             }
 298         }
 299
 300         // if context still valid, then reject drag
 301         if( m_xDropTargetDragContext.is() )
 302         {
 303             m_xDropTargetDragContext.clear();
 304
 305             try
 306             {
 307                 context->rejectDrag();
 308             }
 309             catch (const RuntimeException&)
 310             {
 311             }
 312         }
 313     }
 314
 315     return nRet;
 316 }
 317
 318 //==================================================================================================
 319 // DNDListenerContainer::fireDragEnterEvent
 320 //==================================================================================================
 321
 322 sal_uInt32 DNDListenerContainer::fireDragEnterEvent( const Reference< XDropTargetDragContext >& context,
 323     sal_Int8 dropAction, sal_Int32 locationX, sal_Int32 locationY, sal_Int8 sourceActions,
 324     const Sequence< DataFlavor >& dataFlavors )
 325 {
 326     sal_uInt32 nRet = 0;
 327
 328     // fire DropTargetDropEvent on all XDropTargetListeners
 329     OInterfaceContainerHelper *pContainer = rBHelper.getContainer( getCppuType( ( Reference < XDropTargetListener > * ) 0) );
 330
 331     if( pContainer && m_bActive )
 332     {
 333         OInterfaceIteratorHelper aIterator( *pContainer );
 334
 335         // remember context to use in own context methods
 336         m_xDropTargetDragContext = context;
 337
 338         // do not construct the event before you are sure at least one listener is registered
 339         DropTargetDragEnterEvent aEvent( static_cast < XDropTarget * > (this), 0,
 340             static_cast < XDropTargetDragContext * > (this),
 341             dropAction, locationX, locationY, sourceActions, dataFlavors );
 342
 343         while (aIterator.hasMoreElements())
 344         {
 345             // FIXME: this can be simplified as soon as the Iterator has a remove method
 346             Reference< XInterface > xElement( aIterator.next() );
 347
 348             try
 349             {
 350                 // this may result in a runtime exception
 351                 Reference < XDropTargetListener > xListener( xElement, UNO_QUERY );
 352
 353                 if( xListener.is() )
 354                 {
 355                     if( m_xDropTargetDragContext.is() )
 356                         xListener->dragEnter( aEvent );
 357                     nRet++;
 358                 }
 359             }
 360             catch (const RuntimeException&)
 361             {
 362                 pContainer->removeInterface( xElement );
 363             }
 364         }
 365
 366         // if context still valid, then reject drag
 367         if( m_xDropTargetDragContext.is() )
 368         {
 369             m_xDropTargetDragContext.clear();
 370
 371             try
 372             {
 373                 context->rejectDrag();
 374             }
 375             catch (const RuntimeException&)
 376             {
 377             }
 378         }
 379     }
 380
 381     return nRet;
 382 }
 383
 384 //==================================================================================================
 385 // DNDListenerContainer::fireDropActionChangedEvent
 386 //==================================================================================================
 387
 388 sal_uInt32 DNDListenerContainer::fireDropActionChangedEvent( const Reference< XDropTargetDragContext >& context,
 389     sal_Int8 dropAction, sal_Int32 locationX, sal_Int32 locationY, sal_Int8 sourceActions )
 390 {
 391     sal_uInt32 nRet = 0;
 392
 393     // fire DropTargetDropEvent on all XDropTargetListeners
 394     OInterfaceContainerHelper *pContainer = rBHelper.getContainer( getCppuType( ( Reference < XDropTargetListener > * ) 0) );
 395
 396     if( pContainer && m_bActive )
 397     {
 398         OInterfaceIteratorHelper aIterator( *pContainer );
 399
 400         // remember context to use in own context methods
 401         m_xDropTargetDragContext = context;
 402
 403         // do not construct the event before you are sure at least one listener is registered
 404         DropTargetDragEvent aEvent( static_cast < XDropTarget * > (this), 0,
 405             static_cast < XDropTargetDragContext * > (this),
 406             dropAction, locationX, locationY, sourceActions );
 407
 408         while (aIterator.hasMoreElements())
 409         {
 410             // FIXME: this can be simplified as soon as the Iterator has a remove method
 411             Reference< XInterface > xElement( aIterator.next() );
 412
 413             try
 414             {
 415                 // this may result in a runtime exception
 416                 Reference < XDropTargetListener > xListener( xElement, UNO_QUERY );
 417
 418                 if( xListener.is() )
 419                 {
 420                     if( m_xDropTargetDragContext.is() )
 421                         xListener->dropActionChanged( aEvent );
 422                        nRet++;
 423                 }
 424             }
 425             catch (const RuntimeException&)
 426             {
 427                 pContainer->removeInterface( xElement );
 428             }
 429         }
 430
 431         // if context still valid, then reject drag
 432         if( m_xDropTargetDragContext.is() )
 433         {
 434             m_xDropTargetDragContext.clear();
 435
 436             try
 437             {
 438                 context->rejectDrag();
 439             }
 440             catch (const RuntimeException&)
 441             {
 442             }
 443         }
 444     }
 445
 446     return nRet;
 447 }
 448
 449 //==================================================================================================
 450 // DNDListenerContainer::fireDragGestureEvent
 451 //==================================================================================================
 452
 453 sal_uInt32 DNDListenerContainer::fireDragGestureEvent( sal_Int8 dragAction, sal_Int32 dragOriginX,
 454     sal_Int32 dragOriginY, const Reference< XDragSource >& dragSource, const Any& triggerEvent )
 455 {
 456     sal_uInt32 nRet = 0;
 457
 458     // fire DropTargetDropEvent on all XDropTargetListeners
 459     OInterfaceContainerHelper *pContainer = rBHelper.getContainer( getCppuType( ( Reference < XDragGestureListener > * ) 0) );
 460
 461     if( pContainer )
 462     {
 463         OInterfaceIteratorHelper aIterator( *pContainer );
 464
 465         // do not construct the event before you are sure at least one listener is registered
 466         DragGestureEvent aEvent( static_cast < XDragGestureRecognizer * > (this), dragAction,
 467             dragOriginX, dragOriginY, dragSource, triggerEvent );
 468
 469         while( aIterator.hasMoreElements() )
 470         {
 471             // FIXME: this can be simplified as soon as the Iterator has a remove method
 472             Reference< XInterface > xElement( aIterator.next() );
 473
 474             try
 475             {
 476                 // this may result in a runtime exception
 477                 Reference < XDragGestureListener > xListener( xElement, UNO_QUERY );
 478
 479                 if( xListener.is() )
 480                 {
 481                     xListener->dragGestureRecognized( aEvent );
 482                     nRet++;
 483                 }
 484             }
 485             catch (const RuntimeException&)
 486             {
 487                 pContainer->removeInterface( xElement );
 488             }
 489         }
 490     }
 491
 492     return nRet;
 493 }
 494
 495 //==================================================================================================
 496 // DNDListenerContainer::acceptDrag
 497 //==================================================================================================
 498
 499 void SAL_CALL DNDListenerContainer::acceptDrag( sal_Int8 dragOperation ) throw (RuntimeException)
 500 {
 501     if( m_xDropTargetDragContext.is() )
 502     {
 503         m_xDropTargetDragContext->acceptDrag( dragOperation );
 504         m_xDropTargetDragContext.clear();
 505     }
 506 }
 507
 508 //==================================================================================================
 509 // DNDListenerContainer::rejectDrag
 510 //==================================================================================================
 511
 512 void SAL_CALL DNDListenerContainer::rejectDrag(  ) throw (RuntimeException)
 513 {
 514     // nothing to do here
 515 }
 516
 517 //==================================================================================================
 518 // DNDListenerContainer::acceptDrop
 519 //==================================================================================================
 520
 521 void SAL_CALL DNDListenerContainer::acceptDrop( sal_Int8 dropOperation ) throw (RuntimeException)
 522 {
 523     if( m_xDropTargetDropContext.is() )
 524         m_xDropTargetDropContext->acceptDrop( dropOperation );
 525 }
 526
 527 //==================================================================================================
 528 // DNDListenerContainer::rejectDrop
 529 //==================================================================================================
 530
 531 void SAL_CALL DNDListenerContainer::rejectDrop(  ) throw (RuntimeException)
 532 {
 533     // nothing to do here
 534 }
 535
 536 //==================================================================================================
 537 // DNDListenerContainer::dropComplete
 538 //==================================================================================================
 539
 540 void SAL_CALL DNDListenerContainer::dropComplete( sal_Bool success ) throw (RuntimeException)
 541 {
 542     if( m_xDropTargetDropContext.is() )
 543     {
 544         m_xDropTargetDropContext->dropComplete( success );
 545         m_xDropTargetDropContext.clear();
 546     }
 547 }
 548
 549 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */