vcl/source/window/dndlistenercontainer.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 "dndlistenercontainer.hxx"
  21
  22 using namespace ::cppu;
  23 using namespace ::com::sun::star::uno;
  24 using namespace ::com::sun::star::datatransfer;
  25 using namespace ::com::sun::star::datatransfer::dnd;
  26
  27 DNDListenerContainer::DNDListenerContainer( sal_Int8 nDefaultActions )
  28     : WeakComponentImplHelper< XDragGestureRecognizer, XDropTargetDragContext, XDropTargetDropContext, XDropTarget >(GetMutex())
  29 {
  30     m_bActive = true;
  31     m_nDefaultActions = nDefaultActions;
  32 }
  33
  34 DNDListenerContainer::~DNDListenerContainer()
  35 {
  36 }
  37
  38 void SAL_CALL DNDListenerContainer::addDragGestureListener( const Reference< XDragGestureListener >& dgl )
  39     throw(RuntimeException, std::exception)
  40 {
  41     rBHelper.addListener( cppu::UnoType<XDragGestureListener>::get(), dgl );
  42 }
  43
  44 void SAL_CALL DNDListenerContainer::removeDragGestureListener( const Reference< XDragGestureListener >& dgl )
  45     throw(RuntimeException, std::exception)
  46 {
  47     rBHelper.removeListener( cppu::UnoType<XDragGestureListener>::get(), dgl );
  48 }
  49
  50 void SAL_CALL DNDListenerContainer::resetRecognizer(  )
  51     throw(RuntimeException, std::exception)
  52 {
  53 }
  54
  55 void SAL_CALL DNDListenerContainer::addDropTargetListener( const Reference< XDropTargetListener >& dtl )
  56     throw(RuntimeException, std::exception)
  57 {
  58     rBHelper.addListener( cppu::UnoType<XDropTargetListener>::get(), dtl );
  59 }
  60
  61 void SAL_CALL DNDListenerContainer::removeDropTargetListener( const Reference< XDropTargetListener >& dtl )
  62     throw(RuntimeException, std::exception)
  63 {
  64     rBHelper.removeListener( cppu::UnoType<XDropTargetListener>::get(), dtl );
  65 }
  66
  67 sal_Bool SAL_CALL DNDListenerContainer::isActive(  )
  68     throw(RuntimeException, std::exception)
  69 {
  70     return m_bActive;
  71 }
  72
  73 void SAL_CALL DNDListenerContainer::setActive( sal_Bool active )
  74     throw(RuntimeException, std::exception)
  75 {
  76     m_bActive = active;
  77 }
  78
  79 sal_Int8 SAL_CALL DNDListenerContainer::getDefaultActions(  )
  80     throw(RuntimeException, std::exception)
  81 {
  82     return m_nDefaultActions;
  83 }
  84
  85 void SAL_CALL DNDListenerContainer::setDefaultActions( sal_Int8 actions )
  86     throw(RuntimeException, std::exception)
  87 {
  88     m_nDefaultActions = actions;
  89 }
  90
  91 sal_uInt32 DNDListenerContainer::fireDropEvent( const Reference< XDropTargetDropContext >& context,
  92     sal_Int8 dropAction, sal_Int32 locationX, sal_Int32 locationY, sal_Int8 sourceActions,
  93     const Reference< XTransferable >& transferable )
  94 {
  95     sal_uInt32 nRet = 0;
  96
  97     // fire DropTargetDropEvent on all XDropTargetListeners
  98     OInterfaceContainerHelper *pContainer = rBHelper.getContainer( cppu::UnoType<XDropTargetListener>::get());
  99
 100     if( pContainer && m_bActive )
 101     {
 102         OInterfaceIteratorHelper aIterator( *pContainer );
 103
 104         // remember context to use in own context methods
 105         m_xDropTargetDropContext = context;
 106
 107         // do not construct the event before you are sure at least one listener is registered
 108         DropTargetDropEvent aEvent( static_cast < XDropTarget * > (this), 0,
 109             static_cast < XDropTargetDropContext * > (this), dropAction,
 110             locationX, locationY, sourceActions, transferable );
 111
 112         while (aIterator.hasMoreElements())
 113         {
 114             // FIXME: this can be simplified as soon as the Iterator has a remove method
 115             Reference< XInterface > xElement( aIterator.next() );
 116
 117             try
 118             {
 119                 // this may result in a runtime exception
 120                 Reference < XDropTargetListener > xListener( xElement, UNO_QUERY );
 121
 122                 if( xListener.is() )
 123                 {
 124                     // fire drop until the first one has accepted
 125                     if( m_xDropTargetDropContext.is() )
 126                         xListener->drop( aEvent );
 127                     else
 128                     {
 129                         DropTargetEvent aDTEvent( static_cast < XDropTarget * > (this), 0 );
 130                         xListener->dragExit( aDTEvent );
 131                     }
 132
 133                     nRet++;
 134                 }
 135             }
 136             catch (const RuntimeException&)
 137             {
 138                 pContainer->removeInterface( xElement );
 139             }
 140         }
 141
 142         // if context still valid, then reject drop
 143         if( m_xDropTargetDropContext.is() )
 144         {
 145             m_xDropTargetDropContext.clear();
 146
 147             try
 148             {
 149                 context->rejectDrop();
 150             }
 151             catch (const RuntimeException&)
 152             {
 153             }
 154         }
 155     }
 156
 157     return nRet;
 158 }
 159
 160 sal_uInt32 DNDListenerContainer::fireDragExitEvent()
 161 {
 162     sal_uInt32 nRet = 0;
 163
 164     // fire DropTargetDropEvent on all XDropTargetListeners
 165     OInterfaceContainerHelper *pContainer = rBHelper.getContainer( cppu::UnoType<XDropTargetListener>::get());
 166
 167     if( pContainer && m_bActive )
 168     {
 169         OInterfaceIteratorHelper aIterator( *pContainer );
 170
 171         // do not construct the event before you are sure at least one listener is registered
 172         DropTargetEvent aEvent( static_cast < XDropTarget * > (this), 0 );
 173
 174         while (aIterator.hasMoreElements())
 175         {
 176             // FIXME: this can be simplified as soon as the Iterator has a remove method
 177             Reference< XInterface > xElement( aIterator.next() );
 178
 179             try
 180             {
 181                 // this may result in a runtime exception
 182                 Reference < XDropTargetListener > xListener( xElement, UNO_QUERY );
 183
 184                 if( xListener.is() )
 185                 {
 186                        xListener->dragExit( aEvent );
 187                     nRet++;
 188                 }
 189             }
 190             catch (const RuntimeException&)
 191             {
 192                 pContainer->removeInterface( xElement );
 193             }
 194         }
 195     }
 196
 197     return nRet;
 198 }
 199
 200 sal_uInt32 DNDListenerContainer::fireDragOverEvent( const Reference< XDropTargetDragContext >& context,
 201     sal_Int8 dropAction, sal_Int32 locationX, sal_Int32 locationY, sal_Int8 sourceActions )
 202 {
 203     sal_uInt32 nRet = 0;
 204
 205     // fire DropTargetDropEvent on all XDropTargetListeners
 206     OInterfaceContainerHelper *pContainer = rBHelper.getContainer( cppu::UnoType<XDropTargetListener>::get());
 207
 208     if( pContainer && m_bActive )
 209     {
 210         OInterfaceIteratorHelper aIterator( *pContainer );
 211
 212         // remember context to use in own context methods
 213         m_xDropTargetDragContext = context;
 214
 215         // do not construct the event before you are sure at least one listener is registered
 216         DropTargetDragEvent aEvent( static_cast < XDropTarget * > (this), 0,
 217             static_cast < XDropTargetDragContext * > (this),
 218             dropAction, locationX, locationY, sourceActions );
 219
 220         while (aIterator.hasMoreElements())
 221         {
 222             // FIXME: this can be simplified as soon as the Iterator has a remove method
 223             Reference< XInterface > xElement( aIterator.next() );
 224
 225             try
 226             {
 227                 // this may result in a runtime exception
 228                 Reference < XDropTargetListener > xListener( xElement, UNO_QUERY );
 229
 230                 if( xListener.is() )
 231                 {
 232                     if( m_xDropTargetDragContext.is() )
 233                         xListener->dragOver( aEvent );
 234                       nRet++;
 235                 }
 236             }
 237             catch (const RuntimeException&)
 238             {
 239                 pContainer->removeInterface( xElement );
 240             }
 241         }
 242
 243         // if context still valid, then reject drag
 244         if( m_xDropTargetDragContext.is() )
 245         {
 246             m_xDropTargetDragContext.clear();
 247
 248             try
 249             {
 250                 context->rejectDrag();
 251             }
 252             catch (const RuntimeException&)
 253             {
 254             }
 255         }
 256     }
 257
 258     return nRet;
 259 }
 260
 261 sal_uInt32 DNDListenerContainer::fireDragEnterEvent( const Reference< XDropTargetDragContext >& context,
 262     sal_Int8 dropAction, sal_Int32 locationX, sal_Int32 locationY, sal_Int8 sourceActions,
 263     const Sequence< DataFlavor >& dataFlavors )
 264 {
 265     sal_uInt32 nRet = 0;
 266
 267     // fire DropTargetDropEvent on all XDropTargetListeners
 268     OInterfaceContainerHelper *pContainer = rBHelper.getContainer( cppu::UnoType<XDropTargetListener>::get());
 269
 270     if( pContainer && m_bActive )
 271     {
 272         OInterfaceIteratorHelper aIterator( *pContainer );
 273
 274         // remember context to use in own context methods
 275         m_xDropTargetDragContext = context;
 276
 277         // do not construct the event before you are sure at least one listener is registered
 278         DropTargetDragEnterEvent aEvent( static_cast < XDropTarget * > (this), 0,
 279             static_cast < XDropTargetDragContext * > (this),
 280             dropAction, locationX, locationY, sourceActions, dataFlavors );
 281
 282         while (aIterator.hasMoreElements())
 283         {
 284             // FIXME: this can be simplified as soon as the Iterator has a remove method
 285             Reference< XInterface > xElement( aIterator.next() );
 286
 287             try
 288             {
 289                 // this may result in a runtime exception
 290                 Reference < XDropTargetListener > xListener( xElement, UNO_QUERY );
 291
 292                 if( xListener.is() )
 293                 {
 294                     if( m_xDropTargetDragContext.is() )
 295                         xListener->dragEnter( aEvent );
 296                     nRet++;
 297                 }
 298             }
 299             catch (const RuntimeException&)
 300             {
 301                 pContainer->removeInterface( xElement );
 302             }
 303         }
 304
 305         // if context still valid, then reject drag
 306         if( m_xDropTargetDragContext.is() )
 307         {
 308             m_xDropTargetDragContext.clear();
 309
 310             try
 311             {
 312                 context->rejectDrag();
 313             }
 314             catch (const RuntimeException&)
 315             {
 316             }
 317         }
 318     }
 319
 320     return nRet;
 321 }
 322
 323 sal_uInt32 DNDListenerContainer::fireDropActionChangedEvent( const Reference< XDropTargetDragContext >& context,
 324     sal_Int8 dropAction, sal_Int32 locationX, sal_Int32 locationY, sal_Int8 sourceActions )
 325 {
 326     sal_uInt32 nRet = 0;
 327
 328     // fire DropTargetDropEvent on all XDropTargetListeners
 329     OInterfaceContainerHelper *pContainer = rBHelper.getContainer( cppu::UnoType<XDropTargetListener>::get());
 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         DropTargetDragEvent aEvent( static_cast < XDropTarget * > (this), 0,
 340             static_cast < XDropTargetDragContext * > (this),
 341             dropAction, locationX, locationY, sourceActions );
 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->dropActionChanged( 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 sal_uInt32 DNDListenerContainer::fireDragGestureEvent( sal_Int8 dragAction, sal_Int32 dragOriginX,
 385     sal_Int32 dragOriginY, const Reference< XDragSource >& dragSource, const Any& triggerEvent )
 386 {
 387     sal_uInt32 nRet = 0;
 388
 389     // fire DropTargetDropEvent on all XDropTargetListeners
 390     OInterfaceContainerHelper *pContainer = rBHelper.getContainer( cppu::UnoType<XDragGestureListener>::get());
 391
 392     if( pContainer )
 393     {
 394         OInterfaceIteratorHelper aIterator( *pContainer );
 395
 396         // do not construct the event before you are sure at least one listener is registered
 397         DragGestureEvent aEvent( static_cast < XDragGestureRecognizer * > (this), dragAction,
 398             dragOriginX, dragOriginY, dragSource, triggerEvent );
 399
 400         while( aIterator.hasMoreElements() )
 401         {
 402             // FIXME: this can be simplified as soon as the Iterator has a remove method
 403             Reference< XInterface > xElement( aIterator.next() );
 404
 405             try
 406             {
 407                 // this may result in a runtime exception
 408                 Reference < XDragGestureListener > xListener( xElement, UNO_QUERY );
 409
 410                 if( xListener.is() )
 411                 {
 412                     xListener->dragGestureRecognized( aEvent );
 413                     nRet++;
 414                 }
 415             }
 416             catch (const RuntimeException&)
 417             {
 418                 pContainer->removeInterface( xElement );
 419             }
 420         }
 421     }
 422
 423     return nRet;
 424 }
 425
 426 void SAL_CALL DNDListenerContainer::acceptDrag( sal_Int8 dragOperation ) throw (RuntimeException, std::exception)
 427 {
 428     if( m_xDropTargetDragContext.is() )
 429     {
 430         m_xDropTargetDragContext->acceptDrag( dragOperation );
 431         m_xDropTargetDragContext.clear();
 432     }
 433 }
 434
 435 void SAL_CALL DNDListenerContainer::rejectDrag(  ) throw (RuntimeException, std::exception)
 436 {
 437     // nothing to do here
 438 }
 439
 440 void SAL_CALL DNDListenerContainer::acceptDrop( sal_Int8 dropOperation ) throw (RuntimeException, std::exception)
 441 {
 442     if( m_xDropTargetDropContext.is() )
 443         m_xDropTargetDropContext->acceptDrop( dropOperation );
 444 }
 445
 446 void SAL_CALL DNDListenerContainer::rejectDrop(  ) throw (RuntimeException, std::exception)
 447 {
 448     // nothing to do here
 449 }
 450
 451 void SAL_CALL DNDListenerContainer::dropComplete( sal_Bool success ) throw (RuntimeException, std::exception)
 452 {
 453     if( m_xDropTargetDropContext.is() )
 454     {
 455         m_xDropTargetDropContext->dropComplete( success );
 456         m_xDropTargetDropContext.clear();
 457     }
 458 }
 459
 460 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */