Prioritize reveal clipping over Outline clipping (e83cbd45) · Commits · e / os / android_frameworks_base

core/java/android/view/View.java

+16 −7

Original line number	Diff line number	Diff line
		@@ -444,16 +444,19 @@ import java.util.concurrent.atomic.AtomicInteger;
		* <a name="Drawing"></a>
		* <h3>Drawing</h3>
		* <p>
		* Drawing is handled by walking the tree and rendering each view that
		* intersects the invalid region. Because the tree is traversed in-order,
		* this means that parents will draw before (i.e., behind) their children, with
		* siblings drawn in the order they appear in the tree.
		* If you set a background drawable for a View, then the View will draw it for you
		* before calling back to its <code>onDraw()</code> method.
		* Drawing is handled by walking the tree and recording the drawing commands of
		* any View that needs to update. After this, the drawing commands of the
		* entire tree are issued to screen, clipped to the newly damaged area.
		* </p>
		*
		* <p>
		* Note that the framework will not draw views that are not in the invalid region.
		* The tree is largely recorded and drawn in order, with parents drawn before
		* (i.e., behind) their children, with siblings drawn in the order they appear
		* in the tree. If you set a background drawable for a View, then the View will
		* draw it before calling back to its <code>onDraw()</code> method. The child
		* drawing order can be overridden with
		* {@link ViewGroup#setChildrenDrawingOrderEnabled(boolean) custom child drawing order}
		* in a ViewGroup, and with {@link #setZ(float)} custom Z values} set on Views.
		* </p>
		*
		* <p>
		@@ -10852,6 +10855,12 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		/**
		* Sets whether the View's Outline should be used to clip the contents of the View.
		* <p>
		* Only a single non-rectangular clip can be applied on a View at any time.
		* Circular clips from a {@link ViewAnimationUtils#createCircularReveal(View, int, int, float, float)
		* circular reveal} animation take priority over Outline clipping, and
		* child Outline clipping takes priority over Outline clipping done by a
		* parent.
		* <p>
		* Note that this flag will only be respected if the View's Outline returns true from
		* {@link Outline#canClip()}.
		*

core/java/android/view/ViewAnimationUtils.java

+7 −3

Original line number	Diff line number	Diff line
		@@ -27,9 +27,13 @@ public final class ViewAnimationUtils {
		private ViewAnimationUtils() {}
		/**
		* Returns an Animator which can animate a clipping circle.
		*
		* <p>
		* Any shadow cast by the View will respect the circular clip from this animator.
		*
		* <p>
		* Only a single non-rectangular clip can be applied on a View at any time.
		* Views clipped by a circular reveal animation take priority over
		* {@link View#setClipToOutline(boolean) View Outline clipping}.
		* <p>
		* Note that the animation returned here is a one-shot animation. It cannot
		* be re-used, and once started it cannot be paused or resumed.
		*
		@@ -39,7 +43,7 @@ public final class ViewAnimationUtils {
		* @param startRadius The starting radius of the animating circle.
		* @param endRadius The ending radius of the animating circle.
		*/
		public static final Animator createCircularReveal(View view,
		public static Animator createCircularReveal(View view,
		int centerX, int centerY, float startRadius, float endRadius) {
		return new RevealAnimator(view, centerX, centerY, startRadius, endRadius);
		}

core/java/android/view/ViewGroup.java

+3 −0

Original line number	Diff line number	Diff line
		@@ -5034,6 +5034,9 @@ public abstract class ViewGroup extends View implements ViewParent, ViewManager
		/**
		* Tells the ViewGroup whether to draw its children in the order defined by the method
		* {@link #getChildDrawingOrder(int, int)}.
		* <p>
		* Note that {@link View#getZ() Z} reordering, done by {@link #dispatchDraw(Canvas)},
		* will override custom child ordering done via this method.
		*
		* @param enabled true if the order of the children when drawing is determined by
		* {@link #getChildDrawingOrder(int, int)}, false otherwise

libs/hwui/RenderNode.cpp

+1 −2

Original line number	Diff line number	Diff line
		@@ -405,7 +405,7 @@ void RenderNode::setViewProperties(OpenGLRenderer& renderer, T& handler) {
		handler(op, PROPERTY_SAVECOUNT, properties().getClipToBounds());
		}

		// TODO: support both reveal clip and outline clip simultaneously
		// TODO: support nesting round rect clips
		if (mProperties.getRevealClip().willClip()) {
		Rect bounds;
		mProperties.getRevealClip().getBounds(&bounds);
		@@ -413,7 +413,6 @@ void RenderNode::setViewProperties(OpenGLRenderer& renderer, T& handler) {
		} else if (mProperties.getOutline().willClip()) {
		renderer.setClippingOutline(handler.allocator(), &(mProperties.getOutline()));
		}

		}

		/**

libs/hwui/Snapshot.cpp

+9 −1

Original line number	Diff line number	Diff line
		@@ -216,14 +216,22 @@ void Snapshot::resetTransform(float x, float y, float z) {
		// Clipping round rect
		///////////////////////////////////////////////////////////////////////////////

		void Snapshot::setClippingRoundRect(LinearAllocator& allocator, const Rect& bounds, float radius) {
		void Snapshot::setClippingRoundRect(LinearAllocator& allocator, const Rect& bounds,
		float radius, bool highPriority) {
		if (bounds.isEmpty()) {
		clipRect->setEmpty();
		return;
		}

		if (roundRectClipState && roundRectClipState->highPriority) {
		// ignore, don't replace, already have a high priority clip
		return;
		}

		RoundRectClipState* state = new (allocator) RoundRectClipState;

		state->highPriority = highPriority;

		// store the inverse drawing matrix
		Matrix4 roundRectDrawingMatrix;
		roundRectDrawingMatrix.load(getOrthoMatrix());