The Tor Browser: gfx/layers/apz/src/Axis.h@6474c204b198 (annotated)

gfx/layers/apz/src/Axis.h@6474c204b198 (annotated)

gfx/layers/apz/src/Axis.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- 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/. */
 #ifndef mozilla_layers_Axis_h
 #define mozilla_layers_Axis_h
 #include <sys/types.h>                  // for int32_t
 #include "Units.h"                      // for CSSRect, CSSPoint
 #include "mozilla/TimeStamp.h"          // for TimeDuration
 #include "nsTArray.h"                   // for nsTArray
 namespace mozilla {
 namespace layers {
 const float EPSILON = 0.0001f;
 class AsyncPanZoomController;
 /**
  * Helper class to maintain each axis of movement (X,Y) for panning and zooming.
  * Note that everything here is specific to one axis; that is, the X axis knows
  * nothing about the Y axis and vice versa.
  */
 class Axis {
 public:
   Axis(AsyncPanZoomController* aAsyncPanZoomController);
   enum Overscroll {
     // Overscroll is not happening at all.
     OVERSCROLL_NONE = 0,
     // Overscroll is happening in the negative direction. This means either to
     // the left or to the top depending on the axis.
     OVERSCROLL_MINUS,
     // Overscroll is happening in the positive direction. This means either to
     // the right or to the bottom depending on the axis.
     OVERSCROLL_PLUS,
     // Overscroll is happening both ways. This only means something when the
     // page is scaled out to a smaller size than the viewport.
     OVERSCROLL_BOTH
   };
   /**
    * Notify this Axis that a new touch has been received, including a time delta
    * indicating how long it has been since the previous one. This triggers a
    * recalculation of velocity.
    */
   void UpdateWithTouchAtDevicePoint(int32_t aPos, const TimeDuration& aTimeDelta);
   /**
    * Notify this Axis that a touch has begun, i.e. the user has put their finger
    * on the screen but has not yet tried to pan.
    */
   void StartTouch(int32_t aPos);
   /**
    * Notify this Axis that a touch has ended gracefully. This may perform
    * recalculations of the axis velocity.
    */
   void EndTouch();
   /**
    * Notify this Axis that a touch has ended forcefully. Useful for stopping
    * flings when a user puts their finger down in the middle of one (i.e. to
    * stop a previous touch including its fling so that a new one can take its
    * place).
    */
   void CancelTouch();
   /**
    * Takes a requested displacement to the position of this axis, and adjusts it
    * to account for overscroll (which might decrease the displacement; this is
    * to prevent the viewport from overscrolling the page rect), and axis locking
    * (which might prevent any displacement from happening). If overscroll
    * ocurred, its amount is written to |aOverscrollAmountOut|.
    * The adjusted displacement is returned.
    */
   float AdjustDisplacement(float aDisplacement, float& aOverscrollAmountOut);
   /**
    * Gets the distance between the starting position of the touch supplied in
    * startTouch() and the current touch from the last
    * updateWithTouchAtDevicePoint().
    */
   float PanDistance();
   /**
    * Gets the distance between the starting position of the touch supplied in
    * startTouch() and the supplied position.
    */
   float PanDistance(float aPos);
   /**
    * Applies friction during a fling, or cancels the fling if the velocity is
    * too low. Returns true if the fling should continue to another frame, or
    * false if it should end. |aDelta| is the amount of time that has passed
    * since the last time friction was applied.
    */
   bool FlingApplyFrictionOrCancel(const TimeDuration& aDelta);
   /*
    * Returns true if the page is zoomed in to some degree along this axis such that scrolling is
    * possible and this axis has not been scroll locked while panning. Otherwise, returns false.
    */
   bool Scrollable();
   void SetAxisLocked(bool aAxisLocked) { mAxisLocked = aAxisLocked; }
   /**
    * Gets the overscroll state of the axis in its current position.
    */
   Overscroll GetOverscroll();
   /**
    * If there is overscroll, returns the amount. Sign depends on in what
    * direction it is overscrolling. Positive excess means that it is
    * overscrolling in the positive direction, whereas negative excess means
    * that it is overscrolling in the negative direction. If there is overscroll
    * in both directions, this returns 0; it assumes that you check
    * GetOverscroll() first.
    */
   float GetExcess();
   /**
    * Gets the raw velocity of this axis at this moment.
    */
   float GetVelocity();
   /**
    * Sets the raw velocity of this axis at this moment.
    * Intended to be called only when the axis "takes over" a velocity from
    * another APZC, in which case there are no touch points available to call
    * UpdateWithTouchAtDevicePoint. In other circumstances,
    * UpdateWithTouchAtDevicePoint should be used and the velocity calculated
    * there.
    */
   void SetVelocity(float aVelocity);
   /**
    * Gets the overscroll state of the axis given an additional displacement.
    * That is to say, if the given displacement is applied, this will tell you
    * whether or not it will overscroll, and in what direction.
    */
   Overscroll DisplacementWillOverscroll(float aDisplacement);
   /**
    * If a displacement will overscroll the axis, this returns the amount and in
    * what direction. Similar to GetExcess() but takes a displacement to apply.
    */
   float DisplacementWillOverscrollAmount(float aDisplacement);
   /**
    * If a scale will overscroll the axis, this returns the amount and in what
    * direction. Similar to GetExcess() but takes a displacement to apply.
    *
    * |aFocus| is the point at which the scale is focused at. We will offset the
    * scroll offset in such a way that it remains in the same place on the page
    * relative.
    */
   float ScaleWillOverscrollAmount(float aScale, float aFocus);
   /**
    * Checks if an axis will overscroll in both directions by computing the
    * content rect and checking that its height/width (depending on the axis)
    * does not overextend past the viewport.
    *
    * This gets called by ScaleWillOverscroll().
    */
   bool ScaleWillOverscrollBothSides(float aScale);
   /**
    * Returns whether there is room to pan on this axis in either direction.
    */
   bool HasRoomToPan() const;
   float GetOrigin() const;
   float GetCompositionLength() const;
   float GetPageStart() const;
   float GetPageLength() const;
   float GetCompositionEnd() const;
   float GetPageEnd() const;
   int32_t GetPos() const { return mPos; }
   virtual float GetPointOffset(const CSSPoint& aPoint) const = 0;
   virtual float GetRectLength(const CSSRect& aRect) const = 0;
   virtual float GetRectOffset(const CSSRect& aRect) const = 0;
 protected:
   int32_t mPos;
   int32_t mStartPos;
   float mVelocity;
   bool mAxisLocked;     // Whether movement on this axis is locked.
   AsyncPanZoomController* mAsyncPanZoomController;
   nsTArray<float> mVelocityQueue;
 };
 class AxisX : public Axis {
 public:
   AxisX(AsyncPanZoomController* mAsyncPanZoomController);
   virtual float GetPointOffset(const CSSPoint& aPoint) const;
   virtual float GetRectLength(const CSSRect& aRect) const;
   virtual float GetRectOffset(const CSSRect& aRect) const;
 };
 class AxisY : public Axis {
 public:
   AxisY(AsyncPanZoomController* mAsyncPanZoomController);
   virtual float GetPointOffset(const CSSPoint& aPoint) const;
   virtual float GetRectLength(const CSSRect& aRect) const;
   virtual float GetRectOffset(const CSSRect& aRect) const;
 };
 }
 }
 #endif

The Tor Browser / annotate

gfx/layers/apz/src/Axis.h@6474c204b198 (annotated)

gfx/layers/apz/src/Axis.h