forked from mirrors/gecko-dev
265e672179
# ignore-this-changeset --HG-- extra : amend_source : 4d301d3b0b8711c4692392aa76088ba7fd7d1022
93 lines
3.4 KiB
C++
93 lines
3.4 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 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/. */
|
|
|
|
#ifndef ScrollVelocityQueue_h_
|
|
#define ScrollVelocityQueue_h_
|
|
|
|
#include "nsTArray.h"
|
|
#include "nsPoint.h"
|
|
#include "mozilla/TimeStamp.h"
|
|
|
|
class nsPresContext;
|
|
|
|
namespace mozilla {
|
|
namespace layout {
|
|
|
|
/**
|
|
* ScrollVelocityQueue is used to determine the current velocity of a
|
|
* scroll frame, derived from scroll position samples.
|
|
*
|
|
* Using the last iteration's scroll position, stored in mLastPosition, a
|
|
* delta of the scroll position is calculated and accumulated in mAccumulator
|
|
* until the refresh driver returns a new timestamp for MostRecentRefresh().
|
|
*
|
|
* When there is a new timestamp from the refresh driver, the accumulated
|
|
* change in scroll position is divided by the delta of the timestamp to
|
|
* get an average velocity over that period. This velocity is pushed into
|
|
* mQueue as a std::pair associating each velocity with the
|
|
* duration over which it was sampled.
|
|
*
|
|
* Samples are removed from mQueue, leaving only those necessary to determine
|
|
* the average velocity over the recent relevant period, which has a duration
|
|
* set by the apz.velocity_relevance_time_ms preference.
|
|
*
|
|
* The velocity of each sample is clamped to a value set by the
|
|
* layout.css.scroll-snap.prediction-max-velocity.
|
|
*
|
|
* As the average velocity will later be integrated over a duration set by
|
|
* the layout.css.scroll-snap.prediction-sensitivity preference and the
|
|
* velocity samples are clamped to a set value, the maximum expected scroll
|
|
* offset can be calculated. This maximum offset is used to clamp
|
|
* mAccumulator, eliminating samples that would otherwise result in scroll
|
|
* snap position selection that is not consistent with the user's perception
|
|
* of scroll velocity.
|
|
*/
|
|
|
|
class ScrollVelocityQueue final {
|
|
public:
|
|
explicit ScrollVelocityQueue(nsPresContext* aPresContext)
|
|
: mPresContext(aPresContext) {}
|
|
|
|
// Sample() is to be called periodically when scroll movement occurs, to
|
|
// record samples of scroll position used later by GetVelocity().
|
|
void Sample(const nsPoint& aScrollPosition);
|
|
|
|
// Discards velocity samples, resulting in velocity of 0 returned by
|
|
// GetVelocity until move scroll position updates.
|
|
void Reset();
|
|
|
|
// Get scroll velocity averaged from recent movement, in appunits / second
|
|
nsPoint GetVelocity();
|
|
|
|
private:
|
|
// A queue of (duration, velocity) pairs; these are the historical average
|
|
// velocities over the given durations. Durations are in milliseconds,
|
|
// velocities are in app units per second.
|
|
nsTArray<std::pair<uint32_t, nsPoint> > mQueue;
|
|
|
|
// Accumulates the distance and direction travelled by the scroll frame since
|
|
// mSampleTime.
|
|
nsPoint mAccumulator;
|
|
|
|
// Time that mAccumulator was last reset and began accumulating.
|
|
TimeStamp mSampleTime;
|
|
|
|
// Scroll offset at the mAccumulator was last reset and began
|
|
// accumulating.
|
|
nsPoint mLastPosition;
|
|
|
|
// PresContext of the containing frame, used to get timebase
|
|
nsPresContext* mPresContext;
|
|
|
|
// Remove samples from mQueue that no longer contribute to GetVelocity()
|
|
// due to their age
|
|
void TrimQueue();
|
|
};
|
|
|
|
} // namespace layout
|
|
} // namespace mozilla
|
|
|
|
#endif /* !defined(ScrollVelocityQueue_h_) */
|