Rename DisplayList->RenderNode
Change-Id: Idcca6f26ba6282594789962f5edb3ed53a290fef
diff --git a/core/java/android/view/DisplayList.java b/core/java/android/view/DisplayList.java
index be6f401..ed52803 100644
--- a/core/java/android/view/DisplayList.java
+++ b/core/java/android/view/DisplayList.java
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2010 The Android Open Source Project
+ * Copyright (C) 2014 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.
@@ -16,916 +16,10 @@
package android.view;
-import android.graphics.Matrix;
-import android.graphics.Path;
-
-/**
- * <p>A display list records a series of graphics related operations and can replay
- * them later. Display lists are usually built by recording operations on a
- * {@link HardwareCanvas}. Replaying the operations from a display list avoids
- * executing application code on every frame, and is thus much more efficient.</p>
- *
- * <p>Display lists are used internally for all views by default, and are not
- * typically used directly. One reason to consider using a display is a custom
- * {@link View} implementation that needs to issue a large number of drawing commands.
- * When the view invalidates, all the drawing commands must be reissued, even if
- * large portions of the drawing command stream stay the same frame to frame, which
- * can become a performance bottleneck. To solve this issue, a custom View might split
- * its content into several display lists. A display list is updated only when its
- * content, and only its content, needs to be updated.</p>
- *
- * <p>A text editor might for instance store each paragraph into its own display list.
- * Thus when the user inserts or removes characters, only the display list of the
- * affected paragraph needs to be recorded again.</p>
- *
- * <h3>Hardware acceleration</h3>
- * <p>Display lists can only be replayed using a {@link HardwareCanvas}. They are not
- * supported in software. Always make sure that the {@link android.graphics.Canvas}
- * you are using to render a display list is hardware accelerated using
- * {@link android.graphics.Canvas#isHardwareAccelerated()}.</p>
- *
- * <h3>Creating a display list</h3>
- * <pre class="prettyprint">
- * HardwareRenderer renderer = myView.getHardwareRenderer();
- * if (renderer != null) {
- * DisplayList displayList = renderer.createDisplayList();
- * HardwareCanvas canvas = displayList.start(width, height);
- * try {
- * // Draw onto the canvas
- * // For instance: canvas.drawBitmap(...);
- * } finally {
- * displayList.end();
- * }
- * }
- * </pre>
- *
- * <h3>Rendering a display list on a View</h3>
- * <pre class="prettyprint">
- * protected void onDraw(Canvas canvas) {
- * if (canvas.isHardwareAccelerated()) {
- * HardwareCanvas hardwareCanvas = (HardwareCanvas) canvas;
- * hardwareCanvas.drawDisplayList(mDisplayList);
- * }
- * }
- * </pre>
- *
- * <h3>Releasing resources</h3>
- * <p>This step is not mandatory but recommended if you want to release resources
- * held by a display list as soon as possible.</p>
- * <pre class="prettyprint">
- * // Mark this display list invalid, it cannot be used for drawing anymore,
- * // and release resources held by this display list
- * displayList.clear();
- * </pre>
- *
- * <h3>Properties</h3>
- * <p>In addition, a display list offers several properties, such as
- * {@link #setScaleX(float)} or {@link #setLeft(int)}, that can be used to affect all
- * the drawing commands recorded within. For instance, these properties can be used
- * to move around a large number of images without re-issuing all the individual
- * <code>drawBitmap()</code> calls.</p>
- *
- * <pre class="prettyprint">
- * private void createDisplayList() {
- * mDisplayList = DisplayList.create("MyDisplayList");
- * HardwareCanvas canvas = mDisplayList.start(width, height);
- * try {
- * for (Bitmap b : mBitmaps) {
- * canvas.drawBitmap(b, 0.0f, 0.0f, null);
- * canvas.translate(0.0f, b.getHeight());
- * }
- * } finally {
- * displayList.end();
- * }
- * }
- *
- * protected void onDraw(Canvas canvas) {
- * if (canvas.isHardwareAccelerated()) {
- * HardwareCanvas hardwareCanvas = (HardwareCanvas) canvas;
- * hardwareCanvas.drawDisplayList(mDisplayList);
- * }
- * }
- *
- * private void moveContentBy(int x) {
- * // This will move all the bitmaps recorded inside the display list
- * // by x pixels to the right and redraw this view. All the commands
- * // recorded in createDisplayList() won't be re-issued, only onDraw()
- * // will be invoked and will execute very quickly
- * mDisplayList.offsetLeftAndRight(x);
- * invalidate();
- * }
- * </pre>
- *
- * <h3>Threading</h3>
- * <p>Display lists must be created on and manipulated from the UI thread only.</p>
- *
- * @hide
+/** TODO: Remove once frameworks/webview is updated
+ * @hide
*/
public class DisplayList {
- /**
- * Flag used when calling
- * {@link HardwareCanvas#drawDisplayList(DisplayList, android.graphics.Rect, int)}
- * When this flag is set, draw operations lying outside of the bounds of the
- * display list will be culled early. It is recommeneded to always set this
- * flag.
- *
- * @hide
- */
- public static final int FLAG_CLIP_CHILDREN = 0x1;
-
- // NOTE: The STATUS_* values *must* match the enum in DrawGlInfo.h
-
- /**
- * Indicates that the display list is done drawing.
- *
- * @see HardwareCanvas#drawDisplayList(DisplayList, android.graphics.Rect, int)
- *
- * @hide
- */
+ /** @hide */
public static final int STATUS_DONE = 0x0;
-
- /**
- * Indicates that the display list needs another drawing pass.
- *
- * @see HardwareCanvas#drawDisplayList(DisplayList, android.graphics.Rect, int)
- *
- * @hide
- */
- public static final int STATUS_DRAW = 0x1;
-
- /**
- * Indicates that the display list needs to re-execute its GL functors.
- *
- * @see HardwareCanvas#drawDisplayList(DisplayList, android.graphics.Rect, int)
- * @see HardwareCanvas#callDrawGLFunction(long)
- *
- * @hide
- */
- public static final int STATUS_INVOKE = 0x2;
-
- /**
- * Indicates that the display list performed GL drawing operations.
- *
- * @see HardwareCanvas#drawDisplayList(DisplayList, android.graphics.Rect, int)
- *
- * @hide
- */
- public static final int STATUS_DREW = 0x4;
-
- private boolean mValid;
- private final long mNativeDisplayList;
- private HardwareRenderer mRenderer;
-
- private DisplayList(String name) {
- mNativeDisplayList = nCreate();
- nSetDisplayListName(mNativeDisplayList, name);
- }
-
- /**
- * Creates a new display list that can be used to record batches of
- * drawing operations.
- *
- * @param name The name of the display list, used for debugging purpose. May be null.
- *
- * @return A new display list.
- *
- * @hide
- */
- public static DisplayList create(String name) {
- return new DisplayList(name);
- }
-
- /**
- * Starts recording the display list. All operations performed on the
- * returned canvas are recorded and stored in this display list.
- *
- * Calling this method will mark the display list invalid until
- * {@link #end()} is called. Only valid display lists can be replayed.
- *
- * @param width The width of the display list's viewport
- * @param height The height of the display list's viewport
- *
- * @return A canvas to record drawing operations.
- *
- * @see #end()
- * @see #isValid()
- */
- public HardwareCanvas start(int width, int height) {
- HardwareCanvas canvas = GLES20RecordingCanvas.obtain();
- canvas.setViewport(width, height);
- // The dirty rect should always be null for a display list
- canvas.onPreDraw(null);
- return canvas;
- }
-
- /**
- * Ends the recording for this display list. A display list cannot be
- * replayed if recording is not finished. Calling this method marks
- * the display list valid and {@link #isValid()} will return true.
- *
- * @see #start(int, int)
- * @see #isValid()
- */
- public void end(HardwareRenderer renderer, HardwareCanvas endCanvas) {
- if (!(endCanvas instanceof GLES20RecordingCanvas)) {
- throw new IllegalArgumentException("Passed an invalid canvas to end!");
- }
-
- GLES20RecordingCanvas canvas = (GLES20RecordingCanvas) endCanvas;
- canvas.onPostDraw();
- long displayListData = canvas.finishRecording();
- if (renderer != mRenderer) {
- // If we are changing renderers first destroy with the old
- // renderer, then set with the new one
- destroyDisplayListData();
- }
- mRenderer = renderer;
- setDisplayListData(displayListData);
- canvas.recycle();
- mValid = true;
- }
-
- /**
- * Reset native resources. This is called when cleaning up the state of display lists
- * during destruction of hardware resources, to ensure that we do not hold onto
- * obsolete resources after related resources are gone.
- *
- * @hide
- */
- public void destroyDisplayListData() {
- if (!mValid) return;
-
- setDisplayListData(0);
- mRenderer = null;
- mValid = false;
- }
-
- private void setDisplayListData(long newData) {
- if (mRenderer != null) {
- mRenderer.setDisplayListData(mNativeDisplayList, newData);
- } else {
- throw new IllegalStateException("Trying to set data without a renderer! data=" + newData);
- }
- }
-
- /**
- * Returns whether the display list is currently usable. If this returns false,
- * the display list should be re-recorded prior to replaying it.
- *
- * @return boolean true if the display list is able to be replayed, false otherwise.
- */
- public boolean isValid() { return mValid; }
-
- long getNativeDisplayList() {
- if (!mValid) {
- throw new IllegalStateException("The display list is not valid.");
- }
- return mNativeDisplayList;
- }
-
- ///////////////////////////////////////////////////////////////////////////
- // DisplayList Property Setters
- ///////////////////////////////////////////////////////////////////////////
-
- /**
- * Set the caching property on the display list, which indicates whether the display list
- * holds a layer. Layer display lists should avoid creating an alpha layer, since alpha is
- * handled in the drawLayer operation directly (and more efficiently).
- *
- * @param caching true if the display list represents a hardware layer, false otherwise.
- *
- * @hide
- */
- public void setCaching(boolean caching) {
- nSetCaching(mNativeDisplayList, caching);
- }
-
- /**
- * Set whether the display list should clip itself to its bounds. This property is controlled by
- * the view's parent.
- *
- * @param clipToBounds true if the display list should clip to its bounds
- */
- public void setClipToBounds(boolean clipToBounds) {
- nSetClipToBounds(mNativeDisplayList, clipToBounds);
- }
-
- /**
- * Set whether the display list should collect and Z order all 3d composited descendents, and
- * draw them in order with the default Z=0 content.
- *
- * @param isolatedZVolume true if the display list should collect and Z order descendents.
- */
- public void setIsolatedZVolume(boolean isolatedZVolume) {
- nSetIsolatedZVolume(mNativeDisplayList, isolatedZVolume);
- }
-
- /**
- * Sets whether the display list should be drawn immediately after the
- * closest ancestor display list where isolateZVolume is true. If the
- * display list itself satisfies this constraint, changing this attribute
- * has no effect on drawing order.
- *
- * @param shouldProject true if the display list should be projected onto a
- * containing volume.
- */
- public void setProjectBackwards(boolean shouldProject) {
- nSetProjectBackwards(mNativeDisplayList, shouldProject);
- }
-
- /**
- * Sets whether the display list is a projection receiver - that its parent
- * DisplayList should draw any descendent DisplayLists with
- * ProjectBackwards=true directly on top of it. Default value is false.
- */
- public void setProjectionReceiver(boolean shouldRecieve) {
- nSetProjectionReceiver(mNativeDisplayList, shouldRecieve);
- }
-
- /**
- * Sets the outline, defining the shape that casts a shadow, and the path to
- * be clipped if setClipToOutline is set.
- *
- * Deep copies the native path to simplify reference ownership.
- *
- * @param outline Convex, CW Path to store in the DisplayList. May be null.
- */
- public void setOutline(Path outline) {
- long nativePath = (outline == null) ? 0 : outline.mNativePath;
- nSetOutline(mNativeDisplayList, nativePath);
- }
-
- /**
- * Enables or disables clipping to the outline.
- *
- * @param clipToOutline true if clipping to the outline.
- */
- public void setClipToOutline(boolean clipToOutline) {
- nSetClipToOutline(mNativeDisplayList, clipToOutline);
- }
-
- /**
- * Set whether the DisplayList should cast a shadow.
- *
- * The shape of the shadow casting area is defined by the outline of the display list, if set
- * and non-empty, otherwise it will be the bounds rect.
- */
- public void setCastsShadow(boolean castsShadow) {
- nSetCastsShadow(mNativeDisplayList, castsShadow);
- }
-
- /**
- * Sets whether the DisplayList should be drawn with perspective applied from the global camera.
- *
- * If set to true, camera distance will be ignored. Defaults to false.
- */
- public void setUsesGlobalCamera(boolean usesGlobalCamera) {
- nSetUsesGlobalCamera(mNativeDisplayList, usesGlobalCamera);
- }
-
- /**
- * Set the static matrix on the display list. The specified matrix is combined with other
- * transforms (such as {@link #setScaleX(float)}, {@link #setRotation(float)}, etc.)
- *
- * @param matrix A transform matrix to apply to this display list
- *
- * @see #getMatrix(android.graphics.Matrix)
- * @see #getMatrix()
- */
- public void setStaticMatrix(Matrix matrix) {
- nSetStaticMatrix(mNativeDisplayList, matrix.native_instance);
- }
-
- /**
- * Set the Animation matrix on the display list. This matrix exists if an Animation is
- * currently playing on a View, and is set on the display list during at draw() time. When
- * the Animation finishes, the matrix should be cleared by sending <code>null</code>
- * for the matrix parameter.
- *
- * @param matrix The matrix, null indicates that the matrix should be cleared.
- *
- * @hide
- */
- public void setAnimationMatrix(Matrix matrix) {
- nSetAnimationMatrix(mNativeDisplayList,
- (matrix != null) ? matrix.native_instance : 0);
- }
-
- /**
- * Sets the translucency level for the display list.
- *
- * @param alpha The translucency of the display list, must be a value between 0.0f and 1.0f
- *
- * @see View#setAlpha(float)
- * @see #getAlpha()
- */
- public void setAlpha(float alpha) {
- nSetAlpha(mNativeDisplayList, alpha);
- }
-
- /**
- * Returns the translucency level of this display list.
- *
- * @return A value between 0.0f and 1.0f
- *
- * @see #setAlpha(float)
- */
- public float getAlpha() {
- return nGetAlpha(mNativeDisplayList);
- }
-
- /**
- * Sets whether the display list renders content which overlaps. Non-overlapping rendering
- * can use a fast path for alpha that avoids rendering to an offscreen buffer. By default
- * display lists consider they do not have overlapping content.
- *
- * @param hasOverlappingRendering False if the content is guaranteed to be non-overlapping,
- * true otherwise.
- *
- * @see android.view.View#hasOverlappingRendering()
- * @see #hasOverlappingRendering()
- */
- public void setHasOverlappingRendering(boolean hasOverlappingRendering) {
- nSetHasOverlappingRendering(mNativeDisplayList, hasOverlappingRendering);
- }
-
- /**
- * Indicates whether the content of this display list overlaps.
- *
- * @return True if this display list renders content which overlaps, false otherwise.
- *
- * @see #setHasOverlappingRendering(boolean)
- */
- public boolean hasOverlappingRendering() {
- //noinspection SimplifiableIfStatement
- return nHasOverlappingRendering(mNativeDisplayList);
- }
-
- /**
- * Sets the translation value for the display list on the X axis.
- *
- * @param translationX The X axis translation value of the display list, in pixels
- *
- * @see View#setTranslationX(float)
- * @see #getTranslationX()
- */
- public void setTranslationX(float translationX) {
- nSetTranslationX(mNativeDisplayList, translationX);
- }
-
- /**
- * Returns the translation value for this display list on the X axis, in pixels.
- *
- * @see #setTranslationX(float)
- */
- public float getTranslationX() {
- return nGetTranslationX(mNativeDisplayList);
- }
-
- /**
- * Sets the translation value for the display list on the Y axis.
- *
- * @param translationY The Y axis translation value of the display list, in pixels
- *
- * @see View#setTranslationY(float)
- * @see #getTranslationY()
- */
- public void setTranslationY(float translationY) {
- nSetTranslationY(mNativeDisplayList, translationY);
- }
-
- /**
- * Returns the translation value for this display list on the Y axis, in pixels.
- *
- * @see #setTranslationY(float)
- */
- public float getTranslationY() {
- return nGetTranslationY(mNativeDisplayList);
- }
-
- /**
- * Sets the translation value for the display list on the Z axis.
- *
- * @see View#setTranslationZ(float)
- * @see #getTranslationZ()
- */
- public void setTranslationZ(float translationZ) {
- nSetTranslationZ(mNativeDisplayList, translationZ);
- }
-
- /**
- * Returns the translation value for this display list on the Z axis.
- *
- * @see #setTranslationZ(float)
- */
- public float getTranslationZ() {
- return nGetTranslationZ(mNativeDisplayList);
- }
-
- /**
- * Sets the rotation value for the display list around the Z axis.
- *
- * @param rotation The rotation value of the display list, in degrees
- *
- * @see View#setRotation(float)
- * @see #getRotation()
- */
- public void setRotation(float rotation) {
- nSetRotation(mNativeDisplayList, rotation);
- }
-
- /**
- * Returns the rotation value for this display list around the Z axis, in degrees.
- *
- * @see #setRotation(float)
- */
- public float getRotation() {
- return nGetRotation(mNativeDisplayList);
- }
-
- /**
- * Sets the rotation value for the display list around the X axis.
- *
- * @param rotationX The rotation value of the display list, in degrees
- *
- * @see View#setRotationX(float)
- * @see #getRotationX()
- */
- public void setRotationX(float rotationX) {
- nSetRotationX(mNativeDisplayList, rotationX);
- }
-
- /**
- * Returns the rotation value for this display list around the X axis, in degrees.
- *
- * @see #setRotationX(float)
- */
- public float getRotationX() {
- return nGetRotationX(mNativeDisplayList);
- }
-
- /**
- * Sets the rotation value for the display list around the Y axis.
- *
- * @param rotationY The rotation value of the display list, in degrees
- *
- * @see View#setRotationY(float)
- * @see #getRotationY()
- */
- public void setRotationY(float rotationY) {
- nSetRotationY(mNativeDisplayList, rotationY);
- }
-
- /**
- * Returns the rotation value for this display list around the Y axis, in degrees.
- *
- * @see #setRotationY(float)
- */
- public float getRotationY() {
- return nGetRotationY(mNativeDisplayList);
- }
-
- /**
- * Sets the scale value for the display list on the X axis.
- *
- * @param scaleX The scale value of the display list
- *
- * @see View#setScaleX(float)
- * @see #getScaleX()
- */
- public void setScaleX(float scaleX) {
- nSetScaleX(mNativeDisplayList, scaleX);
- }
-
- /**
- * Returns the scale value for this display list on the X axis.
- *
- * @see #setScaleX(float)
- */
- public float getScaleX() {
- return nGetScaleX(mNativeDisplayList);
- }
-
- /**
- * Sets the scale value for the display list on the Y axis.
- *
- * @param scaleY The scale value of the display list
- *
- * @see View#setScaleY(float)
- * @see #getScaleY()
- */
- public void setScaleY(float scaleY) {
- nSetScaleY(mNativeDisplayList, scaleY);
- }
-
- /**
- * Returns the scale value for this display list on the Y axis.
- *
- * @see #setScaleY(float)
- */
- public float getScaleY() {
- return nGetScaleY(mNativeDisplayList);
- }
-
- /**
- * Sets all of the transform-related values of the display list
- *
- * @param alpha The alpha value of the display list
- * @param translationX The translationX value of the display list
- * @param translationY The translationY value of the display list
- * @param rotation The rotation value of the display list
- * @param rotationX The rotationX value of the display list
- * @param rotationY The rotationY value of the display list
- * @param scaleX The scaleX value of the display list
- * @param scaleY The scaleY value of the display list
- *
- * @hide
- */
- public void setTransformationInfo(float alpha,
- float translationX, float translationY, float translationZ,
- float rotation, float rotationX, float rotationY, float scaleX, float scaleY) {
- nSetTransformationInfo(mNativeDisplayList, alpha,
- translationX, translationY, translationZ,
- rotation, rotationX, rotationY, scaleX, scaleY);
- }
-
- /**
- * Sets the pivot value for the display list on the X axis
- *
- * @param pivotX The pivot value of the display list on the X axis, in pixels
- *
- * @see View#setPivotX(float)
- * @see #getPivotX()
- */
- public void setPivotX(float pivotX) {
- nSetPivotX(mNativeDisplayList, pivotX);
- }
-
- /**
- * Returns the pivot value for this display list on the X axis, in pixels.
- *
- * @see #setPivotX(float)
- */
- public float getPivotX() {
- return nGetPivotX(mNativeDisplayList);
- }
-
- /**
- * Sets the pivot value for the display list on the Y axis
- *
- * @param pivotY The pivot value of the display list on the Y axis, in pixels
- *
- * @see View#setPivotY(float)
- * @see #getPivotY()
- */
- public void setPivotY(float pivotY) {
- nSetPivotY(mNativeDisplayList, pivotY);
- }
-
- /**
- * Returns the pivot value for this display list on the Y axis, in pixels.
- *
- * @see #setPivotY(float)
- */
- public float getPivotY() {
- return nGetPivotY(mNativeDisplayList);
- }
-
- /**
- * Sets the camera distance for the display list. Refer to
- * {@link View#setCameraDistance(float)} for more information on how to
- * use this property.
- *
- * @param distance The distance in Z of the camera of the display list
- *
- * @see View#setCameraDistance(float)
- * @see #getCameraDistance()
- */
- public void setCameraDistance(float distance) {
- nSetCameraDistance(mNativeDisplayList, distance);
- }
-
- /**
- * Returns the distance in Z of the camera of the display list.
- *
- * @see #setCameraDistance(float)
- */
- public float getCameraDistance() {
- return nGetCameraDistance(mNativeDisplayList);
- }
-
- /**
- * Sets the left position for the display list.
- *
- * @param left The left position, in pixels, of the display list
- *
- * @see View#setLeft(int)
- * @see #getLeft()
- */
- public void setLeft(int left) {
- nSetLeft(mNativeDisplayList, left);
- }
-
- /**
- * Returns the left position for the display list in pixels.
- *
- * @see #setLeft(int)
- */
- public float getLeft() {
- return nGetLeft(mNativeDisplayList);
- }
-
- /**
- * Sets the top position for the display list.
- *
- * @param top The top position, in pixels, of the display list
- *
- * @see View#setTop(int)
- * @see #getTop()
- */
- public void setTop(int top) {
- nSetTop(mNativeDisplayList, top);
- }
-
- /**
- * Returns the top position for the display list in pixels.
- *
- * @see #setTop(int)
- */
- public float getTop() {
- return nGetTop(mNativeDisplayList);
- }
-
- /**
- * Sets the right position for the display list.
- *
- * @param right The right position, in pixels, of the display list
- *
- * @see View#setRight(int)
- * @see #getRight()
- */
- public void setRight(int right) {
- nSetRight(mNativeDisplayList, right);
- }
-
- /**
- * Returns the right position for the display list in pixels.
- *
- * @see #setRight(int)
- */
- public float getRight() {
- return nGetRight(mNativeDisplayList);
- }
-
- /**
- * Sets the bottom position for the display list.
- *
- * @param bottom The bottom position, in pixels, of the display list
- *
- * @see View#setBottom(int)
- * @see #getBottom()
- */
- public void setBottom(int bottom) {
- nSetBottom(mNativeDisplayList, bottom);
- }
-
- /**
- * Returns the bottom position for the display list in pixels.
- *
- * @see #setBottom(int)
- */
- public float getBottom() {
- return nGetBottom(mNativeDisplayList);
- }
-
- /**
- * Sets the left and top positions for the display list
- *
- * @param left The left position of the display list, in pixels
- * @param top The top position of the display list, in pixels
- * @param right The right position of the display list, in pixels
- * @param bottom The bottom position of the display list, in pixels
- *
- * @see View#setLeft(int)
- * @see View#setTop(int)
- * @see View#setRight(int)
- * @see View#setBottom(int)
- */
- public void setLeftTopRightBottom(int left, int top, int right, int bottom) {
- nSetLeftTopRightBottom(mNativeDisplayList, left, top, right, bottom);
- }
-
- /**
- * Offsets the left and right positions for the display list
- *
- * @param offset The amount that the left and right positions of the display
- * list are offset, in pixels
- *
- * @see View#offsetLeftAndRight(int)
- */
- public void offsetLeftAndRight(float offset) {
- nOffsetLeftAndRight(mNativeDisplayList, offset);
- }
-
- /**
- * Offsets the top and bottom values for the display list
- *
- * @param offset The amount that the top and bottom positions of the display
- * list are offset, in pixels
- *
- * @see View#offsetTopAndBottom(int)
- */
- public void offsetTopAndBottom(float offset) {
- nOffsetTopAndBottom(mNativeDisplayList, offset);
- }
-
- /**
- * Outputs the display list to the log. This method exists for use by
- * tools to output display lists for selected nodes to the log.
- *
- * @hide
- */
- public void output() {
- nOutput(mNativeDisplayList);
- }
-
- ///////////////////////////////////////////////////////////////////////////
- // Native methods
- ///////////////////////////////////////////////////////////////////////////
-
- private static native long nCreate();
- private static native void nDestroyDisplayList(long displayList);
- private static native void nSetDisplayListName(long displayList, String name);
-
- // Properties
-
- private static native void nOffsetTopAndBottom(long displayList, float offset);
- private static native void nOffsetLeftAndRight(long displayList, float offset);
- private static native void nSetLeftTopRightBottom(long displayList, int left, int top,
- int right, int bottom);
- private static native void nSetBottom(long displayList, int bottom);
- private static native void nSetRight(long displayList, int right);
- private static native void nSetTop(long displayList, int top);
- private static native void nSetLeft(long displayList, int left);
- private static native void nSetCameraDistance(long displayList, float distance);
- private static native void nSetPivotY(long displayList, float pivotY);
- private static native void nSetPivotX(long displayList, float pivotX);
- private static native void nSetCaching(long displayList, boolean caching);
- private static native void nSetClipToBounds(long displayList, boolean clipToBounds);
- private static native void nSetProjectBackwards(long displayList, boolean shouldProject);
- private static native void nSetProjectionReceiver(long displayList, boolean shouldRecieve);
- private static native void nSetIsolatedZVolume(long displayList, boolean isolateZVolume);
- private static native void nSetOutline(long displayList, long nativePath);
- private static native void nSetClipToOutline(long displayList, boolean clipToOutline);
- private static native void nSetCastsShadow(long displayList, boolean castsShadow);
- private static native void nSetUsesGlobalCamera(long displayList, boolean usesGlobalCamera);
- private static native void nSetAlpha(long displayList, float alpha);
- private static native void nSetHasOverlappingRendering(long displayList,
- boolean hasOverlappingRendering);
- private static native void nSetTranslationX(long displayList, float translationX);
- private static native void nSetTranslationY(long displayList, float translationY);
- private static native void nSetTranslationZ(long displayList, float translationZ);
- private static native void nSetRotation(long displayList, float rotation);
- private static native void nSetRotationX(long displayList, float rotationX);
- private static native void nSetRotationY(long displayList, float rotationY);
- private static native void nSetScaleX(long displayList, float scaleX);
- private static native void nSetScaleY(long displayList, float scaleY);
- private static native void nSetTransformationInfo(long displayList, float alpha,
- float translationX, float translationY, float translationZ,
- float rotation, float rotationX, float rotationY, float scaleX, float scaleY);
- private static native void nSetStaticMatrix(long displayList, long nativeMatrix);
- private static native void nSetAnimationMatrix(long displayList, long animationMatrix);
-
- private static native boolean nHasOverlappingRendering(long displayList);
- private static native float nGetAlpha(long displayList);
- private static native float nGetLeft(long displayList);
- private static native float nGetTop(long displayList);
- private static native float nGetRight(long displayList);
- private static native float nGetBottom(long displayList);
- private static native float nGetCameraDistance(long displayList);
- private static native float nGetScaleX(long displayList);
- private static native float nGetScaleY(long displayList);
- private static native float nGetTranslationX(long displayList);
- private static native float nGetTranslationY(long displayList);
- private static native float nGetTranslationZ(long displayList);
- private static native float nGetRotation(long displayList);
- private static native float nGetRotationX(long displayList);
- private static native float nGetRotationY(long displayList);
- private static native float nGetPivotX(long displayList);
- private static native float nGetPivotY(long displayList);
- private static native void nOutput(long displayList);
-
- ///////////////////////////////////////////////////////////////////////////
- // Finalization
- ///////////////////////////////////////////////////////////////////////////
-
- @Override
- protected void finalize() throws Throwable {
- try {
- destroyDisplayListData();
- nDestroyDisplayList(mNativeDisplayList);
- } finally {
- super.finalize();
- }
- }
}
diff --git a/core/java/android/view/GLES20Canvas.java b/core/java/android/view/GLES20Canvas.java
index 6c6fc9b..c274fc4 100644
--- a/core/java/android/view/GLES20Canvas.java
+++ b/core/java/android/view/GLES20Canvas.java
@@ -359,7 +359,7 @@
protected static native long nFinishRecording(long renderer);
@Override
- public int drawDisplayList(DisplayList displayList, Rect dirty, int flags) {
+ public int drawDisplayList(RenderNode displayList, Rect dirty, int flags) {
return nDrawDisplayList(mRenderer, displayList.getNativeDisplayList(),
dirty, flags);
}
diff --git a/core/java/android/view/GLRenderer.java b/core/java/android/view/GLRenderer.java
index 81f778d..4d42c5d 100644
--- a/core/java/android/view/GLRenderer.java
+++ b/core/java/android/view/GLRenderer.java
@@ -1125,7 +1125,7 @@
dirty = beginFrame(canvas, dirty, surfaceState);
- DisplayList displayList = buildDisplayList(view, canvas);
+ RenderNode displayList = buildDisplayList(view, canvas);
flushLayerChanges();
@@ -1137,7 +1137,7 @@
}
int saveCount = 0;
- int status = DisplayList.STATUS_DONE;
+ int status = RenderNode.STATUS_DONE;
long start = getSystemTime();
try {
@@ -1201,7 +1201,7 @@
}
private static native void nSetDisplayListData(long displayList, long newData);
- private DisplayList buildDisplayList(View view, HardwareCanvas canvas) {
+ private RenderNode buildDisplayList(View view, HardwareCanvas canvas) {
if (mDrawDelta <= 0) {
return view.mDisplayList;
}
@@ -1214,7 +1214,7 @@
canvas.clearLayerUpdates();
Trace.traceBegin(Trace.TRACE_TAG_VIEW, "getDisplayList");
- DisplayList displayList = view.getDisplayList();
+ RenderNode displayList = view.getDisplayList();
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
endBuildDisplayListProfiling(buildDisplayListStartTime);
@@ -1279,7 +1279,7 @@
}
private int drawDisplayList(View.AttachInfo attachInfo, HardwareCanvas canvas,
- DisplayList displayList, int status) {
+ RenderNode displayList, int status) {
long drawDisplayListStartTime = 0;
if (mProfileEnabled) {
@@ -1289,7 +1289,7 @@
Trace.traceBegin(Trace.TRACE_TAG_VIEW, "drawDisplayList");
try {
status |= canvas.drawDisplayList(displayList, mRedrawClip,
- DisplayList.FLAG_CLIP_CHILDREN);
+ RenderNode.FLAG_CLIP_CHILDREN);
} finally {
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
}
@@ -1305,7 +1305,7 @@
}
private void swapBuffers(int status) {
- if ((status & DisplayList.STATUS_DREW) == DisplayList.STATUS_DREW) {
+ if ((status & RenderNode.STATUS_DREW) == RenderNode.STATUS_DREW) {
long eglSwapBuffersStartTime = 0;
if (mProfileEnabled) {
eglSwapBuffersStartTime = System.nanoTime();
@@ -1339,7 +1339,7 @@
private void handleFunctorStatus(View.AttachInfo attachInfo, int status) {
// If the draw flag is set, functors will be invoked while executing
// the tree of display lists
- if ((status & DisplayList.STATUS_DRAW) != 0) {
+ if ((status & RenderNode.STATUS_DRAW) != 0) {
if (mRedrawClip.isEmpty()) {
attachInfo.mViewRootImpl.invalidate();
} else {
@@ -1348,7 +1348,7 @@
}
}
- if ((status & DisplayList.STATUS_INVOKE) != 0 ||
+ if ((status & RenderNode.STATUS_INVOKE) != 0 ||
attachInfo.mHandler.hasCallbacks(mFunctorsRunnable)) {
attachInfo.mHandler.removeCallbacks(mFunctorsRunnable);
mFunctorsRunnable.attachInfo = attachInfo;
diff --git a/core/java/android/view/HardwareCanvas.java b/core/java/android/view/HardwareCanvas.java
index a3c7b63..f695b20 100644
--- a/core/java/android/view/HardwareCanvas.java
+++ b/core/java/android/view/HardwareCanvas.java
@@ -42,7 +42,7 @@
* Invoked before any drawing operation is performed in this canvas.
*
* @param dirty The dirty rectangle to update, can be null.
- * @return {@link DisplayList#STATUS_DREW} if anything was drawn (such as a call to clear
+ * @return {@link RenderNode#STATUS_DREW} if anything was drawn (such as a call to clear
* the canvas).
*
* @hide
@@ -58,12 +58,12 @@
/**
* Draws the specified display list onto this canvas. The display list can only
- * be drawn if {@link android.view.DisplayList#isValid()} returns true.
+ * be drawn if {@link android.view.RenderNode#isValid()} returns true.
*
* @param displayList The display list to replay.
*/
- public void drawDisplayList(DisplayList displayList) {
- drawDisplayList(displayList, null, DisplayList.FLAG_CLIP_CHILDREN);
+ public void drawDisplayList(RenderNode displayList) {
+ drawDisplayList(displayList, null, RenderNode.FLAG_CLIP_CHILDREN);
}
/**
@@ -71,17 +71,17 @@
*
* @param displayList The display list to replay.
* @param dirty The dirty region to redraw in the next pass, matters only
- * if this method returns {@link DisplayList#STATUS_DRAW}, can be null.
- * @param flags Optional flags about drawing, see {@link DisplayList} for
+ * if this method returns {@link RenderNode#STATUS_DRAW}, can be null.
+ * @param flags Optional flags about drawing, see {@link RenderNode} for
* the possible flags.
*
- * @return One of {@link DisplayList#STATUS_DONE}, {@link DisplayList#STATUS_DRAW}, or
- * {@link DisplayList#STATUS_INVOKE}, or'd with {@link DisplayList#STATUS_DREW}
+ * @return One of {@link RenderNode#STATUS_DONE}, {@link RenderNode#STATUS_DRAW}, or
+ * {@link RenderNode#STATUS_INVOKE}, or'd with {@link RenderNode#STATUS_DREW}
* if anything was drawn.
*
* @hide
*/
- public abstract int drawDisplayList(DisplayList displayList, Rect dirty, int flags);
+ public abstract int drawDisplayList(RenderNode displayList, Rect dirty, int flags);
/**
* Draws the specified layer onto this canvas.
@@ -102,28 +102,28 @@
*
* @param drawGLFunction A native function pointer
*
- * @return One of {@link DisplayList#STATUS_DONE}, {@link DisplayList#STATUS_DRAW} or
- * {@link DisplayList#STATUS_INVOKE}
+ * @return One of {@link RenderNode#STATUS_DONE}, {@link RenderNode#STATUS_DRAW} or
+ * {@link RenderNode#STATUS_INVOKE}
*
* @hide
*/
public int callDrawGLFunction(long drawGLFunction) {
// Noop - this is done in the display list recorder subclass
- return DisplayList.STATUS_DONE;
+ return RenderNode.STATUS_DONE;
}
/**
* Invoke all the functors who requested to be invoked during the previous frame.
*
- * @param dirty The region to redraw when the functors return {@link DisplayList#STATUS_DRAW}
+ * @param dirty The region to redraw when the functors return {@link RenderNode#STATUS_DRAW}
*
- * @return One of {@link DisplayList#STATUS_DONE}, {@link DisplayList#STATUS_DRAW} or
- * {@link DisplayList#STATUS_INVOKE}
+ * @return One of {@link RenderNode#STATUS_DONE}, {@link RenderNode#STATUS_DRAW} or
+ * {@link RenderNode#STATUS_INVOKE}
*
* @hide
*/
public int invokeFunctors(Rect dirty) {
- return DisplayList.STATUS_DONE;
+ return RenderNode.STATUS_DONE;
}
/**
diff --git a/core/java/android/view/HardwareLayer.java b/core/java/android/view/HardwareLayer.java
index 46e2690..4d78733 100644
--- a/core/java/android/view/HardwareLayer.java
+++ b/core/java/android/view/HardwareLayer.java
@@ -37,7 +37,7 @@
private HardwareRenderer mRenderer;
private Finalizer mFinalizer;
- private DisplayList mDisplayList;
+ private RenderNode mDisplayList;
private final int mLayerType;
private HardwareLayer(HardwareRenderer renderer, long deferredUpdater, int type) {
@@ -122,11 +122,11 @@
}
}
- public DisplayList startRecording() {
+ public RenderNode startRecording() {
assertType(LAYER_TYPE_DISPLAY_LIST);
if (mDisplayList == null) {
- mDisplayList = DisplayList.create("HardwareLayer");
+ mDisplayList = RenderNode.create("HardwareLayer");
}
return mDisplayList;
}
diff --git a/core/java/android/view/RenderNode.java b/core/java/android/view/RenderNode.java
new file mode 100644
index 0000000..430bf5e
--- /dev/null
+++ b/core/java/android/view/RenderNode.java
@@ -0,0 +1,931 @@
+/*
+ * 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.view;
+
+import android.graphics.Matrix;
+import android.graphics.Path;
+
+/**
+ * <p>A display list records a series of graphics related operations and can replay
+ * them later. Display lists are usually built by recording operations on a
+ * {@link HardwareCanvas}. Replaying the operations from a display list avoids
+ * executing application code on every frame, and is thus much more efficient.</p>
+ *
+ * <p>Display lists are used internally for all views by default, and are not
+ * typically used directly. One reason to consider using a display is a custom
+ * {@link View} implementation that needs to issue a large number of drawing commands.
+ * When the view invalidates, all the drawing commands must be reissued, even if
+ * large portions of the drawing command stream stay the same frame to frame, which
+ * can become a performance bottleneck. To solve this issue, a custom View might split
+ * its content into several display lists. A display list is updated only when its
+ * content, and only its content, needs to be updated.</p>
+ *
+ * <p>A text editor might for instance store each paragraph into its own display list.
+ * Thus when the user inserts or removes characters, only the display list of the
+ * affected paragraph needs to be recorded again.</p>
+ *
+ * <h3>Hardware acceleration</h3>
+ * <p>Display lists can only be replayed using a {@link HardwareCanvas}. They are not
+ * supported in software. Always make sure that the {@link android.graphics.Canvas}
+ * you are using to render a display list is hardware accelerated using
+ * {@link android.graphics.Canvas#isHardwareAccelerated()}.</p>
+ *
+ * <h3>Creating a display list</h3>
+ * <pre class="prettyprint">
+ * HardwareRenderer renderer = myView.getHardwareRenderer();
+ * if (renderer != null) {
+ * DisplayList displayList = renderer.createDisplayList();
+ * HardwareCanvas canvas = displayList.start(width, height);
+ * try {
+ * // Draw onto the canvas
+ * // For instance: canvas.drawBitmap(...);
+ * } finally {
+ * displayList.end();
+ * }
+ * }
+ * </pre>
+ *
+ * <h3>Rendering a display list on a View</h3>
+ * <pre class="prettyprint">
+ * protected void onDraw(Canvas canvas) {
+ * if (canvas.isHardwareAccelerated()) {
+ * HardwareCanvas hardwareCanvas = (HardwareCanvas) canvas;
+ * hardwareCanvas.drawDisplayList(mDisplayList);
+ * }
+ * }
+ * </pre>
+ *
+ * <h3>Releasing resources</h3>
+ * <p>This step is not mandatory but recommended if you want to release resources
+ * held by a display list as soon as possible.</p>
+ * <pre class="prettyprint">
+ * // Mark this display list invalid, it cannot be used for drawing anymore,
+ * // and release resources held by this display list
+ * displayList.clear();
+ * </pre>
+ *
+ * <h3>Properties</h3>
+ * <p>In addition, a display list offers several properties, such as
+ * {@link #setScaleX(float)} or {@link #setLeft(int)}, that can be used to affect all
+ * the drawing commands recorded within. For instance, these properties can be used
+ * to move around a large number of images without re-issuing all the individual
+ * <code>drawBitmap()</code> calls.</p>
+ *
+ * <pre class="prettyprint">
+ * private void createDisplayList() {
+ * mDisplayList = DisplayList.create("MyDisplayList");
+ * HardwareCanvas canvas = mDisplayList.start(width, height);
+ * try {
+ * for (Bitmap b : mBitmaps) {
+ * canvas.drawBitmap(b, 0.0f, 0.0f, null);
+ * canvas.translate(0.0f, b.getHeight());
+ * }
+ * } finally {
+ * displayList.end();
+ * }
+ * }
+ *
+ * protected void onDraw(Canvas canvas) {
+ * if (canvas.isHardwareAccelerated()) {
+ * HardwareCanvas hardwareCanvas = (HardwareCanvas) canvas;
+ * hardwareCanvas.drawDisplayList(mDisplayList);
+ * }
+ * }
+ *
+ * private void moveContentBy(int x) {
+ * // This will move all the bitmaps recorded inside the display list
+ * // by x pixels to the right and redraw this view. All the commands
+ * // recorded in createDisplayList() won't be re-issued, only onDraw()
+ * // will be invoked and will execute very quickly
+ * mDisplayList.offsetLeftAndRight(x);
+ * invalidate();
+ * }
+ * </pre>
+ *
+ * <h3>Threading</h3>
+ * <p>Display lists must be created on and manipulated from the UI thread only.</p>
+ *
+ * @hide
+ */
+public class RenderNode {
+ /**
+ * Flag used when calling
+ * {@link HardwareCanvas#drawDisplayList(RenderNode, android.graphics.Rect, int)}
+ * When this flag is set, draw operations lying outside of the bounds of the
+ * display list will be culled early. It is recommeneded to always set this
+ * flag.
+ *
+ * @hide
+ */
+ public static final int FLAG_CLIP_CHILDREN = 0x1;
+
+ // NOTE: The STATUS_* values *must* match the enum in DrawGlInfo.h
+
+ /**
+ * Indicates that the display list is done drawing.
+ *
+ * @see HardwareCanvas#drawDisplayList(RenderNode, android.graphics.Rect, int)
+ *
+ * @hide
+ */
+ public static final int STATUS_DONE = 0x0;
+
+ /**
+ * Indicates that the display list needs another drawing pass.
+ *
+ * @see HardwareCanvas#drawDisplayList(RenderNode, android.graphics.Rect, int)
+ *
+ * @hide
+ */
+ public static final int STATUS_DRAW = 0x1;
+
+ /**
+ * Indicates that the display list needs to re-execute its GL functors.
+ *
+ * @see HardwareCanvas#drawDisplayList(RenderNode, android.graphics.Rect, int)
+ * @see HardwareCanvas#callDrawGLFunction(long)
+ *
+ * @hide
+ */
+ public static final int STATUS_INVOKE = 0x2;
+
+ /**
+ * Indicates that the display list performed GL drawing operations.
+ *
+ * @see HardwareCanvas#drawDisplayList(RenderNode, android.graphics.Rect, int)
+ *
+ * @hide
+ */
+ public static final int STATUS_DREW = 0x4;
+
+ private boolean mValid;
+ private final long mNativeDisplayList;
+ private HardwareRenderer mRenderer;
+
+ private RenderNode(String name) {
+ mNativeDisplayList = nCreate();
+ nSetDisplayListName(mNativeDisplayList, name);
+ }
+
+ /**
+ * Creates a new display list that can be used to record batches of
+ * drawing operations.
+ *
+ * @param name The name of the display list, used for debugging purpose. May be null.
+ *
+ * @return A new display list.
+ *
+ * @hide
+ */
+ public static RenderNode create(String name) {
+ return new RenderNode(name);
+ }
+
+ /**
+ * Starts recording the display list. All operations performed on the
+ * returned canvas are recorded and stored in this display list.
+ *
+ * Calling this method will mark the display list invalid until
+ * {@link #end()} is called. Only valid display lists can be replayed.
+ *
+ * @param width The width of the display list's viewport
+ * @param height The height of the display list's viewport
+ *
+ * @return A canvas to record drawing operations.
+ *
+ * @see #end()
+ * @see #isValid()
+ */
+ public HardwareCanvas start(int width, int height) {
+ HardwareCanvas canvas = GLES20RecordingCanvas.obtain();
+ canvas.setViewport(width, height);
+ // The dirty rect should always be null for a display list
+ canvas.onPreDraw(null);
+ return canvas;
+ }
+
+ /**
+ * Ends the recording for this display list. A display list cannot be
+ * replayed if recording is not finished. Calling this method marks
+ * the display list valid and {@link #isValid()} will return true.
+ *
+ * @see #start(int, int)
+ * @see #isValid()
+ */
+ public void end(HardwareRenderer renderer, HardwareCanvas endCanvas) {
+ if (!(endCanvas instanceof GLES20RecordingCanvas)) {
+ throw new IllegalArgumentException("Passed an invalid canvas to end!");
+ }
+
+ GLES20RecordingCanvas canvas = (GLES20RecordingCanvas) endCanvas;
+ canvas.onPostDraw();
+ long displayListData = canvas.finishRecording();
+ if (renderer != mRenderer) {
+ // If we are changing renderers first destroy with the old
+ // renderer, then set with the new one
+ destroyDisplayListData();
+ }
+ mRenderer = renderer;
+ setDisplayListData(displayListData);
+ canvas.recycle();
+ mValid = true;
+ }
+
+ /**
+ * Reset native resources. This is called when cleaning up the state of display lists
+ * during destruction of hardware resources, to ensure that we do not hold onto
+ * obsolete resources after related resources are gone.
+ *
+ * @hide
+ */
+ public void destroyDisplayListData() {
+ if (!mValid) return;
+
+ setDisplayListData(0);
+ mRenderer = null;
+ mValid = false;
+ }
+
+ private void setDisplayListData(long newData) {
+ if (mRenderer != null) {
+ mRenderer.setDisplayListData(mNativeDisplayList, newData);
+ } else {
+ throw new IllegalStateException("Trying to set data without a renderer! data=" + newData);
+ }
+ }
+
+ /**
+ * Returns whether the display list is currently usable. If this returns false,
+ * the display list should be re-recorded prior to replaying it.
+ *
+ * @return boolean true if the display list is able to be replayed, false otherwise.
+ */
+ public boolean isValid() { return mValid; }
+
+ long getNativeDisplayList() {
+ if (!mValid) {
+ throw new IllegalStateException("The display list is not valid.");
+ }
+ return mNativeDisplayList;
+ }
+
+ ///////////////////////////////////////////////////////////////////////////
+ // DisplayList Property Setters
+ ///////////////////////////////////////////////////////////////////////////
+
+ /**
+ * Set the caching property on the display list, which indicates whether the display list
+ * holds a layer. Layer display lists should avoid creating an alpha layer, since alpha is
+ * handled in the drawLayer operation directly (and more efficiently).
+ *
+ * @param caching true if the display list represents a hardware layer, false otherwise.
+ *
+ * @hide
+ */
+ public void setCaching(boolean caching) {
+ nSetCaching(mNativeDisplayList, caching);
+ }
+
+ /**
+ * Set whether the display list should clip itself to its bounds. This property is controlled by
+ * the view's parent.
+ *
+ * @param clipToBounds true if the display list should clip to its bounds
+ */
+ public void setClipToBounds(boolean clipToBounds) {
+ nSetClipToBounds(mNativeDisplayList, clipToBounds);
+ }
+
+ /**
+ * Set whether the display list should collect and Z order all 3d composited descendents, and
+ * draw them in order with the default Z=0 content.
+ *
+ * @param isolatedZVolume true if the display list should collect and Z order descendents.
+ */
+ public void setIsolatedZVolume(boolean isolatedZVolume) {
+ nSetIsolatedZVolume(mNativeDisplayList, isolatedZVolume);
+ }
+
+ /**
+ * Sets whether the display list should be drawn immediately after the
+ * closest ancestor display list where isolateZVolume is true. If the
+ * display list itself satisfies this constraint, changing this attribute
+ * has no effect on drawing order.
+ *
+ * @param shouldProject true if the display list should be projected onto a
+ * containing volume.
+ */
+ public void setProjectBackwards(boolean shouldProject) {
+ nSetProjectBackwards(mNativeDisplayList, shouldProject);
+ }
+
+ /**
+ * Sets whether the display list is a projection receiver - that its parent
+ * DisplayList should draw any descendent DisplayLists with
+ * ProjectBackwards=true directly on top of it. Default value is false.
+ */
+ public void setProjectionReceiver(boolean shouldRecieve) {
+ nSetProjectionReceiver(mNativeDisplayList, shouldRecieve);
+ }
+
+ /**
+ * Sets the outline, defining the shape that casts a shadow, and the path to
+ * be clipped if setClipToOutline is set.
+ *
+ * Deep copies the native path to simplify reference ownership.
+ *
+ * @param outline Convex, CW Path to store in the DisplayList. May be null.
+ */
+ public void setOutline(Path outline) {
+ long nativePath = (outline == null) ? 0 : outline.mNativePath;
+ nSetOutline(mNativeDisplayList, nativePath);
+ }
+
+ /**
+ * Enables or disables clipping to the outline.
+ *
+ * @param clipToOutline true if clipping to the outline.
+ */
+ public void setClipToOutline(boolean clipToOutline) {
+ nSetClipToOutline(mNativeDisplayList, clipToOutline);
+ }
+
+ /**
+ * Set whether the DisplayList should cast a shadow.
+ *
+ * The shape of the shadow casting area is defined by the outline of the display list, if set
+ * and non-empty, otherwise it will be the bounds rect.
+ */
+ public void setCastsShadow(boolean castsShadow) {
+ nSetCastsShadow(mNativeDisplayList, castsShadow);
+ }
+
+ /**
+ * Sets whether the DisplayList should be drawn with perspective applied from the global camera.
+ *
+ * If set to true, camera distance will be ignored. Defaults to false.
+ */
+ public void setUsesGlobalCamera(boolean usesGlobalCamera) {
+ nSetUsesGlobalCamera(mNativeDisplayList, usesGlobalCamera);
+ }
+
+ /**
+ * Set the static matrix on the display list. The specified matrix is combined with other
+ * transforms (such as {@link #setScaleX(float)}, {@link #setRotation(float)}, etc.)
+ *
+ * @param matrix A transform matrix to apply to this display list
+ *
+ * @see #getMatrix(android.graphics.Matrix)
+ * @see #getMatrix()
+ */
+ public void setStaticMatrix(Matrix matrix) {
+ nSetStaticMatrix(mNativeDisplayList, matrix.native_instance);
+ }
+
+ /**
+ * Set the Animation matrix on the display list. This matrix exists if an Animation is
+ * currently playing on a View, and is set on the display list during at draw() time. When
+ * the Animation finishes, the matrix should be cleared by sending <code>null</code>
+ * for the matrix parameter.
+ *
+ * @param matrix The matrix, null indicates that the matrix should be cleared.
+ *
+ * @hide
+ */
+ public void setAnimationMatrix(Matrix matrix) {
+ nSetAnimationMatrix(mNativeDisplayList,
+ (matrix != null) ? matrix.native_instance : 0);
+ }
+
+ /**
+ * Sets the translucency level for the display list.
+ *
+ * @param alpha The translucency of the display list, must be a value between 0.0f and 1.0f
+ *
+ * @see View#setAlpha(float)
+ * @see #getAlpha()
+ */
+ public void setAlpha(float alpha) {
+ nSetAlpha(mNativeDisplayList, alpha);
+ }
+
+ /**
+ * Returns the translucency level of this display list.
+ *
+ * @return A value between 0.0f and 1.0f
+ *
+ * @see #setAlpha(float)
+ */
+ public float getAlpha() {
+ return nGetAlpha(mNativeDisplayList);
+ }
+
+ /**
+ * Sets whether the display list renders content which overlaps. Non-overlapping rendering
+ * can use a fast path for alpha that avoids rendering to an offscreen buffer. By default
+ * display lists consider they do not have overlapping content.
+ *
+ * @param hasOverlappingRendering False if the content is guaranteed to be non-overlapping,
+ * true otherwise.
+ *
+ * @see android.view.View#hasOverlappingRendering()
+ * @see #hasOverlappingRendering()
+ */
+ public void setHasOverlappingRendering(boolean hasOverlappingRendering) {
+ nSetHasOverlappingRendering(mNativeDisplayList, hasOverlappingRendering);
+ }
+
+ /**
+ * Indicates whether the content of this display list overlaps.
+ *
+ * @return True if this display list renders content which overlaps, false otherwise.
+ *
+ * @see #setHasOverlappingRendering(boolean)
+ */
+ public boolean hasOverlappingRendering() {
+ //noinspection SimplifiableIfStatement
+ return nHasOverlappingRendering(mNativeDisplayList);
+ }
+
+ /**
+ * Sets the translation value for the display list on the X axis.
+ *
+ * @param translationX The X axis translation value of the display list, in pixels
+ *
+ * @see View#setTranslationX(float)
+ * @see #getTranslationX()
+ */
+ public void setTranslationX(float translationX) {
+ nSetTranslationX(mNativeDisplayList, translationX);
+ }
+
+ /**
+ * Returns the translation value for this display list on the X axis, in pixels.
+ *
+ * @see #setTranslationX(float)
+ */
+ public float getTranslationX() {
+ return nGetTranslationX(mNativeDisplayList);
+ }
+
+ /**
+ * Sets the translation value for the display list on the Y axis.
+ *
+ * @param translationY The Y axis translation value of the display list, in pixels
+ *
+ * @see View#setTranslationY(float)
+ * @see #getTranslationY()
+ */
+ public void setTranslationY(float translationY) {
+ nSetTranslationY(mNativeDisplayList, translationY);
+ }
+
+ /**
+ * Returns the translation value for this display list on the Y axis, in pixels.
+ *
+ * @see #setTranslationY(float)
+ */
+ public float getTranslationY() {
+ return nGetTranslationY(mNativeDisplayList);
+ }
+
+ /**
+ * Sets the translation value for the display list on the Z axis.
+ *
+ * @see View#setTranslationZ(float)
+ * @see #getTranslationZ()
+ */
+ public void setTranslationZ(float translationZ) {
+ nSetTranslationZ(mNativeDisplayList, translationZ);
+ }
+
+ /**
+ * Returns the translation value for this display list on the Z axis.
+ *
+ * @see #setTranslationZ(float)
+ */
+ public float getTranslationZ() {
+ return nGetTranslationZ(mNativeDisplayList);
+ }
+
+ /**
+ * Sets the rotation value for the display list around the Z axis.
+ *
+ * @param rotation The rotation value of the display list, in degrees
+ *
+ * @see View#setRotation(float)
+ * @see #getRotation()
+ */
+ public void setRotation(float rotation) {
+ nSetRotation(mNativeDisplayList, rotation);
+ }
+
+ /**
+ * Returns the rotation value for this display list around the Z axis, in degrees.
+ *
+ * @see #setRotation(float)
+ */
+ public float getRotation() {
+ return nGetRotation(mNativeDisplayList);
+ }
+
+ /**
+ * Sets the rotation value for the display list around the X axis.
+ *
+ * @param rotationX The rotation value of the display list, in degrees
+ *
+ * @see View#setRotationX(float)
+ * @see #getRotationX()
+ */
+ public void setRotationX(float rotationX) {
+ nSetRotationX(mNativeDisplayList, rotationX);
+ }
+
+ /**
+ * Returns the rotation value for this display list around the X axis, in degrees.
+ *
+ * @see #setRotationX(float)
+ */
+ public float getRotationX() {
+ return nGetRotationX(mNativeDisplayList);
+ }
+
+ /**
+ * Sets the rotation value for the display list around the Y axis.
+ *
+ * @param rotationY The rotation value of the display list, in degrees
+ *
+ * @see View#setRotationY(float)
+ * @see #getRotationY()
+ */
+ public void setRotationY(float rotationY) {
+ nSetRotationY(mNativeDisplayList, rotationY);
+ }
+
+ /**
+ * Returns the rotation value for this display list around the Y axis, in degrees.
+ *
+ * @see #setRotationY(float)
+ */
+ public float getRotationY() {
+ return nGetRotationY(mNativeDisplayList);
+ }
+
+ /**
+ * Sets the scale value for the display list on the X axis.
+ *
+ * @param scaleX The scale value of the display list
+ *
+ * @see View#setScaleX(float)
+ * @see #getScaleX()
+ */
+ public void setScaleX(float scaleX) {
+ nSetScaleX(mNativeDisplayList, scaleX);
+ }
+
+ /**
+ * Returns the scale value for this display list on the X axis.
+ *
+ * @see #setScaleX(float)
+ */
+ public float getScaleX() {
+ return nGetScaleX(mNativeDisplayList);
+ }
+
+ /**
+ * Sets the scale value for the display list on the Y axis.
+ *
+ * @param scaleY The scale value of the display list
+ *
+ * @see View#setScaleY(float)
+ * @see #getScaleY()
+ */
+ public void setScaleY(float scaleY) {
+ nSetScaleY(mNativeDisplayList, scaleY);
+ }
+
+ /**
+ * Returns the scale value for this display list on the Y axis.
+ *
+ * @see #setScaleY(float)
+ */
+ public float getScaleY() {
+ return nGetScaleY(mNativeDisplayList);
+ }
+
+ /**
+ * Sets all of the transform-related values of the display list
+ *
+ * @param alpha The alpha value of the display list
+ * @param translationX The translationX value of the display list
+ * @param translationY The translationY value of the display list
+ * @param rotation The rotation value of the display list
+ * @param rotationX The rotationX value of the display list
+ * @param rotationY The rotationY value of the display list
+ * @param scaleX The scaleX value of the display list
+ * @param scaleY The scaleY value of the display list
+ *
+ * @hide
+ */
+ public void setTransformationInfo(float alpha,
+ float translationX, float translationY, float translationZ,
+ float rotation, float rotationX, float rotationY, float scaleX, float scaleY) {
+ nSetTransformationInfo(mNativeDisplayList, alpha,
+ translationX, translationY, translationZ,
+ rotation, rotationX, rotationY, scaleX, scaleY);
+ }
+
+ /**
+ * Sets the pivot value for the display list on the X axis
+ *
+ * @param pivotX The pivot value of the display list on the X axis, in pixels
+ *
+ * @see View#setPivotX(float)
+ * @see #getPivotX()
+ */
+ public void setPivotX(float pivotX) {
+ nSetPivotX(mNativeDisplayList, pivotX);
+ }
+
+ /**
+ * Returns the pivot value for this display list on the X axis, in pixels.
+ *
+ * @see #setPivotX(float)
+ */
+ public float getPivotX() {
+ return nGetPivotX(mNativeDisplayList);
+ }
+
+ /**
+ * Sets the pivot value for the display list on the Y axis
+ *
+ * @param pivotY The pivot value of the display list on the Y axis, in pixels
+ *
+ * @see View#setPivotY(float)
+ * @see #getPivotY()
+ */
+ public void setPivotY(float pivotY) {
+ nSetPivotY(mNativeDisplayList, pivotY);
+ }
+
+ /**
+ * Returns the pivot value for this display list on the Y axis, in pixels.
+ *
+ * @see #setPivotY(float)
+ */
+ public float getPivotY() {
+ return nGetPivotY(mNativeDisplayList);
+ }
+
+ /**
+ * Sets the camera distance for the display list. Refer to
+ * {@link View#setCameraDistance(float)} for more information on how to
+ * use this property.
+ *
+ * @param distance The distance in Z of the camera of the display list
+ *
+ * @see View#setCameraDistance(float)
+ * @see #getCameraDistance()
+ */
+ public void setCameraDistance(float distance) {
+ nSetCameraDistance(mNativeDisplayList, distance);
+ }
+
+ /**
+ * Returns the distance in Z of the camera of the display list.
+ *
+ * @see #setCameraDistance(float)
+ */
+ public float getCameraDistance() {
+ return nGetCameraDistance(mNativeDisplayList);
+ }
+
+ /**
+ * Sets the left position for the display list.
+ *
+ * @param left The left position, in pixels, of the display list
+ *
+ * @see View#setLeft(int)
+ * @see #getLeft()
+ */
+ public void setLeft(int left) {
+ nSetLeft(mNativeDisplayList, left);
+ }
+
+ /**
+ * Returns the left position for the display list in pixels.
+ *
+ * @see #setLeft(int)
+ */
+ public float getLeft() {
+ return nGetLeft(mNativeDisplayList);
+ }
+
+ /**
+ * Sets the top position for the display list.
+ *
+ * @param top The top position, in pixels, of the display list
+ *
+ * @see View#setTop(int)
+ * @see #getTop()
+ */
+ public void setTop(int top) {
+ nSetTop(mNativeDisplayList, top);
+ }
+
+ /**
+ * Returns the top position for the display list in pixels.
+ *
+ * @see #setTop(int)
+ */
+ public float getTop() {
+ return nGetTop(mNativeDisplayList);
+ }
+
+ /**
+ * Sets the right position for the display list.
+ *
+ * @param right The right position, in pixels, of the display list
+ *
+ * @see View#setRight(int)
+ * @see #getRight()
+ */
+ public void setRight(int right) {
+ nSetRight(mNativeDisplayList, right);
+ }
+
+ /**
+ * Returns the right position for the display list in pixels.
+ *
+ * @see #setRight(int)
+ */
+ public float getRight() {
+ return nGetRight(mNativeDisplayList);
+ }
+
+ /**
+ * Sets the bottom position for the display list.
+ *
+ * @param bottom The bottom position, in pixels, of the display list
+ *
+ * @see View#setBottom(int)
+ * @see #getBottom()
+ */
+ public void setBottom(int bottom) {
+ nSetBottom(mNativeDisplayList, bottom);
+ }
+
+ /**
+ * Returns the bottom position for the display list in pixels.
+ *
+ * @see #setBottom(int)
+ */
+ public float getBottom() {
+ return nGetBottom(mNativeDisplayList);
+ }
+
+ /**
+ * Sets the left and top positions for the display list
+ *
+ * @param left The left position of the display list, in pixels
+ * @param top The top position of the display list, in pixels
+ * @param right The right position of the display list, in pixels
+ * @param bottom The bottom position of the display list, in pixels
+ *
+ * @see View#setLeft(int)
+ * @see View#setTop(int)
+ * @see View#setRight(int)
+ * @see View#setBottom(int)
+ */
+ public void setLeftTopRightBottom(int left, int top, int right, int bottom) {
+ nSetLeftTopRightBottom(mNativeDisplayList, left, top, right, bottom);
+ }
+
+ /**
+ * Offsets the left and right positions for the display list
+ *
+ * @param offset The amount that the left and right positions of the display
+ * list are offset, in pixels
+ *
+ * @see View#offsetLeftAndRight(int)
+ */
+ public void offsetLeftAndRight(float offset) {
+ nOffsetLeftAndRight(mNativeDisplayList, offset);
+ }
+
+ /**
+ * Offsets the top and bottom values for the display list
+ *
+ * @param offset The amount that the top and bottom positions of the display
+ * list are offset, in pixels
+ *
+ * @see View#offsetTopAndBottom(int)
+ */
+ public void offsetTopAndBottom(float offset) {
+ nOffsetTopAndBottom(mNativeDisplayList, offset);
+ }
+
+ /**
+ * Outputs the display list to the log. This method exists for use by
+ * tools to output display lists for selected nodes to the log.
+ *
+ * @hide
+ */
+ public void output() {
+ nOutput(mNativeDisplayList);
+ }
+
+ ///////////////////////////////////////////////////////////////////////////
+ // Native methods
+ ///////////////////////////////////////////////////////////////////////////
+
+ private static native long nCreate();
+ private static native void nDestroyDisplayList(long displayList);
+ private static native void nSetDisplayListName(long displayList, String name);
+
+ // Properties
+
+ private static native void nOffsetTopAndBottom(long displayList, float offset);
+ private static native void nOffsetLeftAndRight(long displayList, float offset);
+ private static native void nSetLeftTopRightBottom(long displayList, int left, int top,
+ int right, int bottom);
+ private static native void nSetBottom(long displayList, int bottom);
+ private static native void nSetRight(long displayList, int right);
+ private static native void nSetTop(long displayList, int top);
+ private static native void nSetLeft(long displayList, int left);
+ private static native void nSetCameraDistance(long displayList, float distance);
+ private static native void nSetPivotY(long displayList, float pivotY);
+ private static native void nSetPivotX(long displayList, float pivotX);
+ private static native void nSetCaching(long displayList, boolean caching);
+ private static native void nSetClipToBounds(long displayList, boolean clipToBounds);
+ private static native void nSetProjectBackwards(long displayList, boolean shouldProject);
+ private static native void nSetProjectionReceiver(long displayList, boolean shouldRecieve);
+ private static native void nSetIsolatedZVolume(long displayList, boolean isolateZVolume);
+ private static native void nSetOutline(long displayList, long nativePath);
+ private static native void nSetClipToOutline(long displayList, boolean clipToOutline);
+ private static native void nSetCastsShadow(long displayList, boolean castsShadow);
+ private static native void nSetUsesGlobalCamera(long displayList, boolean usesGlobalCamera);
+ private static native void nSetAlpha(long displayList, float alpha);
+ private static native void nSetHasOverlappingRendering(long displayList,
+ boolean hasOverlappingRendering);
+ private static native void nSetTranslationX(long displayList, float translationX);
+ private static native void nSetTranslationY(long displayList, float translationY);
+ private static native void nSetTranslationZ(long displayList, float translationZ);
+ private static native void nSetRotation(long displayList, float rotation);
+ private static native void nSetRotationX(long displayList, float rotationX);
+ private static native void nSetRotationY(long displayList, float rotationY);
+ private static native void nSetScaleX(long displayList, float scaleX);
+ private static native void nSetScaleY(long displayList, float scaleY);
+ private static native void nSetTransformationInfo(long displayList, float alpha,
+ float translationX, float translationY, float translationZ,
+ float rotation, float rotationX, float rotationY, float scaleX, float scaleY);
+ private static native void nSetStaticMatrix(long displayList, long nativeMatrix);
+ private static native void nSetAnimationMatrix(long displayList, long animationMatrix);
+
+ private static native boolean nHasOverlappingRendering(long displayList);
+ private static native float nGetAlpha(long displayList);
+ private static native float nGetLeft(long displayList);
+ private static native float nGetTop(long displayList);
+ private static native float nGetRight(long displayList);
+ private static native float nGetBottom(long displayList);
+ private static native float nGetCameraDistance(long displayList);
+ private static native float nGetScaleX(long displayList);
+ private static native float nGetScaleY(long displayList);
+ private static native float nGetTranslationX(long displayList);
+ private static native float nGetTranslationY(long displayList);
+ private static native float nGetTranslationZ(long displayList);
+ private static native float nGetRotation(long displayList);
+ private static native float nGetRotationX(long displayList);
+ private static native float nGetRotationY(long displayList);
+ private static native float nGetPivotX(long displayList);
+ private static native float nGetPivotY(long displayList);
+ private static native void nOutput(long displayList);
+
+ ///////////////////////////////////////////////////////////////////////////
+ // Finalization
+ ///////////////////////////////////////////////////////////////////////////
+
+ @Override
+ protected void finalize() throws Throwable {
+ try {
+ destroyDisplayListData();
+ nDestroyDisplayList(mNativeDisplayList);
+ } finally {
+ super.finalize();
+ }
+ }
+}
diff --git a/core/java/android/view/ThreadedRenderer.java b/core/java/android/view/ThreadedRenderer.java
index a1fb123..2a488a0 100644
--- a/core/java/android/view/ThreadedRenderer.java
+++ b/core/java/android/view/ThreadedRenderer.java
@@ -163,7 +163,7 @@
view.mPrivateFlags &= ~View.PFLAG_INVALIDATED;
Trace.traceBegin(Trace.TRACE_TAG_VIEW, "getDisplayList");
- DisplayList displayList = view.getDisplayList();
+ RenderNode displayList = view.getDisplayList();
Trace.traceEnd(Trace.TRACE_TAG_VIEW);
view.mRecreateDisplayList = false;
diff --git a/core/java/android/view/View.java b/core/java/android/view/View.java
index 7a58d06..eff78d3 100644
--- a/core/java/android/view/View.java
+++ b/core/java/android/view/View.java
@@ -3269,7 +3269,7 @@
* of the background drawable. It is cleared on temporary detach and reset
* on cleanup.
*/
- private DisplayList mBackgroundDisplayList;
+ private RenderNode mBackgroundDisplayList;
private int mBackgroundResource;
private boolean mBackgroundSizeChanged;
@@ -3559,7 +3559,7 @@
* of the View content. It is cleared on temporary detach and reset on
* cleanup.
*/
- DisplayList mDisplayList;
+ RenderNode mDisplayList;
/**
* Set to true when the view is sending hover accessibility events because it
@@ -13802,7 +13802,7 @@
}
mHardwareLayer.setLayerPaint(mLayerPaint);
- DisplayList displayList = mHardwareLayer.startRecording();
+ RenderNode displayList = mHardwareLayer.startRecording();
if (getDisplayList(displayList, true) != displayList) {
throw new IllegalStateException("getDisplayList() didn't return"
+ " the input displaylist for a hardware layer!");
@@ -13952,7 +13952,7 @@
* the view will avoid creating a layer inside the resulting display list.
* @return A new or reused DisplayList object.
*/
- private DisplayList getDisplayList(DisplayList displayList, boolean isLayer) {
+ private RenderNode getDisplayList(RenderNode displayList, boolean isLayer) {
final HardwareRenderer renderer = getHardwareRenderer();
if (renderer == null || !canHaveDisplayList()) {
return null;
@@ -13978,7 +13978,7 @@
mRecreateDisplayList = true;
}
if (displayList == null) {
- displayList = DisplayList.create(getClass().getName());
+ displayList = RenderNode.create(getClass().getName());
// If we're creating a new display list, make sure our parent gets invalidated
// since they will need to recreate their display list to account for this
// new child display list.
@@ -14065,7 +14065,7 @@
*
* @hide
*/
- public DisplayList getDisplayList() {
+ public RenderNode getDisplayList() {
mDisplayList = getDisplayList(mDisplayList, false);
return mDisplayList;
}
@@ -14671,7 +14671,7 @@
* necessary when a display list is being re-created, because we need to make sure that
* previously-set transform values
*/
- void setDisplayListProperties(DisplayList displayList) {
+ void setDisplayListProperties(RenderNode displayList) {
if (displayList != null) {
displayList.setLeftTopRightBottom(mLeft, mTop, mRight, mBottom);
displayList.setHasOverlappingRendering(hasOverlappingRendering());
@@ -14816,7 +14816,7 @@
mPrivateFlags &= ~PFLAG_INVALIDATED;
}
- DisplayList displayList = null;
+ RenderNode displayList = null;
Bitmap cache = null;
boolean hasDisplayList = false;
if (caching) {
@@ -15295,7 +15295,7 @@
&& mAttachInfo.mHardwareRenderer != null) {
mBackgroundDisplayList = getDrawableDisplayList(background, mBackgroundDisplayList);
- final DisplayList displayList = mBackgroundDisplayList;
+ final RenderNode displayList = mBackgroundDisplayList;
if (displayList != null && displayList.isValid()) {
setBackgroundDisplayListProperties(displayList);
((HardwareCanvas) canvas).drawDisplayList(displayList);
@@ -15319,7 +15319,7 @@
*
* @param displayList Valid display list for the background drawable
*/
- private void setBackgroundDisplayListProperties(DisplayList displayList) {
+ private void setBackgroundDisplayListProperties(RenderNode displayList) {
displayList.setTranslationX(mScrollX);
displayList.setTranslationY(mScrollY);
}
@@ -15332,9 +15332,9 @@
* @param displayList Existing display list, or {@code null}
* @return A valid display list for the specified drawable
*/
- private DisplayList getDrawableDisplayList(Drawable drawable, DisplayList displayList) {
+ private RenderNode getDrawableDisplayList(Drawable drawable, RenderNode displayList) {
if (displayList == null) {
- displayList = DisplayList.create(drawable.getClass().getName());
+ displayList = RenderNode.create(drawable.getClass().getName());
}
final Rect bounds = drawable.getBounds();
diff --git a/core/java/android/view/ViewPropertyAnimator.java b/core/java/android/view/ViewPropertyAnimator.java
index 1892aa7..563ffb7 100644
--- a/core/java/android/view/ViewPropertyAnimator.java
+++ b/core/java/android/view/ViewPropertyAnimator.java
@@ -925,7 +925,7 @@
*/
private void setValue(int propertyConstant, float value) {
final View.TransformationInfo info = mView.mTransformationInfo;
- final DisplayList displayList = mView.mDisplayList;
+ final RenderNode displayList = mView.mDisplayList;
switch (propertyConstant) {
case TRANSLATION_X:
info.mTranslationX = value;
diff --git a/core/java/android/view/ViewRootImpl.java b/core/java/android/view/ViewRootImpl.java
index 18517c5..185cb65 100644
--- a/core/java/android/view/ViewRootImpl.java
+++ b/core/java/android/view/ViewRootImpl.java
@@ -1465,7 +1465,7 @@
mWidth, mHeight);
}
mResizeBuffer.prepare(mWidth, mHeight, false);
- DisplayList layerDisplayList = mResizeBuffer.startRecording();
+ RenderNode layerDisplayList = mResizeBuffer.startRecording();
HardwareCanvas layerCanvas = layerDisplayList.start(mWidth, mHeight);
final int restoreCount = layerCanvas.save();
@@ -1484,10 +1484,10 @@
mTranslator.translateCanvas(layerCanvas);
}
- DisplayList displayList = mView.mDisplayList;
+ RenderNode displayList = mView.mDisplayList;
if (displayList != null && displayList.isValid()) {
layerCanvas.drawDisplayList(displayList, null,
- DisplayList.FLAG_CLIP_CHILDREN);
+ RenderNode.FLAG_CLIP_CHILDREN);
} else {
mView.draw(layerCanvas);
}
@@ -2178,7 +2178,7 @@
* @hide
*/
void outputDisplayList(View view) {
- DisplayList displayList = view.getDisplayList();
+ RenderNode displayList = view.getDisplayList();
if (displayList != null) {
displayList.output();
}
@@ -5206,7 +5206,7 @@
}
private static void getGfxInfo(View view, int[] info) {
- DisplayList displayList = view.mDisplayList;
+ RenderNode displayList = view.mDisplayList;
info[0]++;
if (displayList != null) {
info[1] += 0; /* TODO: Memory used by display lists */
diff --git a/core/java/android/widget/Editor.java b/core/java/android/widget/Editor.java
index 53d9e28..333e631 100644
--- a/core/java/android/widget/Editor.java
+++ b/core/java/android/widget/Editor.java
@@ -74,7 +74,7 @@
import android.util.Log;
import android.view.ActionMode;
import android.view.ActionMode.Callback;
-import android.view.DisplayList;
+import android.view.RenderNode;
import android.view.DragEvent;
import android.view.Gravity;
import android.view.HardwareCanvas;
@@ -138,11 +138,11 @@
InputMethodState mInputMethodState;
private static class TextDisplayList {
- DisplayList displayList;
+ RenderNode displayList;
boolean isDirty;
public TextDisplayList(String name) {
isDirty = true;
- displayList = DisplayList.create(name);
+ displayList = RenderNode.create(name);
}
boolean needsRecord() { return isDirty || !displayList.isValid(); }
}
@@ -289,7 +289,7 @@
private void destroyDisplayListsData() {
if (mTextDisplayLists != null) {
for (int i = 0; i < mTextDisplayLists.length; i++) {
- DisplayList displayList = mTextDisplayLists[i] != null
+ RenderNode displayList = mTextDisplayLists[i] != null
? mTextDisplayLists[i].displayList : null;
if (displayList != null && displayList.isValid()) {
displayList.destroyDisplayListData();
@@ -1371,7 +1371,7 @@
}
final boolean blockDisplayListIsInvalid = mTextDisplayLists[blockIndex].needsRecord();
- DisplayList blockDisplayList = mTextDisplayLists[blockIndex].displayList;
+ RenderNode blockDisplayList = mTextDisplayLists[blockIndex].displayList;
if (i >= indexFirstChangedBlock || blockDisplayListIsInvalid) {
final int blockBeginLine = endOfPreviousBlock + 1;
final int top = layout.getLineTop(blockBeginLine);
diff --git a/core/jni/Android.mk b/core/jni/Android.mk
index a09c314..51c5a86 100644
--- a/core/jni/Android.mk
+++ b/core/jni/Android.mk
@@ -42,7 +42,6 @@
android_database_SQLiteDebug.cpp \
android_emoji_EmojiFactory.cpp \
android_view_DisplayEventReceiver.cpp \
- android_view_DisplayList.cpp \
android_view_Surface.cpp \
android_view_SurfaceControl.cpp \
android_view_SurfaceSession.cpp \
@@ -61,6 +60,7 @@
android_view_ThreadedRenderer.cpp \
android_view_MotionEvent.cpp \
android_view_PointerIcon.cpp \
+ android_view_RenderNode.cpp \
android_view_VelocityTracker.cpp \
android_text_AndroidCharacter.cpp \
android_text_AndroidBidi.cpp \
diff --git a/core/jni/AndroidRuntime.cpp b/core/jni/AndroidRuntime.cpp
index 94c3f44..05d7d29 100644
--- a/core/jni/AndroidRuntime.cpp
+++ b/core/jni/AndroidRuntime.cpp
@@ -119,7 +119,7 @@
extern int register_android_graphics_Xfermode(JNIEnv* env);
extern int register_android_graphics_pdf_PdfDocument(JNIEnv* env);
extern int register_android_view_DisplayEventReceiver(JNIEnv* env);
-extern int register_android_view_DisplayList(JNIEnv* env);
+extern int register_android_view_RenderNode(JNIEnv* env);
extern int register_android_view_GraphicBuffer(JNIEnv* env);
extern int register_android_view_GLES20Canvas(JNIEnv* env);
extern int register_android_view_GLRenderer(JNIEnv* env);
@@ -1173,7 +1173,7 @@
REG_JNI(register_android_nio_utils),
REG_JNI(register_android_graphics_Graphics),
REG_JNI(register_android_view_DisplayEventReceiver),
- REG_JNI(register_android_view_DisplayList),
+ REG_JNI(register_android_view_RenderNode),
REG_JNI(register_android_view_GraphicBuffer),
REG_JNI(register_android_view_GLES20Canvas),
REG_JNI(register_android_view_GLRenderer),
diff --git a/core/jni/android_view_DisplayList.cpp b/core/jni/android_view_RenderNode.cpp
similarity index 67%
rename from core/jni/android_view_DisplayList.cpp
rename to core/jni/android_view_RenderNode.cpp
index 4a6346e..2f69b8b 100644
--- a/core/jni/android_view_DisplayList.cpp
+++ b/core/jni/android_view_RenderNode.cpp
@@ -41,7 +41,7 @@
// DisplayList view properties
// ----------------------------------------------------------------------------
-static void android_view_DisplayList_setDisplayListName(JNIEnv* env,
+static void android_view_RenderNode_setDisplayListName(JNIEnv* env,
jobject clazz, jlong displayListPtr, jstring name) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
if (name != NULL) {
@@ -51,18 +51,18 @@
}
}
-static void android_view_DisplayList_output(JNIEnv* env,
+static void android_view_RenderNode_output(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->output();
}
-static jlong android_view_DisplayList_create(JNIEnv* env, jobject clazz) {
+static jlong android_view_RenderNode_create(JNIEnv* env, jobject clazz) {
RenderNode* displayList = new RenderNode();
return reinterpret_cast<jlong>(displayList);
}
-static void android_view_DisplayList_destroyDisplayList(JNIEnv* env,
+static void android_view_RenderNode_destroyDisplayList(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
RenderNode::destroyDisplayListDeferred(displayList);
@@ -72,135 +72,135 @@
// DisplayList view properties
// ----------------------------------------------------------------------------
-static void android_view_DisplayList_setCaching(JNIEnv* env,
+static void android_view_RenderNode_setCaching(JNIEnv* env,
jobject clazz, jlong displayListPtr, jboolean caching) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setCaching(caching);
}
-static void android_view_DisplayList_setStaticMatrix(JNIEnv* env,
+static void android_view_RenderNode_setStaticMatrix(JNIEnv* env,
jobject clazz, jlong displayListPtr, jlong matrixPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
displayList->properties().setStaticMatrix(matrix);
}
-static void android_view_DisplayList_setAnimationMatrix(JNIEnv* env,
+static void android_view_RenderNode_setAnimationMatrix(JNIEnv* env,
jobject clazz, jlong displayListPtr, jlong matrixPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
displayList->properties().setAnimationMatrix(matrix);
}
-static void android_view_DisplayList_setClipToBounds(JNIEnv* env,
+static void android_view_RenderNode_setClipToBounds(JNIEnv* env,
jobject clazz, jlong displayListPtr, jboolean clipToBounds) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setClipToBounds(clipToBounds);
}
-static void android_view_DisplayList_setIsolatedZVolume(JNIEnv* env,
+static void android_view_RenderNode_setIsolatedZVolume(JNIEnv* env,
jobject clazz, jlong displayListPtr, jboolean shouldIsolate) {
// No-op, TODO: Remove Java usage of this method
}
-static void android_view_DisplayList_setProjectBackwards(JNIEnv* env,
+static void android_view_RenderNode_setProjectBackwards(JNIEnv* env,
jobject clazz, jlong displayListPtr, jboolean shouldProject) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setProjectBackwards(shouldProject);
}
-static void android_view_DisplayList_setProjectionReceiver(JNIEnv* env,
+static void android_view_RenderNode_setProjectionReceiver(JNIEnv* env,
jobject clazz, jlong displayListPtr, jboolean shouldRecieve) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setProjectionReceiver(shouldRecieve);
}
-static void android_view_DisplayList_setOutline(JNIEnv* env,
+static void android_view_RenderNode_setOutline(JNIEnv* env,
jobject clazz, jlong displayListPtr, jlong outlinePathPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
SkPath* outline = reinterpret_cast<SkPath*>(outlinePathPtr);
displayList->properties().setOutline(outline);
}
-static void android_view_DisplayList_setClipToOutline(JNIEnv* env,
+static void android_view_RenderNode_setClipToOutline(JNIEnv* env,
jobject clazz, jlong displayListPtr, jboolean clipToOutline) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setClipToOutline(clipToOutline);
}
-static void android_view_DisplayList_setCastsShadow(JNIEnv* env,
+static void android_view_RenderNode_setCastsShadow(JNIEnv* env,
jobject clazz, jlong displayListPtr, jboolean castsShadow) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setCastsShadow(castsShadow);
}
-static void android_view_DisplayList_setUsesGlobalCamera(JNIEnv* env,
+static void android_view_RenderNode_setUsesGlobalCamera(JNIEnv* env,
jobject clazz, jlong displayListPtr, jboolean usesGlobalCamera) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setUsesGlobalCamera(usesGlobalCamera);
}
-static void android_view_DisplayList_setAlpha(JNIEnv* env,
+static void android_view_RenderNode_setAlpha(JNIEnv* env,
jobject clazz, jlong displayListPtr, float alpha) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setAlpha(alpha);
}
-static void android_view_DisplayList_setHasOverlappingRendering(JNIEnv* env,
+static void android_view_RenderNode_setHasOverlappingRendering(JNIEnv* env,
jobject clazz, jlong displayListPtr, bool hasOverlappingRendering) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setHasOverlappingRendering(hasOverlappingRendering);
}
-static void android_view_DisplayList_setTranslationX(JNIEnv* env,
+static void android_view_RenderNode_setTranslationX(JNIEnv* env,
jobject clazz, jlong displayListPtr, float tx) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setTranslationX(tx);
}
-static void android_view_DisplayList_setTranslationY(JNIEnv* env,
+static void android_view_RenderNode_setTranslationY(JNIEnv* env,
jobject clazz, jlong displayListPtr, float ty) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setTranslationY(ty);
}
-static void android_view_DisplayList_setTranslationZ(JNIEnv* env,
+static void android_view_RenderNode_setTranslationZ(JNIEnv* env,
jobject clazz, jlong displayListPtr, float tz) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setTranslationZ(tz);
}
-static void android_view_DisplayList_setRotation(JNIEnv* env,
+static void android_view_RenderNode_setRotation(JNIEnv* env,
jobject clazz, jlong displayListPtr, float rotation) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setRotation(rotation);
}
-static void android_view_DisplayList_setRotationX(JNIEnv* env,
+static void android_view_RenderNode_setRotationX(JNIEnv* env,
jobject clazz, jlong displayListPtr, float rx) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setRotationX(rx);
}
-static void android_view_DisplayList_setRotationY(JNIEnv* env,
+static void android_view_RenderNode_setRotationY(JNIEnv* env,
jobject clazz, jlong displayListPtr, float ry) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setRotationY(ry);
}
-static void android_view_DisplayList_setScaleX(JNIEnv* env,
+static void android_view_RenderNode_setScaleX(JNIEnv* env,
jobject clazz, jlong displayListPtr, float sx) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setScaleX(sx);
}
-static void android_view_DisplayList_setScaleY(JNIEnv* env,
+static void android_view_RenderNode_setScaleY(JNIEnv* env,
jobject clazz, jlong displayListPtr, float sy) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setScaleY(sy);
}
-static void android_view_DisplayList_setTransformationInfo(JNIEnv* env,
+static void android_view_RenderNode_setTransformationInfo(JNIEnv* env,
jobject clazz, jlong displayListPtr, float alpha,
float translationX, float translationY, float translationZ,
float rotation, float rotationX, float rotationY, float scaleX, float scaleY) {
@@ -216,158 +216,158 @@
displayList->properties().setScaleY(scaleY);
}
-static void android_view_DisplayList_setPivotX(JNIEnv* env,
+static void android_view_RenderNode_setPivotX(JNIEnv* env,
jobject clazz, jlong displayListPtr, float px) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setPivotX(px);
}
-static void android_view_DisplayList_setPivotY(JNIEnv* env,
+static void android_view_RenderNode_setPivotY(JNIEnv* env,
jobject clazz, jlong displayListPtr, float py) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setPivotY(py);
}
-static void android_view_DisplayList_setCameraDistance(JNIEnv* env,
+static void android_view_RenderNode_setCameraDistance(JNIEnv* env,
jobject clazz, jlong displayListPtr, float distance) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setCameraDistance(distance);
}
-static void android_view_DisplayList_setLeft(JNIEnv* env,
+static void android_view_RenderNode_setLeft(JNIEnv* env,
jobject clazz, jlong displayListPtr, int left) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setLeft(left);
}
-static void android_view_DisplayList_setTop(JNIEnv* env,
+static void android_view_RenderNode_setTop(JNIEnv* env,
jobject clazz, jlong displayListPtr, int top) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setTop(top);
}
-static void android_view_DisplayList_setRight(JNIEnv* env,
+static void android_view_RenderNode_setRight(JNIEnv* env,
jobject clazz, jlong displayListPtr, int right) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setRight(right);
}
-static void android_view_DisplayList_setBottom(JNIEnv* env,
+static void android_view_RenderNode_setBottom(JNIEnv* env,
jobject clazz, jlong displayListPtr, int bottom) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setBottom(bottom);
}
-static void android_view_DisplayList_setLeftTopRightBottom(JNIEnv* env,
+static void android_view_RenderNode_setLeftTopRightBottom(JNIEnv* env,
jobject clazz, jlong displayListPtr, int left, int top,
int right, int bottom) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().setLeftTopRightBottom(left, top, right, bottom);
}
-static void android_view_DisplayList_offsetLeftAndRight(JNIEnv* env,
+static void android_view_RenderNode_offsetLeftAndRight(JNIEnv* env,
jobject clazz, jlong displayListPtr, float offset) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().offsetLeftRight(offset);
}
-static void android_view_DisplayList_offsetTopAndBottom(JNIEnv* env,
+static void android_view_RenderNode_offsetTopAndBottom(JNIEnv* env,
jobject clazz, jlong displayListPtr, float offset) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->properties().offsetTopBottom(offset);
}
-static jboolean android_view_DisplayList_hasOverlappingRendering(JNIEnv* env,
+static jboolean android_view_RenderNode_hasOverlappingRendering(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->properties().hasOverlappingRendering();
}
-static jfloat android_view_DisplayList_getAlpha(JNIEnv* env,
+static jfloat android_view_RenderNode_getAlpha(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->properties().getAlpha();
}
-static jfloat android_view_DisplayList_getLeft(JNIEnv* env,
+static jfloat android_view_RenderNode_getLeft(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->properties().getLeft();
}
-static jfloat android_view_DisplayList_getTop(JNIEnv* env,
+static jfloat android_view_RenderNode_getTop(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->properties().getTop();
}
-static jfloat android_view_DisplayList_getRight(JNIEnv* env,
+static jfloat android_view_RenderNode_getRight(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->properties().getRight();
}
-static jfloat android_view_DisplayList_getBottom(JNIEnv* env,
+static jfloat android_view_RenderNode_getBottom(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->properties().getBottom();
}
-static jfloat android_view_DisplayList_getCameraDistance(JNIEnv* env,
+static jfloat android_view_RenderNode_getCameraDistance(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->properties().getCameraDistance();
}
-static jfloat android_view_DisplayList_getScaleX(JNIEnv* env,
+static jfloat android_view_RenderNode_getScaleX(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->properties().getScaleX();
}
-static jfloat android_view_DisplayList_getScaleY(JNIEnv* env,
+static jfloat android_view_RenderNode_getScaleY(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->properties().getScaleY();
}
-static jfloat android_view_DisplayList_getTranslationX(JNIEnv* env,
+static jfloat android_view_RenderNode_getTranslationX(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->properties().getTranslationX();
}
-static jfloat android_view_DisplayList_getTranslationY(JNIEnv* env,
+static jfloat android_view_RenderNode_getTranslationY(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->properties().getTranslationY();
}
-static jfloat android_view_DisplayList_getRotation(JNIEnv* env,
+static jfloat android_view_RenderNode_getRotation(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->properties().getRotation();
}
-static jfloat android_view_DisplayList_getRotationX(JNIEnv* env,
+static jfloat android_view_RenderNode_getRotationX(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->properties().getRotationX();
}
-static jfloat android_view_DisplayList_getRotationY(JNIEnv* env,
+static jfloat android_view_RenderNode_getRotationY(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->properties().getRotationY();
}
-static jfloat android_view_DisplayList_getPivotX(JNIEnv* env,
+static jfloat android_view_RenderNode_getPivotX(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->properties().getPivotX();
}
-static jfloat android_view_DisplayList_getPivotY(JNIEnv* env,
+static jfloat android_view_RenderNode_getPivotY(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->properties().getPivotY();
@@ -379,67 +379,67 @@
// JNI Glue
// ----------------------------------------------------------------------------
-const char* const kClassPathName = "android/view/DisplayList";
+const char* const kClassPathName = "android/view/RenderNode";
static JNINativeMethod gMethods[] = {
#ifdef USE_OPENGL_RENDERER
- { "nCreate", "()J", (void*) android_view_DisplayList_create },
- { "nDestroyDisplayList", "(J)V", (void*) android_view_DisplayList_destroyDisplayList },
+ { "nCreate", "()J", (void*) android_view_RenderNode_create },
+ { "nDestroyDisplayList", "(J)V", (void*) android_view_RenderNode_destroyDisplayList },
{ "nSetDisplayListName", "(JLjava/lang/String;)V",
- (void*) android_view_DisplayList_setDisplayListName },
- { "nOutput", "(J)V", (void*) android_view_DisplayList_output },
+ (void*) android_view_RenderNode_setDisplayListName },
+ { "nOutput", "(J)V", (void*) android_view_RenderNode_output },
- { "nSetCaching", "(JZ)V", (void*) android_view_DisplayList_setCaching },
- { "nSetStaticMatrix", "(JJ)V", (void*) android_view_DisplayList_setStaticMatrix },
- { "nSetAnimationMatrix", "(JJ)V", (void*) android_view_DisplayList_setAnimationMatrix },
- { "nSetClipToBounds", "(JZ)V", (void*) android_view_DisplayList_setClipToBounds },
- { "nSetIsolatedZVolume", "(JZ)V", (void*) android_view_DisplayList_setIsolatedZVolume },
- { "nSetProjectBackwards", "(JZ)V", (void*) android_view_DisplayList_setProjectBackwards },
- { "nSetProjectionReceiver","(JZ)V", (void*) android_view_DisplayList_setProjectionReceiver },
- { "nSetOutline", "(JJ)V", (void*) android_view_DisplayList_setOutline },
- { "nSetClipToOutline", "(JZ)V", (void*) android_view_DisplayList_setClipToOutline },
- { "nSetCastsShadow", "(JZ)V", (void*) android_view_DisplayList_setCastsShadow },
- { "nSetUsesGlobalCamera", "(JZ)V", (void*) android_view_DisplayList_setUsesGlobalCamera },
- { "nSetAlpha", "(JF)V", (void*) android_view_DisplayList_setAlpha },
+ { "nSetCaching", "(JZ)V", (void*) android_view_RenderNode_setCaching },
+ { "nSetStaticMatrix", "(JJ)V", (void*) android_view_RenderNode_setStaticMatrix },
+ { "nSetAnimationMatrix", "(JJ)V", (void*) android_view_RenderNode_setAnimationMatrix },
+ { "nSetClipToBounds", "(JZ)V", (void*) android_view_RenderNode_setClipToBounds },
+ { "nSetIsolatedZVolume", "(JZ)V", (void*) android_view_RenderNode_setIsolatedZVolume },
+ { "nSetProjectBackwards", "(JZ)V", (void*) android_view_RenderNode_setProjectBackwards },
+ { "nSetProjectionReceiver","(JZ)V", (void*) android_view_RenderNode_setProjectionReceiver },
+ { "nSetOutline", "(JJ)V", (void*) android_view_RenderNode_setOutline },
+ { "nSetClipToOutline", "(JZ)V", (void*) android_view_RenderNode_setClipToOutline },
+ { "nSetCastsShadow", "(JZ)V", (void*) android_view_RenderNode_setCastsShadow },
+ { "nSetUsesGlobalCamera", "(JZ)V", (void*) android_view_RenderNode_setUsesGlobalCamera },
+ { "nSetAlpha", "(JF)V", (void*) android_view_RenderNode_setAlpha },
{ "nSetHasOverlappingRendering", "(JZ)V",
- (void*) android_view_DisplayList_setHasOverlappingRendering },
- { "nSetTranslationX", "(JF)V", (void*) android_view_DisplayList_setTranslationX },
- { "nSetTranslationY", "(JF)V", (void*) android_view_DisplayList_setTranslationY },
- { "nSetTranslationZ", "(JF)V", (void*) android_view_DisplayList_setTranslationZ },
- { "nSetRotation", "(JF)V", (void*) android_view_DisplayList_setRotation },
- { "nSetRotationX", "(JF)V", (void*) android_view_DisplayList_setRotationX },
- { "nSetRotationY", "(JF)V", (void*) android_view_DisplayList_setRotationY },
- { "nSetScaleX", "(JF)V", (void*) android_view_DisplayList_setScaleX },
- { "nSetScaleY", "(JF)V", (void*) android_view_DisplayList_setScaleY },
+ (void*) android_view_RenderNode_setHasOverlappingRendering },
+ { "nSetTranslationX", "(JF)V", (void*) android_view_RenderNode_setTranslationX },
+ { "nSetTranslationY", "(JF)V", (void*) android_view_RenderNode_setTranslationY },
+ { "nSetTranslationZ", "(JF)V", (void*) android_view_RenderNode_setTranslationZ },
+ { "nSetRotation", "(JF)V", (void*) android_view_RenderNode_setRotation },
+ { "nSetRotationX", "(JF)V", (void*) android_view_RenderNode_setRotationX },
+ { "nSetRotationY", "(JF)V", (void*) android_view_RenderNode_setRotationY },
+ { "nSetScaleX", "(JF)V", (void*) android_view_RenderNode_setScaleX },
+ { "nSetScaleY", "(JF)V", (void*) android_view_RenderNode_setScaleY },
{ "nSetTransformationInfo","(JFFFFFFFFF)V",
- (void*) android_view_DisplayList_setTransformationInfo },
- { "nSetPivotX", "(JF)V", (void*) android_view_DisplayList_setPivotX },
- { "nSetPivotY", "(JF)V", (void*) android_view_DisplayList_setPivotY },
- { "nSetCameraDistance", "(JF)V", (void*) android_view_DisplayList_setCameraDistance },
- { "nSetLeft", "(JI)V", (void*) android_view_DisplayList_setLeft },
- { "nSetTop", "(JI)V", (void*) android_view_DisplayList_setTop },
- { "nSetRight", "(JI)V", (void*) android_view_DisplayList_setRight },
- { "nSetBottom", "(JI)V", (void*) android_view_DisplayList_setBottom },
- { "nSetLeftTopRightBottom","(JIIII)V", (void*) android_view_DisplayList_setLeftTopRightBottom },
- { "nOffsetLeftAndRight", "(JF)V", (void*) android_view_DisplayList_offsetLeftAndRight },
- { "nOffsetTopAndBottom", "(JF)V", (void*) android_view_DisplayList_offsetTopAndBottom },
+ (void*) android_view_RenderNode_setTransformationInfo },
+ { "nSetPivotX", "(JF)V", (void*) android_view_RenderNode_setPivotX },
+ { "nSetPivotY", "(JF)V", (void*) android_view_RenderNode_setPivotY },
+ { "nSetCameraDistance", "(JF)V", (void*) android_view_RenderNode_setCameraDistance },
+ { "nSetLeft", "(JI)V", (void*) android_view_RenderNode_setLeft },
+ { "nSetTop", "(JI)V", (void*) android_view_RenderNode_setTop },
+ { "nSetRight", "(JI)V", (void*) android_view_RenderNode_setRight },
+ { "nSetBottom", "(JI)V", (void*) android_view_RenderNode_setBottom },
+ { "nSetLeftTopRightBottom","(JIIII)V", (void*) android_view_RenderNode_setLeftTopRightBottom },
+ { "nOffsetLeftAndRight", "(JF)V", (void*) android_view_RenderNode_offsetLeftAndRight },
+ { "nOffsetTopAndBottom", "(JF)V", (void*) android_view_RenderNode_offsetTopAndBottom },
- { "nHasOverlappingRendering", "(J)Z", (void*) android_view_DisplayList_hasOverlappingRendering },
- { "nGetAlpha", "(J)F", (void*) android_view_DisplayList_getAlpha },
- { "nGetLeft", "(J)F", (void*) android_view_DisplayList_getLeft },
- { "nGetTop", "(J)F", (void*) android_view_DisplayList_getTop },
- { "nGetRight", "(J)F", (void*) android_view_DisplayList_getRight },
- { "nGetBottom", "(J)F", (void*) android_view_DisplayList_getBottom },
- { "nGetCameraDistance", "(J)F", (void*) android_view_DisplayList_getCameraDistance },
- { "nGetScaleX", "(J)F", (void*) android_view_DisplayList_getScaleX },
- { "nGetScaleY", "(J)F", (void*) android_view_DisplayList_getScaleY },
- { "nGetTranslationX", "(J)F", (void*) android_view_DisplayList_getTranslationX },
- { "nGetTranslationY", "(J)F", (void*) android_view_DisplayList_getTranslationY },
- { "nGetRotation", "(J)F", (void*) android_view_DisplayList_getRotation },
- { "nGetRotationX", "(J)F", (void*) android_view_DisplayList_getRotationX },
- { "nGetRotationY", "(J)F", (void*) android_view_DisplayList_getRotationY },
- { "nGetPivotX", "(J)F", (void*) android_view_DisplayList_getPivotX },
- { "nGetPivotY", "(J)F", (void*) android_view_DisplayList_getPivotY },
+ { "nHasOverlappingRendering", "(J)Z", (void*) android_view_RenderNode_hasOverlappingRendering },
+ { "nGetAlpha", "(J)F", (void*) android_view_RenderNode_getAlpha },
+ { "nGetLeft", "(J)F", (void*) android_view_RenderNode_getLeft },
+ { "nGetTop", "(J)F", (void*) android_view_RenderNode_getTop },
+ { "nGetRight", "(J)F", (void*) android_view_RenderNode_getRight },
+ { "nGetBottom", "(J)F", (void*) android_view_RenderNode_getBottom },
+ { "nGetCameraDistance", "(J)F", (void*) android_view_RenderNode_getCameraDistance },
+ { "nGetScaleX", "(J)F", (void*) android_view_RenderNode_getScaleX },
+ { "nGetScaleY", "(J)F", (void*) android_view_RenderNode_getScaleY },
+ { "nGetTranslationX", "(J)F", (void*) android_view_RenderNode_getTranslationX },
+ { "nGetTranslationY", "(J)F", (void*) android_view_RenderNode_getTranslationY },
+ { "nGetRotation", "(J)F", (void*) android_view_RenderNode_getRotation },
+ { "nGetRotationX", "(J)F", (void*) android_view_RenderNode_getRotationX },
+ { "nGetRotationY", "(J)F", (void*) android_view_RenderNode_getRotationY },
+ { "nGetPivotX", "(J)F", (void*) android_view_RenderNode_getPivotX },
+ { "nGetPivotY", "(J)F", (void*) android_view_RenderNode_getPivotY },
#endif
};
@@ -456,7 +456,7 @@
#define GET_METHOD_ID(var, clazz, methodName, methodDescriptor)
#endif
-int register_android_view_DisplayList(JNIEnv* env) {
+int register_android_view_RenderNode(JNIEnv* env) {
return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods));
}
diff --git a/tests/HwAccelerationTest/src/com/android/test/hwui/ProjectionActivity.java b/tests/HwAccelerationTest/src/com/android/test/hwui/ProjectionActivity.java
index 208c387..5ba3ad9 100644
--- a/tests/HwAccelerationTest/src/com/android/test/hwui/ProjectionActivity.java
+++ b/tests/HwAccelerationTest/src/com/android/test/hwui/ProjectionActivity.java
@@ -8,7 +8,7 @@
import android.app.Activity;
import android.util.AttributeSet;
-import android.view.DisplayList;
+import android.view.RenderNode;
import android.view.View;
import android.widget.LinearLayout;
@@ -46,7 +46,7 @@
}
private void setProject(boolean value) {
- DisplayList displayList = getDisplayList();
+ RenderNode displayList = getDisplayList();
if (displayList != null) {
displayList.setProjectBackwards(value);
}
diff --git a/tests/RenderThreadTest/src/com/example/renderthread/MainActivity.java b/tests/RenderThreadTest/src/com/example/renderthread/MainActivity.java
index a39aba8..09531fd 100644
--- a/tests/RenderThreadTest/src/com/example/renderthread/MainActivity.java
+++ b/tests/RenderThreadTest/src/com/example/renderthread/MainActivity.java
@@ -7,7 +7,7 @@
import android.os.Bundle;
import android.os.Handler;
import android.os.SystemClock;
-import android.view.DisplayList;
+import android.view.RenderNode;
import android.view.HardwareRenderer;
import android.view.ThreadedRenderer;
import android.view.View;
@@ -70,7 +70,7 @@
private static final TimeInterpolator sDefaultInterpolator =
new AccelerateDecelerateInterpolator();
- DisplayList mDisplayList;
+ RenderNode mDisplayList;
float mFromValue;
float mDelta;
long mDuration = DURATION * 2;