vcl/source/window/dndeventdispatcher.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 "dndeventdispatcher.hxx"
  21 #include "dndlistenercontainer.hxx"
  22 #include <window.h>
  23 #include <svdata.hxx>
  24
  25 #include <osl/mutex.hxx>
  26 #include <vcl/svapp.hxx>
  27 #include <vcl/settings.hxx>
  28
  29 using namespace ::cppu;
  30 using namespace ::com::sun::star::uno;
  31 using namespace ::com::sun::star::lang;
  32 using namespace ::com::sun::star::datatransfer;
  33 using namespace ::com::sun::star::datatransfer::dnd;
  34
  35 DNDEventDispatcher::DNDEventDispatcher( vcl::Window * pTopWindow ):
  36     m_pTopWindow( pTopWindow ),
  37     m_pCurrentWindow( nullptr )
  38 {
  39 }
  40
  41 DNDEventDispatcher::~DNDEventDispatcher()
  42 {
  43     designate_currentwindow(nullptr);
  44 }
  45
  46 vcl::Window* DNDEventDispatcher::findTopLevelWindow(Point location)
  47 {
  48     SolarMutexGuard aSolarGuard;
  49
  50     // find the window that is toplevel for this coordinates
  51     // because those coordinates come from outside, they must be mirrored if RTL layout is active
  52     if( AllSettings::GetLayoutRTL() )
  53         m_pTopWindow->ImplMirrorFramePos( location );
  54     vcl::Window * pChildWindow = m_pTopWindow->ImplFindWindow( location );
  55
  56     if( nullptr == pChildWindow )
  57         pChildWindow = m_pTopWindow;
  58
  59     while( pChildWindow->ImplGetClientWindow() )
  60         pChildWindow = pChildWindow->ImplGetClientWindow();
  61
  62     if( pChildWindow->ImplIsAntiparallel() )
  63     {
  64         const OutputDevice *pChildWinOutDev = pChildWindow->GetOutDev();
  65         pChildWinOutDev->ReMirror( location );
  66     }
  67
  68     return pChildWindow;
  69 }
  70
  71 IMPL_LINK(DNDEventDispatcher, WindowEventListener, VclWindowEvent&, rEvent, void)
  72 {
  73     if (rEvent.GetId() == VCLEVENT_OBJECT_DYING)
  74     {
  75         designate_currentwindow(nullptr);
  76     }
  77 }
  78
  79 void DNDEventDispatcher::designate_currentwindow(vcl::Window *pWindow)
  80 {
  81     if (m_pCurrentWindow)
  82         m_pCurrentWindow->RemoveEventListener(LINK(this, DNDEventDispatcher, WindowEventListener));
  83     m_pCurrentWindow = pWindow;
  84     if (m_pCurrentWindow)
  85         m_pCurrentWindow->AddEventListener(LINK(this, DNDEventDispatcher, WindowEventListener));
  86 }
  87
  88 void SAL_CALL DNDEventDispatcher::drop( const DropTargetDropEvent& dtde )
  89     throw(RuntimeException, std::exception)
  90 {
  91     osl::MutexGuard aImplGuard( m_aMutex );
  92
  93     Point location( dtde.LocationX, dtde.LocationY );
  94
  95     vcl::Window* pChildWindow = findTopLevelWindow(location);
  96
  97     // handle the case that drop is in an other vcl window than the last dragOver
  98     if( pChildWindow != m_pCurrentWindow.get() )
  99     {
 100         // fire dragExit on listeners of previous window
 101         fireDragExitEvent( m_pCurrentWindow );
 102
 103         fireDragEnterEvent( pChildWindow, static_cast < XDropTargetDragContext * > (this),
 104             dtde.DropAction, location, dtde.SourceActions, m_aDataFlavorList );
 105     }
 106
 107     sal_Int32 nListeners = 0;
 108
 109     // send drop event to the child window
 110     nListeners = fireDropEvent( pChildWindow, dtde.Context, dtde.DropAction,
 111         location, dtde.SourceActions, dtde.Transferable );
 112
 113     // reject drop if no listeners found
 114     if( nListeners == 0 ) {
 115         OSL_TRACE( "rejecting drop due to missing listeners." );
 116         dtde.Context->rejectDrop();
 117     }
 118
 119     // this is a drop -> no further drag overs
 120     designate_currentwindow(nullptr);
 121     m_aDataFlavorList.realloc( 0 );
 122 }
 123
 124 void SAL_CALL DNDEventDispatcher::dragEnter( const DropTargetDragEnterEvent& dtdee )
 125     throw(RuntimeException, std::exception)
 126 {
 127     osl::MutexGuard aImplGuard( m_aMutex );
 128     Point location( dtdee.LocationX, dtdee.LocationY );
 129
 130     vcl::Window * pChildWindow = findTopLevelWindow(location);
 131
 132     // assume pointer write operation to be atomic
 133     designate_currentwindow(pChildWindow);
 134     m_aDataFlavorList = dtdee.SupportedDataFlavors;
 135
 136     // fire dragEnter on listeners of current window
 137     sal_Int32 nListeners = fireDragEnterEvent( pChildWindow, dtdee.Context, dtdee.DropAction, location,
 138         dtdee.SourceActions, dtdee.SupportedDataFlavors );
 139
 140     // reject drag if no listener found
 141     if( nListeners == 0 ) {
 142         OSL_TRACE( "rejecting drag enter due to missing listeners." );
 143         dtdee.Context->rejectDrag();
 144     }
 145
 146 }
 147
 148 void SAL_CALL DNDEventDispatcher::dragExit( const DropTargetEvent& /*dte*/ )
 149     throw(RuntimeException, std::exception)
 150 {
 151     osl::MutexGuard aImplGuard( m_aMutex );
 152
 153     fireDragExitEvent( m_pCurrentWindow );
 154
 155     // reset member values
 156     designate_currentwindow(nullptr);
 157     m_aDataFlavorList.realloc( 0 );
 158 }
 159
 160 void SAL_CALL DNDEventDispatcher::dragOver( const DropTargetDragEvent& dtde )
 161     throw(RuntimeException, std::exception)
 162 {
 163     osl::MutexGuard aImplGuard( m_aMutex );
 164
 165     Point location( dtde.LocationX, dtde.LocationY );
 166     sal_Int32 nListeners;
 167
 168     vcl::Window * pChildWindow = findTopLevelWindow(location);
 169
 170     if( pChildWindow != m_pCurrentWindow.get() )
 171     {
 172         // fire dragExit on listeners of previous window
 173         fireDragExitEvent( m_pCurrentWindow );
 174
 175         // remember new window
 176         designate_currentwindow(pChildWindow);
 177
 178         // fire dragEnter on listeners of current window
 179         nListeners = fireDragEnterEvent( pChildWindow, dtde.Context, dtde.DropAction, location,
 180             dtde.SourceActions, m_aDataFlavorList );
 181     }
 182     else
 183     {
 184         // fire dragOver on listeners of current window
 185         nListeners = fireDragOverEvent( pChildWindow, dtde.Context, dtde.DropAction, location,
 186             dtde.SourceActions );
 187     }
 188
 189     // reject drag if no listener found
 190     if( nListeners == 0 )
 191     {
 192         OSL_TRACE( "rejecting drag over due to missing listeners." );
 193         dtde.Context->rejectDrag();
 194     }
 195 }
 196
 197 void SAL_CALL DNDEventDispatcher::dropActionChanged( const DropTargetDragEvent& dtde )
 198     throw(RuntimeException, std::exception)
 199 {
 200     osl::MutexGuard aImplGuard( m_aMutex );
 201
 202     Point location( dtde.LocationX, dtde.LocationY );
 203     sal_Int32 nListeners;
 204
 205     vcl::Window* pChildWindow = findTopLevelWindow(location);
 206
 207     if( pChildWindow != m_pCurrentWindow.get() )
 208     {
 209         // fire dragExit on listeners of previous window
 210         fireDragExitEvent( m_pCurrentWindow );
 211
 212         // remember new window
 213         designate_currentwindow(pChildWindow);
 214
 215         // fire dragEnter on listeners of current window
 216         nListeners = fireDragEnterEvent( pChildWindow, dtde.Context, dtde.DropAction, location,
 217             dtde.SourceActions, m_aDataFlavorList );
 218     }
 219     else
 220     {
 221         // fire dropActionChanged on listeners of current window
 222         nListeners = fireDropActionChangedEvent( pChildWindow, dtde.Context, dtde.DropAction, location,
 223             dtde.SourceActions );
 224     }
 225
 226     // reject drag if no listener found
 227     if( nListeners == 0 )
 228     {
 229         OSL_TRACE( "rejecting dropActionChanged due to missing listeners." );
 230         dtde.Context->rejectDrag();
 231     }
 232 }
 233
 234 void SAL_CALL DNDEventDispatcher::dragGestureRecognized( const DragGestureEvent& dge )
 235     throw(RuntimeException, std::exception)
 236 {
 237     osl::MutexGuard aImplGuard( m_aMutex );
 238
 239     Point origin( dge.DragOriginX, dge.DragOriginY );
 240
 241     vcl::Window* pChildWindow = findTopLevelWindow(origin);
 242
 243     fireDragGestureEvent( pChildWindow, dge.DragSource, dge.Event, origin, dge.DragAction );
 244 }
 245
 246 void SAL_CALL DNDEventDispatcher::disposing( const EventObject& )
 247     throw(RuntimeException, std::exception)
 248 {
 249 }
 250
 251 void SAL_CALL DNDEventDispatcher::acceptDrag( sal_Int8 /*dropAction*/ ) throw(RuntimeException, std::exception)
 252 {
 253 }
 254
 255 void SAL_CALL DNDEventDispatcher::rejectDrag() throw(RuntimeException, std::exception)
 256 {
 257 }
 258
 259 sal_Int32 DNDEventDispatcher::fireDragEnterEvent( vcl::Window *pWindow,
 260     const Reference< XDropTargetDragContext >& xContext, const sal_Int8 nDropAction,
 261     const Point& rLocation, const sal_Int8 nSourceActions, const Sequence< DataFlavor >& aFlavorList
 262 )
 263     throw(RuntimeException)
 264 {
 265     sal_Int32 n = 0;
 266
 267     if( pWindow && pWindow->IsInputEnabled() && ! pWindow->IsInModalMode() )
 268     {
 269         SolarMutexClearableGuard aSolarGuard;
 270
 271         // set an UI lock
 272         pWindow->IncrementLockCount();
 273
 274         // query DropTarget from window
 275         Reference< XDropTarget > xDropTarget = pWindow->GetDropTarget();
 276
 277         if( xDropTarget.is() )
 278         {
 279             // retrieve relative mouse position
 280             Point relLoc = pWindow->ImplFrameToOutput( rLocation );
 281             aSolarGuard.clear();
 282
 283             n = static_cast < DNDListenerContainer * > ( xDropTarget.get() )->fireDragEnterEvent(
 284                 xContext, nDropAction, relLoc.X(), relLoc.Y(), nSourceActions, aFlavorList );
 285         }
 286     }
 287
 288     return n;
 289 }
 290
 291 sal_Int32 DNDEventDispatcher::fireDragOverEvent( vcl::Window *pWindow,
 292     const Reference< XDropTargetDragContext >& xContext, const sal_Int8 nDropAction,
 293     const Point& rLocation, const sal_Int8 nSourceActions
 294 )
 295     throw(RuntimeException)
 296 {
 297     sal_Int32 n = 0;
 298
 299     if( pWindow && pWindow->IsInputEnabled() && ! pWindow->IsInModalMode() )
 300     {
 301         SolarMutexClearableGuard aSolarGuard;
 302
 303         // query DropTarget from window
 304         Reference< XDropTarget > xDropTarget = pWindow->GetDropTarget();
 305
 306         if( xDropTarget.is() )
 307         {
 308             // retrieve relative mouse position
 309             Point relLoc = pWindow->ImplFrameToOutput( rLocation );
 310             aSolarGuard.clear();
 311
 312             n = static_cast < DNDListenerContainer * > ( xDropTarget.get() )->fireDragOverEvent(
 313                 xContext, nDropAction, relLoc.X(), relLoc.Y(), nSourceActions );
 314         }
 315     }
 316
 317     return n;
 318 }
 319
 320 sal_Int32 DNDEventDispatcher::fireDragExitEvent( vcl::Window *pWindow ) throw(RuntimeException)
 321 {
 322     sal_Int32 n = 0;
 323
 324     if( pWindow && pWindow->IsInputEnabled() && ! pWindow->IsInModalMode() )
 325     {
 326         SolarMutexClearableGuard aGuard;
 327
 328         // query DropTarget from window
 329         Reference< XDropTarget > xDropTarget = pWindow->GetDropTarget();
 330
 331         aGuard.clear();
 332
 333         if( xDropTarget.is() )
 334             n = static_cast < DNDListenerContainer * > ( xDropTarget.get() )->fireDragExitEvent();
 335
 336         // release UI lock
 337         pWindow->DecrementLockCount();
 338     }
 339
 340     return n;
 341 }
 342
 343 sal_Int32 DNDEventDispatcher::fireDropActionChangedEvent( vcl::Window *pWindow,
 344     const Reference< XDropTargetDragContext >& xContext, const sal_Int8 nDropAction,
 345     const Point& rLocation, const sal_Int8 nSourceActions
 346 )
 347     throw(RuntimeException)
 348 {
 349     sal_Int32 n = 0;
 350
 351     if( pWindow && pWindow->IsInputEnabled() && ! pWindow->IsInModalMode() )
 352     {
 353         SolarMutexClearableGuard aGuard;
 354
 355         // query DropTarget from window
 356         Reference< XDropTarget > xDropTarget = pWindow->GetDropTarget();
 357
 358         if( xDropTarget.is() )
 359         {
 360             // retrieve relative mouse position
 361             Point relLoc = pWindow->ImplFrameToOutput( rLocation );
 362             aGuard.clear();
 363
 364             n = static_cast < DNDListenerContainer * > ( xDropTarget.get() )->fireDropActionChangedEvent(
 365                 xContext, nDropAction, relLoc.X(), relLoc.Y(), nSourceActions );
 366         }
 367     }
 368
 369     return n;
 370 }
 371
 372 sal_Int32 DNDEventDispatcher::fireDropEvent( vcl::Window *pWindow,
 373     const Reference< XDropTargetDropContext >& xContext, const sal_Int8 nDropAction, const Point& rLocation,
 374     const sal_Int8 nSourceActions, const Reference< XTransferable >& xTransferable
 375 )
 376     throw(RuntimeException)
 377 {
 378     sal_Int32 n = 0;
 379
 380     if( pWindow && pWindow->IsInputEnabled() && ! pWindow->IsInModalMode() )
 381     {
 382         SolarMutexClearableGuard aGuard;
 383
 384         // query DropTarget from window
 385         Reference< XDropTarget > xDropTarget = pWindow->GetDropTarget();
 386
 387         // window may be destroyed in drop event handler
 388         VclPtr<vcl::Window> xWindow = pWindow;
 389
 390         if( xDropTarget.is() )
 391         {
 392             // retrieve relative mouse position
 393             Point relLoc = pWindow->ImplFrameToOutput( rLocation );
 394             aGuard.clear();
 395
 396             n = static_cast < DNDListenerContainer * > ( xDropTarget.get() )->fireDropEvent(
 397                 xContext, nDropAction, relLoc.X(), relLoc.Y(), nSourceActions, xTransferable );
 398         }
 399
 400         if ( !xWindow->IsDisposed() )
 401         {
 402             // release UI lock
 403             pWindow->DecrementLockCount();
 404         }
 405
 406     }
 407
 408     return n;
 409 }
 410
 411 sal_Int32 DNDEventDispatcher::fireDragGestureEvent( vcl::Window *pWindow,
 412     const Reference< XDragSource >& xSource, const Any& event,
 413     const Point& rOrigin, const sal_Int8 nDragAction
 414 )
 415     throw(css::uno::RuntimeException)
 416 {
 417     sal_Int32 n = 0;
 418
 419     if( pWindow && pWindow->IsInputEnabled() && ! pWindow->IsInModalMode() )
 420     {
 421         SolarMutexClearableGuard aGuard;
 422
 423         // query DropTarget from window
 424         Reference< XDragGestureRecognizer > xDragGestureRecognizer = pWindow->GetDragGestureRecognizer();
 425
 426         if( xDragGestureRecognizer.is() )
 427         {
 428             // retrieve relative mouse position
 429             Point relLoc = pWindow->ImplFrameToOutput( rOrigin );
 430             aGuard.clear();
 431
 432             n = static_cast < DNDListenerContainer * > ( xDragGestureRecognizer.get() )->fireDragGestureEvent(
 433                 nDragAction, relLoc.X(), relLoc.Y(), xSource, event );
 434         }
 435
 436         // release UI lock
 437         pWindow->DecrementLockCount();
 438     }
 439
 440     return n;
 441 }
 442
 443 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */