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