summaryrefslogtreecommitdiffstats
path: root/layout/base/ViewportUtils.cpp
blob: 8b8e4a4d27110c5b4716f7655093864f6a7c5dd8 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
/* 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 "Units.h"
#include "mozilla/PresShell.h"
#include "mozilla/ViewportFrame.h"
#include "mozilla/ViewportUtils.h"
#include "mozilla/dom/BrowserChild.h"
#include "mozilla/layers/APZCCallbackHelper.h"
#include "mozilla/layers/InputAPZContext.h"
#include "mozilla/layers/ScrollableLayerGuid.h"
#include "nsIContent.h"
#include "nsIFrame.h"
#include "nsIScrollableFrame.h"
#include "nsLayoutUtils.h"
#include "nsQueryFrame.h"
#include "nsStyleStruct.h"

namespace mozilla {

using layers::APZCCallbackHelper;
using layers::InputAPZContext;
using layers::ScrollableLayerGuid;

template <typename Units>
gfx::Matrix4x4Typed<Units, Units> ViewportUtils::GetVisualToLayoutTransform(
    ScrollableLayerGuid::ViewID aScrollId) {
  static_assert(
      std::is_same_v<Units, CSSPixel> ||
          std::is_same_v<Units, LayoutDevicePixel>,
      "GetCallbackTransform() may only be used with CSS or LayoutDevice units");

  if (aScrollId == ScrollableLayerGuid::NULL_SCROLL_ID) {
    return {};
  }
  nsCOMPtr<nsIContent> content = nsLayoutUtils::FindContentFor(aScrollId);
  if (!content || !content->GetPrimaryFrame()) {
    return {};
  }

  // First, scale inversely by the root content document's pres shell
  // resolution to cancel the scale-to-resolution transform that the
  // compositor adds to the layer with the pres shell resolution. The points
  // sent to Gecko by APZ don't have this transform unapplied (unlike other
  // compositor-side transforms) because Gecko needs it applied when hit
  // testing against content that's conceptually outside the resolution,
  // such as scrollbars.
  float resolution = 1.0f;
  if (PresShell* presShell =
          APZCCallbackHelper::GetRootContentDocumentPresShellForContent(
              content)) {
    resolution = presShell->GetResolution();
  }

  // Now apply the callback-transform. This is only approximately correct,
  // see the comment on GetCumulativeApzCallbackTransform for details.
  gfx::PointTyped<Units> transform;
  CSSPoint transformCSS = nsLayoutUtils::GetCumulativeApzCallbackTransform(
      content->GetPrimaryFrame());
  if constexpr (std::is_same_v<Units, CSSPixel>) {
    transform = transformCSS;
  } else {  // Units == LayoutDevicePixel
    transform = transformCSS *
                content->GetPrimaryFrame()->PresContext()->CSSToDevPixelScale();
  }

  return gfx::Matrix4x4Typed<Units, Units>::Scaling(1 / resolution,
                                                    1 / resolution, 1)
      .PostTranslate(transform.x, transform.y, 0);
}

CSSToCSSMatrix4x4 GetVisualToLayoutTransform(PresShell* aContext) {
  ScrollableLayerGuid::ViewID targetScrollId =
      InputAPZContext::GetTargetLayerGuid().mScrollId;
  if (targetScrollId == ScrollableLayerGuid::NULL_SCROLL_ID) {
    if (nsIFrame* rootScrollFrame = aContext->GetRootScrollFrame()) {
      targetScrollId =
          nsLayoutUtils::FindOrCreateIDFor(rootScrollFrame->GetContent());
    }
  }
  return ViewportUtils::GetVisualToLayoutTransform(targetScrollId);
}

nsPoint ViewportUtils::VisualToLayout(const nsPoint& aPt, PresShell* aContext) {
  auto visualToLayout = mozilla::GetVisualToLayoutTransform(aContext);
  CSSPoint cssPt = CSSPoint::FromAppUnits(aPt);
  cssPt = visualToLayout.TransformPoint(cssPt);
  return CSSPoint::ToAppUnits(cssPt);
}

nsRect ViewportUtils::VisualToLayout(const nsRect& aRect, PresShell* aContext) {
  auto visualToLayout = mozilla::GetVisualToLayoutTransform(aContext);
  CSSRect cssRect = CSSRect::FromAppUnits(aRect);
  cssRect = visualToLayout.TransformBounds(cssRect);
  nsRect result = CSSRect::ToAppUnits(cssRect);

  // In hit testing codepaths, the input rect often has dimensions of one app
  // units. If we are zoomed in enough, the rounded size of the output rect
  // can be zero app units, which will fail to Intersect() with anything, and
  // therefore cause hit testing to fail. To avoid this, we expand the output
  // rect to one app units.
  if (!aRect.IsEmpty() && result.IsEmpty()) {
    result.width = 1;
    result.height = 1;
  }

  return result;
}

nsPoint ViewportUtils::LayoutToVisual(const nsPoint& aPt, PresShell* aContext) {
  auto visualToLayout = mozilla::GetVisualToLayoutTransform(aContext);
  CSSPoint cssPt = CSSPoint::FromAppUnits(aPt);
  auto transformed = visualToLayout.Inverse().TransformPoint(cssPt);
  return CSSPoint::ToAppUnits(transformed);
}

LayoutDevicePoint ViewportUtils::DocumentRelativeLayoutToVisual(
    const LayoutDevicePoint& aPoint, PresShell* aShell) {
  ScrollableLayerGuid::ViewID targetScrollId =
      nsLayoutUtils::ScrollIdForRootScrollFrame(aShell->GetPresContext());
  auto visualToLayout =
      ViewportUtils::GetVisualToLayoutTransform<LayoutDevicePixel>(
          targetScrollId);
  return visualToLayout.Inverse().TransformPoint(aPoint);
}

LayoutDeviceRect ViewportUtils::DocumentRelativeLayoutToVisual(
    const LayoutDeviceRect& aRect, PresShell* aShell) {
  ScrollableLayerGuid::ViewID targetScrollId =
      nsLayoutUtils::ScrollIdForRootScrollFrame(aShell->GetPresContext());
  auto visualToLayout =
      ViewportUtils::GetVisualToLayoutTransform<LayoutDevicePixel>(
          targetScrollId);
  return visualToLayout.Inverse().TransformBounds(aRect);
}

LayoutDeviceRect ViewportUtils::DocumentRelativeLayoutToVisual(
    const LayoutDeviceIntRect& aRect, PresShell* aShell) {
  return DocumentRelativeLayoutToVisual(IntRectToRect(aRect), aShell);
}

CSSRect ViewportUtils::DocumentRelativeLayoutToVisual(const CSSRect& aRect,
                                                      PresShell* aShell) {
  ScrollableLayerGuid::ViewID targetScrollId =
      nsLayoutUtils::ScrollIdForRootScrollFrame(aShell->GetPresContext());
  auto visualToLayout =
      ViewportUtils::GetVisualToLayoutTransform(targetScrollId);
  return visualToLayout.Inverse().TransformBounds(aRect);
}

template <class SourceUnits, class DestUnits>
gfx::PointTyped<DestUnits> TransformPointOrRect(
    const gfx::Matrix4x4Typed<SourceUnits, DestUnits>& aMatrix,
    const gfx::PointTyped<SourceUnits>& aPoint) {
  return aMatrix.TransformPoint(aPoint);
}

template <class SourceUnits, class DestUnits>
gfx::RectTyped<DestUnits> TransformPointOrRect(
    const gfx::Matrix4x4Typed<SourceUnits, DestUnits>& aMatrix,
    const gfx::RectTyped<SourceUnits>& aRect) {
  return aMatrix.TransformBounds(aRect);
}

template <class LDPointOrRect>
LDPointOrRect ConvertToScreenRelativeVisual(const LDPointOrRect& aInput,
                                            nsPresContext* aCtx) {
  MOZ_ASSERT(aCtx);

  LDPointOrRect layoutToVisual(aInput);
  nsIFrame* prevRootFrame = nullptr;
  nsPresContext* prevCtx = nullptr;

  // Walk up to the rootmost prescontext, transforming as we go.
  for (nsPresContext* ctx = aCtx; ctx; ctx = ctx->GetParentPresContext()) {
    PresShell* shell = ctx->PresShell();
    nsIFrame* rootFrame = shell->GetRootFrame();
    if (prevRootFrame) {
      // Convert layoutToVisual from being relative to `prevRootFrame`
      // to being relative to `rootFrame` (layout space).
      nscoord apd = prevCtx->AppUnitsPerDevPixel();
      nsPoint offset = prevRootFrame->GetOffsetToCrossDoc(rootFrame, apd);
      layoutToVisual += LayoutDevicePoint::FromAppUnits(offset, apd);
    }
    if (shell->GetResolution() != 1.0) {
      // Found the APZ zoom root, so do the layout -> visual conversion.
      layoutToVisual =
          ViewportUtils::DocumentRelativeLayoutToVisual(layoutToVisual, shell);
    }

    prevRootFrame = rootFrame;
    prevCtx = ctx;
  }

  // If we're in a nested content process, the above traversal will not have
  // encountered the APZ zoom root. The translation part of the layout-to-visual
  // transform will be included in |rootScreenRect.TopLeft()|, added below
  // (that ultimately comes from nsIWidget::WidgetToScreenOffset(), which for an
  // OOP iframe's widget includes this translation), but the scale part needs to
  // be computed and added separately.
  Scale2D enclosingResolution =
      ViewportUtils::TryInferEnclosingResolution(prevCtx->GetPresShell());
  if (enclosingResolution != Scale2D{1.0f, 1.0f}) {
    layoutToVisual = TransformPointOrRect(
        LayoutDeviceToLayoutDeviceMatrix4x4::Scaling(
            enclosingResolution.xScale, enclosingResolution.yScale, 1.0f),
        layoutToVisual);
  }

  // Then we do the conversion from the rootmost presContext's root frame (in
  // visual space) to screen space.
  LayoutDeviceIntRect rootScreenRect =
      LayoutDeviceIntRect::FromAppUnitsToNearest(
          prevRootFrame->GetScreenRectInAppUnits(),
          prevCtx->AppUnitsPerDevPixel());

  return layoutToVisual + rootScreenRect.TopLeft();
}

LayoutDevicePoint ViewportUtils::ToScreenRelativeVisual(
    const LayoutDevicePoint& aPt, nsPresContext* aCtx) {
  return ConvertToScreenRelativeVisual(aPt, aCtx);
}

LayoutDeviceRect ViewportUtils::ToScreenRelativeVisual(
    const LayoutDeviceRect& aRect, nsPresContext* aCtx) {
  return ConvertToScreenRelativeVisual(aRect, aCtx);
}

// Definitions of the two explicit instantiations forward declared in the header
// file. This causes code for these instantiations to be emitted into the object
// file for ViewportUtils.cpp.
template CSSToCSSMatrix4x4 ViewportUtils::GetVisualToLayoutTransform<CSSPixel>(
    ScrollableLayerGuid::ViewID);
template LayoutDeviceToLayoutDeviceMatrix4x4
    ViewportUtils::GetVisualToLayoutTransform<LayoutDevicePixel>(
        ScrollableLayerGuid::ViewID);

const nsIFrame* ViewportUtils::IsZoomedContentRoot(const nsIFrame* aFrame) {
  if (!aFrame) {
    return nullptr;
  }
  if (aFrame->Type() == LayoutFrameType::Canvas ||
      aFrame->Type() == LayoutFrameType::PageSequence) {
    nsIScrollableFrame* sf = do_QueryFrame(aFrame->GetParent());
    if (sf && sf->IsRootScrollFrameOfDocument() &&
        aFrame->PresContext()->IsRootContentDocumentCrossProcess()) {
      return aFrame->GetParent();
    }
  } else if (aFrame->StyleDisplay()->mPosition ==
             StylePositionProperty::Fixed) {
    if (ViewportFrame* viewportFrame = do_QueryFrame(aFrame->GetParent())) {
      if (viewportFrame->PresContext()->IsRootContentDocumentCrossProcess()) {
        return viewportFrame->PresShell()->GetRootScrollFrame();
      }
    }
  }
  return nullptr;
}

Scale2D ViewportUtils::TryInferEnclosingResolution(PresShell* aShell) {
  if (!XRE_IsContentProcess()) {
    return {1.0f, 1.0f};
  }
  MOZ_ASSERT(aShell && aShell->GetPresContext());
  MOZ_ASSERT(!aShell->GetPresContext()->GetParentPresContext(),
             "TryInferEnclosingResolution can only be called for a root pres "
             "shell within a process");
  if (dom::BrowserChild* bc = dom::BrowserChild::GetFrom(aShell)) {
    if (!bc->IsTopLevel()) {
      // The enclosing resolution is not directly available in the BrowserChild.
      // The closest thing available is GetChildToParentConversionMatrix(),
      // which also includes any enclosing CSS transforms.
      // The behaviour implemented here will not provide an accurate answer
      // in the presence of CSS transforms, but it tries to do something
      // reasonable:
      //  - If there are no enclosing CSS transforms, it will return the
      //    resolution.
      //  - If the enclosing transforms contain scales and translations only,
      //    it will return the resolution times the CSS transform scale
      //    (choosing the x-scale if they are different).
      //  - Otherwise, it will return the resolution times a scale component
      //    of the transform as returned by Matrix4x4Typed::Decompose().
      //  - If the enclosing transform is sufficiently complex that
      //    Decompose() returns false, give up and return 1.0.
      gfx::Point3DTyped<gfx::UnknownUnits> translation;
      gfx::Quaternion rotation;
      gfx::Point3DTyped<gfx::UnknownUnits> scale;
      if (bc->GetChildToParentConversionMatrix().Decompose(translation,
                                                           rotation, scale)) {
        return {scale.x, scale.y};
      }
    }
  }
  return {1.0f, 1.0f};
}

}  // namespace mozilla