The Tor Browser: comparison gfx/layers/apz/src/Axis.cpp

--1:000000000000
+:67245678c732
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et tw=80 : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "Axis.h"
+#include <math.h>                       // for fabsf, pow, powf
+#include <algorithm>                    // for max
+#include "AsyncPanZoomController.h"     // for AsyncPanZoomController
+#include "mozilla/layers/APZCTreeManager.h" // for APZCTreeManager
+#include "FrameMetrics.h"               // for FrameMetrics
+#include "mozilla/Attributes.h"         // for MOZ_FINAL
+#include "mozilla/Preferences.h"        // for Preferences
+#include "mozilla/gfx/Rect.h"           // for RoundedIn
+#include "mozilla/mozalloc.h"           // for operator new
+#include "nsMathUtils.h"                // for NS_lround
+#include "nsThreadUtils.h"              // for NS_DispatchToMainThread, etc
+#include "nscore.h"                     // for NS_IMETHOD
+#include "gfxPrefs.h"                   // for the preferences
+namespace mozilla {
+namespace layers {
+Axis::Axis(AsyncPanZoomController* aAsyncPanZoomController)
+: mPos(0),
+mVelocity(0.0f),
+mAxisLocked(false),
+mAsyncPanZoomController(aAsyncPanZoomController)
+{
+}
+void Axis::UpdateWithTouchAtDevicePoint(int32_t aPos, const TimeDuration& aTimeDelta) {
+float newVelocity = mAxisLocked ? 0 : (mPos - aPos) / aTimeDelta.ToMilliseconds();
+if (gfxPrefs::APZMaxVelocity() > 0.0f) {
+newVelocity = std::min(newVelocity, gfxPrefs::APZMaxVelocity() * APZCTreeManager::GetDPI());
+}
+mVelocity = newVelocity;
+mPos = aPos;
+// Limit queue size pased on pref
+mVelocityQueue.AppendElement(mVelocity);
+if (mVelocityQueue.Length() > gfxPrefs::APZMaxVelocityQueueSize()) {
+mVelocityQueue.RemoveElementAt(0);
+}
+}
+void Axis::StartTouch(int32_t aPos) {
+mStartPos = aPos;
+mPos = aPos;
+mAxisLocked = false;
+}
+float Axis::AdjustDisplacement(float aDisplacement, float& aOverscrollAmountOut) {
+if (mAxisLocked) {
+aOverscrollAmountOut = 0;
+return 0;
+}
+float displacement = aDisplacement;
+// If this displacement will cause an overscroll, throttle it. Can potentially
+// bring it to 0 even if the velocity is high.
+if (DisplacementWillOverscroll(displacement) != OVERSCROLL_NONE) {
+// No need to have a velocity along this axis anymore; it won't take us
+// anywhere, so we're just spinning needlessly.
+mVelocity = 0.0f;
+aOverscrollAmountOut = DisplacementWillOverscrollAmount(displacement);
+displacement -= aOverscrollAmountOut;
+}
+return displacement;
+}
+float Axis::PanDistance() {
+return fabsf(mPos - mStartPos);
+}
+float Axis::PanDistance(float aPos) {
+return fabsf(aPos - mStartPos);
+}
+void Axis::EndTouch() {
+// Calculate the mean velocity and empty the queue.
+int count = mVelocityQueue.Length();
+if (count) {
+mVelocity = 0;
+while (!mVelocityQueue.IsEmpty()) {
+mVelocity += mVelocityQueue[0];
+mVelocityQueue.RemoveElementAt(0);
+}
+mVelocity /= count;
+}
+}
+void Axis::CancelTouch() {
+mVelocity = 0.0f;
+while (!mVelocityQueue.IsEmpty()) {
+mVelocityQueue.RemoveElementAt(0);
+}
+}
+bool Axis::Scrollable() {
+if (mAxisLocked) {
+return false;
+}
+return GetCompositionLength() < GetPageLength();
+}
+bool Axis::FlingApplyFrictionOrCancel(const TimeDuration& aDelta) {
+if (fabsf(mVelocity) <= gfxPrefs::APZFlingStoppedThreshold()) {
+// If the velocity is very low, just set it to 0 and stop the fling,
+// otherwise we'll just asymptotically approach 0 and the user won't
+// actually see any changes.
+mVelocity = 0.0f;
+return false;
+} else {
+mVelocity *= pow(1.0f - gfxPrefs::APZFlingFriction(), float(aDelta.ToMilliseconds()));
+}
+return true;
+}
+Axis::Overscroll Axis::GetOverscroll() {
+// If the current pan takes the window to the left of or above the current
+// page rect.
+bool minus = GetOrigin() < GetPageStart();
+// If the current pan takes the window to the right of or below the current
+// page rect.
+bool plus = GetCompositionEnd() > GetPageEnd();
+if (minus && plus) {
+return OVERSCROLL_BOTH;
+}
+if (minus) {
+return OVERSCROLL_MINUS;
+}
+if (plus) {
+return OVERSCROLL_PLUS;
+}
+return OVERSCROLL_NONE;
+}
+float Axis::GetExcess() {
+switch (GetOverscroll()) {
+case OVERSCROLL_MINUS: return GetOrigin() - GetPageStart();
+case OVERSCROLL_PLUS: return GetCompositionEnd() - GetPageEnd();
+case OVERSCROLL_BOTH: return (GetCompositionEnd() - GetPageEnd()) +
+(GetPageStart() - GetOrigin());
+default: return 0;
+}
+}
+Axis::Overscroll Axis::DisplacementWillOverscroll(float aDisplacement) {
+// If the current pan plus a displacement takes the window to the left of or
+// above the current page rect.
+bool minus = GetOrigin() + aDisplacement < GetPageStart();
+// If the current pan plus a displacement takes the window to the right of or
+// below the current page rect.
+bool plus = GetCompositionEnd() + aDisplacement > GetPageEnd();
+if (minus && plus) {
+return OVERSCROLL_BOTH;
+}
+if (minus) {
+return OVERSCROLL_MINUS;
+}
+if (plus) {
+return OVERSCROLL_PLUS;
+}
+return OVERSCROLL_NONE;
+}
+float Axis::DisplacementWillOverscrollAmount(float aDisplacement) {
+switch (DisplacementWillOverscroll(aDisplacement)) {
+case OVERSCROLL_MINUS: return (GetOrigin() + aDisplacement) - GetPageStart();
+case OVERSCROLL_PLUS: return (GetCompositionEnd() + aDisplacement) - GetPageEnd();
+// Don't handle overscrolled in both directions; a displacement can't cause
+// this, it must have already been zoomed out too far.
+default: return 0;
+}
+}
+float Axis::ScaleWillOverscrollAmount(float aScale, float aFocus) {
+float originAfterScale = (GetOrigin() + aFocus) - (aFocus / aScale);
+bool both = ScaleWillOverscrollBothSides(aScale);
+bool minus = originAfterScale < GetPageStart();
+bool plus = (originAfterScale + (GetCompositionLength() / aScale)) > GetPageEnd();
+if ((minus && plus) || both) {
+// If we ever reach here it's a bug in the client code.
+MOZ_ASSERT(false, "In an OVERSCROLL_BOTH condition in ScaleWillOverscrollAmount");
+return 0;
+}
+if (minus) {
+return originAfterScale - GetPageStart();
+}
+if (plus) {
+return originAfterScale + (GetCompositionLength() / aScale) - GetPageEnd();
+}
+return 0;
+}
+float Axis::GetVelocity() {
+return mAxisLocked ? 0 : mVelocity;
+}
+void Axis::SetVelocity(float aVelocity) {
+mVelocity = aVelocity;
+}
+float Axis::GetCompositionEnd() const {
+return GetOrigin() + GetCompositionLength();
+}
+float Axis::GetPageEnd() const {
+return GetPageStart() + GetPageLength();
+}
+float Axis::GetOrigin() const {
+CSSPoint origin = mAsyncPanZoomController->GetFrameMetrics().GetScrollOffset();
+return GetPointOffset(origin);
+}
+float Axis::GetCompositionLength() const {
+const FrameMetrics& metrics = mAsyncPanZoomController->GetFrameMetrics();
+return GetRectLength(metrics.CalculateCompositedRectInCssPixels());
+}
+float Axis::GetPageStart() const {
+CSSRect pageRect = mAsyncPanZoomController->GetFrameMetrics().mScrollableRect;
+return GetRectOffset(pageRect);
+}
+float Axis::GetPageLength() const {
+CSSRect pageRect = mAsyncPanZoomController->GetFrameMetrics().mScrollableRect;
+return GetRectLength(pageRect);
+}
+bool Axis::ScaleWillOverscrollBothSides(float aScale) {
+const FrameMetrics& metrics = mAsyncPanZoomController->GetFrameMetrics();
+CSSToParentLayerScale scale(metrics.GetZoomToParent().scale * aScale);
+CSSRect cssCompositionBounds = metrics.mCompositionBounds / scale;
+return GetRectLength(metrics.mScrollableRect) < GetRectLength(cssCompositionBounds);
+}
+bool Axis::HasRoomToPan() const {
+return GetOrigin() > GetPageStart()
+|| GetCompositionEnd() < GetPageEnd();
+}
+AxisX::AxisX(AsyncPanZoomController* aAsyncPanZoomController)
+: Axis(aAsyncPanZoomController)
+{
+}
+float AxisX::GetPointOffset(const CSSPoint& aPoint) const
+{
+return aPoint.x;
+}
+float AxisX::GetRectLength(const CSSRect& aRect) const
+{
+return aRect.width;
+}
+float AxisX::GetRectOffset(const CSSRect& aRect) const
+{
+return aRect.x;
+}
+AxisY::AxisY(AsyncPanZoomController* aAsyncPanZoomController)
+: Axis(aAsyncPanZoomController)
+{
+}
+float AxisY::GetPointOffset(const CSSPoint& aPoint) const
+{
+return aPoint.y;
+}
+float AxisY::GetRectLength(const CSSRect& aRect) const
+{
+return aRect.height;
+}
+float AxisY::GetRectOffset(const CSSRect& aRect) const
+{
+return aRect.y;
+}
+}
+}

The Tor Browser / file comparison

comparison: gfx/layers/apz/src/Axis.cpp

gfx/layers/apz/src/Axis.cpp