/* -*- 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/. */

#include "ScrollThumbUtils.h"
#include "AsyncPanZoomController.h"
#include "FrameMetrics.h"
#include "gfxPlatform.h"
#include "mozilla/gfx/Matrix.h"

namespace mozilla {
namespace layers {
namespace apz {

struct AsyncScrollThumbTransformer {
  // Inputs
  const LayerToParentLayerMatrix4x4& mCurrentTransform;
  const gfx::Matrix4x4& mScrollableContentTransform;
  AsyncPanZoomController* mApzc;
  const FrameMetrics& mMetrics;
  const ScrollbarData& mScrollbarData;
  bool mScrollbarIsDescendant;

  // Intermediate results
  AsyncTransformComponentMatrix mAsyncTransform;
  AsyncTransformComponentMatrix mScrollbarTransform;
  CSSToParentLayerScale mEffectiveZoom;
  float mUnitlessThumbRatio;

  LayerToParentLayerMatrix4x4 ComputeTransform();

 private:
  // Helper functions for ComputeTransform().

  // If the thumb's orientation is along |aAxis|, add transformations
  // of the thumb into |mScrollbarTransform|.
  void ApplyTransformForAxis(const Axis& aAxis);

  enum class ScrollThumbExtent { Start, End };

  // Scale the thumb by |aScale| along |aAxis|, while keeping constant the
  // position of the top denoted by |aExtent|.
  void ScaleThumbBy(const Axis& aAxis, float aScale, ScrollThumbExtent aExtent);
};

void AsyncScrollThumbTransformer::ScaleThumbBy(const Axis& aAxis, float aScale,
                                               ScrollThumbExtent aExtent) {
  // To keep the position of the top of the thumb constant, the thumb needs to
  // translated to compensate for the scale applied. The origin with respect to
  // which the scale is applied is the origin of the layer tree, rather than
  // the origin of the scroll thumb. This means that the space between the
  // origin and the top of thumb (including the part of the scrollbar track
  // above the thumb, plus whatever content is above the scroll frame) is scaled
  // too, effectively translating the thumb. We undo that translation here.
  // (One can think of the adjustment being done to the translation here as a
  // change of basis. We have a method to help with that,
  // Matrix4x4::ChangeBasis(), but it wouldn't necessarily make the code cleaner
  // in this case).
  CSSCoord thumbExtentRelativeToCompBounds =
      (aAxis.GetPointOffset(mMetrics.GetVisualScrollOffset()) *
       mUnitlessThumbRatio);
  CSSCoord compBoundsOrigin = aAxis.GetPointOffset(
      mMetrics.CalculateCompositionBoundsInCssPixelsOfSurroundingContent()
          .TopLeft());
  CSSCoord thumbExtent = compBoundsOrigin + thumbExtentRelativeToCompBounds;
  if (aExtent == ScrollThumbExtent::End) {
    thumbExtent += mScrollbarData.mThumbLength;
  }
  const CSSCoord thumbExtentScaled = thumbExtent * aScale;
  const CSSCoord thumbExtentDelta = thumbExtentScaled - thumbExtent;
  const ParentLayerCoord thumbExtentDeltaPL = thumbExtentDelta * mEffectiveZoom;

  aAxis.PostScale(mScrollbarTransform, aScale);
  aAxis.PostTranslate(mScrollbarTransform, -thumbExtentDeltaPL);
}

void AsyncScrollThumbTransformer::ApplyTransformForAxis(const Axis& aAxis) {
  ParentLayerCoord asyncScroll = aAxis.GetTransformTranslation(mAsyncTransform);
  const float asyncZoom = aAxis.GetTransformScale(mAsyncTransform);

  // The scroll thumb needs to be scaled in the direction of scrolling by the
  // inverse of the async zoom. This is because zooming in decreases the
  // fraction of the whole srollable rect that is in view.
  const float scale = 1.f / asyncZoom;

  // Note: |metrics.GetZoom()| doesn't yet include the async zoom.
  mEffectiveZoom = CSSToParentLayerScale(mMetrics.GetZoom().scale * asyncZoom);

  if (gfxPlatform::UseDesktopZoomingScrollbars()) {
    // As computed by GetCurrentAsyncTransform, asyncScrollY is
    //   asyncScrollY = -(GetEffectiveScrollOffset -
    //   mLastContentPaintMetrics.GetLayoutScrollOffset()) *
    //   effectiveZoom
    // where GetEffectiveScrollOffset includes the visual viewport offset that
    // the main thread knows about plus any async scrolling to the visual
    // viewport offset that the main thread does not (yet) know about. We want
    // asyncScrollY to be
    //   asyncScrollY = -(GetEffectiveScrollOffset -
    //   mLastContentPaintMetrics.GetVisualScrollOffset()) * effectiveZoom
    // because the main thread positions the scrollbars at the visual viewport
    // offset that it knows about. (aMetrics is mLastContentPaintMetrics)

    asyncScroll -= aAxis.GetPointOffset(
        (mMetrics.GetLayoutScrollOffset() - mMetrics.GetVisualScrollOffset()) *
        mEffectiveZoom);
  }

  // Here we convert the scrollbar thumb ratio into a true unitless ratio by
  // dividing out the conversion factor from the scrollframe's parent's space
  // to the scrollframe's space.
  mUnitlessThumbRatio = mScrollbarData.mThumbRatio /
                        (mMetrics.GetPresShellResolution() * asyncZoom);

  // The scroll thumb needs to be translated in opposite direction of the
  // async scroll. This is because scrolling down, which translates the layer
  // content up, should result in moving the scroll thumb down.
  ParentLayerCoord translation = -asyncScroll * mUnitlessThumbRatio;

  // The translation we computed is in the scroll frame's ParentLayer space.
  // This includes the full cumulative resolution, even if we are a subframe.
  // However, the resulting transform is used in a context where the scrollbar
  // is already subject to the resolutions of enclosing scroll frames. To avoid
  // double application of these enclosing resolutions, divide them out, leaving
  // only the local resolution if any.
  translation /= (mMetrics.GetCumulativeResolution().scale /
                  mMetrics.GetPresShellResolution());

  // When scaling the thumb to account for the async zoom, keep the position
  // of the start of the thumb (which corresponds to the scroll offset)
  // constant.
  ScaleThumbBy(aAxis, scale, ScrollThumbExtent::Start);

  // If the page is overscrolled, additionally squish the thumb in accordance
  // with the overscroll amount.
  ParentLayerCoord overscroll =
      aAxis.GetPointOffset(mApzc->GetOverscrollAmount());
  if (overscroll != 0) {
    float overscrollScale =
        1.0f - (std::abs(overscroll.value) /
                aAxis.GetRectLength(mMetrics.GetCompositionBounds()));
    MOZ_ASSERT(overscrollScale > 0.0f && overscrollScale <= 1.0f);
    // If we're overscrolled at the top, keep the top of the thumb in place
    // as we squish it. If we're overscrolled at the bottom, keep the bottom of
    // the thumb in place.
    ScaleThumbBy(
        aAxis, overscrollScale,
        overscroll < 0 ? ScrollThumbExtent::Start : ScrollThumbExtent::End);
  }

  aAxis.PostTranslate(mScrollbarTransform, translation);
}

LayerToParentLayerMatrix4x4 AsyncScrollThumbTransformer::ComputeTransform() {
  // We only apply the transform if the scroll-target layer has non-container
  // children (i.e. when it has some possibly-visible content). This is to
  // avoid moving scroll-bars in the situation that only a scroll information
  // layer has been built for a scroll frame, as this would result in a
  // disparity between scrollbars and visible content.
  if (mMetrics.IsScrollInfoLayer()) {
    return LayerToParentLayerMatrix4x4{};
  }

  MOZ_RELEASE_ASSERT(mApzc);

  mAsyncTransform =
      mApzc->GetCurrentAsyncTransform(AsyncPanZoomController::eForCompositing);

  // |mAsyncTransform| represents the amount by which we have scrolled and
  // zoomed since the last paint. Because the scrollbar was sized and positioned
  // based on the painted content, we need to adjust it based on asyncTransform
  // so that it reflects what the user is actually seeing now.
  if (*mScrollbarData.mDirection == ScrollDirection::eVertical) {
    ApplyTransformForAxis(mApzc->mY);
  }
  if (*mScrollbarData.mDirection == ScrollDirection::eHorizontal) {
    ApplyTransformForAxis(mApzc->mX);
  }

  LayerToParentLayerMatrix4x4 transform =
      mCurrentTransform * mScrollbarTransform;

  AsyncTransformComponentMatrix compensation;
  // If the scrollbar layer is a child of the content it is a scrollbar for,
  // then we need to adjust for any async transform (including an overscroll
  // transform) on the content. This needs to be cancelled out because layout
  // positions and sizes the scrollbar on the assumption that there is no async
  // transform, and without this adjustment the scrollbar will end up in the
  // wrong place.
  //
  // Note that since the async transform is applied on top of the content's
  // regular transform, we need to make sure to unapply the async transform in
  // the same coordinate space. This requires applying the content transform
  // and then unapplying it after unapplying the async transform.
  if (mScrollbarIsDescendant) {
    AsyncTransformComponentMatrix overscroll =
        mApzc->GetOverscrollTransform(AsyncPanZoomController::eForCompositing);
    gfx::Matrix4x4 asyncUntransform =
        (mAsyncTransform * overscroll).Inverse().ToUnknownMatrix();
    const gfx::Matrix4x4& contentTransform = mScrollableContentTransform;
    gfx::Matrix4x4 contentUntransform = contentTransform.Inverse();

    compensation *= ViewAs<AsyncTransformComponentMatrix>(
        contentTransform * asyncUntransform * contentUntransform);
  }
  transform = transform * compensation;

  return transform;
}

LayerToParentLayerMatrix4x4 ComputeTransformForScrollThumb(
    const LayerToParentLayerMatrix4x4& aCurrentTransform,
    const gfx::Matrix4x4& aScrollableContentTransform,
    AsyncPanZoomController* aApzc, const FrameMetrics& aMetrics,
    const ScrollbarData& aScrollbarData, bool aScrollbarIsDescendant) {
  return AsyncScrollThumbTransformer{
      aCurrentTransform, aScrollableContentTransform, aApzc, aMetrics,
      aScrollbarData,    aScrollbarIsDescendant}
      .ComputeTransform();
}

}  // namespace apz
}  // namespace layers
}  // namespace mozilla