Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-13 05:15:45 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1180295 - Remove the margins information from ImmutableViewportMetrics. r=rbarker

Browse Source 
--HG--
extra : commitid : 5VpOP33T9F4
This commit is contained in:
Kartikaya Gupta 2015-08-18 14:27:20 -04:00
parent 2cb02dbf56
commit d54ad14fa5
7 changed files with 36 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
mobile/android/base/gfx/GeckoLayerClient.java
View File

@ -824,7 +824,6 @@ class GeckoLayerClient implements LayerView.Listener, PanZoomTarget
// ever be updated is in GeckoLayerClient.setFixedLayerMargins; both of these assign to
// mViewportMetrics directly.
metrics = metrics.setViewportSize(mViewportMetrics.viewportRectWidth, mViewportMetrics.viewportRectHeight);
metrics = metrics.setMarginsFrom(mViewportMetrics);
mViewportMetrics = metrics;
viewportMetricsChanged(notifyGecko);
@ -925,8 +924,6 @@ class GeckoLayerClient implements LayerView.Listener, PanZoomTarget
ImmutableViewportMetrics viewportMetrics = mViewportMetrics;
PointF origin = viewportMetrics.getOrigin();
PointF offset = viewportMetrics.getMarginOffset();
origin.offset(-offset.x, -offset.y);
float zoom = viewportMetrics.zoomFactor;
ImmutableViewportMetrics geckoViewport = mGeckoViewport;
PointF geckoOrigin = geckoViewport.getOrigin();

108
mobile/android/base/gfx/ImmutableViewportMetrics.java
View File

@ -34,10 +34,6 @@ public class ImmutableViewportMetrics {
public final int viewportRectWidth;
public final int viewportRectHeight;
public final float marginLeft;
public final float marginTop;
public final float marginRight;
public final float marginBottom;
public final float zoomFactor;
public final boolean isRTL;
@ -48,7 +44,6 @@ public class ImmutableViewportMetrics {
viewportRectHeight = metrics.heightPixels;
pageRectRight = cssPageRectRight = metrics.widthPixels;
pageRectBottom = cssPageRectBottom = metrics.heightPixels;
marginLeft = marginTop = marginRight = marginBottom = 0;
zoomFactor = 1.0f;
isRTL = false;
}
@ -67,16 +62,14 @@ public class ImmutableViewportMetrics {
aPageRectRight, aPageRectBottom, aCssPageRectLeft,
aCssPageRectTop, aCssPageRectRight, aCssPageRectBottom,
aViewportRectLeft, aViewportRectTop, aViewportRectWidth,
aViewportRectHeight, 0.0f, 0.0f, 0.0f, 0.0f, aZoomFactor, false);
aViewportRectHeight, aZoomFactor, false);
}
private 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 aMarginLeft,
float aMarginTop, float aMarginRight,
float aMarginBottom, float aZoomFactor, boolean aIsRTL)
int aViewportRectHeight, float aZoomFactor, boolean aIsRTL)
{
pageRectLeft = aPageRectLeft;
pageRectTop = aPageRectTop;
@ -90,10 +83,6 @@ public class ImmutableViewportMetrics {
viewportRectTop = aViewportRectTop;
viewportRectWidth = aViewportRectWidth;
viewportRectHeight = aViewportRectHeight;
marginLeft = aMarginLeft;
marginTop = aMarginTop;
marginRight = aMarginRight;
marginBottom = aMarginBottom;
zoomFactor = aZoomFactor;
isRTL = aIsRTL;
}
@ -114,25 +103,10 @@ public class ImmutableViewportMetrics {
return viewportRectTop + viewportRectHeight;
}
public float getWidthWithoutMargins() {
return viewportRectWidth - marginLeft - marginRight;
}
public float getHeightWithoutMargins() {
return viewportRectHeight - marginTop - marginBottom;
}
public PointF getOrigin() {
return new PointF(viewportRectLeft, viewportRectTop);
}
public PointF getMarginOffset() {
if (isRTL) {
return new PointF(marginLeft - marginRight, marginTop);
}
return new PointF(marginLeft, marginTop);
}
public FloatSize getSize() {
return new FloatSize(viewportRectWidth, viewportRectHeight);
}
@ -156,18 +130,10 @@ public class ImmutableViewportMetrics {
return pageRectRight - pageRectLeft;
}
public float getPageWidthWithMargins() {
return (pageRectRight - pageRectLeft) + marginLeft + marginRight;
}
public float getPageHeight() {
return pageRectBottom - pageRectTop;
}
public float getPageHeightWithMargins() {
return (pageRectBottom - pageRectTop) + marginTop + marginBottom;
}
public RectF getCssPageRect() {
return new RectF(cssPageRectLeft, cssPageRectTop, cssPageRectRight, cssPageRectBottom);
}
@ -198,10 +164,6 @@ public class ImmutableViewportMetrics {
FloatUtils.interpolate(viewportRectTop, to.viewportRectTop, t),
(int)FloatUtils.interpolate(viewportRectWidth, to.viewportRectWidth, t),
(int)FloatUtils.interpolate(viewportRectHeight, to.viewportRectHeight, t),
FloatUtils.interpolate(marginLeft, to.marginLeft, t),
FloatUtils.interpolate(marginTop, to.marginTop, t),
FloatUtils.interpolate(marginRight, to.marginRight, t),
FloatUtils.interpolate(marginBottom, to.marginBottom, t),
FloatUtils.interpolate(zoomFactor, to.zoomFactor, t),
t >= 0.5 ? to.isRTL : isRTL);
}
@ -215,7 +177,6 @@ public class ImmutableViewportMetrics {
pageRectLeft, pageRectTop, pageRectRight, pageRectBottom,
cssPageRectLeft, cssPageRectTop, cssPageRectRight, cssPageRectBottom,
viewportRectLeft, viewportRectTop, width, height,
marginLeft, marginTop, marginRight, marginBottom,
zoomFactor, isRTL);
}
@ -224,7 +185,6 @@ public class ImmutableViewportMetrics {
pageRectLeft, pageRectTop, pageRectRight, pageRectBottom,
cssPageRectLeft, cssPageRectTop, cssPageRectRight, cssPageRectBottom,
newOriginX, newOriginY, viewportRectWidth, viewportRectHeight,
marginLeft, marginTop, marginRight, marginBottom,
zoomFactor, isRTL);
}
@ -233,7 +193,6 @@ public class ImmutableViewportMetrics {
pageRectLeft, pageRectTop, pageRectRight, pageRectBottom,
cssPageRectLeft, cssPageRectTop, cssPageRectRight, cssPageRectBottom,
viewportRectLeft, viewportRectTop, viewportRectWidth, viewportRectHeight,
marginLeft, marginTop, marginRight, marginBottom,
newZoomFactor, isRTL);
}
@ -244,12 +203,12 @@ public class ImmutableViewportMetrics {
public ImmutableViewportMetrics offsetViewportByAndClamp(float dx, float dy) {
if (isRTL) {
return setViewportOrigin(
Math.min(pageRectRight - getWidthWithoutMargins(), Math.max(viewportRectLeft + dx, pageRectLeft)),
Math.max(pageRectTop, Math.min(viewportRectTop + dy, pageRectBottom - getHeightWithoutMargins())));
Math.min(pageRectRight - getWidth(), Math.max(viewportRectLeft + dx, pageRectLeft)),
Math.max(pageRectTop, Math.min(viewportRectTop + dy, pageRectBottom - getHeight())));
}
return setViewportOrigin(
Math.max(pageRectLeft, Math.min(viewportRectLeft + dx, pageRectRight - getWidthWithoutMargins())),
Math.max(pageRectTop, Math.min(viewportRectTop + dy, pageRectBottom - getHeightWithoutMargins())));
Math.max(pageRectLeft, Math.min(viewportRectLeft + dx, pageRectRight - getWidth())),
Math.max(pageRectTop, Math.min(viewportRectTop + dy, pageRectBottom - getHeight())));
}
public ImmutableViewportMetrics setPageRect(RectF pageRect, RectF cssPageRect) {
@ -257,32 +216,9 @@ public class ImmutableViewportMetrics {
pageRect.left, pageRect.top, pageRect.right, pageRect.bottom,
cssPageRect.left, cssPageRect.top, cssPageRect.right, cssPageRect.bottom,
viewportRectLeft, viewportRectTop, viewportRectWidth, viewportRectHeight,
marginLeft, marginTop, marginRight, marginBottom,
zoomFactor, isRTL);
}
public ImmutableViewportMetrics setMargins(float left, float top, float right, float bottom) {
if (FloatUtils.fuzzyEquals(left, marginLeft)
&& FloatUtils.fuzzyEquals(top, marginTop)
&& FloatUtils.fuzzyEquals(right, marginRight)
&& FloatUtils.fuzzyEquals(bottom, marginBottom)) {
return this;
}
return new ImmutableViewportMetrics(
pageRectLeft, pageRectTop, pageRectRight, pageRectBottom,
cssPageRectLeft, cssPageRectTop, cssPageRectRight, cssPageRectBottom,
viewportRectLeft, viewportRectTop, viewportRectWidth, viewportRectHeight,
left, top, right, bottom, zoomFactor, isRTL);
}
public ImmutableViewportMetrics setMarginsFrom(ImmutableViewportMetrics fromMetrics) {
return setMargins(fromMetrics.marginLeft,
fromMetrics.marginTop,
fromMetrics.marginRight,
fromMetrics.marginBottom);
}
public ImmutableViewportMetrics setIsRTL(boolean aIsRTL) {
if (isRTL == aIsRTL) {
return this;
@ -292,7 +228,7 @@ public class ImmutableViewportMetrics {
pageRectLeft, pageRectTop, pageRectRight, pageRectBottom,
cssPageRectLeft, cssPageRectTop, cssPageRectRight, cssPageRectBottom,
viewportRectLeft, viewportRectTop, viewportRectWidth, viewportRectHeight,
marginLeft, marginTop, marginRight, marginBottom, zoomFactor, aIsRTL);
zoomFactor, aIsRTL);
}
/* This will set the zoom factor and re-scale page-size and viewport offset
@ -316,24 +252,21 @@ public class ImmutableViewportMetrics {
newPageRectLeft, newPageRectTop, newPageRectRight, newPageRectBottom,
cssPageRectLeft, cssPageRectTop, cssPageRectRight, cssPageRectBottom,
origin.x, origin.y, viewportRectWidth, viewportRectHeight,
marginLeft, marginTop, marginRight, marginBottom,
newZoomFactor, isRTL);
}
/** Clamps the viewport to remain within the page rect. */
private ImmutableViewportMetrics clamp(float marginLeft, float marginTop,
float marginRight, float marginBottom) {
public ImmutableViewportMetrics clamp() {
RectF newViewport = getViewport();
PointF offset = getMarginOffset();
// The viewport bounds ought to never exceed the page bounds.
if (newViewport.right > pageRectRight + marginLeft + marginRight)
newViewport.offset((pageRectRight + marginLeft + marginRight) - newViewport.right, 0);
if (newViewport.right > pageRectRight)
newViewport.offset((pageRectRight) - newViewport.right, 0);
if (newViewport.left < pageRectLeft)
newViewport.offset(pageRectLeft - newViewport.left, 0);
if (newViewport.bottom > pageRectBottom + marginTop + marginBottom)
newViewport.offset(0, (pageRectBottom + marginTop + marginBottom) - newViewport.bottom);
if (newViewport.bottom > pageRectBottom)
newViewport.offset(0, (pageRectBottom) - newViewport.bottom);
if (newViewport.top < pageRectTop)
newViewport.offset(0, pageRectTop - newViewport.top);
@ -343,26 +276,13 @@ public class ImmutableViewportMetrics {
pageRectLeft, pageRectTop, pageRectRight, pageRectBottom,
cssPageRectLeft, cssPageRectTop, cssPageRectRight, cssPageRectBottom,
newViewport.left, newViewport.top, viewportRectWidth, viewportRectHeight,
marginLeft, marginTop, marginRight, marginBottom,
zoomFactor, isRTL);
}
public ImmutableViewportMetrics clamp() {
return clamp(0, 0, 0, 0);
}
public ImmutableViewportMetrics clampWithMargins() {
return clamp(marginLeft, marginTop,
marginRight, marginBottom);
}
public boolean fuzzyEquals(ImmutableViewportMetrics other) {
// Don't bother checking the pageRectXXX values because they are a product
// of the cssPageRectXXX values and the zoomFactor, except with more rounding
// error. Checking those is both inefficient and can lead to false negatives.
//
// This doesn't return false if the margins differ as none of the users
// of this function are interested in the margins in that way.
return FloatUtils.fuzzyEquals(cssPageRectLeft, other.cssPageRectLeft)
&& FloatUtils.fuzzyEquals(cssPageRectTop, other.cssPageRectTop)
&& FloatUtils.fuzzyEquals(cssPageRectRight, other.cssPageRectRight)
@ -380,8 +300,6 @@ public class ImmutableViewportMetrics {
+ viewportRectWidth + "x" + viewportRectHeight + ") p=(" + pageRectLeft + ","
+ pageRectTop + "," + pageRectRight + "," + pageRectBottom + ") c=("
+ cssPageRectLeft + "," + cssPageRectTop + "," + cssPageRectRight + ","
+ cssPageRectBottom + ") m=(" + marginLeft + ","
+ marginTop + "," + marginRight + ","
+ marginBottom + ") z=" + zoomFactor + ", rtl=" + isRTL;
+ cssPageRectBottom + ") z=" + zoomFactor + ", rtl=" + isRTL;
}
}

6
mobile/android/base/gfx/JavaPanZoomController.java
View File

@ -1087,7 +1087,7 @@ class JavaPanZoomController
}
/* Now we pan to the right origin. */
viewportMetrics = viewportMetrics.clampWithMargins();
viewportMetrics = viewportMetrics.clamp();
return viewportMetrics;
}
@ -1101,7 +1101,7 @@ class JavaPanZoomController
@Override
protected float getPageStart() { return getMetrics().pageRectLeft; }
@Override
protected float getPageLength() { return getMetrics().getPageWidthWithMargins(); }
protected float getPageLength() { return getMetrics().getPageWidth(); }
@Override
protected float getVisibleEndOfLayerView() {
return mTarget.getVisibleEndOfLayerView().x;
@ -1129,7 +1129,7 @@ class JavaPanZoomController
@Override
protected float getPageStart() { return getMetrics().pageRectTop; }
@Override
protected float getPageLength() { return getMetrics().getPageHeightWithMargins(); }
protected float getPageLength() { return getMetrics().getPageHeight(); }
@Override
protected float getVisibleEndOfLayerView() {
return mTarget.getVisibleEndOfLayerView().y;

7
mobile/android/base/gfx/Layer.java
View File

@ -177,17 +177,15 @@ public abstract class Layer {
public final RectF viewport;
public final RectF pageRect;
public final float zoomFactor;
public final PointF offset;
public final int positionHandle;
public final int textureHandle;
public final FloatBuffer coordBuffer;
public RenderContext(RectF aViewport, RectF aPageRect, float aZoomFactor, PointF aOffset,
public RenderContext(RectF aViewport, RectF aPageRect, float aZoomFactor,
int aPositionHandle, int aTextureHandle, FloatBuffer aCoordBuffer) {
viewport = aViewport;
pageRect = aPageRect;
zoomFactor = aZoomFactor;
offset = aOffset;
positionHandle = aPositionHandle;
textureHandle = aTextureHandle;
coordBuffer = aCoordBuffer;
@ -199,8 +197,7 @@ public abstract class Layer {
}
return RectUtils.fuzzyEquals(viewport, other.viewport)
&& RectUtils.fuzzyEquals(pageRect, other.pageRect)
&& FloatUtils.fuzzyEquals(zoomFactor, other.zoomFactor)
&& FloatUtils.fuzzyEquals(offset, other.offset);
&& FloatUtils.fuzzyEquals(zoomFactor, other.zoomFactor);
}
}
}

22
mobile/android/base/gfx/LayerRenderer.java
View File

@ -323,22 +323,22 @@ public class LayerRenderer implements Tabs.OnTabsChangedListener {
return pixelBuffer;
}
private RenderContext createScreenContext(ImmutableViewportMetrics metrics, PointF offset) {
private RenderContext createScreenContext(ImmutableViewportMetrics metrics) {
RectF viewport = new RectF(0.0f, 0.0f, metrics.getWidth(), metrics.getHeight());
RectF pageRect = metrics.getPageRect();
return createContext(viewport, pageRect, 1.0f, offset);
return createContext(viewport, pageRect, 1.0f);
}
private RenderContext createPageContext(ImmutableViewportMetrics metrics, PointF offset) {
private RenderContext createPageContext(ImmutableViewportMetrics metrics) {
RectF viewport = metrics.getViewport();
RectF pageRect = metrics.getPageRect();
float zoomFactor = metrics.zoomFactor;
return createContext(new RectF(RectUtils.round(viewport)), pageRect, zoomFactor, offset);
return createContext(new RectF(RectUtils.round(viewport)), pageRect, zoomFactor);
}
private RenderContext createContext(RectF viewport, RectF pageRect, float zoomFactor, PointF offset) {
private RenderContext createContext(RectF viewport, RectF pageRect, float zoomFactor) {
if (mCoordBuffer == null) {
// Initialize the FloatBuffer that will be used to store all vertices and texture
// coordinates in draw() commands.
@ -349,7 +349,7 @@ public class LayerRenderer implements Tabs.OnTabsChangedListener {
throw new IllegalStateException();
}
}
return new RenderContext(viewport, pageRect, zoomFactor, offset,
return new RenderContext(viewport, pageRect, zoomFactor,
mPositionHandle, mTextureHandle, mCoordBuffer);
}
@ -435,16 +435,14 @@ public class LayerRenderer implements Tabs.OnTabsChangedListener {
private boolean mUpdated;
private final Rect mPageRect;
private final Rect mAbsolutePageRect;
private final PointF mRenderOffset;
public Frame(ImmutableViewportMetrics metrics) {
mFrameMetrics = metrics;
// Work out the offset due to margins
Layer rootLayer = mView.getLayerClient().getRoot();
mRenderOffset = mFrameMetrics.getMarginOffset();
mPageContext = createPageContext(metrics, mRenderOffset);
mScreenContext = createScreenContext(metrics, mRenderOffset);
mPageContext = createPageContext(metrics);
mScreenContext = createScreenContext(metrics);
RectF pageRect = mFrameMetrics.getPageRect();
mAbsolutePageRect = RectUtils.round(pageRect);
@ -582,8 +580,8 @@ public class LayerRenderer implements Tabs.OnTabsChangedListener {
// When scrolling fast, do not request zoomed view render to avoid to slow down
// the scroll in the main view.
// Speed is estimated using the offset changes between 2 display frame calls
final float viewLeft = context.viewport.left - context.offset.x;
final float viewTop = context.viewport.top - context.offset.y;
final float viewLeft = context.viewport.left;
final float viewTop = context.viewport.top;
boolean shouldWaitToRender = false;
if (Math.abs(mLastViewLeft - viewLeft) > MAX_SCROLL_SPEED_TO_REQUEST_ZOOM_RENDER ||

5
mobile/android/base/gfx/PluginLayer.java
View File

@ -107,7 +107,7 @@ public class PluginLayer extends Layer {
mLastZoomFactor = context.zoomFactor;
mLastViewport = context.viewport;
mLayoutParams.reposition(context.viewport, context.offset, context.zoomFactor);
mLayoutParams.reposition(context.viewport, context.zoomFactor);
showView();
}
@ -148,10 +148,9 @@ public class PluginLayer extends Layer {
mRect = rect;
}
public void reposition(RectF viewport, PointF offset, float zoomFactor) {
public void reposition(RectF viewport, float zoomFactor) {
RectF scaled = RectUtils.scale(mRect, zoomFactor);
scaled.offset(offset.x, offset.y);
this.x = Math.round(scaled.left - viewport.left);
this.y = Math.round(scaled.top - viewport.top);

13
mobile/android/base/gfx/ScrollbarLayer.java
View File

@ -202,7 +202,6 @@ public class ScrollbarLayer extends Layer {
float viewHeight = context.viewport.height();
mBarRectF.set(mBarRect.left, viewHeight - mBarRect.top, mBarRect.right, viewHeight - mBarRect.bottom);
mBarRectF.offset(context.offset.x, -context.offset.y);
// We take a 1-pixel slice from the center of the image and scale it to become the bar
fillRectCoordBuffer(mCoords, mBarRectF, viewWidth, viewHeight, mBodyTexCoords, mTexWidth, mTexHeight);
@ -286,9 +285,9 @@ public class ScrollbarLayer extends Layer {
private void getVerticalRect(RenderContext context, RectF dest) {
RectF viewport = context.viewport;
RectF pageRect = context.pageRect;
float viewportHeight = viewport.height() - context.offset.y;
float barStart = ((viewport.top - context.offset.y - pageRect.top) * (viewportHeight / pageRect.height())) + mCapLength;
float barEnd = ((viewport.bottom - context.offset.y - pageRect.top) * (viewportHeight / pageRect.height())) - mCapLength;
float viewportHeight = viewport.height();
float barStart = ((viewport.top - pageRect.top) * (viewportHeight / pageRect.height())) + mCapLength;
float barEnd = ((viewport.bottom - pageRect.top) * (viewportHeight / pageRect.height())) - mCapLength;
if (barStart > barEnd) {
float middle = (barStart + barEnd) / 2.0f;
barStart = barEnd = middle;
@ -299,9 +298,9 @@ public class ScrollbarLayer extends Layer {
private void getHorizontalRect(RenderContext context, RectF dest) {
RectF viewport = context.viewport;
RectF pageRect = context.pageRect;
float viewportWidth = viewport.width() - context.offset.x;
float barStart = ((viewport.left - context.offset.x - pageRect.left) * (viewport.width() / pageRect.width())) + mCapLength;
float barEnd = ((viewport.right - context.offset.x - pageRect.left) * (viewport.width() / pageRect.width())) - mCapLength;
float viewportWidth = viewport.width();
float barStart = ((viewport.left - pageRect.left) * (viewport.width() / pageRect.width())) + mCapLength;
float barEnd = ((viewport.right - pageRect.left) * (viewport.width() / pageRect.width())) - mCapLength;
if (barStart > barEnd) {
float middle = (barStart + barEnd) / 2.0f;
barStart = barEnd = middle;