vcl/source/window/scrwnd.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 <limits.h>
  21
  22 #include <o3tl/float_int_conversion.hxx>
  23 #include <tools/time.hxx>
  24
  25 #include <bitmaps.hlst>
  26 #include <svdata.hxx>
  27 #include <scrwnd.hxx>
  28
  29 #include <vcl/timer.hxx>
  30 #include <vcl/commandevent.hxx>
  31 #include <vcl/event.hxx>
  32 #include <vcl/ptrstyle.hxx>
  33 #include <sal/log.hxx>
  34
  35 #include <math.h>
  36
  37 #define WHEEL_WIDTH     25
  38 #define WHEEL_RADIUS    ((WHEEL_WIDTH) >> 1 )
  39 #define MAX_TIME        300
  40 #define MIN_TIME        20
  41 #define DEF_TIMEOUT     50
  42
  43 ImplWheelWindow::ImplWheelWindow( vcl::Window* pParent ) :
  44             FloatingWindow  ( pParent, 0 ),
  45             mnRepaintTime   ( 1 ),
  46             mnTimeout       ( DEF_TIMEOUT ),
  47             mnWheelMode     ( WheelMode::NONE ),
  48             mnActDist       ( 0 ),
  49             mnActDeltaX     ( 0 ),
  50             mnActDeltaY     ( 0 )
  51 {
  52     // we need a parent
  53     SAL_WARN_IF( !pParent, "vcl", "ImplWheelWindow::ImplWheelWindow(): Parent not set!" );
  54
  55     const Size      aSize( pParent->GetOutputSizePixel() );
  56     const StartAutoScrollFlags nFlags = ImplGetSVData()->mpWinData->mnAutoScrollFlags;
  57     const bool      bHorz( nFlags & StartAutoScrollFlags::Horz );
  58     const bool      bVert( nFlags & StartAutoScrollFlags::Vert );
  59
  60     // calculate maximum speed distance
  61     mnMaxWidth = static_cast<sal_uLong>( 0.4 * hypot( static_cast<double>(aSize.Width()), aSize.Height() ) );
  62
  63     // create wheel window
  64     SetTitleType( FloatWinTitleType::NONE );
  65     ImplCreateImageList();
  66     BitmapEx aBmp(SV_RESID_BITMAP_SCROLLMSK);
  67     ImplSetRegion(aBmp.GetBitmap());
  68
  69     // set wheel mode
  70     if( bHorz && bVert )
  71         ImplSetWheelMode( WheelMode::VH );
  72     else if( bHorz )
  73         ImplSetWheelMode( WheelMode::H );
  74     else
  75         ImplSetWheelMode( WheelMode::V );
  76
  77     // init timer
  78     mpTimer.reset(new Timer("WheelWindowTimer"));
  79     mpTimer->SetInvokeHandler( LINK( this, ImplWheelWindow, ImplScrollHdl ) );
  80     mpTimer->SetTimeout( mnTimeout );
  81     mpTimer->Start();
  82
  83     CaptureMouse();
  84 }
  85
  86 ImplWheelWindow::~ImplWheelWindow()
  87 {
  88     disposeOnce();
  89 }
  90
  91 void ImplWheelWindow::dispose()
  92 {
  93     ImplStop();
  94     mpTimer.reset();
  95     FloatingWindow::dispose();
  96 }
  97
  98 void ImplWheelWindow::ImplStop()
  99 {
 100     ReleaseMouse();
 101     mpTimer->Stop();
 102     Show(false);
 103 }
 104
 105 void ImplWheelWindow::ImplSetRegion( const Bitmap& rRegionBmp )
 106 {
 107     Point           aPos( GetPointerPosPixel() );
 108     const Size      aSize( rRegionBmp.GetSizePixel() );
 109     const tools::Rectangle aRect( Point(), aSize );
 110
 111     maCenter = maLastMousePos = aPos;
 112     aPos.AdjustX( -(aSize.Width() >> 1) );
 113     aPos.AdjustY( -(aSize.Height() >> 1) );
 114
 115     SetPosSizePixel( aPos, aSize );
 116     SetWindowRegionPixel( rRegionBmp.CreateRegion( COL_BLACK, aRect ) );
 117 }
 118
 119 void ImplWheelWindow::ImplCreateImageList()
 120 {
 121     maImgList.emplace_back(StockImage::Yes, SV_RESID_BITMAP_SCROLLVH);
 122     maImgList.emplace_back(StockImage::Yes, SV_RESID_BITMAP_SCROLLV);
 123     maImgList.emplace_back(StockImage::Yes, SV_RESID_BITMAP_SCROLLH);
 124     maImgList.emplace_back(StockImage::Yes, SV_RESID_BITMAP_WHEELVH);
 125     maImgList.emplace_back(StockImage::Yes, SV_RESID_BITMAP_WHEELV);
 126     maImgList.emplace_back(StockImage::Yes, SV_RESID_BITMAP_WHEELH);
 127 }
 128
 129 void ImplWheelWindow::ImplSetWheelMode( WheelMode nWheelMode )
 130 {
 131     if( nWheelMode == mnWheelMode )
 132         return;
 133
 134     mnWheelMode = nWheelMode;
 135
 136     if( WheelMode::NONE == mnWheelMode )
 137     {
 138         if( IsVisible() )
 139             Hide();
 140     }
 141     else
 142     {
 143         if( !IsVisible() )
 144             Show();
 145
 146         Invalidate();
 147     }
 148 }
 149
 150 void ImplWheelWindow::ImplDrawWheel(vcl::RenderContext& rRenderContext)
 151 {
 152     int nIndex;
 153
 154     switch (mnWheelMode)
 155     {
 156         case WheelMode::VH:
 157             nIndex = 0;
 158         break;
 159         case WheelMode::V:
 160             nIndex = 1;
 161         break;
 162         case WheelMode::H:
 163             nIndex = 2;
 164         break;
 165         case WheelMode::ScrollVH:
 166             nIndex = 3;
 167         break;
 168         case WheelMode::ScrollV:
 169             nIndex = 4;
 170         break;
 171         case WheelMode::ScrollH:
 172             nIndex = 5;
 173         break;
 174         default:
 175             nIndex = -1;
 176         break;
 177     }
 178
 179     if (nIndex >= 0)
 180         rRenderContext.DrawImage(Point(), maImgList[nIndex]);
 181 }
 182
 183 void ImplWheelWindow::ImplRecalcScrollValues()
 184 {
 185     if( mnActDist < WHEEL_RADIUS )
 186     {
 187         mnActDeltaX = mnActDeltaY = 0;
 188         mnTimeout = DEF_TIMEOUT;
 189     }
 190     else
 191     {
 192         sal_uInt64 nCurTime;
 193
 194         // calc current time
 195         if( mnMaxWidth )
 196         {
 197             const double fExp = ( static_cast<double>(mnActDist) / mnMaxWidth ) * log10( double(MAX_TIME) / MIN_TIME );
 198             nCurTime = static_cast<sal_uInt64>( MAX_TIME / pow( 10., fExp ) );
 199         }
 200         else
 201             nCurTime = MAX_TIME;
 202
 203         if( !nCurTime )
 204             nCurTime = 1;
 205
 206         if( mnRepaintTime <= nCurTime )
 207             mnTimeout = nCurTime - mnRepaintTime;
 208         else
 209         {
 210             sal_uInt64 nMult = mnRepaintTime / nCurTime;
 211
 212             if( !( mnRepaintTime % nCurTime ) )
 213                 mnTimeout = 0;
 214             else
 215                 mnTimeout = ++nMult * nCurTime - mnRepaintTime;
 216
 217             double fValX = static_cast<double>(mnActDeltaX) * nMult;
 218             double fValY = static_cast<double>(mnActDeltaY) * nMult;
 219
 220             mnActDeltaX = o3tl::saturating_cast<tools::Long>(fValX);
 221             mnActDeltaY = o3tl::saturating_cast<tools::Long>(fValY);
 222         }
 223     }
 224 }
 225
 226 PointerStyle ImplWheelWindow::ImplGetMousePointer( tools::Long nDistX, tools::Long nDistY ) const
 227 {
 228     PointerStyle    eStyle;
 229     const StartAutoScrollFlags nFlags = ImplGetSVData()->mpWinData->mnAutoScrollFlags;
 230     const bool      bHorz( nFlags & StartAutoScrollFlags::Horz );
 231     const bool      bVert( nFlags & StartAutoScrollFlags::Vert );
 232
 233     if( bHorz || bVert )
 234     {
 235         if( mnActDist < WHEEL_RADIUS )
 236         {
 237             if( bHorz && bVert )
 238                 eStyle = PointerStyle::AutoScrollNSWE;
 239             else if( bHorz )
 240                 eStyle = PointerStyle::AutoScrollWE;
 241             else
 242                 eStyle = PointerStyle::AutoScrollNS;
 243         }
 244         else
 245         {
 246             double fAngle = basegfx::rad2deg(atan2(static_cast<double>(-nDistY), nDistX));
 247
 248             if( fAngle < 0.0 )
 249                 fAngle += 360.;
 250
 251             if( bHorz && bVert )
 252             {
 253                 if( fAngle >= 22.5 && fAngle <= 67.5 )
 254                     eStyle = PointerStyle::AutoScrollNE;
 255                 else if( fAngle >= 67.5 && fAngle <= 112.5 )
 256                     eStyle = PointerStyle::AutoScrollN;
 257                 else if( fAngle >= 112.5 && fAngle <= 157.5 )
 258                     eStyle = PointerStyle::AutoScrollNW;
 259                 else if( fAngle >= 157.5 && fAngle <= 202.5 )
 260                     eStyle = PointerStyle::AutoScrollW;
 261                 else if( fAngle >= 202.5 && fAngle <= 247.5 )
 262                     eStyle = PointerStyle::AutoScrollSW;
 263                 else if( fAngle >= 247.5 && fAngle <= 292.5 )
 264                     eStyle = PointerStyle::AutoScrollS;
 265                 else if( fAngle >= 292.5 && fAngle <= 337.5 )
 266                     eStyle = PointerStyle::AutoScrollSE;
 267                 else
 268                     eStyle = PointerStyle::AutoScrollE;
 269             }
 270             else if( bHorz )
 271             {
 272                 if( fAngle >= 270. || fAngle <= 90. )
 273                     eStyle = PointerStyle::AutoScrollE;
 274                 else
 275                     eStyle = PointerStyle::AutoScrollW;
 276             }
 277             else
 278             {
 279                 if( fAngle >= 0. && fAngle <= 180. )
 280                     eStyle = PointerStyle::AutoScrollN;
 281                 else
 282                     eStyle = PointerStyle::AutoScrollS;
 283             }
 284         }
 285     }
 286     else
 287         eStyle = PointerStyle::Arrow;
 288
 289     return eStyle;
 290 }
 291
 292 void ImplWheelWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)
 293 {
 294     ImplDrawWheel(rRenderContext);
 295 }
 296
 297 void ImplWheelWindow::MouseMove( const MouseEvent& rMEvt )
 298 {
 299     FloatingWindow::MouseMove( rMEvt );
 300
 301     const Point aMousePos( OutputToScreenPixel( rMEvt.GetPosPixel() ) );
 302     const tools::Long  nDistX = aMousePos.X() - maCenter.X();
 303     const tools::Long  nDistY = aMousePos.Y() - maCenter.Y();
 304
 305     mnActDist = static_cast<sal_uLong>(hypot( static_cast<double>(nDistX), nDistY ));
 306
 307     const PointerStyle  eActStyle = ImplGetMousePointer( nDistX, nDistY );
 308     const StartAutoScrollFlags nFlags = ImplGetSVData()->mpWinData->mnAutoScrollFlags;
 309     const bool          bHorz( nFlags & StartAutoScrollFlags::Horz );
 310     const bool          bVert( nFlags & StartAutoScrollFlags::Vert );
 311     const bool          bOuter = mnActDist > WHEEL_RADIUS;
 312
 313     if( bOuter && ( maLastMousePos != aMousePos ) )
 314     {
 315         switch( eActStyle )
 316         {
 317             case PointerStyle::AutoScrollN:   mnActDeltaX = +0; mnActDeltaY = +1; break;
 318             case PointerStyle::AutoScrollS:   mnActDeltaX = +0; mnActDeltaY = -1; break;
 319             case PointerStyle::AutoScrollW:   mnActDeltaX = +1; mnActDeltaY = +0; break;
 320             case PointerStyle::AutoScrollE:   mnActDeltaX = -1; mnActDeltaY = +0; break;
 321             case PointerStyle::AutoScrollNW:  mnActDeltaX = +1; mnActDeltaY = +1; break;
 322             case PointerStyle::AutoScrollNE:  mnActDeltaX = -1; mnActDeltaY = +1; break;
 323             case PointerStyle::AutoScrollSW:  mnActDeltaX = +1; mnActDeltaY = -1; break;
 324             case PointerStyle::AutoScrollSE:  mnActDeltaX = -1; mnActDeltaY = -1; break;
 325
 326             default:
 327             break;
 328         }
 329     }
 330
 331     ImplRecalcScrollValues();
 332     maLastMousePos = aMousePos;
 333     SetPointer( eActStyle );
 334
 335     if( bHorz && bVert )
 336         ImplSetWheelMode( bOuter ? WheelMode::ScrollVH : WheelMode::VH );
 337     else if( bHorz )
 338         ImplSetWheelMode( bOuter ? WheelMode::ScrollH : WheelMode::H );
 339     else
 340         ImplSetWheelMode( bOuter ? WheelMode::ScrollV : WheelMode::V );
 341 }
 342
 343 void ImplWheelWindow::MouseButtonUp( const MouseEvent& rMEvt )
 344 {
 345     if( mnActDist > WHEEL_RADIUS )
 346         GetParent()->EndAutoScroll();
 347     else
 348         FloatingWindow::MouseButtonUp( rMEvt );
 349 }
 350
 351 IMPL_LINK_NOARG(ImplWheelWindow, ImplScrollHdl, Timer *, void)
 352 {
 353     if ( mnActDeltaX || mnActDeltaY )
 354     {
 355         vcl::Window*             pWindow = GetParent();
 356         const Point         aMousePos( pWindow->OutputToScreenPixel( pWindow->GetPointerPosPixel() ) );
 357         Point               aCmdMousePos( pWindow->ImplFrameToOutput( aMousePos ) );
 358         CommandScrollData   aScrollData( mnActDeltaX, mnActDeltaY );
 359         CommandEvent        aCEvt( aCmdMousePos, CommandEventId::AutoScroll, true, &aScrollData );
 360         NotifyEvent         aNCmdEvt( NotifyEventType::COMMAND, pWindow, &aCEvt );
 361
 362         if ( !ImplCallPreNotify( aNCmdEvt ) )
 363         {
 364             const sal_uInt64 nTime = tools::Time::GetSystemTicks();
 365             VclPtr<ImplWheelWindow> xWin(this);
 366             pWindow->Command( aCEvt );
 367             if( xWin->isDisposed() )
 368                 return;
 369             mnRepaintTime = std::max( tools::Time::GetSystemTicks() - nTime, sal_uInt64(1) );
 370             ImplRecalcScrollValues();
 371         }
 372     }
 373
 374     if ( mnTimeout != mpTimer->GetTimeout() )
 375         mpTimer->SetTimeout( mnTimeout );
 376     mpTimer->Start();
 377 }
 378
 379 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */