1 /* -*- Mode: Java; c-basic-offset: 4; tab-width: 20; indent-tabs-mode: nil; -*-
2  * This Source Code Form is subject to the terms of the Mozilla Public
3  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
4  * You can obtain one at http://mozilla.org/MPL/2.0/. */
5 
6 package org.mozilla.gecko.gfx;
7 
8 import org.mozilla.gecko.annotation.WrapForJNI;
9 import org.mozilla.gecko.util.FloatUtils;
10 
11 import android.graphics.PointF;
12 import android.graphics.RectF;
13 import android.util.DisplayMetrics;
14 
15 /**
16  * ImmutableViewportMetrics are used to store the viewport metrics
17  * in way that we can access a version of them from multiple threads
18  * without having to take a lock
19  */
20 public class ImmutableViewportMetrics {
21 
22     // We need to flatten the RectF and FloatSize structures
23     // because Java doesn't have the concept of const classes
24     public final float pageRectLeft;
25     public final float pageRectTop;
26     public final float pageRectRight;
27     public final float pageRectBottom;
28     public final float cssPageRectLeft;
29     public final float cssPageRectTop;
30     public final float cssPageRectRight;
31     public final float cssPageRectBottom;
32     public final float viewportRectLeft;
33     public final float viewportRectTop;
34     public final int viewportRectWidth;
35     public final int viewportRectHeight;
36 
37     public final float zoomFactor;
38 
ImmutableViewportMetrics(DisplayMetrics metrics)39     public ImmutableViewportMetrics(DisplayMetrics metrics) {
40         viewportRectLeft   = pageRectLeft   = cssPageRectLeft   = 0;
41         viewportRectTop    = pageRectTop    = cssPageRectTop    = 0;
42         viewportRectWidth = metrics.widthPixels;
43         viewportRectHeight = metrics.heightPixels;
44         pageRectRight  = cssPageRectRight  = metrics.widthPixels;
45         pageRectBottom = cssPageRectBottom = metrics.heightPixels;
46         zoomFactor = 1.0f;
47     }
48 
49     /** This constructor is used by native code in AndroidJavaWrappers.cpp, be
50      * careful when modifying the signature.
51      */
52     @WrapForJNI(calledFrom = "gecko")
ImmutableViewportMetrics(float aPageRectLeft, float aPageRectTop, float aPageRectRight, float aPageRectBottom, float aCssPageRectLeft, float aCssPageRectTop, float aCssPageRectRight, float aCssPageRectBottom, float aViewportRectLeft, float aViewportRectTop, int aViewportRectWidth, int aViewportRectHeight, float aZoomFactor)53     private ImmutableViewportMetrics(float aPageRectLeft, float aPageRectTop,
54         float aPageRectRight, float aPageRectBottom, float aCssPageRectLeft,
55         float aCssPageRectTop, float aCssPageRectRight, float aCssPageRectBottom,
56         float aViewportRectLeft, float aViewportRectTop, int aViewportRectWidth,
57         int aViewportRectHeight, float aZoomFactor)
58     {
59         pageRectLeft = aPageRectLeft;
60         pageRectTop = aPageRectTop;
61         pageRectRight = aPageRectRight;
62         pageRectBottom = aPageRectBottom;
63         cssPageRectLeft = aCssPageRectLeft;
64         cssPageRectTop = aCssPageRectTop;
65         cssPageRectRight = aCssPageRectRight;
66         cssPageRectBottom = aCssPageRectBottom;
67         viewportRectLeft = aViewportRectLeft;
68         viewportRectTop = aViewportRectTop;
69         viewportRectWidth = aViewportRectWidth;
70         viewportRectHeight = aViewportRectHeight;
71         zoomFactor = aZoomFactor;
72     }
73 
getWidth()74     public float getWidth() {
75         return viewportRectWidth;
76     }
77 
getHeight()78     public float getHeight() {
79         return viewportRectHeight;
80     }
81 
viewportRectRight()82     public float viewportRectRight() {
83         return viewportRectLeft + viewportRectWidth;
84     }
85 
viewportRectBottom()86     public float viewportRectBottom() {
87         return viewportRectTop + viewportRectHeight;
88     }
89 
getOrigin()90     public PointF getOrigin() {
91         return new PointF(viewportRectLeft, viewportRectTop);
92     }
93 
getSize()94     public FloatSize getSize() {
95         return new FloatSize(viewportRectWidth, viewportRectHeight);
96     }
97 
getViewport()98     public RectF getViewport() {
99         return new RectF(viewportRectLeft,
100                          viewportRectTop,
101                          viewportRectRight(),
102                          viewportRectBottom());
103     }
104 
getCssViewport()105     public RectF getCssViewport() {
106         return RectUtils.scale(getViewport(), 1 / zoomFactor);
107     }
108 
getPageRect()109     public RectF getPageRect() {
110         return new RectF(pageRectLeft, pageRectTop, pageRectRight, pageRectBottom);
111     }
112 
getPageWidth()113     public float getPageWidth() {
114         return pageRectRight - pageRectLeft;
115     }
116 
getPageHeight()117     public float getPageHeight() {
118         return pageRectBottom - pageRectTop;
119     }
120 
getCssPageRect()121     public RectF getCssPageRect() {
122         return new RectF(cssPageRectLeft, cssPageRectTop, cssPageRectRight, cssPageRectBottom);
123     }
124 
getOverscroll()125     public RectF getOverscroll() {
126         return new RectF(Math.max(0, pageRectLeft - viewportRectLeft),
127                          Math.max(0, pageRectTop - viewportRectTop),
128                          Math.max(0, viewportRectRight() - pageRectRight),
129                          Math.max(0, viewportRectBottom() - pageRectBottom));
130     }
131 
132     /*
133      * Returns the viewport metrics that represent a linear transition between "this" and "to" at
134      * time "t", which is on the scale [0, 1). This function interpolates all values stored in
135      * the viewport metrics.
136      */
interpolate(ImmutableViewportMetrics to, float t)137     public ImmutableViewportMetrics interpolate(ImmutableViewportMetrics to, float t) {
138         return new ImmutableViewportMetrics(
139             FloatUtils.interpolate(pageRectLeft, to.pageRectLeft, t),
140             FloatUtils.interpolate(pageRectTop, to.pageRectTop, t),
141             FloatUtils.interpolate(pageRectRight, to.pageRectRight, t),
142             FloatUtils.interpolate(pageRectBottom, to.pageRectBottom, t),
143             FloatUtils.interpolate(cssPageRectLeft, to.cssPageRectLeft, t),
144             FloatUtils.interpolate(cssPageRectTop, to.cssPageRectTop, t),
145             FloatUtils.interpolate(cssPageRectRight, to.cssPageRectRight, t),
146             FloatUtils.interpolate(cssPageRectBottom, to.cssPageRectBottom, t),
147             FloatUtils.interpolate(viewportRectLeft, to.viewportRectLeft, t),
148             FloatUtils.interpolate(viewportRectTop, to.viewportRectTop, t),
149             (int)FloatUtils.interpolate(viewportRectWidth, to.viewportRectWidth, t),
150             (int)FloatUtils.interpolate(viewportRectHeight, to.viewportRectHeight, t),
151             FloatUtils.interpolate(zoomFactor, to.zoomFactor, t));
152     }
153 
setViewportSize(int width, int height)154     public ImmutableViewportMetrics setViewportSize(int width, int height) {
155         if (width == viewportRectWidth && height == viewportRectHeight) {
156             return this;
157         }
158 
159         return new ImmutableViewportMetrics(
160             pageRectLeft, pageRectTop, pageRectRight, pageRectBottom,
161             cssPageRectLeft, cssPageRectTop, cssPageRectRight, cssPageRectBottom,
162             viewportRectLeft, viewportRectTop, width, height,
163             zoomFactor);
164     }
165 
setViewportOrigin(float newOriginX, float newOriginY)166     public ImmutableViewportMetrics setViewportOrigin(float newOriginX, float newOriginY) {
167         return new ImmutableViewportMetrics(
168             pageRectLeft, pageRectTop, pageRectRight, pageRectBottom,
169             cssPageRectLeft, cssPageRectTop, cssPageRectRight, cssPageRectBottom,
170             newOriginX, newOriginY, viewportRectWidth, viewportRectHeight,
171             zoomFactor);
172     }
173 
setZoomFactor(float newZoomFactor)174     public ImmutableViewportMetrics setZoomFactor(float newZoomFactor) {
175         return new ImmutableViewportMetrics(
176             pageRectLeft, pageRectTop, pageRectRight, pageRectBottom,
177             cssPageRectLeft, cssPageRectTop, cssPageRectRight, cssPageRectBottom,
178             viewportRectLeft, viewportRectTop, viewportRectWidth, viewportRectHeight,
179             newZoomFactor);
180     }
181 
offsetViewportBy(float dx, float dy)182     public ImmutableViewportMetrics offsetViewportBy(float dx, float dy) {
183         return setViewportOrigin(viewportRectLeft + dx, viewportRectTop + dy);
184     }
185 
offsetViewportByAndClamp(float dx, float dy)186     public ImmutableViewportMetrics offsetViewportByAndClamp(float dx, float dy) {
187         return setViewportOrigin(
188             Math.max(pageRectLeft, Math.min(viewportRectLeft + dx, pageRectRight - getWidth())),
189             Math.max(pageRectTop, Math.min(viewportRectTop + dy, pageRectBottom - getHeight())));
190     }
191 
setPageRect(RectF pageRect, RectF cssPageRect)192     public ImmutableViewportMetrics setPageRect(RectF pageRect, RectF cssPageRect) {
193         return new ImmutableViewportMetrics(
194             pageRect.left, pageRect.top, pageRect.right, pageRect.bottom,
195             cssPageRect.left, cssPageRect.top, cssPageRect.right, cssPageRect.bottom,
196             viewportRectLeft, viewportRectTop, viewportRectWidth, viewportRectHeight,
197             zoomFactor);
198     }
199 
setPageRectFrom(ImmutableViewportMetrics aMetrics)200     public ImmutableViewportMetrics setPageRectFrom(ImmutableViewportMetrics aMetrics) {
201         if (aMetrics.cssPageRectLeft == cssPageRectLeft &&
202             aMetrics.cssPageRectTop == cssPageRectTop &&
203             aMetrics.cssPageRectRight == cssPageRectRight &&
204             aMetrics.cssPageRectBottom == cssPageRectBottom) {
205             return this;
206         }
207         RectF css = aMetrics.getCssPageRect();
208         return setPageRect(RectUtils.scale(css, zoomFactor), css);
209     }
210 
211     /* This will set the zoom factor and re-scale page-size and viewport offset
212      * accordingly. The given focus will remain at the same point on the screen
213      * after scaling.
214      */
scaleTo(float newZoomFactor, PointF focus)215     public ImmutableViewportMetrics scaleTo(float newZoomFactor, PointF focus) {
216         // cssPageRect* is invariant, since we're setting the scale factor
217         // here. The page rect is based on the CSS page rect.
218         float newPageRectLeft = cssPageRectLeft * newZoomFactor;
219         float newPageRectTop = cssPageRectTop * newZoomFactor;
220         float newPageRectRight = cssPageRectLeft + ((cssPageRectRight - cssPageRectLeft) * newZoomFactor);
221         float newPageRectBottom = cssPageRectTop + ((cssPageRectBottom - cssPageRectTop) * newZoomFactor);
222 
223         PointF origin = getOrigin();
224         origin.offset(focus.x, focus.y);
225         origin = PointUtils.scale(origin, newZoomFactor / zoomFactor);
226         origin.offset(-focus.x, -focus.y);
227 
228         return new ImmutableViewportMetrics(
229             newPageRectLeft, newPageRectTop, newPageRectRight, newPageRectBottom,
230             cssPageRectLeft, cssPageRectTop, cssPageRectRight, cssPageRectBottom,
231             origin.x, origin.y, viewportRectWidth, viewportRectHeight,
232             newZoomFactor);
233     }
234 
235     /** Clamps the viewport to remain within the page rect. */
clamp()236     public ImmutableViewportMetrics clamp() {
237         RectF newViewport = getViewport();
238 
239         // The viewport bounds ought to never exceed the page bounds.
240         if (newViewport.right > pageRectRight)
241             newViewport.offset((pageRectRight) - newViewport.right, 0);
242         if (newViewport.left < pageRectLeft)
243             newViewport.offset(pageRectLeft - newViewport.left, 0);
244 
245         if (newViewport.bottom > pageRectBottom)
246             newViewport.offset(0, (pageRectBottom) - newViewport.bottom);
247         if (newViewport.top < pageRectTop)
248             newViewport.offset(0, pageRectTop - newViewport.top);
249 
250         // Note that since newViewport is only translated around, the viewport's
251         // width and height are unchanged.
252         return new ImmutableViewportMetrics(
253             pageRectLeft, pageRectTop, pageRectRight, pageRectBottom,
254             cssPageRectLeft, cssPageRectTop, cssPageRectRight, cssPageRectBottom,
255             newViewport.left, newViewport.top, viewportRectWidth, viewportRectHeight,
256             zoomFactor);
257     }
258 
fuzzyEquals(ImmutableViewportMetrics other)259     public boolean fuzzyEquals(ImmutableViewportMetrics other) {
260         // Don't bother checking the pageRectXXX values because they are a product
261         // of the cssPageRectXXX values and the zoomFactor, except with more rounding
262         // error. Checking those is both inefficient and can lead to false negatives.
263         return FloatUtils.fuzzyEquals(cssPageRectLeft, other.cssPageRectLeft)
264             && FloatUtils.fuzzyEquals(cssPageRectTop, other.cssPageRectTop)
265             && FloatUtils.fuzzyEquals(cssPageRectRight, other.cssPageRectRight)
266             && FloatUtils.fuzzyEquals(cssPageRectBottom, other.cssPageRectBottom)
267             && FloatUtils.fuzzyEquals(viewportRectLeft, other.viewportRectLeft)
268             && FloatUtils.fuzzyEquals(viewportRectTop, other.viewportRectTop)
269             && viewportRectWidth == other.viewportRectWidth
270             && viewportRectHeight == other.viewportRectHeight
271             && FloatUtils.fuzzyEquals(zoomFactor, other.zoomFactor);
272     }
273 
274     @Override
toString()275     public String toString() {
276         return "ImmutableViewportMetrics v=(" + viewportRectLeft + "," + viewportRectTop + ","
277                 + viewportRectWidth + "x" + viewportRectHeight + ") p=(" + pageRectLeft + ","
278                 + pageRectTop + "," + pageRectRight + "," + pageRectBottom + ") c=("
279                 + cssPageRectLeft + "," + cssPageRectTop + "," + cssPageRectRight + ","
280                 + cssPageRectBottom + ") z=" + zoomFactor;
281     }
282 }
283