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()->maWinData.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(Image(StockImage::Yes, SV_RESID_BITMAP_SCROLLVH));
 122     maImgList.emplace_back(Image(StockImage::Yes, SV_RESID_BITMAP_SCROLLV));
 123     maImgList.emplace_back(Image(StockImage::Yes, SV_RESID_BITMAP_SCROLLH));
 124     maImgList.emplace_back(Image(StockImage::Yes, SV_RESID_BITMAP_WHEELVH));
 125     maImgList.emplace_back(Image(StockImage::Yes, SV_RESID_BITMAP_WHEELV));
 126     maImgList.emplace_back(Image(StockImage::Yes, SV_RESID_BITMAP_WHEELH));
 127 }
 128
 129 void ImplWheelWindow::ImplSetWheelMode( WheelMode nWheelMode )
 130 {
 131     if( nWheelMode != mnWheelMode )
 132     {
 133         mnWheelMode = nWheelMode;
 134
 135         if( WheelMode::NONE == mnWheelMode )
 136         {
 137             if( IsVisible() )
 138                 Hide();
 139         }
 140         else
 141         {
 142             if( !IsVisible() )
 143                 Show();
 144
 145             Invalidate();
 146         }
 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             if( !o3tl::convertsToAtMost(fValX, LONG_MAX) )
 221                 mnActDeltaX = LONG_MAX;
 222             else if( !o3tl::convertsToAtLeast(fValX, LONG_MIN) )
 223                 mnActDeltaX = LONG_MIN;
 224             else
 225                 mnActDeltaX = static_cast<long>(fValX);
 226
 227             if( !o3tl::convertsToAtMost(fValY, LONG_MAX) )
 228                 mnActDeltaY = LONG_MAX;
 229             else if( !o3tl::convertsToAtLeast(fValY, LONG_MIN) )
 230                 mnActDeltaY = LONG_MIN;
 231             else
 232                 mnActDeltaY = static_cast<long>(fValY);
 233         }
 234     }
 235 }
 236
 237 PointerStyle ImplWheelWindow::ImplGetMousePointer( long nDistX, long nDistY )
 238 {
 239     PointerStyle    eStyle;
 240     const StartAutoScrollFlags nFlags = ImplGetSVData()->maWinData.mnAutoScrollFlags;
 241     const bool      bHorz( nFlags & StartAutoScrollFlags::Horz );
 242     const bool      bVert( nFlags & StartAutoScrollFlags::Vert );
 243
 244     if( bHorz || bVert )
 245     {
 246         if( mnActDist < WHEEL_RADIUS )
 247         {
 248             if( bHorz && bVert )
 249                 eStyle = PointerStyle::AutoScrollNSWE;
 250             else if( bHorz )
 251                 eStyle = PointerStyle::AutoScrollWE;
 252             else
 253                 eStyle = PointerStyle::AutoScrollNS;
 254         }
 255         else
 256         {
 257             double fAngle = basegfx::rad2deg(atan2(static_cast<double>(-nDistY), nDistX));
 258
 259             if( fAngle < 0.0 )
 260                 fAngle += 360.;
 261
 262             if( bHorz && bVert )
 263             {
 264                 if( fAngle >= 22.5 && fAngle <= 67.5 )
 265                     eStyle = PointerStyle::AutoScrollNE;
 266                 else if( fAngle >= 67.5 && fAngle <= 112.5 )
 267                     eStyle = PointerStyle::AutoScrollN;
 268                 else if( fAngle >= 112.5 && fAngle <= 157.5 )
 269                     eStyle = PointerStyle::AutoScrollNW;
 270                 else if( fAngle >= 157.5 && fAngle <= 202.5 )
 271                     eStyle = PointerStyle::AutoScrollW;
 272                 else if( fAngle >= 202.5 && fAngle <= 247.5 )
 273                     eStyle = PointerStyle::AutoScrollSW;
 274                 else if( fAngle >= 247.5 && fAngle <= 292.5 )
 275                     eStyle = PointerStyle::AutoScrollS;
 276                 else if( fAngle >= 292.5 && fAngle <= 337.5 )
 277                     eStyle = PointerStyle::AutoScrollSE;
 278                 else
 279                     eStyle = PointerStyle::AutoScrollE;
 280             }
 281             else if( bHorz )
 282             {
 283                 if( fAngle >= 270. || fAngle <= 90. )
 284                     eStyle = PointerStyle::AutoScrollE;
 285                 else
 286                     eStyle = PointerStyle::AutoScrollW;
 287             }
 288             else
 289             {
 290                 if( fAngle >= 0. && fAngle <= 180. )
 291                     eStyle = PointerStyle::AutoScrollN;
 292                 else
 293                     eStyle = PointerStyle::AutoScrollS;
 294             }
 295         }
 296     }
 297     else
 298         eStyle = PointerStyle::Arrow;
 299
 300     return eStyle;
 301 }
 302
 303 void ImplWheelWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)
 304 {
 305     ImplDrawWheel(rRenderContext);
 306 }
 307
 308 void ImplWheelWindow::MouseMove( const MouseEvent& rMEvt )
 309 {
 310     FloatingWindow::MouseMove( rMEvt );
 311
 312     const Point aMousePos( OutputToScreenPixel( rMEvt.GetPosPixel() ) );
 313     const long  nDistX = aMousePos.X() - maCenter.X();
 314     const long  nDistY = aMousePos.Y() - maCenter.Y();
 315
 316     mnActDist = static_cast<sal_uLong>(hypot( static_cast<double>(nDistX), nDistY ));
 317
 318     const PointerStyle  eActStyle = ImplGetMousePointer( nDistX, nDistY );
 319     const StartAutoScrollFlags nFlags = ImplGetSVData()->maWinData.mnAutoScrollFlags;
 320     const bool          bHorz( nFlags & StartAutoScrollFlags::Horz );
 321     const bool          bVert( nFlags & StartAutoScrollFlags::Vert );
 322     const bool          bOuter = mnActDist > WHEEL_RADIUS;
 323
 324     if( bOuter && ( maLastMousePos != aMousePos ) )
 325     {
 326         switch( eActStyle )
 327         {
 328             case PointerStyle::AutoScrollN:   mnActDeltaX = +0; mnActDeltaY = +1; break;
 329             case PointerStyle::AutoScrollS:   mnActDeltaX = +0; mnActDeltaY = -1; break;
 330             case PointerStyle::AutoScrollW:   mnActDeltaX = +1; mnActDeltaY = +0; break;
 331             case PointerStyle::AutoScrollE:   mnActDeltaX = -1; mnActDeltaY = +0; break;
 332             case PointerStyle::AutoScrollNW:  mnActDeltaX = +1; mnActDeltaY = +1; break;
 333             case PointerStyle::AutoScrollNE:  mnActDeltaX = -1; mnActDeltaY = +1; break;
 334             case PointerStyle::AutoScrollSW:  mnActDeltaX = +1; mnActDeltaY = -1; break;
 335             case PointerStyle::AutoScrollSE:  mnActDeltaX = -1; mnActDeltaY = -1; break;
 336
 337             default:
 338             break;
 339         }
 340     }
 341
 342     ImplRecalcScrollValues();
 343     maLastMousePos = aMousePos;
 344     SetPointer( eActStyle );
 345
 346     if( bHorz && bVert )
 347         ImplSetWheelMode( bOuter ? WheelMode::ScrollVH : WheelMode::VH );
 348     else if( bHorz )
 349         ImplSetWheelMode( bOuter ? WheelMode::ScrollH : WheelMode::H );
 350     else
 351         ImplSetWheelMode( bOuter ? WheelMode::ScrollV : WheelMode::V );
 352 }
 353
 354 void ImplWheelWindow::MouseButtonUp( const MouseEvent& rMEvt )
 355 {
 356     if( mnActDist > WHEEL_RADIUS )
 357         GetParent()->EndAutoScroll();
 358     else
 359         FloatingWindow::MouseButtonUp( rMEvt );
 360 }
 361
 362 IMPL_LINK_NOARG(ImplWheelWindow, ImplScrollHdl, Timer *, void)
 363 {
 364     if ( mnActDeltaX || mnActDeltaY )
 365     {
 366         vcl::Window*             pWindow = GetParent();
 367         const Point         aMousePos( pWindow->OutputToScreenPixel( pWindow->GetPointerPosPixel() ) );
 368         Point               aCmdMousePos( pWindow->ImplFrameToOutput( aMousePos ) );
 369         CommandScrollData   aScrollData( mnActDeltaX, mnActDeltaY );
 370         CommandEvent        aCEvt( aCmdMousePos, CommandEventId::AutoScroll, true, &aScrollData );
 371         NotifyEvent         aNCmdEvt( MouseNotifyEvent::COMMAND, pWindow, &aCEvt );
 372
 373         if ( !ImplCallPreNotify( aNCmdEvt ) )
 374         {
 375             const sal_uInt64 nTime = tools::Time::GetSystemTicks();
 376             VclPtr<ImplWheelWindow> xWin(this);
 377             pWindow->Command( aCEvt );
 378             if( xWin->IsDisposed() )
 379                 return;
 380             mnRepaintTime = std::max( tools::Time::GetSystemTicks() - nTime, sal_uInt64(1) );
 381             ImplRecalcScrollValues();
 382         }
 383     }
 384
 385     if ( mnTimeout != mpTimer->GetTimeout() )
 386         mpTimer->SetTimeout( mnTimeout );
 387     mpTimer->Start();
 388 }
 389
 390 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */