Merge "Reimplement the native matrix method using the new delegate way."
diff --git a/tools/layoutlib/bridge/.classpath b/tools/layoutlib/bridge/.classpath
index 70140d8..d3bcb6c 100644
--- a/tools/layoutlib/bridge/.classpath
+++ b/tools/layoutlib/bridge/.classpath
@@ -6,7 +6,7 @@
<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/3"/>
<classpathentry kind="var" path="ANDROID_SRC/prebuilt/common/layoutlib_api/layoutlib_api-prebuilt.jar"/>
<classpathentry kind="var" path="ANDROID_SRC/prebuilt/common/kxml2/kxml2-2.3.0.jar" sourcepath="/ANDROID_SRC/dalvik/libcore/xml/src/main/java"/>
- <classpathentry kind="var" path="ANDROID_OUT_FRAMEWORK/layoutlib.jar" sourcepath="/ANDROID_SRC/frameworks/base/core/java"/>
+ <classpathentry kind="var" path="ANDROID_PLAT_OUT_FRAMEWORK/layoutlib.jar" sourcepath="/ANDROID_PLAT_SRC/frameworks/base"/>
<classpathentry kind="var" path="ANDROID_OUT_FRAMEWORK/ninepatch.jar" sourcepath="/ANDROID_SRC/development/tools/ninepatch/src"/>
<classpathentry kind="output" path="bin"/>
</classpath>
diff --git a/tools/layoutlib/bridge/src/android/graphics/Canvas.java b/tools/layoutlib/bridge/src/android/graphics/Canvas.java
index 1e1aba9..0dccc0d6 100644
--- a/tools/layoutlib/bridge/src/android/graphics/Canvas.java
+++ b/tools/layoutlib/bridge/src/android/graphics/Canvas.java
@@ -18,13 +18,6 @@
import com.android.layoutlib.api.ILayoutLog;
-import android.graphics.DrawFilter;
-import android.graphics.Picture;
-import android.graphics.PorterDuff;
-import android.graphics.Rect;
-import android.graphics.RectF;
-import android.graphics.Region;
-import android.graphics.Xfermode;
import android.graphics.Paint.Align;
import android.graphics.Paint.FontInfo;
import android.graphics.Paint.Style;
@@ -42,8 +35,6 @@
import java.util.List;
import java.util.Stack;
-import javax.microedition.khronos.opengles.GL;
-
/**
* Re-implementation of the Canvas, 100% in java on top of a BufferedImage.
*/
@@ -509,7 +500,7 @@
// get the Graphics2D current matrix
AffineTransform currentTx = g.getTransform();
// get the AffineTransform from the matrix
- AffineTransform matrixTx = matrix.getTransform();
+ AffineTransform matrixTx = Matrix_Delegate.getAffineTransform(matrix);
// combine them so that the matrix is applied after.
currentTx.preConcatenate(matrixTx);
@@ -969,9 +960,9 @@
Graphics2D g = getGraphics2d();
// and apply the matrix
- g.setTransform(matrix.getTransform());
+ g.setTransform(Matrix_Delegate.getAffineTransform(matrix));
- if (mLogger != null && matrix.hasPerspective()) {
+ if (mLogger != null && Matrix_Delegate.hasPerspective(matrix)) {
mLogger.warning("android.graphics.Canvas#setMatrix(android.graphics.Matrix) only supports affine transformations in the Layout Editor.");
}
}
@@ -987,7 +978,7 @@
// get its current matrix
AffineTransform currentTx = g.getTransform();
// get the AffineTransform of the given matrix
- AffineTransform matrixTx = matrix.getTransform();
+ AffineTransform matrixTx = Matrix_Delegate.getAffineTransform(matrix);
// combine them so that the given matrix is applied after.
currentTx.preConcatenate(matrixTx);
diff --git a/tools/layoutlib/bridge/src/android/graphics/Matrix.java b/tools/layoutlib/bridge/src/android/graphics/Matrix.java
deleted file mode 100644
index 9e30671..0000000
--- a/tools/layoutlib/bridge/src/android/graphics/Matrix.java
+++ /dev/null
@@ -1,1032 +0,0 @@
-/*
- * Copyright (C) 2008 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.graphics;
-
-import java.awt.geom.AffineTransform;
-import java.awt.geom.NoninvertibleTransformException;
-
-
-/**
- * A matrix implementation overridden by the LayoutLib bridge.
- */
-public class Matrix extends _Original_Matrix {
-
- float mValues[] = new float[9];
-
- /**
- * Create an identity matrix
- */
- public Matrix() {
- reset();
- }
-
- /**
- * Create a matrix that is a (deep) copy of src
- * @param src The matrix to copy into this matrix
- */
- public Matrix(Matrix src) {
- set(src);
- }
-
- /**
- * Creates a Matrix object from the float array. The array becomes the internal storage
- * of the object.
- * @param data
- */
- private Matrix(float[] data) {
- assert data.length != 9;
- mValues = data;
- }
-
- //---------- Custom Methods
-
- /**
- * Adds the given transformation to the current Matrix
- * <p/>This in effect does this = this*matrix
- * @param matrix
- */
- private void addTransform(float[] matrix) {
- float[] tmp = new float[9];
-
- // first row
- tmp[0] = matrix[0] * mValues[0] + matrix[1] * mValues[3] + matrix[2] * mValues[6];
- tmp[1] = matrix[0] * mValues[1] + matrix[1] * mValues[4] + matrix[2] * mValues[7];
- tmp[2] = matrix[0] * mValues[2] + matrix[1] * mValues[5] + matrix[2] * mValues[8];
-
- // 2nd row
- tmp[3] = matrix[3] * mValues[0] + matrix[4] * mValues[3] + matrix[5] * mValues[6];
- tmp[4] = matrix[3] * mValues[1] + matrix[4] * mValues[4] + matrix[5] * mValues[7];
- tmp[5] = matrix[3] * mValues[2] + matrix[4] * mValues[5] + matrix[5] * mValues[8];
-
- // 3rd row
- tmp[6] = matrix[6] * mValues[0] + matrix[7] * mValues[3] + matrix[8] * mValues[6];
- tmp[7] = matrix[6] * mValues[1] + matrix[7] * mValues[4] + matrix[8] * mValues[7];
- tmp[8] = matrix[6] * mValues[2] + matrix[7] * mValues[5] + matrix[8] * mValues[8];
-
- // copy the result over to mValues
- mValues = tmp;
- }
-
- public AffineTransform getTransform() {
- // the AffineTransform constructor takes the value in a different order
- // for a matrix [ 0 1 2 ]
- // [ 3 4 5 ]
- // the order is 0, 3, 1, 4, 2, 5...
- return new AffineTransform(mValues[0], mValues[3], mValues[1],
- mValues[4], mValues[2], mValues[5]);
- }
-
- public boolean hasPerspective() {
- return (mValues[6] != 0 || mValues[7] != 0 || mValues[8] != 1);
- }
-
- //----------
-
- /**
- * Returns true if the matrix is identity.
- * This maybe faster than testing if (getType() == 0)
- */
- @Override
- public boolean isIdentity() {
- for (int i = 0, k = 0; i < 3; i++) {
- for (int j = 0; j < 3; j++, k++) {
- if (mValues[k] != ((i==j) ? 1 : 0)) {
- return false;
- }
- }
- }
-
- return true;
- }
-
- /**
- * Returns true if will map a rectangle to another rectangle. This can be
- * true if the matrix is identity, scale-only, or rotates a multiple of 90
- * degrees.
- */
- @Override
- public boolean rectStaysRect() {
- return (computeTypeMask() & kRectStaysRect_Mask) != 0;
- }
-
- /**
- * (deep) copy the src matrix into this matrix. If src is null, reset this
- * matrix to the identity matrix.
- */
- public void set(Matrix src) {
- if (src == null) {
- reset();
- } else {
- System.arraycopy(src.mValues, 0, mValues, 0, mValues.length);
- }
- }
-
- @Override
- public void set(_Original_Matrix src) {
- throw new UnsupportedOperationException("CALL TO PARENT FORBIDDEN");
- }
-
- /** Returns true if obj is a Matrix and its values equal our values.
- */
- @Override
- public boolean equals(Object obj) {
- if (obj != null && obj instanceof Matrix) {
- Matrix matrix = (Matrix)obj;
- for (int i = 0 ; i < 9 ; i++) {
- if (mValues[i] != matrix.mValues[i]) {
- return false;
- }
- }
-
- return true;
- }
-
- return false;
- }
-
- /** Set the matrix to identity */
- @Override
- public void reset() {
- for (int i = 0, k = 0; i < 3; i++) {
- for (int j = 0; j < 3; j++, k++) {
- mValues[k] = ((i==j) ? 1 : 0);
- }
- }
- }
-
- /** Set the matrix to translate by (dx, dy). */
- @Override
- public void setTranslate(float dx, float dy) {
- mValues[0] = 1;
- mValues[1] = 0;
- mValues[2] = dx;
- mValues[3] = 0;
- mValues[4] = 1;
- mValues[5] = dy;
- mValues[6] = 0;
- mValues[7] = 0;
- mValues[8] = 1;
- }
-
- /**
- * Set the matrix to scale by sx and sy, with a pivot point at (px, py).
- * The pivot point is the coordinate that should remain unchanged by the
- * specified transformation.
- */
- @Override
- public void setScale(float sx, float sy, float px, float py) {
- // TODO: do it in one pass
-
- // translate so that the pivot is in 0,0
- mValues[0] = 1;
- mValues[1] = 0;
- mValues[2] = -px;
- mValues[3] = 0;
- mValues[4] = 1;
- mValues[5] = -py;
- mValues[6] = 0;
- mValues[7] = 0;
- mValues[8] = 1;
-
- // scale
- addTransform(new float[] { sx, 0, 0, 0, sy, 0, 0, 0, 1 });
- // translate back the pivot
- addTransform(new float[] { 1, 0, px, 0, 1, py, 0, 0, 1 });
- }
-
- /** Set the matrix to scale by sx and sy. */
- @Override
- public void setScale(float sx, float sy) {
- mValues[0] = sx;
- mValues[1] = 0;
- mValues[2] = 0;
- mValues[3] = 0;
- mValues[4] = sy;
- mValues[5] = 0;
- mValues[6] = 0;
- mValues[7] = 0;
- mValues[8] = 1;
- }
-
- /**
- * Set the matrix to rotate by the specified number of degrees, with a pivot
- * point at (px, py). The pivot point is the coordinate that should remain
- * unchanged by the specified transformation.
- */
- @Override
- public void setRotate(float degrees, float px, float py) {
- // TODO: do it in one pass
-
- // translate so that the pivot is in 0,0
- mValues[0] = 1;
- mValues[1] = 0;
- mValues[2] = -px;
- mValues[3] = 0;
- mValues[4] = 1;
- mValues[5] = -py;
- mValues[6] = 0;
- mValues[7] = 0;
- mValues[8] = 1;
-
- // scale
- double rad = Math.toRadians(degrees);
- float cos = (float)Math.cos(rad);
- float sin = (float)Math.sin(rad);
- addTransform(new float[] { cos, -sin, 0, sin, cos, 0, 0, 0, 1 });
- // translate back the pivot
- addTransform(new float[] { 1, 0, px, 0, 1, py, 0, 0, 1 });
- }
-
- /**
- * Set the matrix to rotate about (0,0) by the specified number of degrees.
- */
- @Override
- public void setRotate(float degrees) {
- double rad = Math.toRadians(degrees);
- float cos = (float)Math.cos(rad);
- float sin = (float)Math.sin(rad);
-
- mValues[0] = cos;
- mValues[1] = -sin;
- mValues[2] = 0;
- mValues[3] = sin;
- mValues[4] = cos;
- mValues[5] = 0;
- mValues[6] = 0;
- mValues[7] = 0;
- mValues[8] = 1;
- }
-
- /**
- * Set the matrix to rotate by the specified sine and cosine values, with a
- * pivot point at (px, py). The pivot point is the coordinate that should
- * remain unchanged by the specified transformation.
- */
- @Override
- public void setSinCos(float sinValue, float cosValue, float px, float py) {
- // TODO: do it in one pass
-
- // translate so that the pivot is in 0,0
- mValues[0] = 1;
- mValues[1] = 0;
- mValues[2] = -px;
- mValues[3] = 0;
- mValues[4] = 1;
- mValues[5] = -py;
- mValues[6] = 0;
- mValues[7] = 0;
- mValues[8] = 1;
-
- // scale
- addTransform(new float[] { cosValue, -sinValue, 0, sinValue, cosValue, 0, 0, 0, 1 });
- // translate back the pivot
- addTransform(new float[] { 1, 0, px, 0, 1, py, 0, 0, 1 });
- }
-
- /** Set the matrix to rotate by the specified sine and cosine values. */
- @Override
- public void setSinCos(float sinValue, float cosValue) {
- mValues[0] = cosValue;
- mValues[1] = -sinValue;
- mValues[2] = 0;
- mValues[3] = sinValue;
- mValues[4] = cosValue;
- mValues[5] = 0;
- mValues[6] = 0;
- mValues[7] = 0;
- mValues[8] = 1;
- }
-
- /**
- * Set the matrix to skew by sx and sy, with a pivot point at (px, py).
- * The pivot point is the coordinate that should remain unchanged by the
- * specified transformation.
- */
- @Override
- public void setSkew(float kx, float ky, float px, float py) {
- // TODO: do it in one pass
-
- // translate so that the pivot is in 0,0
- mValues[0] = 1;
- mValues[1] = 0;
- mValues[2] = -px;
- mValues[3] = 0;
- mValues[4] = 1;
- mValues[5] = -py;
- mValues[6] = 0;
- mValues[7] = 0;
- mValues[8] = 1;
-
- // scale
- addTransform(new float[] { 1, kx, 0, ky, 1, 0, 0, 0, 1 });
- // translate back the pivot
- addTransform(new float[] { 1, 0, px, 0, 1, py, 0, 0, 1 });
- }
-
- /** Set the matrix to skew by sx and sy. */
- @Override
- public void setSkew(float kx, float ky) {
- mValues[0] = 1;
- mValues[1] = kx;
- mValues[2] = -0;
- mValues[3] = ky;
- mValues[4] = 1;
- mValues[5] = 0;
- mValues[6] = 0;
- mValues[7] = 0;
- mValues[8] = 1;
- }
-
- /**
- * Set the matrix to the concatenation of the two specified matrices,
- * returning true if the the result can be represented. Either of the two
- * matrices may also be the target matrix. this = a * b
- */
- public boolean setConcat(Matrix a, Matrix b) {
- if (a == this) {
- preConcat(b);
- } else if (b == this) {
- postConcat(b);
- } else {
- Matrix tmp = new Matrix(b);
- tmp.addTransform(a.mValues);
- set(tmp);
- }
-
- return true;
- }
-
- @Override
- public boolean setConcat(_Original_Matrix a, _Original_Matrix b) {
- throw new UnsupportedOperationException("CALL TO PARENT FORBIDDEN");
- }
-
- /**
- * Preconcats the matrix with the specified translation.
- * M' = M * T(dx, dy)
- */
- @Override
- public boolean preTranslate(float dx, float dy) {
- // create a matrix that will be multiply by this
- Matrix m = new Matrix(new float[] { 1, 0, dx, 0, 1, dy, 0, 0, 1 });
- m.addTransform(this.mValues);
-
- System.arraycopy(m.mValues, 0, mValues, 0, 9);
- return true;
- }
-
- /**
- * Preconcats the matrix with the specified scale.
- * M' = M * S(sx, sy, px, py)
- */
- @Override
- public boolean preScale(float sx, float sy, float px, float py) {
- Matrix m = new Matrix();
- m.setScale(sx, sy, px, py);
- m.addTransform(mValues);
- set(m);
-
- return true;
- }
-
- /**
- * Preconcats the matrix with the specified scale.
- * M' = M * S(sx, sy)
- */
- @Override
- public boolean preScale(float sx, float sy) {
- Matrix m = new Matrix();
- m.setScale(sx, sy);
- m.addTransform(mValues);
- set(m);
-
- return true;
- }
-
- /**
- * Preconcats the matrix with the specified rotation.
- * M' = M * R(degrees, px, py)
- */
- @Override
- public boolean preRotate(float degrees, float px, float py) {
- Matrix m = new Matrix();
- m.setRotate(degrees, px, py);
- m.addTransform(mValues);
- set(m);
-
- return true;
- }
-
- /**
- * Preconcats the matrix with the specified rotation.
- * M' = M * R(degrees)
- */
- @Override
- public boolean preRotate(float degrees) {
- Matrix m = new Matrix();
- m.setRotate(degrees);
- m.addTransform(mValues);
- set(m);
-
- return true;
- }
-
- /**
- * Preconcats the matrix with the specified skew.
- * M' = M * K(kx, ky, px, py)
- */
- @Override
- public boolean preSkew(float kx, float ky, float px, float py) {
- Matrix m = new Matrix();
- m.setSkew(kx, ky, px, py);
- m.addTransform(mValues);
- set(m);
-
- return true;
- }
-
- /**
- * Preconcats the matrix with the specified skew.
- * M' = M * K(kx, ky)
- */
- @Override
- public boolean preSkew(float kx, float ky) {
- Matrix m = new Matrix();
- m.setSkew(kx, ky);
- m.addTransform(mValues);
- set(m);
-
- return true;
- }
-
- /**
- * Preconcats the matrix with the specified matrix.
- * M' = M * other
- */
- public boolean preConcat(Matrix other) {
- Matrix m = new Matrix(other);
- other.addTransform(mValues);
- set(m);
-
- return true;
- }
-
- @Override
- public boolean preConcat(_Original_Matrix other) {
- throw new UnsupportedOperationException("CALL TO PARENT FORBIDDEN");
- }
-
- /**
- * Postconcats the matrix with the specified translation.
- * M' = T(dx, dy) * M
- */
- @Override
- public boolean postTranslate(float dx, float dy) {
- addTransform(new float[] { 1, 0, dx, 0, 1, dy, 0, 0, 1 });
- return true;
- }
-
- /**
- * Postconcats the matrix with the specified scale.
- * M' = S(sx, sy, px, py) * M
- */
- @Override
- public boolean postScale(float sx, float sy, float px, float py) {
- // TODO: do it in one pass
- // translate so that the pivot is in 0,0
- addTransform(new float[] { 1, 0, -px, 0, 1, py, 0, 0, 1 });
- // scale
- addTransform(new float[] { sx, 0, 0, 0, sy, 0, 0, 0, 1 });
- // translate back the pivot
- addTransform(new float[] { 1, 0, px, 0, 1, py, 0, 0, 1 });
-
- return true;
- }
-
- /**
- * Postconcats the matrix with the specified scale.
- * M' = S(sx, sy) * M
- */
- @Override
- public boolean postScale(float sx, float sy) {
- addTransform(new float[] { sx, 0, 0, 0, sy, 0, 0, 0, 1 });
- return true;
- }
-
- /**
- * Postconcats the matrix with the specified rotation.
- * M' = R(degrees, px, py) * M
- */
- @Override
- public boolean postRotate(float degrees, float px, float py) {
- // TODO: do it in one pass
- // translate so that the pivot is in 0,0
- addTransform(new float[] { 1, 0, -px, 0, 1, py, 0, 0, 1 });
- // scale
- double rad = Math.toRadians(degrees);
- float cos = (float)Math.cos(rad);
- float sin = (float)Math.sin(rad);
- addTransform(new float[] { cos, -sin, 0, sin, cos, 0, 0, 0, 1 });
- // translate back the pivot
- addTransform(new float[] { 1, 0, px, 0, 1, py, 0, 0, 1 });
-
- return true;
- }
-
- /**
- * Postconcats the matrix with the specified rotation.
- * M' = R(degrees) * M
- */
- @Override
- public boolean postRotate(float degrees) {
- double rad = Math.toRadians(degrees);
- float cos = (float)Math.cos(rad);
- float sin = (float)Math.sin(rad);
- addTransform(new float[] { cos, -sin, 0, sin, cos, 0, 0, 0, 1 });
-
- return true;
- }
-
- /**
- * Postconcats the matrix with the specified skew.
- * M' = K(kx, ky, px, py) * M
- */
- @Override
- public boolean postSkew(float kx, float ky, float px, float py) {
- // TODO: do it in one pass
- // translate so that the pivot is in 0,0
- addTransform(new float[] { 1, 0, -px, 0, 1, py, 0, 0, 1 });
- // scale
- addTransform(new float[] { 1, kx, 0, ky, 1, 0, 0, 0, 1 });
- // translate back the pivot
- addTransform(new float[] { 1, 0, px, 0, 1, py, 0, 0, 1 });
-
- return true;
- }
-
- /**
- * Postconcats the matrix with the specified skew.
- * M' = K(kx, ky) * M
- */
- @Override
- public boolean postSkew(float kx, float ky) {
- addTransform(new float[] { 1, kx, 0, ky, 1, 0, 0, 0, 1 });
-
- return true;
- }
-
- /**
- * Postconcats the matrix with the specified matrix.
- * M' = other * M
- */
- public boolean postConcat(Matrix other) {
- addTransform(other.mValues);
-
- return true;
- }
-
- @Override
- public boolean postConcat(_Original_Matrix other) {
- throw new UnsupportedOperationException("CALL TO PARENT FORBIDDEN");
- }
-
- /** Controlls how the src rect should align into the dst rect for
- setRectToRect().
- */
- public enum ScaleToFit {
- /**
- * Scale in X and Y independently, so that src matches dst exactly.
- * This may change the aspect ratio of the src.
- */
- FILL (0),
- /**
- * Compute a scale that will maintain the original src aspect ratio,
- * but will also ensure that src fits entirely inside dst. At least one
- * axis (X or Y) will fit exactly. START aligns the result to the
- * left and top edges of dst.
- */
- START (1),
- /**
- * Compute a scale that will maintain the original src aspect ratio,
- * but will also ensure that src fits entirely inside dst. At least one
- * axis (X or Y) will fit exactly. The result is centered inside dst.
- */
- CENTER (2),
- /**
- * Compute a scale that will maintain the original src aspect ratio,
- * but will also ensure that src fits entirely inside dst. At least one
- * axis (X or Y) will fit exactly. END aligns the result to the
- * right and bottom edges of dst.
- */
- END (3);
-
- // the native values must match those in SkMatrix.h
- ScaleToFit(int nativeInt) {
- this.nativeInt = nativeInt;
- }
- final int nativeInt;
- }
-
- /**
- * Set the matrix to the scale and translate values that map the source
- * rectangle to the destination rectangle, returning true if the result
- * can be represented.
- *
- * @param src the source rectangle to map from.
- * @param dst the destination rectangle to map to.
- * @param stf the ScaleToFit option
- * @return true if the matrix can be represented by the rectangle mapping.
- */
- public boolean setRectToRect(RectF src, RectF dst, ScaleToFit stf) {
- if (dst == null || src == null) {
- throw new NullPointerException();
- }
-
- if (src.isEmpty()) {
- reset();
- return false;
- }
-
- if (dst.isEmpty()) {
- mValues[0] = mValues[1] = mValues[2] = mValues[3] = mValues[4] = mValues[5]
- = mValues[6] = mValues[7] = 0;
- mValues[8] = 1;
- } else {
- float tx, sx = dst.width() / src.width();
- float ty, sy = dst.height() / src.height();
- boolean xLarger = false;
-
- if (stf != ScaleToFit.FILL) {
- if (sx > sy) {
- xLarger = true;
- sx = sy;
- } else {
- sy = sx;
- }
- }
-
- tx = dst.left - src.left * sx;
- ty = dst.top - src.top * sy;
- if (stf == ScaleToFit.CENTER || stf == ScaleToFit.END) {
- float diff;
-
- if (xLarger) {
- diff = dst.width() - src.width() * sy;
- } else {
- diff = dst.height() - src.height() * sy;
- }
-
- if (stf == ScaleToFit.CENTER) {
- diff = diff / 2;
- }
-
- if (xLarger) {
- tx += diff;
- } else {
- ty += diff;
- }
- }
-
- mValues[0] = sx;
- mValues[4] = sy;
- mValues[2] = tx;
- mValues[5] = ty;
- mValues[1] = mValues[3] = mValues[6] = mValues[7] = 0;
-
- }
- // shared cleanup
- mValues[8] = 1;
- return true;
- }
-
- @Override
- public boolean setRectToRect(RectF src, RectF dst, _Original_Matrix.ScaleToFit stf) {
- throw new UnsupportedOperationException("CALL TO PARENT FORBIDDEN");
- }
-
- /**
- * Set the matrix such that the specified src points would map to the
- * specified dst points. The "points" are represented as an array of floats,
- * order [x0, y0, x1, y1, ...], where each "point" is 2 float values.
- *
- * @param src The array of src [x,y] pairs (points)
- * @param srcIndex Index of the first pair of src values
- * @param dst The array of dst [x,y] pairs (points)
- * @param dstIndex Index of the first pair of dst values
- * @param pointCount The number of pairs/points to be used. Must be [0..4]
- * @return true if the matrix was set to the specified transformation
- */
- @Override
- public boolean setPolyToPoly(float[] src, int srcIndex,
- float[] dst, int dstIndex,
- int pointCount) {
- if (pointCount > 4) {
- throw new IllegalArgumentException();
- }
- checkPointArrays(src, srcIndex, dst, dstIndex, pointCount);
- throw new UnsupportedOperationException("STUB NEEDED");
- }
-
- /**
- * If this matrix can be inverted, return true and if inverse is not null,
- * set inverse to be the inverse of this matrix. If this matrix cannot be
- * inverted, ignore inverse and return false.
- */
- public boolean invert(Matrix inverse) {
- if (inverse == null) {
- return false;
- }
-
- try {
- AffineTransform affineTransform = getTransform();
- AffineTransform inverseTransform = affineTransform.createInverse();
- inverse.mValues[0] = (float)inverseTransform.getScaleX();
- inverse.mValues[1] = (float)inverseTransform.getShearX();
- inverse.mValues[2] = (float)inverseTransform.getTranslateX();
- inverse.mValues[3] = (float)inverseTransform.getScaleX();
- inverse.mValues[4] = (float)inverseTransform.getShearY();
- inverse.mValues[5] = (float)inverseTransform.getTranslateY();
-
- return true;
- } catch (NoninvertibleTransformException e) {
- return false;
- }
- }
-
- @Override
- public boolean invert(_Original_Matrix inverse) {
- throw new UnsupportedOperationException("CALL TO PARENT FORBIDDEN");
- }
-
- /**
- * Apply this matrix to the array of 2D points specified by src, and write
- * the transformed points into the array of points specified by dst. The
- * two arrays represent their "points" as pairs of floats [x, y].
- *
- * @param dst The array of dst points (x,y pairs)
- * @param dstIndex The index of the first [x,y] pair of dst floats
- * @param src The array of src points (x,y pairs)
- * @param srcIndex The index of the first [x,y] pair of src floats
- * @param pointCount The number of points (x,y pairs) to transform
- */
- @Override
- public void mapPoints(float[] dst, int dstIndex, float[] src, int srcIndex,
- int pointCount) {
- checkPointArrays(src, srcIndex, dst, dstIndex, pointCount);
-
- for (int i = 0 ; i < pointCount ; i++) {
- // just in case we are doing in place, we better put this in temp vars
- float x = mValues[0] * src[i + srcIndex] +
- mValues[1] * src[i + srcIndex + 1] +
- mValues[2];
- float y = mValues[3] * src[i + srcIndex] +
- mValues[4] * src[i + srcIndex + 1] +
- mValues[5];
-
- dst[i + dstIndex] = x;
- dst[i + dstIndex + 1] = y;
- }
- }
-
- /**
- * Apply this matrix to the array of 2D vectors specified by src, and write
- * the transformed vectors into the array of vectors specified by dst. The
- * two arrays represent their "vectors" as pairs of floats [x, y].
- *
- * @param dst The array of dst vectors (x,y pairs)
- * @param dstIndex The index of the first [x,y] pair of dst floats
- * @param src The array of src vectors (x,y pairs)
- * @param srcIndex The index of the first [x,y] pair of src floats
- * @param vectorCount The number of vectors (x,y pairs) to transform
- */
- @Override
- public void mapVectors(float[] dst, int dstIndex, float[] src, int srcIndex,
- int vectorCount) {
- checkPointArrays(src, srcIndex, dst, dstIndex, vectorCount);
- throw new UnsupportedOperationException("STUB NEEDED");
- }
-
- /**
- * Apply this matrix to the array of 2D points specified by src, and write
- * the transformed points into the array of points specified by dst. The
- * two arrays represent their "points" as pairs of floats [x, y].
- *
- * @param dst The array of dst points (x,y pairs)
- * @param src The array of src points (x,y pairs)
- */
- @Override
- public void mapPoints(float[] dst, float[] src) {
- if (dst.length != src.length) {
- throw new ArrayIndexOutOfBoundsException();
- }
- mapPoints(dst, 0, src, 0, dst.length >> 1);
- }
-
- /**
- * Apply this matrix to the array of 2D vectors specified by src, and write
- * the transformed vectors into the array of vectors specified by dst. The
- * two arrays represent their "vectors" as pairs of floats [x, y].
- *
- * @param dst The array of dst vectors (x,y pairs)
- * @param src The array of src vectors (x,y pairs)
- */
- @Override
- public void mapVectors(float[] dst, float[] src) {
- if (dst.length != src.length) {
- throw new ArrayIndexOutOfBoundsException();
- }
- mapVectors(dst, 0, src, 0, dst.length >> 1);
- }
-
- /**
- * Apply this matrix to the array of 2D points, and write the transformed
- * points back into the array
- *
- * @param pts The array [x0, y0, x1, y1, ...] of points to transform.
- */
- @Override
- public void mapPoints(float[] pts) {
- mapPoints(pts, 0, pts, 0, pts.length >> 1);
- }
-
- /**
- * Apply this matrix to the array of 2D vectors, and write the transformed
- * vectors back into the array.
- * @param vecs The array [x0, y0, x1, y1, ...] of vectors to transform.
- */
- @Override
- public void mapVectors(float[] vecs) {
- mapVectors(vecs, 0, vecs, 0, vecs.length >> 1);
- }
-
- /**
- * Apply this matrix to the src rectangle, and write the transformed
- * rectangle into dst. This is accomplished by transforming the 4 corners of
- * src, and then setting dst to the bounds of those points.
- *
- * @param dst Where the transformed rectangle is written.
- * @param src The original rectangle to be transformed.
- * @return the result of calling rectStaysRect()
- */
- @Override
- public boolean mapRect(RectF dst, RectF src) {
- if (dst == null || src == null) {
- throw new NullPointerException();
- }
-
- // array with 4 corners
- float[] corners = new float[] {
- src.left, src.top,
- src.right, src.top,
- src.right, src.bottom,
- src.left, src.bottom,
- };
-
- // apply the transform to them.
- mapPoints(corners);
-
- // now put the result in the rect. We take the min/max of Xs and min/max of Ys
- dst.left = Math.min(Math.min(corners[0], corners[2]), Math.min(corners[4], corners[6]));
- dst.right = Math.max(Math.max(corners[0], corners[2]), Math.max(corners[4], corners[6]));
-
- dst.top = Math.min(Math.min(corners[1], corners[3]), Math.min(corners[5], corners[7]));
- dst.bottom = Math.max(Math.max(corners[1], corners[3]), Math.max(corners[5], corners[7]));
-
- return rectStaysRect();
- }
-
- /**
- * Apply this matrix to the rectangle, and write the transformed rectangle
- * back into it. This is accomplished by transforming the 4 corners of rect,
- * and then setting it to the bounds of those points
- *
- * @param rect The rectangle to transform.
- * @return the result of calling rectStaysRect()
- */
- @Override
- public boolean mapRect(RectF rect) {
- return mapRect(rect, rect);
- }
-
- /**
- * Return the mean radius of a circle after it has been mapped by
- * this matrix. NOTE: in perspective this value assumes the circle
- * has its center at the origin.
- */
- @Override
- public float mapRadius(float radius) {
- throw new UnsupportedOperationException("STUB NEEDED");
- }
-
- /** Copy 9 values from the matrix into the array.
- */
- @Override
- public void getValues(float[] values) {
- if (values.length < 9) {
- throw new ArrayIndexOutOfBoundsException();
- }
- System.arraycopy(mValues, 0, values, 0, mValues.length);
- }
-
- /** Copy 9 values from the array into the matrix.
- Depending on the implementation of Matrix, these may be
- transformed into 16.16 integers in the Matrix, such that
- a subsequent call to getValues() will not yield exactly
- the same values.
- */
- @Override
- public void setValues(float[] values) {
- if (values.length < 9) {
- throw new ArrayIndexOutOfBoundsException();
- }
- System.arraycopy(values, 0, mValues, 0, mValues.length);
- }
-
- @SuppressWarnings("unused")
- private final static int kIdentity_Mask = 0;
- private final static int kTranslate_Mask = 0x01; //!< set if the matrix has translation
- private final static int kScale_Mask = 0x02; //!< set if the matrix has X or Y scale
- private final static int kAffine_Mask = 0x04; //!< set if the matrix skews or rotates
- private final static int kPerspective_Mask = 0x08; //!< set if the matrix is in perspective
- private final static int kRectStaysRect_Mask = 0x10;
- @SuppressWarnings("unused")
- private final static int kUnknown_Mask = 0x80;
-
- @SuppressWarnings("unused")
- private final static int kAllMasks = kTranslate_Mask |
- kScale_Mask |
- kAffine_Mask |
- kPerspective_Mask |
- kRectStaysRect_Mask;
-
- // these guys align with the masks, so we can compute a mask from a variable 0/1
- @SuppressWarnings("unused")
- private final static int kTranslate_Shift = 0;
- @SuppressWarnings("unused")
- private final static int kScale_Shift = 1;
- @SuppressWarnings("unused")
- private final static int kAffine_Shift = 2;
- @SuppressWarnings("unused")
- private final static int kPerspective_Shift = 3;
- private final static int kRectStaysRect_Shift = 4;
-
- private int computeTypeMask() {
- int mask = 0;
-
- if (mValues[6] != 0. || mValues[7] != 0. || mValues[8] != 1.) {
- mask |= kPerspective_Mask;
- }
-
- if (mValues[2] != 0. || mValues[5] != 0.) {
- mask |= kTranslate_Mask;
- }
-
- float m00 = mValues[0];
- float m01 = mValues[1];
- float m10 = mValues[3];
- float m11 = mValues[4];
-
- if (m01 != 0. || m10 != 0.) {
- mask |= kAffine_Mask;
- }
-
- if (m00 != 1. || m11 != 1.) {
- mask |= kScale_Mask;
- }
-
- if ((mask & kPerspective_Mask) == 0) {
- // map non-zero to 1
- int im00 = m00 != 0 ? 1 : 0;
- int im01 = m01 != 0 ? 1 : 0;
- int im10 = m10 != 0 ? 1 : 0;
- int im11 = m11 != 0 ? 1 : 0;
-
- // record if the (p)rimary and (s)econdary diagonals are all 0 or
- // all non-zero (answer is 0 or 1)
- int dp0 = (im00 | im11) ^ 1; // true if both are 0
- int dp1 = im00 & im11; // true if both are 1
- int ds0 = (im01 | im10) ^ 1; // true if both are 0
- int ds1 = im01 & im10; // true if both are 1
-
- // return 1 if primary is 1 and secondary is 0 or
- // primary is 0 and secondary is 1
- mask |= ((dp0 & ds1) | (dp1 & ds0)) << kRectStaysRect_Shift;
- }
-
- return mask;
- }
-}
diff --git a/tools/layoutlib/bridge/src/android/graphics/Matrix_Delegate.java b/tools/layoutlib/bridge/src/android/graphics/Matrix_Delegate.java
new file mode 100644
index 0000000..ed2eff2
--- /dev/null
+++ b/tools/layoutlib/bridge/src/android/graphics/Matrix_Delegate.java
@@ -0,0 +1,1011 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.graphics;
+
+
+import com.android.layoutlib.bridge.DelegateManager;
+
+import android.graphics.Matrix.ScaleToFit;
+
+import java.awt.geom.AffineTransform;
+import java.awt.geom.NoninvertibleTransformException;
+
+/**
+ * Delegate implementing the native methods of android.graphics.Matrix
+ *
+ * Through the layoutlib_create tool, the original native methods of Matrix have been replaced
+ * by calls to methods of the same name in this delegate class.
+ *
+ * This class behaves like the original native implementation, but in Java, keeping previously
+ * native data into its own objects and mapping them to int that are sent back and forth between
+ * it and the original Matrix class.
+ *
+ * @see DelegateManager
+ *
+ */
+public final class Matrix_Delegate {
+
+ private final static int MATRIX_SIZE = 9;
+
+ // ---- delegate manager ----
+ private static final DelegateManager<Matrix_Delegate> sManager =
+ new DelegateManager<Matrix_Delegate>();
+
+ // ---- delegate data ----
+ private float mValues[] = new float[MATRIX_SIZE];
+
+ // ---- Public Helper methods ----
+
+ /**
+ * Returns an {@link AffineTransform} matching the given Matrix.
+ */
+ public static AffineTransform getAffineTransform(Matrix m) {
+ Matrix_Delegate delegate = sManager.getDelegate(m.native_instance);
+ if (delegate == null) {
+ assert false;
+ return null;
+ }
+
+ return getAffineTransform(delegate);
+ }
+
+ public static boolean hasPerspective(Matrix m) {
+ Matrix_Delegate delegate = sManager.getDelegate(m.native_instance);
+ if (delegate == null) {
+ assert false;
+ return false;
+ }
+
+ return (delegate.mValues[6] != 0 || delegate.mValues[7] != 0 || delegate.mValues[8] != 1);
+ }
+
+
+ // ---- native methods ----
+
+ public static int native_create(int native_src_or_zero) {
+ // create the delegate
+ Matrix_Delegate newDelegate = new Matrix_Delegate();
+
+ // copy from values if needed.
+ if (native_src_or_zero > 0) {
+ Matrix_Delegate oldDelegate = sManager.getDelegate(native_src_or_zero);
+ if (oldDelegate != null) {
+ System.arraycopy(
+ oldDelegate.mValues, 0,
+ newDelegate.mValues, 0,
+ MATRIX_SIZE);
+ }
+ }
+
+ return sManager.addDelegate(newDelegate);
+ }
+
+ public static boolean native_isIdentity(int native_object) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ for (int i = 0, k = 0; i < 3; i++) {
+ for (int j = 0; j < 3; j++, k++) {
+ if (d.mValues[k] != ((i==j) ? 1 : 0)) {
+ return false;
+ }
+ }
+ }
+
+ return true;
+ }
+
+ public static boolean native_rectStaysRect(int native_object) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return true;
+ }
+
+ return (d.computeTypeMask() & kRectStaysRect_Mask) != 0;
+ }
+
+ public static void native_reset(int native_object) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return;
+ }
+
+ reset(d.mValues);
+ }
+
+ public static void native_set(int native_object, int other) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return;
+ }
+
+ Matrix_Delegate src = sManager.getDelegate(other);
+ if (src == null) {
+ assert false;
+ return;
+ }
+
+ System.arraycopy(src.mValues, 0, d.mValues, 0, MATRIX_SIZE);
+ }
+
+ public static void native_setTranslate(int native_object, float dx, float dy) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return;
+ }
+
+ setTranslate(d.mValues, dx, dy);
+ }
+
+ public static void native_setScale(int native_object, float sx, float sy, float px, float py) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return;
+ }
+
+ d.mValues = getScale(sx, sy, px, py);
+ }
+
+ public static void native_setScale(int native_object, float sx, float sy) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return;
+ }
+
+ d.mValues[0] = sx;
+ d.mValues[1] = 0;
+ d.mValues[2] = 0;
+ d.mValues[3] = 0;
+ d.mValues[4] = sy;
+ d.mValues[5] = 0;
+ d.mValues[6] = 0;
+ d.mValues[7] = 0;
+ d.mValues[8] = 1;
+ }
+
+ public static void native_setRotate(int native_object, float degrees, float px, float py) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return;
+ }
+
+ d.mValues = getRotate(degrees, px, py);
+ }
+
+ public static void native_setRotate(int native_object, float degrees) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return;
+ }
+
+ setRotate(d.mValues, degrees);
+ }
+
+ public static void native_setSinCos(int native_object, float sinValue, float cosValue,
+ float px, float py) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return;
+ }
+
+ // TODO: do it in one pass
+
+ // translate so that the pivot is in 0,0
+ setTranslate(d.mValues, -px, -py);
+
+ // scale
+ d.postTransform(getRotate(sinValue, cosValue));
+ // translate back the pivot
+ d.postTransform(getTranslate(px, py));
+ }
+
+ public static void native_setSinCos(int native_object, float sinValue, float cosValue) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return;
+ }
+
+ setRotate(d.mValues, sinValue, cosValue);
+ }
+
+ public static void native_setSkew(int native_object, float kx, float ky, float px, float py) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return;
+ }
+
+ d.mValues = getSkew(kx, ky, px, py);
+ }
+
+ public static void native_setSkew(int native_object, float kx, float ky) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return;
+ }
+
+ d.mValues[0] = 1;
+ d.mValues[1] = kx;
+ d.mValues[2] = -0;
+ d.mValues[3] = ky;
+ d.mValues[4] = 1;
+ d.mValues[5] = 0;
+ d.mValues[6] = 0;
+ d.mValues[7] = 0;
+ d.mValues[8] = 1;
+ }
+
+ public static boolean native_setConcat(int native_object, int a, int b) {
+ if (a == native_object) {
+ return native_preConcat(native_object, b);
+ } else if (b == native_object) {
+ return native_postConcat(native_object, a);
+ }
+
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ Matrix_Delegate a_mtx = sManager.getDelegate(a);
+ if (a_mtx == null) {
+ assert false;
+ return false;
+ }
+
+ Matrix_Delegate b_mtx = sManager.getDelegate(b);
+ if (b_mtx == null) {
+ assert false;
+ return false;
+ }
+
+ multiply(d.mValues, a_mtx.mValues, b_mtx.mValues);
+
+ return true;
+ }
+
+ public static boolean native_preTranslate(int native_object, float dx, float dy) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ d.preTransform(getTranslate(dx, dy));
+ return true;
+ }
+
+ public static boolean native_preScale(int native_object, float sx, float sy,
+ float px, float py) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ d.preTransform(getScale(sx, sy, px, py));
+ return true;
+ }
+
+ public static boolean native_preScale(int native_object, float sx, float sy) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ d.preTransform(getScale(sx, sy));
+ return true;
+ }
+
+ public static boolean native_preRotate(int native_object, float degrees, float px, float py) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ d.preTransform(getRotate(degrees, px, py));
+ return true;
+ }
+
+ public static boolean native_preRotate(int native_object, float degrees) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ double rad = Math.toRadians(degrees);
+ float sin = (float)Math.sin(rad);
+ float cos = (float)Math.cos(rad);
+
+ d.preTransform(getRotate(sin, cos));
+ return true;
+ }
+
+ public static boolean native_preSkew(int native_object, float kx, float ky,
+ float px, float py) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ d.preTransform(getSkew(kx, ky, px, py));
+ return true;
+ }
+
+ public static boolean native_preSkew(int native_object, float kx, float ky) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ d.preTransform(getSkew(kx, ky));
+ return true;
+ }
+
+ public static boolean native_preConcat(int native_object, int other_matrix) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ Matrix_Delegate other = sManager.getDelegate(other_matrix);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ d.preTransform(other.mValues);
+ return true;
+ }
+
+ public static boolean native_postTranslate(int native_object, float dx, float dy) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ d.postTransform(getTranslate(dx, dy));
+ return true;
+ }
+
+ public static boolean native_postScale(int native_object, float sx, float sy,
+ float px, float py) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ d.postTransform(getScale(sx, sy, px, py));
+ return true;
+ }
+
+ public static boolean native_postScale(int native_object, float sx, float sy) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ d.postTransform(getScale(sx, sy));
+ return true;
+ }
+
+ public static boolean native_postRotate(int native_object, float degrees, float px, float py) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ d.preTransform(getRotate(degrees, px, py));
+ return true;
+ }
+
+ public static boolean native_postRotate(int native_object, float degrees) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ d.postTransform(getRotate(degrees));
+ return true;
+ }
+
+ public static boolean native_postSkew(int native_object, float kx, float ky,
+ float px, float py) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ d.postTransform(getSkew(kx, ky, px, py));
+ return true;
+ }
+
+ public static boolean native_postSkew(int native_object, float kx, float ky) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ d.postTransform(getSkew(kx, ky));
+ return true;
+ }
+
+ public static boolean native_postConcat(int native_object, int other_matrix) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ Matrix_Delegate other = sManager.getDelegate(other_matrix);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ d.postTransform(other.mValues);
+ return true;
+ }
+
+ public static boolean native_setRectToRect(int native_object, RectF src, RectF dst, int stf) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ if (src.isEmpty()) {
+ reset(d.mValues);
+ return false;
+ }
+
+ if (dst.isEmpty()) {
+ d.mValues[0] = d.mValues[1] = d.mValues[2] = d.mValues[3] = d.mValues[4] = d.mValues[5]
+ = d.mValues[6] = d.mValues[7] = 0;
+ d.mValues[8] = 1;
+ } else {
+ float tx, sx = dst.width() / src.width();
+ float ty, sy = dst.height() / src.height();
+ boolean xLarger = false;
+
+ if (stf != ScaleToFit.FILL.nativeInt) {
+ if (sx > sy) {
+ xLarger = true;
+ sx = sy;
+ } else {
+ sy = sx;
+ }
+ }
+
+ tx = dst.left - src.left * sx;
+ ty = dst.top - src.top * sy;
+ if (stf == ScaleToFit.CENTER.nativeInt || stf == ScaleToFit.END.nativeInt) {
+ float diff;
+
+ if (xLarger) {
+ diff = dst.width() - src.width() * sy;
+ } else {
+ diff = dst.height() - src.height() * sy;
+ }
+
+ if (stf == ScaleToFit.CENTER.nativeInt) {
+ diff = diff / 2;
+ }
+
+ if (xLarger) {
+ tx += diff;
+ } else {
+ ty += diff;
+ }
+ }
+
+ d.mValues[0] = sx;
+ d.mValues[4] = sy;
+ d.mValues[2] = tx;
+ d.mValues[5] = ty;
+ d.mValues[1] = d.mValues[3] = d.mValues[6] = d.mValues[7] = 0;
+
+ }
+ // shared cleanup
+ d.mValues[8] = 1;
+ return true;
+ }
+
+ public static boolean native_setPolyToPoly(int native_object, float[] src, int srcIndex,
+ float[] dst, int dstIndex, int pointCount) {
+ // FIXME
+ throw new UnsupportedOperationException("NATIVE DELEGATE NEEDED");
+ }
+
+ public static boolean native_invert(int native_object, int inverse) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ Matrix_Delegate inv_mtx = sManager.getDelegate(inverse);
+ if (inv_mtx == null) {
+ assert false;
+ return false;
+ }
+
+
+ try {
+ AffineTransform affineTransform = getAffineTransform(d);
+ AffineTransform inverseTransform = affineTransform.createInverse();
+ inv_mtx.mValues[0] = (float)inverseTransform.getScaleX();
+ inv_mtx.mValues[1] = (float)inverseTransform.getShearX();
+ inv_mtx.mValues[2] = (float)inverseTransform.getTranslateX();
+ inv_mtx.mValues[3] = (float)inverseTransform.getScaleX();
+ inv_mtx.mValues[4] = (float)inverseTransform.getShearY();
+ inv_mtx.mValues[5] = (float)inverseTransform.getTranslateY();
+
+ return true;
+ } catch (NoninvertibleTransformException e) {
+ return false;
+ }
+ }
+
+ public static void native_mapPoints(int native_object, float[] dst, int dstIndex,
+ float[] src, int srcIndex, int ptCount, boolean isPts) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return;
+ }
+
+ if (isPts) {
+ d.mapPoints(dst, dstIndex, src, srcIndex, ptCount);
+ } else {
+ // src is vectors
+ // FIXME
+ throw new UnsupportedOperationException("NATIVE DELEGATE NEEDED");
+ }
+ }
+
+ public static boolean native_mapRect(int native_object, RectF dst, RectF src) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return false;
+ }
+
+ // array with 4 corners
+ float[] corners = new float[] {
+ src.left, src.top,
+ src.right, src.top,
+ src.right, src.bottom,
+ src.left, src.bottom,
+ };
+
+ // apply the transform to them.
+ d.mapPoints(corners);
+
+ // now put the result in the rect. We take the min/max of Xs and min/max of Ys
+ dst.left = Math.min(Math.min(corners[0], corners[2]), Math.min(corners[4], corners[6]));
+ dst.right = Math.max(Math.max(corners[0], corners[2]), Math.max(corners[4], corners[6]));
+
+ dst.top = Math.min(Math.min(corners[1], corners[3]), Math.min(corners[5], corners[7]));
+ dst.bottom = Math.max(Math.max(corners[1], corners[3]), Math.max(corners[5], corners[7]));
+
+
+ return (d.computeTypeMask() & kRectStaysRect_Mask) != 0;
+ }
+
+ public static float native_mapRadius(int native_object, float radius) {
+ // FIXME
+ throw new UnsupportedOperationException();
+ }
+
+ public static void native_getValues(int native_object, float[] values) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return;
+ }
+
+ System.arraycopy(d.mValues, 0, d.mValues, 0, MATRIX_SIZE);
+ }
+
+ public static void native_setValues(int native_object, float[] values) {
+ Matrix_Delegate d = sManager.getDelegate(native_object);
+ if (d == null) {
+ assert false;
+ return;
+ }
+
+ System.arraycopy(values, 0, d.mValues, 0, MATRIX_SIZE);
+ }
+
+ public static boolean native_equals(int native_a, int native_b) {
+ Matrix_Delegate a = sManager.getDelegate(native_a);
+ if (a == null) {
+ assert false;
+ return false;
+ }
+
+ Matrix_Delegate b = sManager.getDelegate(native_b);
+ if (b == null) {
+ assert false;
+ return false;
+ }
+
+ for (int i = 0 ; i < MATRIX_SIZE ; i++) {
+ if (a.mValues[i] != b.mValues[i]) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ public static void finalizer(int native_instance) {
+ sManager.removeDelegate(native_instance);
+ }
+
+ // ---- Private helper methods ----
+
+ private static AffineTransform getAffineTransform(Matrix_Delegate d) {
+ // the AffineTransform constructor takes the value in a different order
+ // for a matrix [ 0 1 2 ]
+ // [ 3 4 5 ]
+ // the order is 0, 3, 1, 4, 2, 5...
+ return new AffineTransform(
+ d.mValues[0], d.mValues[3], d.mValues[1],
+ d.mValues[4], d.mValues[2], d.mValues[5]);
+ }
+
+
+ /**
+ * Reset a matrix to the identity
+ */
+ private static void reset(float[] mtx) {
+ for (int i = 0, k = 0; i < 3; i++) {
+ for (int j = 0; j < 3; j++, k++) {
+ mtx[k] = ((i==j) ? 1 : 0);
+ }
+ }
+ }
+
+ @SuppressWarnings("unused")
+ private final static int kIdentity_Mask = 0;
+ private final static int kTranslate_Mask = 0x01; //!< set if the matrix has translation
+ private final static int kScale_Mask = 0x02; //!< set if the matrix has X or Y scale
+ private final static int kAffine_Mask = 0x04; //!< set if the matrix skews or rotates
+ private final static int kPerspective_Mask = 0x08; //!< set if the matrix is in perspective
+ private final static int kRectStaysRect_Mask = 0x10;
+ @SuppressWarnings("unused")
+ private final static int kUnknown_Mask = 0x80;
+
+ @SuppressWarnings("unused")
+ private final static int kAllMasks = kTranslate_Mask |
+ kScale_Mask |
+ kAffine_Mask |
+ kPerspective_Mask |
+ kRectStaysRect_Mask;
+
+ // these guys align with the masks, so we can compute a mask from a variable 0/1
+ @SuppressWarnings("unused")
+ private final static int kTranslate_Shift = 0;
+ @SuppressWarnings("unused")
+ private final static int kScale_Shift = 1;
+ @SuppressWarnings("unused")
+ private final static int kAffine_Shift = 2;
+ @SuppressWarnings("unused")
+ private final static int kPerspective_Shift = 3;
+ private final static int kRectStaysRect_Shift = 4;
+
+ private int computeTypeMask() {
+ int mask = 0;
+
+ if (mValues[6] != 0. || mValues[7] != 0. || mValues[8] != 1.) {
+ mask |= kPerspective_Mask;
+ }
+
+ if (mValues[2] != 0. || mValues[5] != 0.) {
+ mask |= kTranslate_Mask;
+ }
+
+ float m00 = mValues[0];
+ float m01 = mValues[1];
+ float m10 = mValues[3];
+ float m11 = mValues[4];
+
+ if (m01 != 0. || m10 != 0.) {
+ mask |= kAffine_Mask;
+ }
+
+ if (m00 != 1. || m11 != 1.) {
+ mask |= kScale_Mask;
+ }
+
+ if ((mask & kPerspective_Mask) == 0) {
+ // map non-zero to 1
+ int im00 = m00 != 0 ? 1 : 0;
+ int im01 = m01 != 0 ? 1 : 0;
+ int im10 = m10 != 0 ? 1 : 0;
+ int im11 = m11 != 0 ? 1 : 0;
+
+ // record if the (p)rimary and (s)econdary diagonals are all 0 or
+ // all non-zero (answer is 0 or 1)
+ int dp0 = (im00 | im11) ^ 1; // true if both are 0
+ int dp1 = im00 & im11; // true if both are 1
+ int ds0 = (im01 | im10) ^ 1; // true if both are 0
+ int ds1 = im01 & im10; // true if both are 1
+
+ // return 1 if primary is 1 and secondary is 0 or
+ // primary is 0 and secondary is 1
+ mask |= ((dp0 & ds1) | (dp1 & ds0)) << kRectStaysRect_Shift;
+ }
+
+ return mask;
+ }
+
+ /**
+ * Adds the given transformation to the current Matrix
+ * <p/>This in effect does this = this*matrix
+ * @param matrix
+ */
+ private void postTransform(float[] matrix) {
+ float[] tmp = new float[9];
+ multiply(tmp, mValues, matrix);
+ mValues = tmp;
+ }
+
+ /**
+ * Adds the given transformation to the current Matrix
+ * <p/>This in effect does this = matrix*this
+ * @param matrix
+ */
+ private void preTransform(float[] matrix) {
+ float[] tmp = new float[9];
+ multiply(tmp, matrix, mValues);
+ mValues = tmp;
+ }
+
+ /**
+ * Apply this matrix to the array of 2D points specified by src, and write
+ * the transformed points into the array of points specified by dst. The
+ * two arrays represent their "points" as pairs of floats [x, y].
+ *
+ * @param dst The array of dst points (x,y pairs)
+ * @param dstIndex The index of the first [x,y] pair of dst floats
+ * @param src The array of src points (x,y pairs)
+ * @param srcIndex The index of the first [x,y] pair of src floats
+ * @param pointCount The number of points (x,y pairs) to transform
+ */
+
+ private void mapPoints(float[] dst, int dstIndex, float[] src, int srcIndex,
+ int pointCount) {
+ //checkPointArrays(src, srcIndex, dst, dstIndex, pointCount);
+
+ float[] tmpDest = dst;
+ boolean inPlace = dst == src;
+ if (inPlace) {
+ tmpDest = new float[dstIndex + pointCount * 2];
+ }
+
+ for (int i = 0 ; i < pointCount ; i++) {
+ // just in case we are doing in place, we better put this in temp vars
+ float x = mValues[0] * src[i + srcIndex] +
+ mValues[1] * src[i + srcIndex + 1] +
+ mValues[2];
+ float y = mValues[3] * src[i + srcIndex] +
+ mValues[4] * src[i + srcIndex + 1] +
+ mValues[5];
+
+ tmpDest[i + dstIndex] = x;
+ tmpDest[i + dstIndex + 1] = y;
+ }
+
+ if (inPlace) {
+ System.arraycopy(tmpDest, dstIndex, dst, dstIndex, pointCount * 2);
+ }
+ }
+
+ /**
+ * Apply this matrix to the array of 2D points, and write the transformed
+ * points back into the array
+ *
+ * @param pts The array [x0, y0, x1, y1, ...] of points to transform.
+ */
+
+ private void mapPoints(float[] pts) {
+ mapPoints(pts, 0, pts, 0, pts.length >> 1);
+ }
+
+ /**
+ * multiply two matrices and store them in a 3rd.
+ * <p/>This in effect does dest = a*b
+ * dest cannot be the same as a or b.
+ */
+ private static void multiply(float dest[], float[] a, float[] b) {
+ // first row
+ dest[0] = b[0] * a[0] + b[1] * a[3] + b[2] * a[6];
+ dest[1] = b[0] * a[1] + b[1] * a[4] + b[2] * a[7];
+ dest[2] = b[0] * a[2] + b[1] * a[5] + b[2] * a[8];
+
+ // 2nd row
+ dest[3] = b[3] * a[0] + b[4] * a[3] + b[5] * a[6];
+ dest[4] = b[3] * a[1] + b[4] * a[4] + b[5] * a[7];
+ dest[5] = b[3] * a[2] + b[4] * a[5] + b[5] * a[8];
+
+ // 3rd row
+ dest[6] = b[6] * a[0] + b[7] * a[3] + b[8] * a[6];
+ dest[7] = b[6] * a[1] + b[7] * a[4] + b[8] * a[7];
+ dest[8] = b[6] * a[2] + b[7] * a[5] + b[8] * a[8];
+ }
+
+ /**
+ * Returns a matrix that represents a given translate
+ * @param dx
+ * @param dy
+ * @return
+ */
+ private static float[] getTranslate(float dx, float dy) {
+ return setTranslate(new float[9], dx, dy);
+ }
+
+ private static float[] setTranslate(float[] dest, float dx, float dy) {
+ dest[0] = 1;
+ dest[1] = 0;
+ dest[2] = dx;
+ dest[3] = 0;
+ dest[4] = 1;
+ dest[5] = dy;
+ dest[6] = 0;
+ dest[7] = 0;
+ dest[8] = 1;
+ return dest;
+ }
+
+ private static float[] getScale(float sx, float sy) {
+ return new float[] { sx, 0, 0, 0, sy, 0, 0, 0, 1 };
+ }
+
+ /**
+ * Returns a matrix that represents the given scale info.
+ * @param sx
+ * @param sy
+ * @param px
+ * @param py
+ */
+ private static float[] getScale(float sx, float sy, float px, float py) {
+ float[] tmp = new float[9];
+ float[] tmp2 = new float[9];
+
+ // TODO: do it in one pass
+
+ // translate tmp so that the pivot is in 0,0
+ setTranslate(tmp, -px, -py);
+
+ // scale into tmp2
+ multiply(tmp2, tmp, getScale(sx, sy));
+
+ // translate back the pivot back into tmp
+ multiply(tmp, tmp2, getTranslate(px, py));
+
+ return tmp;
+ }
+
+
+ private static float[] getRotate(float degrees) {
+ double rad = Math.toRadians(degrees);
+ float sin = (float)Math.sin(rad);
+ float cos = (float)Math.cos(rad);
+
+ return getRotate(sin, cos);
+ }
+
+ private static float[] getRotate(float sin, float cos) {
+ return setRotate(new float[9], sin, cos);
+ }
+
+ private static float[] setRotate(float[] dest, float degrees) {
+ double rad = Math.toRadians(degrees);
+ float sin = (float)Math.sin(rad);
+ float cos = (float)Math.cos(rad);
+
+ return setRotate(dest, sin, cos);
+ }
+
+ private static float[] setRotate(float[] dest, float sin, float cos) {
+ dest[0] = cos;
+ dest[1] = -sin;
+ dest[2] = 0;
+ dest[3] = sin;
+ dest[4] = cos;
+ dest[5] = 0;
+ dest[6] = 0;
+ dest[7] = 0;
+ dest[8] = 1;
+ return dest;
+ }
+
+ private static float[] getRotate(float degrees, float px, float py) {
+ float[] tmp = new float[9];
+ float[] tmp2 = new float[9];
+
+ // TODO: do it in one pass
+
+ // translate so that the pivot is in 0,0
+ setTranslate(tmp, -px, -py);
+
+ // rotate into tmp2
+ double rad = Math.toRadians(degrees);
+ float cos = (float)Math.cos(rad);
+ float sin = (float)Math.sin(rad);
+ multiply(tmp2, tmp, getRotate(sin, cos));
+
+ // translate back the pivot back into tmp
+ multiply(tmp, tmp2, getTranslate(px, py));
+
+ return tmp;
+ }
+
+ private static float[] getSkew(float kx, float ky) {
+ return new float[] { 1, kx, 0, ky, 1, 0, 0, 0, 1 };
+ }
+
+ private static float[] getSkew(float kx, float ky, float px, float py) {
+ float[] tmp = new float[9];
+ float[] tmp2 = new float[9];
+
+ // TODO: do it in one pass
+
+ // translate so that the pivot is in 0,0
+ setTranslate(tmp, -px, -py);
+
+ // skew into tmp2
+ multiply(tmp2, tmp, new float[] { 1, kx, 0, ky, 1, 0, 0, 0, 1 });
+ // translate back the pivot back into tmp
+ multiply(tmp, tmp2, getTranslate(px, py));
+
+ return tmp;
+ }
+
+
+}
diff --git a/tools/layoutlib/bridge/src/android/graphics/Path.java b/tools/layoutlib/bridge/src/android/graphics/Path.java
index 12d2cde..c0bc005 100644
--- a/tools/layoutlib/bridge/src/android/graphics/Path.java
+++ b/tools/layoutlib/bridge/src/android/graphics/Path.java
@@ -31,13 +31,13 @@
* text on a path.
*/
public class Path {
-
+
private FillType mFillType = FillType.WINDING;
private GeneralPath mPath = new GeneralPath();
-
+
private float mLastX = 0;
private float mLastY = 0;
-
+
//---------- Custom methods ----------
public Shape getAwtShape() {
@@ -60,7 +60,7 @@
public Path(Path src) {
mPath.append(src.mPath, false /* connect */);
}
-
+
/**
* Clear any lines and curves from the path, making it empty.
* This does NOT change the fill-type setting.
@@ -92,7 +92,7 @@
EVEN_ODD (GeneralPath.WIND_EVEN_ODD, false),
INVERSE_WINDING (GeneralPath.WIND_NON_ZERO, true),
INVERSE_EVEN_ODD(GeneralPath.WIND_EVEN_ODD, true);
-
+
FillType(int rule, boolean inverse) {
this.rule = rule;
this.inverse = inverse;
@@ -101,7 +101,7 @@
final int rule;
final boolean inverse;
}
-
+
/**
* Return the path's fill type. This defines how "inside" is
* computed. The default value is WINDING.
@@ -121,7 +121,7 @@
mFillType = ft;
mPath.setWindingRule(ft.rule);
}
-
+
/**
* Returns true if the filltype is one of the INVERSE variants
*
@@ -130,7 +130,7 @@
public boolean isInverseFillType() {
return mFillType.inverse;
}
-
+
/**
* Toggles the INVERSE state of the filltype
*/
@@ -150,7 +150,7 @@
break;
}
}
-
+
/**
* Returns true if the path is empty (contains no lines or curves)
*
@@ -350,7 +350,7 @@
boolean forceMoveTo) {
throw new UnsupportedOperationException();
}
-
+
/**
* Append the specified arc to the path as a new contour. If the start of
* the path is different from the path's current last point, then an
@@ -365,7 +365,7 @@
public void arcTo(RectF oval, float startAngle, float sweepAngle) {
throw new UnsupportedOperationException();
}
-
+
/**
* Close the current contour. If the current point is not equal to the
* first point of the contour, a line segment is automatically added.
@@ -383,13 +383,13 @@
CW (0), // must match enum in SkPath.h
/** counter-clockwise */
CCW (1); // must match enum in SkPath.h
-
+
Direction(int ni) {
nativeInt = ni;
}
final int nativeInt;
}
-
+
/**
* Add a closed rectangle contour to the path
*
@@ -400,7 +400,7 @@
if (rect == null) {
throw new NullPointerException("need rect parameter");
}
-
+
addRect(rect.left, rect.top, rect.right, rect.bottom, dir);
}
@@ -446,7 +446,7 @@
// FIXME Need to support direction
Ellipse2D ovalShape = new Ellipse2D.Float(oval.left, oval.top, oval.width(), oval.height());
-
+
mPath.append(ovalShape, false /* connect */);
}
@@ -493,7 +493,7 @@
// FIXME
throw new UnsupportedOperationException();
}
-
+
/**
* Add a closed round-rectangle contour to the path. Each corner receives
* two radius values [X, Y]. The corners are ordered top-left, top-right,
@@ -513,7 +513,7 @@
// FIXME
throw new UnsupportedOperationException();
}
-
+
/**
* Add a copy of src to the path, offset by (dx,dy)
*
@@ -554,11 +554,11 @@
*/
public void offset(float dx, float dy, Path dst) {
GeneralPath newPath = new GeneralPath();
-
+
PathIterator iterator = mPath.getPathIterator(new AffineTransform(0, 0, dx, 0, 0, dy));
-
+
newPath.append(iterator, false /* connect */);
-
+
if (dst != null) {
dst.mPath = newPath;
} else {
diff --git a/tools/layoutlib/bridge/src/com/android/layoutlib/bridge/DelegateManager.java b/tools/layoutlib/bridge/src/com/android/layoutlib/bridge/DelegateManager.java
new file mode 100644
index 0000000..3d9f960
--- /dev/null
+++ b/tools/layoutlib/bridge/src/com/android/layoutlib/bridge/DelegateManager.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.layoutlib.bridge;
+
+import android.util.SparseArray;
+
+/**
+ * Manages native delegates.
+ *
+ * This is used in conjunction with layoublib_create: certain Android java classes are mere
+ * wrappers around a heavily native based implementation, and we need a way to run these classes
+ * in our Eclipse rendering framework without bringing all the native code from the Android
+ * platform.
+ *
+ * Thus we instruct layoutlib_create to modify the bytecode of these classes to replace their
+ * native methods by "delegate calls".
+ *
+ * For example, a native method android.graphics.Matrix.init(...) will actually become
+ * a call to android.graphics.Matrix_Delegate.init(...).
+ *
+ * The Android java classes that use native code uses an int (Java side) to reference native
+ * objects. This int is generally directly the pointer to the C structure counterpart.
+ * Typically a creation method will return such an int, and then this int will be passed later
+ * to a Java method to identify the C object to manipulate.
+ *
+ * Since we cannot use the Java object reference as the int directly, DelegateManager manages the
+ * int -> Delegate class link.
+ *
+ * Native methods usually always have the int as parameters. The first thing the delegate method
+ * will do is call {@link #getDelegate(int)} to get the Java object matching the int.
+ *
+ * Typical native init methods are returning a new int back to the Java class, so
+ * {@link #addDelegate(Object)} does the same.
+ *
+ * @param <T> the delegate class to manage
+ */
+public final class DelegateManager<T> {
+
+ private final SparseArray<T> mDelegates = new SparseArray<T>();
+ private int mDelegateCounter = 0;
+
+ /**
+ * Returns the delegate from the given native int.
+ * @param native_object the native int.
+ * @return the delegate or null if not found.
+ */
+ public T getDelegate(int native_object) {
+ synchronized (mDelegates) {
+ return mDelegates.get(native_object);
+ }
+ }
+
+ /**
+ * Adds a delegate to the manager and returns the native int used to identify it.
+ * @param newDelegate the delegate to add
+ * @return a unique native int to identify the delegate
+ */
+ public int addDelegate(T newDelegate) {
+ synchronized (mDelegates) {
+ int native_object = ++mDelegateCounter;
+ mDelegates.put(native_object, newDelegate);
+ return native_object;
+ }
+ }
+
+ /**
+ * Removes the delegate matching the given native int.
+ * @param native_object the native int.
+ */
+ public void removeDelegate(int native_object) {
+ synchronized (mDelegates) {
+ mDelegates.remove(native_object);
+ }
+ }
+}
diff --git a/tools/layoutlib/bridge/tests/com/android/layoutlib/bridge/TestNativeDelegate.java b/tools/layoutlib/bridge/tests/com/android/layoutlib/bridge/TestNativeDelegate.java
new file mode 100644
index 0000000..6eed8ba
--- /dev/null
+++ b/tools/layoutlib/bridge/tests/com/android/layoutlib/bridge/TestNativeDelegate.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.layoutlib.bridge;
+
+import com.android.tools.layoutlib.annotations.LayoutlibDelegate;
+import com.android.tools.layoutlib.create.CreateInfo;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+import junit.framework.TestCase;
+
+/**
+ * Tests that native delegate classes implement all the required methods.
+ *
+ * This looks at {@link CreateInfo#DELEGATE_CLASS_NATIVES} to get the list of classes that
+ * have their native methods reimplemented through a delegate.
+ *
+ * Since the reimplemented methods are not native anymore, we look for the annotation
+ * {@link LayoutlibDelegate}, and look for a matching method in the delegate (named the same
+ * as the modified class with _Delegate added as a suffix).
+ * If the original native method is not static, then we make sure the delegate method also
+ * include the original class as first parameter (to access "this").
+ *
+ */
+public class TestNativeDelegate extends TestCase {
+
+ public void testNativeDelegates() {
+
+ final String[] classes = CreateInfo.DELEGATE_CLASS_NATIVES;
+ final int count = classes.length;
+ for (int i = 0 ; i < count ; i++) {
+ loadAndCompareClasses(classes[i], classes[i] + "_Delegate");
+ }
+ }
+
+ private void loadAndCompareClasses(String originalClassName, String delegateClassName) {
+ // load the classes
+ try {
+ ClassLoader classLoader = TestNativeDelegate.class.getClassLoader();
+ Class<?> originalClass = classLoader.loadClass(originalClassName);
+ Class<?> delegateClass = classLoader.loadClass(delegateClassName);
+
+ compare(originalClass, delegateClass);
+ } catch (ClassNotFoundException e) {
+ fail("Failed to load class: " + e.getMessage());
+ } catch (SecurityException e) {
+ fail("Failed to load class: " + e.getMessage());
+ }
+ }
+
+ private void compare(Class<?> originalClass, Class<?> delegateClass) throws SecurityException {
+ Method[] originalMethods = originalClass.getDeclaredMethods();
+
+ for (Method originalMethod : originalMethods) {
+ // look for methods that were native: they have the LayoutlibDelegate annotation
+ if (originalMethod.getAnnotation(LayoutlibDelegate.class) == null) {
+ continue;
+ }
+
+ // get the signature.
+ Class<?>[] parameters = originalMethod.getParameterTypes();
+
+ // if the method is not static, then the class is added as the first parameter
+ // (for "this")
+ if ((originalMethod.getModifiers() & Modifier.STATIC) == 0) {
+
+ Class<?>[] newParameters = new Class<?>[parameters.length + 1];
+ newParameters[0] = originalClass;
+ System.arraycopy(parameters, 0, newParameters, 1, parameters.length);
+ parameters = newParameters;
+ }
+
+ try {
+ // try to load the method with the given parameter types.
+ delegateClass.getMethod(originalMethod.getName(), parameters);
+ } catch (NoSuchMethodException e) {
+ // compute a full class name that's long but not too long.
+ StringBuilder sb = new StringBuilder(originalMethod.getName() + "(");
+ for (int j = 0; j < parameters.length; j++) {
+ Class<?> theClass = parameters[j];
+ sb.append(theClass.getName());
+ int dimensions = 0;
+ while (theClass.isArray()) {
+ dimensions++;
+ theClass = theClass.getComponentType();
+ }
+ for (int i = 0; i < dimensions; i++) {
+ sb.append("[]");
+ }
+ if (j < (parameters.length - 1)) {
+ sb.append(",");
+ }
+ }
+ sb.append(")");
+
+ fail(String.format("Missing %1$s.%2$s", delegateClass.getName(), sb.toString()));
+ }
+ }
+ }
+}
diff --git a/tools/layoutlib/create/src/com/android/tools/layoutlib/create/CreateInfo.java b/tools/layoutlib/create/src/com/android/tools/layoutlib/create/CreateInfo.java
index 92892784..2d0ee6d 100644
--- a/tools/layoutlib/create/src/com/android/tools/layoutlib/create/CreateInfo.java
+++ b/tools/layoutlib/create/src/com/android/tools/layoutlib/create/CreateInfo.java
@@ -16,6 +16,8 @@
package com.android.tools.layoutlib.create;
+import com.android.tools.layoutlib.annotations.LayoutlibDelegate;
+
/**
* Describes the work to be done by {@link AsmGenerator}.
*/
@@ -83,7 +85,9 @@
OverrideMethod.class,
MethodListener.class,
MethodAdapter.class,
- CreateInfo.class
+ ICreateInfo.class,
+ CreateInfo.class,
+ LayoutlibDelegate.class
};
/**
@@ -99,8 +103,7 @@
* The list of classes on which to delegate all native methods.
*/
private final static String[] DELEGATE_CLASS_NATIVES = new String[] {
- // TODO: comment out once DelegateClass is working
- // "android.graphics.Paint"
+ "android.graphics.Matrix",
};
/**
@@ -126,7 +129,6 @@
"android.graphics.ComposeShader", "android.graphics._Original_ComposeShader",
"android.graphics.DashPathEffect", "android.graphics._Original_DashPathEffect",
"android.graphics.LinearGradient", "android.graphics._Original_LinearGradient",
- "android.graphics.Matrix", "android.graphics._Original_Matrix",
"android.graphics.Paint", "android.graphics._Original_Paint",
"android.graphics.Path", "android.graphics._Original_Path",
"android.graphics.PorterDuffXfermode", "android.graphics._Original_PorterDuffXfermode",