The Tor Browser: mobile/android/base/gfx/Layer.java@6474c204b198 (annotated)

mobile/android/base/gfx/Layer.java@6474c204b198 (annotated)

mobile/android/base/gfx/Layer.java

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: Java; c-basic-offset: 4; tab-width: 20; indent-tabs-mode: nil; -*-
  * 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/. */
 package org.mozilla.gecko.gfx;
 import org.mozilla.gecko.util.FloatUtils;
 import android.graphics.PointF;
 import android.graphics.Rect;
 import android.graphics.RectF;
 import java.nio.FloatBuffer;
 import java.util.concurrent.locks.ReentrantLock;
 public abstract class Layer {
     private final ReentrantLock mTransactionLock;
     private boolean mInTransaction;
     private Rect mNewPosition;
     private float mNewResolution;
     protected Rect mPosition;
     protected float mResolution;
     public Layer() {
         this(null);
     }
     public Layer(IntSize size) {
         mTransactionLock = new ReentrantLock();
         if (size == null) {
             mPosition = new Rect();
         } else {
             mPosition = new Rect(0, 0, size.width, size.height);
         }
         mResolution = 1.0f;
     }
     /**
      * Updates the layer. This returns false if there is still work to be done
      * after this update.
      */
     public final boolean update(RenderContext context) {
         if (mTransactionLock.isHeldByCurrentThread()) {
             throw new RuntimeException("draw() called while transaction lock held by this " +
                                        "thread?!");
         }
         if (mTransactionLock.tryLock()) {
             try {
                 performUpdates(context);
                 return true;
             } finally {
                 mTransactionLock.unlock();
             }
         }
         return false;
     }
     /** Subclasses override this function to draw the layer. */
     public abstract void draw(RenderContext context);
     /** Given the intrinsic size of the layer, returns the pixel boundaries of the layer rect. */
     protected RectF getBounds(RenderContext context) {
         return RectUtils.scale(new RectF(mPosition), context.zoomFactor / mResolution);
     }
     /**
      * Call this before modifying the layer. Note that, for TileLayers, "modifying the layer"
      * includes altering the underlying CairoImage in any way. Thus you must call this function
      * before modifying the byte buffer associated with this layer.
      *
      * This function may block, so you should never call this on the main UI thread.
      */
     public void beginTransaction() {
         if (mTransactionLock.isHeldByCurrentThread())
             throw new RuntimeException("Nested transactions are not supported");
         mTransactionLock.lock();
         mInTransaction = true;
         mNewResolution = mResolution;
     }
     /** Call this when you're done modifying the layer. */
     public void endTransaction() {
         if (!mInTransaction)
             throw new RuntimeException("endTransaction() called outside a transaction");
         mInTransaction = false;
         mTransactionLock.unlock();
     }
     /** Returns true if the layer is currently in a transaction and false otherwise. */
     protected boolean inTransaction() {
         return mInTransaction;
     }
     /** Returns the current layer position. */
     public Rect getPosition() {
         return mPosition;
     }
     /** Sets the position. Only valid inside a transaction. */
     public void setPosition(Rect newPosition) {
         if (!mInTransaction)
             throw new RuntimeException("setPosition() is only valid inside a transaction");
         mNewPosition = newPosition;
     }
     /** Returns the current layer's resolution. */
     public float getResolution() {
         return mResolution;
     }
     /**
      * Sets the layer resolution. This value is used to determine how many pixels per
      * device pixel this layer was rendered at. This will be reflected by scaling by
      * the reciprocal of the resolution in the layer's transform() function.
      * Only valid inside a transaction. */
     public void setResolution(float newResolution) {
         if (!mInTransaction)
             throw new RuntimeException("setResolution() is only valid inside a transaction");
         mNewResolution = newResolution;
     }
     /**
      * Subclasses may override this method to perform custom layer updates. This will be called
      * with the transaction lock held. Subclass implementations of this method must call the
      * superclass implementation. Returns false if there is still work to be done after this
      * update is complete.
      */
     protected void performUpdates(RenderContext context) {
         if (mNewPosition != null) {
             mPosition = mNewPosition;
             mNewPosition = null;
         }
         if (mNewResolution != 0.0f) {
             mResolution = mNewResolution;
             mNewResolution = 0.0f;
         }
     }
     /**
      * This function fills in the provided <tt>dest</tt> array with values to render a texture.
      * The array is filled with 4 sets of {x, y, z, texture_x, texture_y} values (so 20 values
      * in total) corresponding to the corners of the rect.
      */
     protected final void fillRectCoordBuffer(float[] dest, RectF rect, float viewWidth, float viewHeight,
                                              Rect cropRect, float texWidth, float texHeight) {
         //x, y, z, texture_x, texture_y
         dest[0] = rect.left / viewWidth;
         dest[1] = rect.bottom / viewHeight;
         dest[2] = 0;
         dest[3] = cropRect.left / texWidth;
         dest[4] = cropRect.top / texHeight;
         dest[5] = rect.left / viewWidth;
         dest[6] = rect.top / viewHeight;
         dest[7] = 0;
         dest[8] = cropRect.left / texWidth;
         dest[9] = cropRect.bottom / texHeight;
         dest[10] = rect.right / viewWidth;
         dest[11] = rect.bottom / viewHeight;
         dest[12] = 0;
         dest[13] = cropRect.right / texWidth;
         dest[14] = cropRect.top / texHeight;
         dest[15] = rect.right / viewWidth;
         dest[16] = rect.top / viewHeight;
         dest[17] = 0;
         dest[18] = cropRect.right / texWidth;
         dest[19] = cropRect.bottom / texHeight;
     }
     public static class RenderContext {
         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,
                              int aPositionHandle, int aTextureHandle, FloatBuffer aCoordBuffer) {
             viewport = aViewport;
             pageRect = aPageRect;
             zoomFactor = aZoomFactor;
             offset = aOffset;
             positionHandle = aPositionHandle;
             textureHandle = aTextureHandle;
             coordBuffer = aCoordBuffer;
         }
         public boolean fuzzyEquals(RenderContext other) {
             if (other == null) {
                 return false;
             }
             return RectUtils.fuzzyEquals(viewport, other.viewport)
                 && RectUtils.fuzzyEquals(pageRect, other.pageRect)
                 && FloatUtils.fuzzyEquals(zoomFactor, other.zoomFactor)
                 && FloatUtils.fuzzyEquals(offset, other.offset);
         }
     }
 }

The Tor Browser / annotate

mobile/android/base/gfx/Layer.java@6474c204b198 (annotated)

mobile/android/base/gfx/Layer.java