vcl/source/window/mouse.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 <config_features.h>
  22
  23 #include <tools/time.hxx>
  24
  25 #include <LibreOfficeKit/LibreOfficeKitEnums.h>
  26
  27 #include <vcl/ITiledRenderable.hxx>
  28 #include <vcl/svapp.hxx>
  29 #include <vcl/salgtype.hxx>
  30 #include <vcl/window.hxx>
  31 #include <vcl/floatwin.hxx>
  32 #include <vcl/cursor.hxx>
  33 #include <vcl/sysdata.hxx>
  34
  35 #include <sal/types.h>
  36
  37 #include <window.h>
  38 #include <outdev.h>
  39 #include <svdata.hxx>
  40 #include <salobj.hxx>
  41 #include <salgdi.hxx>
  42 #include <salframe.hxx>
  43
  44 #include "dndlistenercontainer.hxx"
  45 #include "dndeventdispatcher.hxx"
  46
  47 #include <com/sun/star/datatransfer/dnd/XDragSource.hpp>
  48 #include <com/sun/star/datatransfer/dnd/XDropTarget.hpp>
  49
  50 #include <comphelper/processfactory.hxx>
  51
  52 using namespace ::com::sun::star::uno;
  53
  54 namespace vcl {
  55
  56 WindowHitTest Window::ImplHitTest( const Point& rFramePos )
  57 {
  58     Point aFramePos( rFramePos );
  59     if( ImplIsAntiparallel() )
  60     {
  61         // - RTL - re-mirror frame pos at this window
  62         const OutputDevice *pOutDev = GetOutDev();
  63         pOutDev->ReMirror( aFramePos );
  64     }
  65     Rectangle aRect( Point( mnOutOffX, mnOutOffY ), Size( mnOutWidth, mnOutHeight ) );
  66     if ( !aRect.IsInside( aFramePos ) )
  67         return WindowHitTest::NONE;
  68     if ( mpWindowImpl->mbWinRegion )
  69     {
  70         Point aTempPos = aFramePos;
  71         aTempPos.X() -= mnOutOffX;
  72         aTempPos.Y() -= mnOutOffY;
  73         if ( !mpWindowImpl->maWinRegion.IsInside( aTempPos ) )
  74             return WindowHitTest::NONE;
  75     }
  76
  77     WindowHitTest nHitTest = WindowHitTest::Inside;
  78     if ( mpWindowImpl->mbMouseTransparent )
  79         nHitTest |= WindowHitTest::Transparent;
  80     return nHitTest;
  81 }
  82
  83 bool Window::ImplTestMousePointerSet()
  84 {
  85     // as soon as mouse is captured, switch mouse-pointer
  86     if ( IsMouseCaptured() )
  87         return true;
  88
  89     // if the mouse is over the window, switch it
  90     Rectangle aClientRect( Point( 0, 0 ), GetOutputSizePixel() );
  91     if ( aClientRect.IsInside( GetPointerPosPixel() ) )
  92         return true;
  93
  94     return false;
  95 }
  96
  97 PointerStyle Window::ImplGetMousePointer() const
  98 {
  99     PointerStyle    ePointerStyle;
 100     bool            bWait = false;
 101
 102     if ( IsEnabled() && IsInputEnabled() && ! IsInModalMode() )
 103         ePointerStyle = GetPointer().GetStyle();
 104     else
 105         ePointerStyle = PointerStyle::Arrow;
 106
 107     const vcl::Window* pWindow = this;
 108     do
 109     {
 110         // when the pointer is not visible stop the search, as
 111         // this status should not be overwritten
 112         if ( pWindow->mpWindowImpl->mbNoPtrVisible )
 113             return PointerStyle::Null;
 114
 115         if ( !bWait )
 116         {
 117             if ( pWindow->mpWindowImpl->mnWaitCount )
 118             {
 119                 ePointerStyle = PointerStyle::Wait;
 120                 bWait = true;
 121             }
 122             else
 123             {
 124                 if ( pWindow->mpWindowImpl->mbChildPtrOverwrite )
 125                     ePointerStyle = pWindow->GetPointer().GetStyle();
 126             }
 127         }
 128
 129         if ( pWindow->ImplIsOverlapWindow() )
 130             break;
 131
 132         pWindow = pWindow->ImplGetParent();
 133     }
 134     while ( pWindow );
 135
 136     return ePointerStyle;
 137 }
 138
 139 void Window::ImplCallMouseMove( sal_uInt16 nMouseCode, bool bModChanged )
 140 {
 141     if ( mpWindowImpl->mpFrameData->mbMouseIn && mpWindowImpl->mpFrameWindow->mpWindowImpl->mbReallyVisible )
 142     {
 143         sal_uInt64 nTime   = tools::Time::GetSystemTicks();
 144         long    nX      = mpWindowImpl->mpFrameData->mnLastMouseX;
 145         long    nY      = mpWindowImpl->mpFrameData->mnLastMouseY;
 146         sal_uInt16  nCode   = nMouseCode;
 147         MouseEventModifiers nMode = mpWindowImpl->mpFrameData->mnMouseMode;
 148         bool    bLeave;
 149         // check for MouseLeave
 150         if ( ((nX < 0) || (nY < 0) ||
 151               (nX >= mpWindowImpl->mpFrameWindow->mnOutWidth) ||
 152               (nY >= mpWindowImpl->mpFrameWindow->mnOutHeight)) &&
 153              !ImplGetSVData()->maWinData.mpCaptureWin )
 154             bLeave = true;
 155         else
 156             bLeave = false;
 157         nMode |= MouseEventModifiers::SYNTHETIC;
 158         if ( bModChanged )
 159             nMode |= MouseEventModifiers::MODIFIERCHANGED;
 160         ImplHandleMouseEvent( mpWindowImpl->mpFrameWindow, MouseNotifyEvent::MOUSEMOVE, bLeave, nX, nY, nTime, nCode, nMode );
 161     }
 162 }
 163
 164 void Window::ImplGenerateMouseMove()
 165 {
 166     if ( mpWindowImpl && mpWindowImpl->mpFrameData &&
 167          !mpWindowImpl->mpFrameData->mnMouseMoveId )
 168         mpWindowImpl->mpFrameData->mnMouseMoveId = Application::PostUserEvent( LINK( mpWindowImpl->mpFrameWindow, Window, ImplGenerateMouseMoveHdl ), nullptr, true );
 169 }
 170
 171 IMPL_LINK_NOARG(Window, ImplGenerateMouseMoveHdl, void*, void)
 172 {
 173     mpWindowImpl->mpFrameData->mnMouseMoveId = nullptr;
 174     vcl::Window* pCaptureWin = ImplGetSVData()->maWinData.mpCaptureWin;
 175     if( ! pCaptureWin ||
 176         (pCaptureWin->mpWindowImpl && pCaptureWin->mpWindowImpl->mpFrame == mpWindowImpl->mpFrame)
 177     )
 178     {
 179         ImplCallMouseMove( mpWindowImpl->mpFrameData->mnMouseCode );
 180     }
 181 }
 182
 183 void Window::ImplInvertFocus( const Rectangle& rRect )
 184 {
 185     InvertTracking( rRect, ShowTrackFlags::Small | ShowTrackFlags::TrackWindow );
 186 }
 187
 188 static bool IsWindowFocused(const WindowImpl& rWinImpl)
 189 {
 190     if (rWinImpl.mpSysObj)
 191         return true;
 192
 193     if (rWinImpl.mpFrameData->mbHasFocus)
 194         return true;
 195
 196     if (rWinImpl.mbFakeFocusSet)
 197         return true;
 198
 199     return false;
 200 }
 201
 202 void Window::ImplGrabFocus( GetFocusFlags nFlags )
 203 {
 204     // #143570# no focus for destructing windows
 205     if( !mpWindowImpl || mpWindowImpl->mbInDispose )
 206         return;
 207
 208     // some event listeners do really bad stuff
 209     // => prepare for the worst
 210     VclPtr<vcl::Window> xWindow( this );
 211
 212     // Currently the client window should always get the focus
 213     // Should the border window at some point be focusable
 214     // we need to change all GrabFocus() instances in VCL,
 215     // e.g. in ToTop()
 216
 217     if ( mpWindowImpl->mpClientWindow )
 218     {
 219         // For a lack of design we need a little hack here to
 220         // ensure that dialogs on close pass the focus back to
 221         // the correct window
 222         if ( mpWindowImpl->mpLastFocusWindow && (mpWindowImpl->mpLastFocusWindow.get() != this) &&
 223              !(mpWindowImpl->mnDlgCtrlFlags & DialogControlFlags::WantFocus) &&
 224              mpWindowImpl->mpLastFocusWindow->IsEnabled() &&
 225              mpWindowImpl->mpLastFocusWindow->IsInputEnabled() &&
 226              ! mpWindowImpl->mpLastFocusWindow->IsInModalMode()
 227              )
 228             mpWindowImpl->mpLastFocusWindow->GrabFocus();
 229         else
 230             mpWindowImpl->mpClientWindow->GrabFocus();
 231         return;
 232     }
 233     else if ( mpWindowImpl->mbFrame )
 234     {
 235         // For a lack of design we need a little hack here to
 236         // ensure that dialogs on close pass the focus back to
 237         // the correct window
 238         if ( mpWindowImpl->mpLastFocusWindow && (mpWindowImpl->mpLastFocusWindow.get() != this) &&
 239              !(mpWindowImpl->mnDlgCtrlFlags & DialogControlFlags::WantFocus) &&
 240              mpWindowImpl->mpLastFocusWindow->IsEnabled() &&
 241              mpWindowImpl->mpLastFocusWindow->IsInputEnabled() &&
 242              ! mpWindowImpl->mpLastFocusWindow->IsInModalMode()
 243              )
 244         {
 245             mpWindowImpl->mpLastFocusWindow->GrabFocus();
 246             return;
 247         }
 248     }
 249
 250     // If the Window is disabled, then we don't change the focus
 251     if ( !IsEnabled() || !IsInputEnabled() || IsInModalMode() )
 252         return;
 253
 254     // we only need to set the focus if it is not already set
 255     // note: if some other frame is waiting for an asynchronous focus event
 256     // we also have to post an asynchronous focus event for this frame
 257     // which is done using ToTop
 258     ImplSVData* pSVData = ImplGetSVData();
 259
 260     bool bAsyncFocusWaiting = false;
 261     vcl::Window *pFrame = pSVData->maWinData.mpFirstFrame;
 262     while( pFrame  )
 263     {
 264         if( pFrame != mpWindowImpl->mpFrameWindow.get() && pFrame->mpWindowImpl->mpFrameData->mnFocusId )
 265         {
 266             bAsyncFocusWaiting = true;
 267             break;
 268         }
 269         pFrame = pFrame->mpWindowImpl->mpFrameData->mpNextFrame;
 270     }
 271
 272     bool bHasFocus = IsWindowFocused(*mpWindowImpl);
 273
 274     bool bMustNotGrabFocus = false;
 275     // #100242#, check parent hierarchy if some floater prohibits grab focus
 276
 277     vcl::Window *pParent = this;
 278     while( pParent )
 279     {
 280         if ((pParent->GetStyle() & WB_SYSTEMFLOATWIN) && !(pParent->GetStyle() & WB_MOVEABLE))
 281         {
 282             bMustNotGrabFocus = true;
 283             break;
 284         }
 285         pParent = pParent->mpWindowImpl->mpParent;
 286     }
 287
 288     if ( ( pSVData->maWinData.mpFocusWin.get() != this &&
 289            !mpWindowImpl->mbInDispose ) ||
 290          ( bAsyncFocusWaiting && !bHasFocus && !bMustNotGrabFocus ) )
 291     {
 292         // EndExtTextInput if it is not the same window
 293         if ( pSVData->maWinData.mpExtTextInputWin &&
 294              (pSVData->maWinData.mpExtTextInputWin.get() != this) )
 295             pSVData->maWinData.mpExtTextInputWin->EndExtTextInput();
 296
 297         // mark this windows as the last FocusWindow
 298         vcl::Window* pOverlapWindow = ImplGetFirstOverlapWindow();
 299         pOverlapWindow->mpWindowImpl->mpLastFocusWindow = this;
 300         mpWindowImpl->mpFrameData->mpFocusWin = this;
 301
 302         if( !bHasFocus )
 303         {
 304             // menu windows never get the system focus
 305             // the application will keep the focus
 306             if( bMustNotGrabFocus )
 307                 return;
 308             else
 309             {
 310                 // here we already switch focus as ToTop()
 311                 // should not give focus to another window
 312                 mpWindowImpl->mpFrame->ToTop( SalFrameToTop::GrabFocus | SalFrameToTop::GrabFocusOnly );
 313                 return;
 314             }
 315         }
 316
 317         VclPtr<vcl::Window> pOldFocusWindow = pSVData->maWinData.mpFocusWin;
 318
 319         pSVData->maWinData.mpFocusWin = this;
 320
 321         if ( pOldFocusWindow )
 322         {
 323             // Cursor hidden
 324             if ( pOldFocusWindow->mpWindowImpl->mpCursor )
 325                 pOldFocusWindow->mpWindowImpl->mpCursor->ImplHide();
 326         }
 327
 328         // !!!!! due to old SV-Office Activate/Deactivate handling
 329         // !!!!! first as before
 330         if ( pOldFocusWindow )
 331         {
 332             // remember Focus
 333             vcl::Window* pOldOverlapWindow = pOldFocusWindow->ImplGetFirstOverlapWindow();
 334             vcl::Window* pNewOverlapWindow = ImplGetFirstOverlapWindow();
 335             if ( pOldOverlapWindow != pNewOverlapWindow )
 336                 ImplCallFocusChangeActivate( pNewOverlapWindow, pOldOverlapWindow );
 337         }
 338         else
 339         {
 340             vcl::Window* pNewOverlapWindow = ImplGetFirstOverlapWindow();
 341             vcl::Window* pNewRealWindow = pNewOverlapWindow->ImplGetWindow();
 342             pNewOverlapWindow->mpWindowImpl->mbActive = true;
 343             pNewOverlapWindow->Activate();
 344             if ( pNewRealWindow != pNewOverlapWindow )
 345             {
 346                 pNewRealWindow->mpWindowImpl->mbActive = true;
 347                 pNewRealWindow->Activate();
 348             }
 349         }
 350
 351         // call Get- and LoseFocus
 352         if ( pOldFocusWindow && ! pOldFocusWindow->IsDisposed() )
 353         {
 354             if ( pOldFocusWindow->IsTracking() &&
 355                  (pSVData->maWinData.mnTrackFlags & StartTrackingFlags::FocusCancel) )
 356                 pOldFocusWindow->EndTracking( TrackingEventFlags::Cancel | TrackingEventFlags::Focus );
 357             NotifyEvent aNEvt( MouseNotifyEvent::LOSEFOCUS, pOldFocusWindow );
 358             if ( !ImplCallPreNotify( aNEvt ) )
 359                 pOldFocusWindow->CompatLoseFocus();
 360             pOldFocusWindow->ImplCallDeactivateListeners( this );
 361         }
 362
 363         if ( pSVData->maWinData.mpFocusWin.get() == this )
 364         {
 365             if ( mpWindowImpl->mpSysObj )
 366             {
 367                 mpWindowImpl->mpFrameData->mpFocusWin = this;
 368                 if ( !mpWindowImpl->mpFrameData->mbInSysObjFocusHdl )
 369                     mpWindowImpl->mpSysObj->GrabFocus();
 370             }
 371
 372             if ( pSVData->maWinData.mpFocusWin.get() == this )
 373             {
 374                 if ( mpWindowImpl->mpCursor )
 375                     mpWindowImpl->mpCursor->ImplShow();
 376                 mpWindowImpl->mbInFocusHdl = true;
 377                 mpWindowImpl->mnGetFocusFlags = nFlags;
 378                 // if we're changing focus due to closing a popup floating window
 379                 // notify the new focus window so it can restore the inner focus
 380                 // eg, toolboxes can select their recent active item
 381                 if( pOldFocusWindow &&
 382                     ! pOldFocusWindow->IsDisposed() &&
 383                     ( pOldFocusWindow->GetDialogControlFlags() & DialogControlFlags::FloatWinPopupModeEndCancel ) )
 384                     mpWindowImpl->mnGetFocusFlags |= GetFocusFlags::FloatWinPopupModeEndCancel;
 385                 NotifyEvent aNEvt( MouseNotifyEvent::GETFOCUS, this );
 386                 if ( !ImplCallPreNotify( aNEvt ) && !xWindow->IsDisposed() )
 387                     CompatGetFocus();
 388                 if( !xWindow->IsDisposed() )
 389                     ImplCallActivateListeners( (pOldFocusWindow && ! pOldFocusWindow->IsDisposed()) ? pOldFocusWindow : nullptr );
 390                 if( !xWindow->IsDisposed() )
 391                 {
 392                     mpWindowImpl->mnGetFocusFlags = GetFocusFlags::NONE;
 393                     mpWindowImpl->mbInFocusHdl = false;
 394                 }
 395             }
 396         }
 397
 398         ImplNewInputContext();
 399     }
 400 }
 401
 402 void Window::ImplGrabFocusToDocument( GetFocusFlags nFlags )
 403 {
 404     vcl::Window *pWin = this;
 405     while( pWin )
 406     {
 407         if( !pWin->GetParent() )
 408         {
 409             pWin->ImplGetFrameWindow()->GetWindow( GetWindowType::Client )->ImplGrabFocus(nFlags);
 410             return;
 411         }
 412         pWin = pWin->GetParent();
 413     }
 414 }
 415
 416 void Window::MouseMove( const MouseEvent& rMEvt )
 417 {
 418     NotifyEvent aNEvt( MouseNotifyEvent::MOUSEMOVE, this, &rMEvt );
 419     if (!EventNotify(aNEvt))
 420         mpWindowImpl->mbMouseMove = true;
 421 }
 422
 423 void Window::MouseButtonDown( const MouseEvent& rMEvt )
 424 {
 425     NotifyEvent aNEvt( MouseNotifyEvent::MOUSEBUTTONDOWN, this, &rMEvt );
 426     if (!EventNotify(aNEvt))
 427         mpWindowImpl->mbMouseButtonDown = true;
 428 }
 429
 430 void Window::MouseButtonUp( const MouseEvent& rMEvt )
 431 {
 432     NotifyEvent aNEvt( MouseNotifyEvent::MOUSEBUTTONUP, this, &rMEvt );
 433     if (!EventNotify(aNEvt))
 434         mpWindowImpl->mbMouseButtonUp = true;
 435 }
 436
 437 void Window::SetMouseTransparent( bool bTransparent )
 438 {
 439
 440     if ( mpWindowImpl->mpBorderWindow )
 441         mpWindowImpl->mpBorderWindow->SetMouseTransparent( bTransparent );
 442
 443     if( mpWindowImpl->mpSysObj )
 444         mpWindowImpl->mpSysObj->SetMouseTransparent( bTransparent );
 445
 446     mpWindowImpl->mbMouseTransparent = bTransparent;
 447 }
 448
 449 void Window::CaptureMouse()
 450 {
 451
 452     ImplSVData* pSVData = ImplGetSVData();
 453
 454     // possibly stop tracking
 455     if ( pSVData->maWinData.mpTrackWin.get() != this )
 456     {
 457         if ( pSVData->maWinData.mpTrackWin )
 458             pSVData->maWinData.mpTrackWin->EndTracking( TrackingEventFlags::Cancel );
 459     }
 460
 461     if ( pSVData->maWinData.mpCaptureWin.get() != this )
 462     {
 463         pSVData->maWinData.mpCaptureWin = this;
 464         mpWindowImpl->mpFrame->CaptureMouse( true );
 465     }
 466 }
 467
 468 void Window::ReleaseMouse()
 469 {
 470
 471     ImplSVData* pSVData = ImplGetSVData();
 472
 473     SAL_WARN_IF(!IsMouseCaptured(), "vcl",
 474                        "Window::ReleaseMouse(): window doesn't have the mouse capture" );
 475
 476     if (IsMouseCaptured())
 477     {
 478         pSVData->maWinData.mpCaptureWin = nullptr;
 479         mpWindowImpl->mpFrame->CaptureMouse( false );
 480         ImplGenerateMouseMove();
 481     }
 482 }
 483
 484 bool Window::IsMouseCaptured() const
 485 {
 486
 487     return (this == ImplGetSVData()->maWinData.mpCaptureWin);
 488 }
 489
 490 void Window::SetPointer( const Pointer& rPointer )
 491 {
 492
 493     if ( mpWindowImpl->maPointer == rPointer )
 494         return;
 495
 496     mpWindowImpl->maPointer   = rPointer;
 497
 498     // possibly immediately move pointer
 499     if ( !mpWindowImpl->mpFrameData->mbInMouseMove && ImplTestMousePointerSet() )
 500         mpWindowImpl->mpFrame->SetPointer( ImplGetMousePointer() );
 501
 502     if (VclPtr<vcl::Window> pWin = GetParentWithLOKNotifier())
 503     {
 504         Pointer aPointer = GetPointer();
 505         // We don't map all possible pointers hence we need a default
 506         OString aPointerString = "default";
 507         auto aIt = vcl::gaLOKPointerMap.find(aPointer.GetStyle());
 508         if (aIt != vcl::gaLOKPointerMap.end())
 509         {
 510             aPointerString = aIt->second;
 511         }
 512
 513         // issue mouse pointer events only for document windows
 514         // Doc windows' immediate parent SfxFrameViewWindow_Impl is the one with
 515         // parent notifier set during initialization
 516         if (GetParent()->ImplGetWindowImpl()->mbLOKParentNotifier &&
 517             GetParent()->ImplGetWindowImpl()->mnLOKWindowId == 0)
 518         {
 519             pWin->GetLOKNotifier()->libreOfficeKitViewCallback(LOK_CALLBACK_MOUSE_POINTER, aPointerString.getStr());
 520         }
 521     }
 522 }
 523
 524 void Window::EnableChildPointerOverwrite( bool bOverwrite )
 525 {
 526
 527     if ( mpWindowImpl->mbChildPtrOverwrite == bOverwrite )
 528         return;
 529
 530     mpWindowImpl->mbChildPtrOverwrite  = bOverwrite;
 531
 532     // possibly immediately move pointer
 533     if ( !mpWindowImpl->mpFrameData->mbInMouseMove && ImplTestMousePointerSet() )
 534         mpWindowImpl->mpFrame->SetPointer( ImplGetMousePointer() );
 535 }
 536
 537 void Window::SetPointerPosPixel( const Point& rPos )
 538 {
 539     Point aPos = ImplOutputToFrame( rPos );
 540     const OutputDevice *pOutDev = GetOutDev();
 541     if( pOutDev->HasMirroredGraphics() )
 542     {
 543         if( !IsRTLEnabled() )
 544         {
 545             // --- RTL --- (re-mirror mouse pos at this window)
 546             pOutDev->ReMirror( aPos );
 547         }
 548         // mirroring is required here, SetPointerPos bypasses SalGraphics
 549         mpGraphics->mirror( aPos.X(), this );
 550     }
 551     else if( ImplIsAntiparallel() )
 552     {
 553         pOutDev->ReMirror( aPos );
 554     }
 555     mpWindowImpl->mpFrame->SetPointerPos( aPos.X(), aPos.Y() );
 556 }
 557
 558 void Window::SetLastMousePos(const Point& rPos)
 559 {
 560     // Do this conversion, so when GetPointerPosPixel() calls
 561     // ImplFrameToOutput(), we get back the original position.
 562     Point aPos = ImplOutputToFrame(rPos);
 563     mpWindowImpl->mpFrameData->mnLastMouseX = aPos.X();
 564     mpWindowImpl->mpFrameData->mnLastMouseY = aPos.Y();
 565 }
 566
 567 Point Window::GetPointerPosPixel()
 568 {
 569
 570     Point aPos( mpWindowImpl->mpFrameData->mnLastMouseX, mpWindowImpl->mpFrameData->mnLastMouseY );
 571     if( ImplIsAntiparallel() )
 572     {
 573         // --- RTL --- (re-mirror mouse pos at this window)
 574         const OutputDevice *pOutDev = GetOutDev();
 575         pOutDev->ReMirror( aPos );
 576     }
 577     return ImplFrameToOutput( aPos );
 578 }
 579
 580 Point Window::GetLastPointerPosPixel()
 581 {
 582
 583     Point aPos( mpWindowImpl->mpFrameData->mnBeforeLastMouseX, mpWindowImpl->mpFrameData->mnBeforeLastMouseY );
 584     if( ImplIsAntiparallel() )
 585     {
 586         // --- RTL --- (re-mirror mouse pos at this window)
 587         const OutputDevice *pOutDev = GetOutDev();
 588         pOutDev->ReMirror( aPos );
 589     }
 590     return ImplFrameToOutput( aPos );
 591 }
 592
 593 void Window::ShowPointer( bool bVisible )
 594 {
 595
 596     if ( mpWindowImpl->mbNoPtrVisible != !bVisible )
 597     {
 598         mpWindowImpl->mbNoPtrVisible = !bVisible;
 599
 600         // possibly immediately move pointer
 601         if ( !mpWindowImpl->mpFrameData->mbInMouseMove && ImplTestMousePointerSet() )
 602             mpWindowImpl->mpFrame->SetPointer( ImplGetMousePointer() );
 603     }
 604 }
 605
 606 Window::PointerState Window::GetPointerState()
 607 {
 608     PointerState aState;
 609     aState.mnState = 0;
 610
 611     if (mpWindowImpl->mpFrame)
 612     {
 613         SalFrame::SalPointerState aSalPointerState;
 614
 615         aSalPointerState = mpWindowImpl->mpFrame->GetPointerState();
 616         if( ImplIsAntiparallel() )
 617         {
 618             // --- RTL --- (re-mirror mouse pos at this window)
 619             const OutputDevice *pOutDev = GetOutDev();
 620             pOutDev->ReMirror( aSalPointerState.maPos );
 621         }
 622         aState.maPos = ImplFrameToOutput( aSalPointerState.maPos );
 623         aState.mnState = aSalPointerState.mnState;
 624     }
 625     return aState;
 626 }
 627
 628 bool Window::IsMouseOver()
 629 {
 630     return ImplGetWinData()->mbMouseOver;
 631 }
 632
 633 void Window::EnterWait()
 634 {
 635
 636     mpWindowImpl->mnWaitCount++;
 637
 638     if ( mpWindowImpl->mnWaitCount == 1 )
 639     {
 640         // possibly immediately move pointer
 641         if ( !mpWindowImpl->mpFrameData->mbInMouseMove && ImplTestMousePointerSet() )
 642             mpWindowImpl->mpFrame->SetPointer( ImplGetMousePointer() );
 643     }
 644 }
 645
 646 void Window::LeaveWait()
 647 {
 648
 649     if ( mpWindowImpl->mnWaitCount )
 650     {
 651         mpWindowImpl->mnWaitCount--;
 652
 653         if ( !mpWindowImpl->mnWaitCount )
 654         {
 655             // possibly immediately move pointer
 656             if ( !mpWindowImpl->mpFrameData->mbInMouseMove && ImplTestMousePointerSet() )
 657                 mpWindowImpl->mpFrame->SetPointer( ImplGetMousePointer() );
 658         }
 659     }
 660 }
 661
 662 bool Window::ImplStopDnd()
 663 {
 664     bool bRet = false;
 665     if( mpWindowImpl->mpFrameData && mpWindowImpl->mpFrameData->mxDropTargetListener.is() )
 666     {
 667         bRet = true;
 668         mpWindowImpl->mpFrameData->mxDropTarget.clear();
 669         mpWindowImpl->mpFrameData->mxDragSource.clear();
 670         mpWindowImpl->mpFrameData->mxDropTargetListener.clear();
 671     }
 672
 673     return bRet;
 674 }
 675
 676 void Window::ImplStartDnd()
 677 {
 678     GetDropTarget();
 679 }
 680
 681 Reference< css::datatransfer::dnd::XDropTarget > Window::GetDropTarget()
 682 {
 683     if( !mpWindowImpl )
 684         return Reference< css::datatransfer::dnd::XDropTarget >();
 685
 686     if( ! mpWindowImpl->mxDNDListenerContainer.is() )
 687     {
 688         sal_Int8 nDefaultActions = 0;
 689
 690         if( mpWindowImpl->mpFrameData )
 691         {
 692             if( ! mpWindowImpl->mpFrameData->mxDropTarget.is() )
 693             {
 694                 // initialization is done in GetDragSource
 695                 Reference< css::datatransfer::dnd::XDragSource > xDragSource = GetDragSource();
 696             }
 697
 698             if( mpWindowImpl->mpFrameData->mxDropTarget.is() )
 699             {
 700                 nDefaultActions = mpWindowImpl->mpFrameData->mxDropTarget->getDefaultActions();
 701
 702                 if( ! mpWindowImpl->mpFrameData->mxDropTargetListener.is() )
 703                 {
 704                     mpWindowImpl->mpFrameData->mxDropTargetListener = new DNDEventDispatcher( mpWindowImpl->mpFrameWindow );
 705
 706                     try
 707                     {
 708                         mpWindowImpl->mpFrameData->mxDropTarget->addDropTargetListener( mpWindowImpl->mpFrameData->mxDropTargetListener );
 709
 710                         // register also as drag gesture listener if directly supported by drag source
 711                         Reference< css::datatransfer::dnd::XDragGestureRecognizer > xDragGestureRecognizer =
 712                             Reference< css::datatransfer::dnd::XDragGestureRecognizer > (mpWindowImpl->mpFrameData->mxDragSource, UNO_QUERY);
 713
 714                         if( xDragGestureRecognizer.is() )
 715                         {
 716                             xDragGestureRecognizer->addDragGestureListener(
 717                                 Reference< css::datatransfer::dnd::XDragGestureListener > (mpWindowImpl->mpFrameData->mxDropTargetListener, UNO_QUERY));
 718                         }
 719                         else
 720                             mpWindowImpl->mpFrameData->mbInternalDragGestureRecognizer = true;
 721
 722                     }
 723                     catch (const RuntimeException&)
 724                     {
 725                         // release all instances
 726                         mpWindowImpl->mpFrameData->mxDropTarget.clear();
 727                         mpWindowImpl->mpFrameData->mxDragSource.clear();
 728                     }
 729                 }
 730             }
 731
 732         }
 733
 734         mpWindowImpl->mxDNDListenerContainer = static_cast < css::datatransfer::dnd::XDropTarget * > ( new DNDListenerContainer( nDefaultActions ) );
 735     }
 736
 737     // this object is located in the same process, so there will be no runtime exception
 738     return Reference< css::datatransfer::dnd::XDropTarget > ( mpWindowImpl->mxDNDListenerContainer, UNO_QUERY );
 739 }
 740
 741 Reference< css::datatransfer::dnd::XDragSource > Window::GetDragSource()
 742 {
 743
 744 #if HAVE_FEATURE_DESKTOP
 745
 746     if( mpWindowImpl->mpFrameData )
 747     {
 748         if( ! mpWindowImpl->mpFrameData->mxDragSource.is() )
 749         {
 750             try
 751             {
 752                 Reference< XComponentContext > xContext( comphelper::getProcessComponentContext() );
 753                 const SystemEnvData * pEnvData = GetSystemData();
 754
 755                 if( pEnvData )
 756                 {
 757                     Sequence< Any > aDragSourceAL( 2 ), aDropTargetAL( 2 );
 758                     OUString aDragSourceSN, aDropTargetSN;
 759 #if defined(_WIN32)
 760                     aDragSourceSN = "com.sun.star.datatransfer.dnd.OleDragSource";
 761                     aDropTargetSN = "com.sun.star.datatransfer.dnd.OleDropTarget";
 762                     aDragSourceAL[ 1 ] = makeAny( static_cast<sal_uInt64>( reinterpret_cast<sal_IntPtr>(pEnvData->hWnd) ) );
 763                     aDropTargetAL[ 0 ] = makeAny( static_cast<sal_uInt64>( reinterpret_cast<sal_IntPtr>(pEnvData->hWnd) ) );
 764 #elif defined MACOSX
 765             /* FIXME: Mac OS X specific dnd interface does not exist! *
 766              * Using Windows based dnd as a temporary solution        */
 767                     aDragSourceSN = "com.sun.star.datatransfer.dnd.OleDragSource";
 768                     aDropTargetSN = "com.sun.star.datatransfer.dnd.OleDropTarget";
 769                     aDragSourceAL[ 1 ] = makeAny( static_cast<sal_uInt64>( reinterpret_cast<sal_IntPtr>(pEnvData->mpNSView) ) );
 770                     aDropTargetAL[ 0 ] = makeAny( static_cast<sal_uInt64>( reinterpret_cast<sal_IntPtr>(pEnvData->mpNSView) ) );
 771 #elif HAVE_FEATURE_X11
 772                     aDragSourceSN = "com.sun.star.datatransfer.dnd.X11DragSource";
 773                     aDropTargetSN = "com.sun.star.datatransfer.dnd.X11DropTarget";
 774
 775                     aDragSourceAL[ 0 ] = makeAny( Application::GetDisplayConnection() );
 776                     aDragSourceAL[ 1 ] = makeAny(static_cast<sal_IntPtr>(pEnvData->aShellWindow));
 777                     aDropTargetAL[ 0 ] = makeAny( Application::GetDisplayConnection() );
 778                     aDropTargetAL[ 1 ] = makeAny(static_cast<sal_IntPtr>(pEnvData->aShellWindow));
 779 #endif
 780                     if( !aDragSourceSN.isEmpty() )
 781                         mpWindowImpl->mpFrameData->mxDragSource.set(
 782                             xContext->getServiceManager()->createInstanceWithArgumentsAndContext( aDragSourceSN, aDragSourceAL, xContext ),
 783                             UNO_QUERY );
 784
 785                     if( !aDropTargetSN.isEmpty() )
 786                         mpWindowImpl->mpFrameData->mxDropTarget.set(
 787                            xContext->getServiceManager()->createInstanceWithArgumentsAndContext( aDropTargetSN, aDropTargetAL, xContext ),
 788                            UNO_QUERY );
 789                 }
 790             }
 791
 792             // createInstance can throw any exception
 793             catch (const Exception&)
 794             {
 795                 // release all instances
 796                 mpWindowImpl->mpFrameData->mxDropTarget.clear();
 797                 mpWindowImpl->mpFrameData->mxDragSource.clear();
 798             }
 799         }
 800
 801         return mpWindowImpl->mpFrameData->mxDragSource;
 802     }
 803 #endif
 804     return Reference< css::datatransfer::dnd::XDragSource > ();
 805 }
 806
 807 Reference< css::datatransfer::dnd::XDragGestureRecognizer > Window::GetDragGestureRecognizer()
 808 {
 809     return Reference< css::datatransfer::dnd::XDragGestureRecognizer > ( GetDropTarget(), UNO_QUERY );
 810 }
 811
 812 } /* namespace vcl */
 813
 814 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */