Adding upstream version 2:20.4+dfsg.upstream/2%20.4+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 235 insertions, 0 deletions

diff --git a/xbmc/input/InertialScrollingHandler.cpp b/xbmc/input/InertialScrollingHandler.cpp
new file mode 100644
index 0000000..1248722
--- /dev/null
+++ b/xbmc/input/InertialScrollingHandler.cpp
@@ -0,0 +1,235 @@
+/*
+ *  Copyright (C) 2011-2018 Team Kodi
+ *  This file is part of Kodi - https://kodi.tv
+ *
+ *  SPDX-License-Identifier: GPL-2.0-or-later
+ *  See LICENSES/README.md for more information.
+ */
+
+#include "InertialScrollingHandler.h"
+
+#include "ServiceBroker.h"
+#include "application/Application.h"
+#include "application/ApplicationComponents.h"
+#include "application/ApplicationPowerHandling.h"
+#include "guilib/GUIComponent.h"
+#include "guilib/GUIWindowManager.h"
+#include "input/actions/Action.h"
+#include "input/actions/ActionIDs.h"
+#include "input/touch/generic/GenericTouchInputHandler.h"
+#include "utils/TimeUtils.h"
+#include "windowing/WinSystem.h"
+
+#include <cmath>
+#include <numeric>
+
+// time for reaching velocity 0 in secs
+#define TIME_TO_ZERO_SPEED 1.0f
+// minimum speed for doing inertial scroll is 100 pixels / s
+#define MINIMUM_SPEED_FOR_INERTIA 200
+// maximum speed for reducing time to zero
+#define MAXIMUM_SPEED_FOR_REDUCTION 750
+// maximum time between last movement and gesture end in ms to consider as moving
+#define MAXIMUM_DELAY_FOR_INERTIA 200
+
+CInertialScrollingHandler::CInertialScrollingHandler() : m_iLastGesturePoint(CPoint(0, 0))
+{
+}
+
+unsigned int CInertialScrollingHandler::PanPoint::TimeElapsed() const
+{
+  return CTimeUtils::GetFrameTime() - time;
+}
+
+bool CInertialScrollingHandler::CheckForInertialScrolling(const CAction* action)
+{
+  bool ret = false; // return value - false no inertial scrolling - true - inertial scrolling
+
+  if (CServiceBroker::GetWinSystem()->HasInertialGestures())
+  {
+    return ret; // no need for emulating inertial scrolling - windowing does support it natively.
+  }
+
+  // reset screensaver during pan
+  if (action->GetID() == ACTION_GESTURE_PAN)
+  {
+    auto& components = CServiceBroker::GetAppComponents();
+    const auto appPower = components.GetComponent<CApplicationPowerHandling>();
+    if (appPower)
+      appPower->ResetScreenSaver();
+    if (!m_bScrolling)
+    {
+      m_panPoints.emplace_back(CTimeUtils::GetFrameTime(),
+                               CVector{action->GetAmount(4), action->GetAmount(5)});
+    }
+    return false;
+  }
+
+  // mouse click aborts scrolling
+  if (m_bScrolling && action->GetID() == ACTION_MOUSE_LEFT_CLICK)
+  {
+    ret = true;
+    m_bAborting = true; // lets abort
+  }
+
+  // trim saved pan points to time range that qualifies for inertial scrolling
+  while (!m_panPoints.empty() && m_panPoints.front().TimeElapsed() > MAXIMUM_DELAY_FOR_INERTIA)
+    m_panPoints.pop_front();
+
+  // on begin/tap stop all inertial scrolling
+  if (action->GetID() == ACTION_GESTURE_BEGIN)
+  {
+    // release any former exclusive mouse mode
+    // for making switching between multiple lists
+    // possible
+    CGUIMessage message(GUI_MSG_EXCLUSIVE_MOUSE, 0, 0);
+    CServiceBroker::GetGUI()->GetWindowManager().SendMessage(message);
+    m_bScrolling = false;
+    // wakeup screensaver on pan begin
+    auto& components = CServiceBroker::GetAppComponents();
+    const auto appPower = components.GetComponent<CApplicationPowerHandling>();
+    appPower->ResetScreenSaver();
+    appPower->WakeUpScreenSaverAndDPMS();
+  }
+  else if (action->GetID() == ACTION_GESTURE_END &&
+           !m_panPoints.empty()) // do we need to animate inertial scrolling?
+  {
+    // Calculate velocity in the last MAXIMUM_DELAY_FOR_INERTIA milliseconds.
+    // Do not use the velocity given by the ACTION_GESTURE_END data - it is calculated
+    // for the whole duration of the touch and thus useless for inertia. The user
+    // may scroll around for a few seconds and then only at the end flick in one
+    // direction. Only the last flick should be relevant here.
+    auto velocitySum =
+        std::accumulate(m_panPoints.cbegin(), m_panPoints.cend(), CVector{},
+                        [](CVector val, PanPoint const& p) { return val + p.velocity; });
+    auto velocityX = velocitySum.x / m_panPoints.size();
+    auto velocityY = velocitySum.y / m_panPoints.size();
+
+    m_timeToZero = TIME_TO_ZERO_SPEED;
+    auto velocityMax = std::max(std::abs(velocityX), std::abs(velocityY));
+#ifdef TARGET_DARWIN_OSX
+    float dpiScale = 1.0;
+#else
+    float dpiScale = CGenericTouchInputHandler::GetInstance().GetScreenDPI() / 160.0f;
+#endif
+    if (velocityMax > MINIMUM_SPEED_FOR_INERTIA * dpiScale)
+    {
+      if (velocityMax < MAXIMUM_SPEED_FOR_REDUCTION * dpiScale)
+        m_timeToZero = (m_timeToZero * velocityMax) / (MAXIMUM_SPEED_FOR_REDUCTION * dpiScale);
+
+      bool inertialRequested = false;
+      CGUIMessage message(GUI_MSG_GESTURE_NOTIFY, 0, 0, static_cast<int>(velocityX),
+                          static_cast<int>(velocityY));
+
+      // ask if the control wants inertial scrolling
+      if (CServiceBroker::GetGUI()->GetWindowManager().SendMessage(message))
+      {
+        int result = 0;
+        if (message.GetPointer())
+        {
+          int* p = static_cast<int*>(message.GetPointer());
+          message.SetPointer(nullptr);
+          result = *p;
+          delete p;
+        }
+        if (result == EVENT_RESULT_PAN_HORIZONTAL || result == EVENT_RESULT_PAN_VERTICAL)
+        {
+          inertialRequested = true;
+        }
+      }
+
+      if (inertialRequested)
+      {
+        m_iFlickVelocity.x = velocityX; // in pixels per sec
+        m_iFlickVelocity.y = velocityY; // in pixels per sec
+        m_iLastGesturePoint.x = action->GetAmount(2); // last gesture point x
+        m_iLastGesturePoint.y = action->GetAmount(3); // last gesture point y
+
+        // calc deacceleration for fullstop in TIME_TO_ZERO_SPEED secs
+        // v = a*t + v0 -> set v = 0 because we want to stop scrolling
+        // a = -v0 / t
+        m_inertialDeacceleration.x = -1 * m_iFlickVelocity.x / m_timeToZero;
+        m_inertialDeacceleration.y = -1 * m_iFlickVelocity.y / m_timeToZero;
+
+        m_inertialStartTime = CTimeUtils::GetFrameTime(); // start time of inertial scrolling
+        ret = true;
+        m_bScrolling = true; // activate the inertial scrolling animation
+      }
+    }
+  }
+
+  if (action->GetID() == ACTION_GESTURE_BEGIN || action->GetID() == ACTION_GESTURE_END ||
+      action->GetID() == ACTION_GESTURE_ABORT)
+  {
+    m_panPoints.clear();
+  }
+
+  return ret;
+}
+
+bool CInertialScrollingHandler::ProcessInertialScroll(float frameTime)
+{
+  // do inertial scroll animation by sending gesture_pan
+  if (m_bScrolling)
+  {
+    float xMovement = 0.0;
+    float yMovement = 0.0;
+
+    // decrease based on negative acceleration
+    // calc the overall inertial scrolling time in secs
+    float absoluteInertialTime = (CTimeUtils::GetFrameTime() - m_inertialStartTime) / (float)1000;
+
+    // as long as we aren't over the overall inertial scroll time - do the deacceleration
+    if (absoluteInertialTime < m_timeToZero)
+    {
+      // v = s/t -> s = t * v
+      xMovement = frameTime * m_iFlickVelocity.x;
+      yMovement = frameTime * m_iFlickVelocity.y;
+
+      // save new gesture point
+      m_iLastGesturePoint.x += xMovement;
+      m_iLastGesturePoint.y += yMovement;
+
+      // fire the pan action
+      if (!g_application.OnAction(CAction(ACTION_GESTURE_PAN, 0, m_iLastGesturePoint.x,
+                                          m_iLastGesturePoint.y, xMovement, yMovement,
+                                          m_iFlickVelocity.x, m_iFlickVelocity.y)))
+      {
+        m_bAborting = true; // we are done
+      }
+
+      // calc new velocity based on deacceleration
+      // v = a*t + v0
+      m_iFlickVelocity.x = m_inertialDeacceleration.x * frameTime + m_iFlickVelocity.x;
+      m_iFlickVelocity.y = m_inertialDeacceleration.y * frameTime + m_iFlickVelocity.y;
+
+      // check if the signs are equal - which would mean we deaccelerated to long and reversed the
+      // direction
+      if ((m_inertialDeacceleration.x < 0) == (m_iFlickVelocity.x < 0))
+      {
+        m_iFlickVelocity.x = 0;
+      }
+      if ((m_inertialDeacceleration.y < 0) == (m_iFlickVelocity.y < 0))
+      {
+        m_iFlickVelocity.y = 0;
+      }
+    }
+    else // no movement -> done
+    {
+      m_bAborting = true; // we are done
+    }
+  }
+
+  // if we are done - or we where aborted
+  if (m_bAborting)
+  {
+    // fire gesture end action
+    g_application.OnAction(CAction(ACTION_GESTURE_END, 0, 0.0f, 0.0f, 0.0f, 0.0f));
+    m_bAborting = false;
+    m_bScrolling = false; // stop scrolling
+    m_iFlickVelocity.x = 0;
+    m_iFlickVelocity.y = 0;
+  }
+
+  return true;
+}