core/java/android/view/GLES20DisplayList.java - platform/frameworks/base - Git at Google

 /*
  * 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.Bitmap;
 import android.graphics.Matrix;

 import java.util.ArrayList;

 /**
  * An implementation of display list for OpenGL ES 2.0.
  */
 class GLES20DisplayList extends DisplayList {
     // These lists ensure that any Bitmaps and DisplayLists recorded by a DisplayList are kept
     // alive as long as the DisplayList is alive.  The Bitmap and DisplayList lists
     // are populated by the GLES20RecordingCanvas during appropriate drawing calls and are
     // cleared at the start of a new drawing frame or when the view is detached from the window.
     final ArrayList<Bitmap> mBitmaps = new ArrayList<Bitmap>(5);
     final ArrayList<DisplayList> mChildDisplayLists = new ArrayList<DisplayList>();

     private GLES20RecordingCanvas mCanvas;
     private boolean mValid;

     // Used for debugging
     private final String mName;

     // The native display list will be destroyed when this object dies.
     // DO NOT overwrite this reference once it is set.
     private DisplayListFinalizer mFinalizer;

     GLES20DisplayList(String name) {
         mName = name;
     }

     boolean hasNativeDisplayList() {
         return mValid && mFinalizer != null;
     }

     int getNativeDisplayList() {
         if (!mValid || mFinalizer == null) {
             throw new IllegalStateException("The display list is not valid.");
         }
         return mFinalizer.mNativeDisplayList;
     }

     @Override
     public HardwareCanvas start() {
         if (mCanvas != null) {
             throw new IllegalStateException("Recording has already started");
         }

         mValid = false;
         mCanvas = GLES20RecordingCanvas.obtain(this);
         mCanvas.start();
         return mCanvas;
     }

     @Override
     public void invalidate() {
         if (mCanvas != null) {
             mCanvas.recycle();
             mCanvas = null;
         }
         mValid = false;
     }

     @Override
     public void clear() {
         if (!mValid) {
             mBitmaps.clear();
             mChildDisplayLists.clear();
         }
     }

     @Override
     public void reset() {
         if (hasNativeDisplayList()) {
             nReset(mFinalizer.mNativeDisplayList);
         }
     }

     @Override
     public boolean isValid() {
         return mValid;
     }

     @Override
     public void end() {
         if (mCanvas != null) {
             if (mFinalizer != null) {
                 mCanvas.end(mFinalizer.mNativeDisplayList);
             } else {
                 mFinalizer = new DisplayListFinalizer(mCanvas.end(0));
                 GLES20Canvas.setDisplayListName(mFinalizer.mNativeDisplayList, mName);
             }
             mCanvas.recycle();
             mCanvas = null;
             mValid = true;
         }
     }

     @Override
     public int getSize() {
         if (mFinalizer == null) return 0;
         return GLES20Canvas.getDisplayListSize(mFinalizer.mNativeDisplayList);
     }

     ///////////////////////////////////////////////////////////////////////////
     // Native View Properties
     ///////////////////////////////////////////////////////////////////////////

     @Override
     public void setCaching(boolean caching) {
         if (hasNativeDisplayList()) {
             nSetCaching(mFinalizer.mNativeDisplayList, caching);
         }
     }

     @Override
     public void setClipChildren(boolean clipChildren) {
         if (hasNativeDisplayList()) {
             nSetClipChildren(mFinalizer.mNativeDisplayList, clipChildren);
         }
     }

     @Override
     public void setStaticMatrix(Matrix matrix) {
         if (hasNativeDisplayList()) {
             nSetStaticMatrix(mFinalizer.mNativeDisplayList, matrix.native_instance);
         }
     }

     @Override
     public void setAnimationMatrix(Matrix matrix) {
         if (hasNativeDisplayList()) {
             nSetAnimationMatrix(mFinalizer.mNativeDisplayList,
                     (matrix != null) ? matrix.native_instance : 0);
         }
     }

     @Override
     public void setAlpha(float alpha) {
         if (hasNativeDisplayList()) {
             nSetAlpha(mFinalizer.mNativeDisplayList, alpha);
         }
     }

     @Override
     public void setHasOverlappingRendering(boolean hasOverlappingRendering) {
         if (hasNativeDisplayList()) {
             nSetHasOverlappingRendering(mFinalizer.mNativeDisplayList, hasOverlappingRendering);
         }
     }

     @Override
     public void setTranslationX(float translationX) {
         if (hasNativeDisplayList()) {
             nSetTranslationX(mFinalizer.mNativeDisplayList, translationX);
         }
     }

     @Override
     public void setTranslationY(float translationY) {
         if (hasNativeDisplayList()) {
             nSetTranslationY(mFinalizer.mNativeDisplayList, translationY);
         }
     }

     @Override
     public void setRotation(float rotation) {
         if (hasNativeDisplayList()) {
             nSetRotation(mFinalizer.mNativeDisplayList, rotation);
         }
     }

     @Override
     public void setRotationX(float rotationX) {
         if (hasNativeDisplayList()) {
             nSetRotationX(mFinalizer.mNativeDisplayList, rotationX);
         }
     }

     @Override
     public void setRotationY(float rotationY) {
         if (hasNativeDisplayList()) {
             nSetRotationY(mFinalizer.mNativeDisplayList, rotationY);
         }
     }

     @Override
     public void setScaleX(float scaleX) {
         if (hasNativeDisplayList()) {
             nSetScaleX(mFinalizer.mNativeDisplayList, scaleX);
         }
     }

     @Override
     public void setScaleY(float scaleY) {
         if (hasNativeDisplayList()) {
             nSetScaleY(mFinalizer.mNativeDisplayList, scaleY);
         }
     }

     @Override
     public void setTransformationInfo(float alpha, float translationX, float translationY,
             float rotation, float rotationX, float rotationY, float scaleX, float scaleY) {
         if (hasNativeDisplayList()) {
             nSetTransformationInfo(mFinalizer.mNativeDisplayList, alpha, translationX, translationY,
                     rotation, rotationX, rotationY, scaleX, scaleY);
         }
     }

     @Override
     public void setPivotX(float pivotX) {
         if (hasNativeDisplayList()) {
             nSetPivotX(mFinalizer.mNativeDisplayList, pivotX);
         }
     }

     @Override
     public void setPivotY(float pivotY) {
         if (hasNativeDisplayList()) {
             nSetPivotY(mFinalizer.mNativeDisplayList, pivotY);
         }
     }

     @Override
     public void setCameraDistance(float distance) {
         if (hasNativeDisplayList()) {
             nSetCameraDistance(mFinalizer.mNativeDisplayList, distance);
         }
     }

     @Override
     public void setLeft(int left) {
         if (hasNativeDisplayList()) {
             nSetLeft(mFinalizer.mNativeDisplayList, left);
         }
     }

     @Override
     public void setTop(int top) {
         if (hasNativeDisplayList()) {
             nSetTop(mFinalizer.mNativeDisplayList, top);
         }
     }

     @Override
     public void setRight(int right) {
         if (hasNativeDisplayList()) {
             nSetRight(mFinalizer.mNativeDisplayList, right);
         }
     }

     @Override
     public void setBottom(int bottom) {
         if (hasNativeDisplayList()) {
             nSetBottom(mFinalizer.mNativeDisplayList, bottom);
         }
     }

     @Override
     public void setLeftTop(int left, int top) {
         if (hasNativeDisplayList()) {
             nSetLeftTop(mFinalizer.mNativeDisplayList, left, top);
         }
     }

     @Override
     public void setLeftTopRightBottom(int left, int top, int right, int bottom) {
         if (hasNativeDisplayList()) {
             nSetLeftTopRightBottom(mFinalizer.mNativeDisplayList, left, top, right, bottom);
         }
     }

     @Override
     public void offsetLeftRight(int offset) {
         if (hasNativeDisplayList()) {
             nOffsetLeftRight(mFinalizer.mNativeDisplayList, offset);
         }
     }

     @Override
     public void offsetTopBottom(int offset) {
         if (hasNativeDisplayList()) {
             nOffsetTopBottom(mFinalizer.mNativeDisplayList, offset);
         }
     }

     private static native void nReset(int displayList);
     private static native void nOffsetTopBottom(int displayList, int offset);
     private static native void nOffsetLeftRight(int displayList, int offset);
     private static native void nSetLeftTopRightBottom(int displayList, int left, int top,
             int right, int bottom);
     private static native void nSetLeftTop(int displayList, int left, int top);
     private static native void nSetBottom(int displayList, int bottom);
     private static native void nSetRight(int displayList, int right);
     private static native void nSetTop(int displayList, int top);
     private static native void nSetLeft(int displayList, int left);
     private static native void nSetCameraDistance(int displayList, float distance);
     private static native void nSetPivotY(int displayList, float pivotY);
     private static native void nSetPivotX(int displayList, float pivotX);
     private static native void nSetCaching(int displayList, boolean caching);
     private static native void nSetClipChildren(int displayList, boolean clipChildren);
     private static native void nSetAlpha(int displayList, float alpha);
     private static native void nSetHasOverlappingRendering(int displayList,
             boolean hasOverlappingRendering);
     private static native void nSetTranslationX(int displayList, float translationX);
     private static native void nSetTranslationY(int displayList, float translationY);
     private static native void nSetRotation(int displayList, float rotation);
     private static native void nSetRotationX(int displayList, float rotationX);
     private static native void nSetRotationY(int displayList, float rotationY);
     private static native void nSetScaleX(int displayList, float scaleX);
     private static native void nSetScaleY(int displayList, float scaleY);
     private static native void nSetTransformationInfo(int displayList, float alpha,
             float translationX, float translationY, float rotation, float rotationX,
             float rotationY, float scaleX, float scaleY);
     private static native void nSetStaticMatrix(int displayList, int nativeMatrix);
     private static native void nSetAnimationMatrix(int displayList, int animationMatrix);


     ///////////////////////////////////////////////////////////////////////////
     // Finalization
     ///////////////////////////////////////////////////////////////////////////

     private static class DisplayListFinalizer {
         final int mNativeDisplayList;

         public DisplayListFinalizer(int nativeDisplayList) {
             mNativeDisplayList = nativeDisplayList;
         }

         @Override
         protected void finalize() throws Throwable {
             try {
                 GLES20Canvas.destroyDisplayList(mNativeDisplayList);
             } finally {
                 super.finalize();
             }
         }
     }
 }
	/*
	* 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.Bitmap;
	import android.graphics.Matrix;

	import java.util.ArrayList;

	/**
	* An implementation of display list for OpenGL ES 2.0.
	*/
	class GLES20DisplayList extends DisplayList {
	// These lists ensure that any Bitmaps and DisplayLists recorded by a DisplayList are kept
	// alive as long as the DisplayList is alive. The Bitmap and DisplayList lists
	// are populated by the GLES20RecordingCanvas during appropriate drawing calls and are
	// cleared at the start of a new drawing frame or when the view is detached from the window.
	final ArrayList<Bitmap> mBitmaps = new ArrayList<Bitmap>(5);
	final ArrayList<DisplayList> mChildDisplayLists = new ArrayList<DisplayList>();

	private GLES20RecordingCanvas mCanvas;
	private boolean mValid;

	// Used for debugging
	private final String mName;

	// The native display list will be destroyed when this object dies.
	// DO NOT overwrite this reference once it is set.
	private DisplayListFinalizer mFinalizer;

	GLES20DisplayList(String name) {
	mName = name;
	}

	boolean hasNativeDisplayList() {
	return mValid && mFinalizer != null;
	}

	int getNativeDisplayList() {
	if (!mValid \|\| mFinalizer == null) {
	throw new IllegalStateException("The display list is not valid.");
	}
	return mFinalizer.mNativeDisplayList;
	}

	@Override
	public HardwareCanvas start() {
	if (mCanvas != null) {
	throw new IllegalStateException("Recording has already started");
	}

	mValid = false;
	mCanvas = GLES20RecordingCanvas.obtain(this);
	mCanvas.start();
	return mCanvas;
	}

	@Override
	public void invalidate() {
	if (mCanvas != null) {
	mCanvas.recycle();
	mCanvas = null;
	}
	mValid = false;
	}

	@Override
	public void clear() {
	if (!mValid) {
	mBitmaps.clear();
	mChildDisplayLists.clear();
	}
	}

	@Override
	public void reset() {
	if (hasNativeDisplayList()) {
	nReset(mFinalizer.mNativeDisplayList);
	}
	}

	@Override
	public boolean isValid() {
	return mValid;
	}

	@Override
	public void end() {
	if (mCanvas != null) {
	if (mFinalizer != null) {
	mCanvas.end(mFinalizer.mNativeDisplayList);
	} else {
	mFinalizer = new DisplayListFinalizer(mCanvas.end(0));
	GLES20Canvas.setDisplayListName(mFinalizer.mNativeDisplayList, mName);
	}
	mCanvas.recycle();
	mCanvas = null;
	mValid = true;
	}
	}

	@Override
	public int getSize() {
	if (mFinalizer == null) return 0;
	return GLES20Canvas.getDisplayListSize(mFinalizer.mNativeDisplayList);
	}

	///////////////////////////////////////////////////////////////////////////
	// Native View Properties
	///////////////////////////////////////////////////////////////////////////

	@Override
	public void setCaching(boolean caching) {
	if (hasNativeDisplayList()) {
	nSetCaching(mFinalizer.mNativeDisplayList, caching);
	}
	}

	@Override
	public void setClipChildren(boolean clipChildren) {
	if (hasNativeDisplayList()) {
	nSetClipChildren(mFinalizer.mNativeDisplayList, clipChildren);
	}
	}

	@Override
	public void setStaticMatrix(Matrix matrix) {
	if (hasNativeDisplayList()) {
	nSetStaticMatrix(mFinalizer.mNativeDisplayList, matrix.native_instance);
	}
	}

	@Override
	public void setAnimationMatrix(Matrix matrix) {
	if (hasNativeDisplayList()) {
	nSetAnimationMatrix(mFinalizer.mNativeDisplayList,
	(matrix != null) ? matrix.native_instance : 0);
	}
	}

	@Override
	public void setAlpha(float alpha) {
	if (hasNativeDisplayList()) {
	nSetAlpha(mFinalizer.mNativeDisplayList, alpha);
	}
	}

	@Override
	public void setHasOverlappingRendering(boolean hasOverlappingRendering) {
	if (hasNativeDisplayList()) {
	nSetHasOverlappingRendering(mFinalizer.mNativeDisplayList, hasOverlappingRendering);
	}
	}

	@Override
	public void setTranslationX(float translationX) {
	if (hasNativeDisplayList()) {
	nSetTranslationX(mFinalizer.mNativeDisplayList, translationX);
	}
	}

	@Override
	public void setTranslationY(float translationY) {
	if (hasNativeDisplayList()) {
	nSetTranslationY(mFinalizer.mNativeDisplayList, translationY);
	}
	}

	@Override
	public void setRotation(float rotation) {
	if (hasNativeDisplayList()) {
	nSetRotation(mFinalizer.mNativeDisplayList, rotation);
	}
	}

	@Override
	public void setRotationX(float rotationX) {
	if (hasNativeDisplayList()) {
	nSetRotationX(mFinalizer.mNativeDisplayList, rotationX);
	}
	}

	@Override
	public void setRotationY(float rotationY) {
	if (hasNativeDisplayList()) {
	nSetRotationY(mFinalizer.mNativeDisplayList, rotationY);
	}
	}

	@Override
	public void setScaleX(float scaleX) {
	if (hasNativeDisplayList()) {
	nSetScaleX(mFinalizer.mNativeDisplayList, scaleX);
	}
	}

	@Override
	public void setScaleY(float scaleY) {
	if (hasNativeDisplayList()) {
	nSetScaleY(mFinalizer.mNativeDisplayList, scaleY);
	}
	}

	@Override
	public void setTransformationInfo(float alpha, float translationX, float translationY,
	float rotation, float rotationX, float rotationY, float scaleX, float scaleY) {
	if (hasNativeDisplayList()) {
	nSetTransformationInfo(mFinalizer.mNativeDisplayList, alpha, translationX, translationY,
	rotation, rotationX, rotationY, scaleX, scaleY);
	}
	}

	@Override
	public void setPivotX(float pivotX) {
	if (hasNativeDisplayList()) {
	nSetPivotX(mFinalizer.mNativeDisplayList, pivotX);
	}
	}

	@Override
	public void setPivotY(float pivotY) {
	if (hasNativeDisplayList()) {
	nSetPivotY(mFinalizer.mNativeDisplayList, pivotY);
	}
	}

	@Override
	public void setCameraDistance(float distance) {
	if (hasNativeDisplayList()) {
	nSetCameraDistance(mFinalizer.mNativeDisplayList, distance);
	}
	}

	@Override
	public void setLeft(int left) {
	if (hasNativeDisplayList()) {
	nSetLeft(mFinalizer.mNativeDisplayList, left);
	}
	}

	@Override
	public void setTop(int top) {
	if (hasNativeDisplayList()) {
	nSetTop(mFinalizer.mNativeDisplayList, top);
	}
	}

	@Override
	public void setRight(int right) {
	if (hasNativeDisplayList()) {
	nSetRight(mFinalizer.mNativeDisplayList, right);
	}
	}

	@Override
	public void setBottom(int bottom) {
	if (hasNativeDisplayList()) {
	nSetBottom(mFinalizer.mNativeDisplayList, bottom);
	}
	}

	@Override
	public void setLeftTop(int left, int top) {
	if (hasNativeDisplayList()) {
	nSetLeftTop(mFinalizer.mNativeDisplayList, left, top);
	}
	}

	@Override
	public void setLeftTopRightBottom(int left, int top, int right, int bottom) {
	if (hasNativeDisplayList()) {
	nSetLeftTopRightBottom(mFinalizer.mNativeDisplayList, left, top, right, bottom);
	}
	}

	@Override
	public void offsetLeftRight(int offset) {
	if (hasNativeDisplayList()) {
	nOffsetLeftRight(mFinalizer.mNativeDisplayList, offset);
	}
	}

	@Override
	public void offsetTopBottom(int offset) {
	if (hasNativeDisplayList()) {
	nOffsetTopBottom(mFinalizer.mNativeDisplayList, offset);
	}
	}

	private static native void nReset(int displayList);
	private static native void nOffsetTopBottom(int displayList, int offset);
	private static native void nOffsetLeftRight(int displayList, int offset);
	private static native void nSetLeftTopRightBottom(int displayList, int left, int top,
	int right, int bottom);
	private static native void nSetLeftTop(int displayList, int left, int top);
	private static native void nSetBottom(int displayList, int bottom);
	private static native void nSetRight(int displayList, int right);
	private static native void nSetTop(int displayList, int top);
	private static native void nSetLeft(int displayList, int left);
	private static native void nSetCameraDistance(int displayList, float distance);
	private static native void nSetPivotY(int displayList, float pivotY);
	private static native void nSetPivotX(int displayList, float pivotX);
	private static native void nSetCaching(int displayList, boolean caching);
	private static native void nSetClipChildren(int displayList, boolean clipChildren);
	private static native void nSetAlpha(int displayList, float alpha);
	private static native void nSetHasOverlappingRendering(int displayList,
	boolean hasOverlappingRendering);
	private static native void nSetTranslationX(int displayList, float translationX);
	private static native void nSetTranslationY(int displayList, float translationY);
	private static native void nSetRotation(int displayList, float rotation);
	private static native void nSetRotationX(int displayList, float rotationX);
	private static native void nSetRotationY(int displayList, float rotationY);
	private static native void nSetScaleX(int displayList, float scaleX);
	private static native void nSetScaleY(int displayList, float scaleY);
	private static native void nSetTransformationInfo(int displayList, float alpha,
	float translationX, float translationY, float rotation, float rotationX,
	float rotationY, float scaleX, float scaleY);
	private static native void nSetStaticMatrix(int displayList, int nativeMatrix);
	private static native void nSetAnimationMatrix(int displayList, int animationMatrix);


	///////////////////////////////////////////////////////////////////////////
	// Finalization
	///////////////////////////////////////////////////////////////////////////

	private static class DisplayListFinalizer {
	final int mNativeDisplayList;

	public DisplayListFinalizer(int nativeDisplayList) {
	mNativeDisplayList = nativeDisplayList;
	}

	@Override
	protected void finalize() throws Throwable {
	try {
	GLES20Canvas.destroyDisplayList(mNativeDisplayList);
	} finally {
	super.finalize();
	}
	}
	}
	}