Exemple #1
0
 public override void initializeInvalidateRegion(int left, int top, int right, int
                                                 bottom)
 {
     android.graphics.RectF region = mPreviousRegion;
     region.set(left, top, right, bottom);
     region.inset(-1.0f, -1.0f);
     if (mFillBefore)
     {
         int count = mAnimations.size();
         java.util.ArrayList <android.view.animation.Animation> animations = mAnimations;
         android.view.animation.Transformation temp = mTempTransformation;
         android.view.animation.Transformation previousTransformation = mPreviousTransformation;
         {
             for (int i = count - 1; i >= 0; --i)
             {
                 android.view.animation.Animation a = animations.get(i);
                 temp.clear();
                 android.view.animation.Interpolator interpolator = a.mInterpolator;
                 a.applyTransformation(interpolator != null ? interpolator.getInterpolation(0.0f) :
                                       0.0f, temp);
                 previousTransformation.compose(temp);
             }
         }
     }
 }
        protected internal override void applyTransformation(float interpolatedTime, android.view.animation.Transformation
                                                             t)
        {
            float alpha = mFromAlpha;

            t.setAlpha(alpha + ((mToAlpha - alpha) * interpolatedTime));
        }
Exemple #3
0
 protected override void applyTransformation(float arg0, android.view.animation.Transformation arg1)
 {
     global::MonoJavaBridge.JNIEnv @__env = global::MonoJavaBridge.JNIEnv.ThreadEnv;
     if (!IsClrObject)
     {
         @__env.CallVoidMethod(this.JvmHandle, global::android.view.animation.ScaleAnimation._applyTransformation10053, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0), global::MonoJavaBridge.JavaBridge.ConvertToValue(arg1));
     }
     else
     {
         @__env.CallNonVirtualVoidMethod(this.JvmHandle, global::android.view.animation.ScaleAnimation.staticClass, global::android.view.animation.ScaleAnimation._applyTransformation10053, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0), global::MonoJavaBridge.JavaBridge.ConvertToValue(arg1));
     }
 }
Exemple #4
0
 protected override bool getChildStaticTransformation(android.view.View arg0, android.view.animation.Transformation arg1)
 {
     global::MonoJavaBridge.JNIEnv @__env = global::MonoJavaBridge.JNIEnv.ThreadEnv;
     if (!IsClrObject)
     {
         return(@__env.CallBooleanMethod(this.JvmHandle, global::android.widget.Gallery._getChildStaticTransformation11330, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0), global::MonoJavaBridge.JavaBridge.ConvertToValue(arg1)));
     }
     else
     {
         return(@__env.CallNonVirtualBooleanMethod(this.JvmHandle, global::android.widget.Gallery.staticClass, global::android.widget.Gallery._getChildStaticTransformation11330, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0), global::MonoJavaBridge.JavaBridge.ConvertToValue(arg1)));
     }
 }
Exemple #5
0
 public virtual void compose(android.view.animation.Transformation arg0)
 {
     global::MonoJavaBridge.JNIEnv @__env = global::MonoJavaBridge.JNIEnv.ThreadEnv;
     if (!IsClrObject)
     {
         @__env.CallVoidMethod(this.JvmHandle, global::android.view.animation.Transformation._compose10061, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0));
     }
     else
     {
         @__env.CallNonVirtualVoidMethod(this.JvmHandle, global::android.view.animation.Transformation.staticClass, global::android.view.animation.Transformation._compose10061, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0));
     }
 }
Exemple #6
0
 public override bool getTransformation(long arg0, android.view.animation.Transformation arg1)
 {
     global::MonoJavaBridge.JNIEnv @__env = global::MonoJavaBridge.JNIEnv.ThreadEnv;
     if (!IsClrObject)
     {
         return(@__env.CallBooleanMethod(this.JvmHandle, global::android.view.animation.AnimationSet._getTransformation9966, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0), global::MonoJavaBridge.JavaBridge.ConvertToValue(arg1)));
     }
     else
     {
         return(@__env.CallNonVirtualBooleanMethod(this.JvmHandle, global::android.view.animation.AnimationSet.staticClass, global::android.view.animation.AnimationSet._getTransformation9966, global::MonoJavaBridge.JavaBridge.ConvertToValue(arg0), global::MonoJavaBridge.JavaBridge.ConvertToValue(arg1)));
     }
 }
        protected internal override void applyTransformation(float interpolatedTime, android.view.animation.Transformation
                                                             t)
        {
            float degrees = mFromDegrees + ((mToDegrees - mFromDegrees) * interpolatedTime);
            float scale   = getScaleFactor();

            if (mPivotX == 0.0f && mPivotY == 0.0f)
            {
                t.getMatrix().setRotate(degrees);
            }
            else
            {
                t.getMatrix().setRotate(degrees, mPivotX * scale, mPivotY * scale);
            }
        }
        protected internal override void applyTransformation(float interpolatedTime, android.view.animation.Transformation
                                                             t)
        {
            float dx = mFromXDelta;
            float dy = mFromYDelta;

            if (mFromXDelta != mToXDelta)
            {
                dx = mFromXDelta + ((mToXDelta - mFromXDelta) * interpolatedTime);
            }
            if (mFromYDelta != mToYDelta)
            {
                dy = mFromYDelta + ((mToYDelta - mFromYDelta) * interpolatedTime);
            }
            t.getMatrix().setTranslate(dx, dy);
        }
		protected internal override void applyTransformation(float interpolatedTime, Transformation t)
		{
			float height = (mToHeight - mFromHeight) * interpolatedTime + mFromHeight;
			float width = (mToWidth - mFromWidth) * interpolatedTime + mFromWidth;
			LayoutParams p = (LayoutParams) mView.LayoutParams;
			p.height = (int) height;
			p.width = (int) width;
			this.endCondition(width, height);
			if (width == 0 && this.mToWidth == 0)
			{
				p.height = 0;
			}
			if (height == 0 && this.mToHeight == 0)
			{
				p.width = 0;
			}
			mView.requestLayout();
			mView.invalidate();
		}
Exemple #10
0
        protected internal override void applyTransformation(float interpolatedTime, Transformation t)
        {
            float        height = (mToHeight - mFromHeight) * interpolatedTime + mFromHeight;
            float        width  = (mToWidth - mFromWidth) * interpolatedTime + mFromWidth;
            LayoutParams p      = (LayoutParams)mView.LayoutParams;

            p.height = (int)height;
            p.width  = (int)width;
            this.endCondition(width, height);
            if (width == 0 && this.mToWidth == 0)
            {
                p.height = 0;
            }
            if (height == 0 && this.mToHeight == 0)
            {
                p.width = 0;
            }
            mView.requestLayout();
            mView.invalidate();
        }
Exemple #11
0
        public override bool getTransformation(long currentTime, android.view.animation.Transformation
                                               t)
        {
            int count = mAnimations.size();

            java.util.ArrayList <android.view.animation.Animation> animations = mAnimations;
            android.view.animation.Transformation temp = mTempTransformation;
            bool more    = false;
            bool started = false;
            bool ended   = true;

            t.clear();
            {
                for (int i = count - 1; i >= 0; --i)
                {
                    android.view.animation.Animation a = animations.get(i);
                    temp.clear();
                    more = a.getTransformation(currentTime, temp, getScaleFactor()) || more;
                    t.compose(temp);
                    started = started || a.hasStarted();
                    ended   = a.hasEnded() && ended;
                }
            }
            if (started && !mStarted)
            {
                if (mListener != null)
                {
                    mListener.onAnimationStart(this);
                }
                mStarted = true;
            }
            if (ended != mEnded)
            {
                if (mListener != null)
                {
                    mListener.onAnimationEnd(this);
                }
                mEnded = ended;
            }
            return(more);
        }
Exemple #12
0
        protected internal override void applyTransformation(float interpolatedTime, android.view.animation.Transformation
                                                             t)
        {
            float sx    = 1.0f;
            float sy    = 1.0f;
            float scale = getScaleFactor();

            if (mFromX != 1.0f || mToX != 1.0f)
            {
                sx = mFromX + ((mToX - mFromX) * interpolatedTime);
            }
            if (mFromY != 1.0f || mToY != 1.0f)
            {
                sy = mFromY + ((mToY - mFromY) * interpolatedTime);
            }
            if (mPivotX == 0 && mPivotY == 0)
            {
                t.getMatrix().setScale(sx, sy);
            }
            else
            {
                t.getMatrix().setScale(sx, sy, scale * mPivotX, scale * mPivotY);
            }
        }
Exemple #13
0
 /// <summary>Apply this Transformation to an existing Transformation, e.g.</summary>
 /// <remarks>
 /// Apply this Transformation to an existing Transformation, e.g. apply
 /// a scale effect to something that has already been rotated.
 /// </remarks>
 /// <param name="t"></param>
 public virtual void compose(android.view.animation.Transformation t)
 {
     mAlpha *= t.getAlpha();
     mMatrix.preConcat(t.getMatrix());
 }
Exemple #14
0
 /// <summary>Clones the specified transformation.</summary>
 /// <remarks>Clones the specified transformation.</remarks>
 /// <param name="t">The transformation to clone.</param>
 public virtual void set(android.view.animation.Transformation t)
 {
     mAlpha = t.getAlpha();
     mMatrix.set(t.getMatrix());
     mTransformationType = t.getTransformationType();
 }
Exemple #15
0
		/// <summary>Draw one child of this View Group.</summary>
		/// <remarks>
		/// Draw one child of this View Group. This method is responsible for getting
		/// the canvas in the right state. This includes clipping, translating so
		/// that the child's scrolled origin is at 0, 0, and applying any animation
		/// transformations.
		/// </remarks>
		/// <param name="canvas">The canvas on which to draw the child</param>
		/// <param name="child">Who to draw</param>
		/// <param name="drawingTime">The time at which draw is occuring</param>
		/// <returns>True if an invalidate() was issued</returns>
		protected internal virtual bool drawChild(android.graphics.Canvas canvas, android.view.View
			 child, long drawingTime)
		{
			bool more = false;
			int cl = child.mLeft;
			int ct = child.mTop;
			int cr = child.mRight;
			int cb = child.mBottom;
			bool childHasIdentityMatrix = child.hasIdentityMatrix();
			int flags = mGroupFlags;
			if ((flags & FLAG_CLEAR_TRANSFORMATION) == FLAG_CLEAR_TRANSFORMATION)
			{
				mChildTransformation.clear();
				mGroupFlags &= ~FLAG_CLEAR_TRANSFORMATION;
			}
			android.view.animation.Transformation transformToApply = null;
			android.view.animation.Transformation invalidationTransform;
			android.view.animation.Animation a = child.getAnimation();
			bool concatMatrix = false;
			bool scalingRequired = false;
			bool caching;
			int layerType = mDrawLayers ? child.getLayerType() : LAYER_TYPE_NONE;
			bool hardwareAccelerated = canvas.isHardwareAccelerated();
			if ((flags & FLAG_CHILDREN_DRAWN_WITH_CACHE) == FLAG_CHILDREN_DRAWN_WITH_CACHE ||
				 (flags & FLAG_ALWAYS_DRAWN_WITH_CACHE) == FLAG_ALWAYS_DRAWN_WITH_CACHE)
			{
				caching = true;
				if (mAttachInfo != null)
				{
					scalingRequired = mAttachInfo.mScalingRequired;
				}
			}
			else
			{
				caching = (layerType != LAYER_TYPE_NONE) || hardwareAccelerated;
			}
			if (a != null)
			{
				bool initialized = a.isInitialized();
				if (!initialized)
				{
					a.initialize(cr - cl, cb - ct, getWidth(), getHeight());
					a.initializeInvalidateRegion(0, 0, cr - cl, cb - ct);
					child.onAnimationStart();
				}
				more = a.getTransformation(drawingTime, mChildTransformation, scalingRequired ? mAttachInfo
					.mApplicationScale : 1f);
				if (scalingRequired && mAttachInfo.mApplicationScale != 1f)
				{
					if (mInvalidationTransformation == null)
					{
						mInvalidationTransformation = new android.view.animation.Transformation();
					}
					invalidationTransform = mInvalidationTransformation;
					a.getTransformation(drawingTime, invalidationTransform, 1f);
				}
				else
				{
					invalidationTransform = mChildTransformation;
				}
				transformToApply = mChildTransformation;
				concatMatrix = a.willChangeTransformationMatrix();
				if (more)
				{
					if (!a.willChangeBounds())
					{
						if ((flags & (FLAG_OPTIMIZE_INVALIDATE | FLAG_ANIMATION_DONE)) == FLAG_OPTIMIZE_INVALIDATE)
						{
							mGroupFlags |= FLAG_INVALIDATE_REQUIRED;
						}
						else
						{
							if ((flags & FLAG_INVALIDATE_REQUIRED) == 0)
							{
								// The child need to draw an animation, potentially offscreen, so
								// make sure we do not cancel invalidate requests
								mPrivateFlags |= DRAW_ANIMATION;
								invalidate(cl, ct, cr, cb);
							}
						}
					}
					else
					{
						if (mInvalidateRegion == null)
						{
							mInvalidateRegion = new android.graphics.RectF();
						}
						android.graphics.RectF region = mInvalidateRegion;
						a.getInvalidateRegion(0, 0, cr - cl, cb - ct, region, invalidationTransform);
						// The child need to draw an animation, potentially offscreen, so
						// make sure we do not cancel invalidate requests
						mPrivateFlags |= DRAW_ANIMATION;
						int left = cl + (int)region.left;
						int top = ct + (int)region.top;
						invalidate(left, top, left + (int)(region.width() + .5f), top + (int)(region.height
							() + .5f));
					}
				}
			}
			else
			{
				if ((flags & FLAG_SUPPORT_STATIC_TRANSFORMATIONS) == FLAG_SUPPORT_STATIC_TRANSFORMATIONS)
				{
					bool hasTransform = getChildStaticTransformation(child, mChildTransformation);
					if (hasTransform)
					{
						int transformType = mChildTransformation.getTransformationType();
						transformToApply = transformType != android.view.animation.Transformation.TYPE_IDENTITY
							 ? mChildTransformation : null;
						concatMatrix = (transformType & android.view.animation.Transformation.TYPE_MATRIX
							) != 0;
					}
				}
			}
			concatMatrix |= !childHasIdentityMatrix;
			// Sets the flag as early as possible to allow draw() implementations
			// to call invalidate() successfully when doing animations
			child.mPrivateFlags |= DRAWN;
			if (!concatMatrix && canvas.quickReject(cl, ct, cr, cb, android.graphics.Canvas.EdgeType
				.BW) && (child.mPrivateFlags & DRAW_ANIMATION) == 0)
			{
				return more;
			}
			float alpha = child.getAlpha();
			// Bail out early if the view does not need to be drawn
			if (alpha <= android.view.ViewConfiguration.ALPHA_THRESHOLD && (child.mPrivateFlags
				 & ALPHA_SET) == 0 && !(child is android.view.SurfaceView))
			{
				return more;
			}
			if (hardwareAccelerated)
			{
				// Clear INVALIDATED flag to allow invalidation to occur during rendering, but
				// retain the flag's value temporarily in the mRecreateDisplayList flag
				child.mRecreateDisplayList = (child.mPrivateFlags & INVALIDATED) == INVALIDATED;
				child.mPrivateFlags &= ~INVALIDATED;
			}
			child.computeScroll();
			int sx = child.mScrollX;
			int sy = child.mScrollY;
			android.view.DisplayList displayList = null;
			android.graphics.Bitmap cache = null;
			bool hasDisplayList = false;
			if (caching)
			{
				if (!hardwareAccelerated)
				{
					if (layerType != LAYER_TYPE_NONE)
					{
						layerType = LAYER_TYPE_SOFTWARE;
						child.buildDrawingCache(true);
					}
					cache = child.getDrawingCache(true);
				}
				else
				{
					switch (layerType)
					{
						case LAYER_TYPE_SOFTWARE:
						{
							child.buildDrawingCache(true);
							cache = child.getDrawingCache(true);
							break;
						}

						case LAYER_TYPE_NONE:
						{
							// Delay getting the display list until animation-driven alpha values are
							// set up and possibly passed on to the view
							hasDisplayList = child.canHaveDisplayList();
							break;
						}
					}
				}
			}
			bool hasNoCache = cache == null || hasDisplayList;
			bool offsetForScroll = cache == null && !hasDisplayList && layerType != LAYER_TYPE_HARDWARE;
			int restoreTo = canvas.save();
			if (offsetForScroll)
			{
				canvas.translate(cl - sx, ct - sy);
			}
			else
			{
				canvas.translate(cl, ct);
				if (scalingRequired)
				{
					// mAttachInfo cannot be null, otherwise scalingRequired == false
					float scale = 1.0f / mAttachInfo.mApplicationScale;
					canvas.scale(scale, scale);
				}
			}
			if (transformToApply != null || alpha < 1.0f || !child.hasIdentityMatrix())
			{
				if (transformToApply != null || !childHasIdentityMatrix)
				{
					int transX = 0;
					int transY = 0;
					if (offsetForScroll)
					{
						transX = -sx;
						transY = -sy;
					}
					if (transformToApply != null)
					{
						if (concatMatrix)
						{
							// Undo the scroll translation, apply the transformation matrix,
							// then redo the scroll translate to get the correct result.
							canvas.translate(-transX, -transY);
							canvas.concat(transformToApply.getMatrix());
							canvas.translate(transX, transY);
							mGroupFlags |= FLAG_CLEAR_TRANSFORMATION;
						}
						float transformAlpha = transformToApply.getAlpha();
						if (transformAlpha < 1.0f)
						{
							alpha *= transformToApply.getAlpha();
							mGroupFlags |= FLAG_CLEAR_TRANSFORMATION;
						}
					}
					if (!childHasIdentityMatrix)
					{
						canvas.translate(-transX, -transY);
						canvas.concat(child.getMatrix());
						canvas.translate(transX, transY);
					}
				}
				if (alpha < 1.0f)
				{
					mGroupFlags |= FLAG_CLEAR_TRANSFORMATION;
					if (hasNoCache)
					{
						int multipliedAlpha = (int)(255 * alpha);
						if (!child.onSetAlpha(multipliedAlpha))
						{
							int layerFlags = android.graphics.Canvas.HAS_ALPHA_LAYER_SAVE_FLAG;
							if ((flags & FLAG_CLIP_CHILDREN) == FLAG_CLIP_CHILDREN || layerType != LAYER_TYPE_NONE)
							{
								layerFlags |= android.graphics.Canvas.CLIP_TO_LAYER_SAVE_FLAG;
							}
							if (layerType == LAYER_TYPE_NONE)
							{
								int scrollX = hasDisplayList ? 0 : sx;
								int scrollY = hasDisplayList ? 0 : sy;
								canvas.saveLayerAlpha(scrollX, scrollY, scrollX + cr - cl, scrollY + cb - ct, multipliedAlpha
									, layerFlags);
							}
						}
						else
						{
							// Alpha is handled by the child directly, clobber the layer's alpha
							child.mPrivateFlags |= ALPHA_SET;
						}
					}
				}
			}
			else
			{
				if ((child.mPrivateFlags & ALPHA_SET) == ALPHA_SET)
				{
					child.onSetAlpha(255);
					child.mPrivateFlags &= ~ALPHA_SET;
				}
			}
			if ((flags & FLAG_CLIP_CHILDREN) == FLAG_CLIP_CHILDREN)
			{
				if (offsetForScroll)
				{
					canvas.clipRect(sx, sy, sx + (cr - cl), sy + (cb - ct));
				}
				else
				{
					if (!scalingRequired || cache == null)
					{
						canvas.clipRect(0, 0, cr - cl, cb - ct);
					}
					else
					{
						canvas.clipRect(0, 0, cache.getWidth(), cache.getHeight());
					}
				}
			}
			if (hasDisplayList)
			{
				displayList = child.getDisplayList();
				if (!displayList.isValid())
				{
					// Uncommon, but possible. If a view is removed from the hierarchy during the call
					// to getDisplayList(), the display list will be marked invalid and we should not
					// try to use it again.
					displayList = null;
					hasDisplayList = false;
				}
			}
			if (hasNoCache)
			{
				bool layerRendered = false;
				if (layerType == LAYER_TYPE_HARDWARE)
				{
					android.view.HardwareLayer layer = child.getHardwareLayer();
					if (layer != null && layer.isValid())
					{
						child.mLayerPaint.setAlpha((int)(alpha * 255));
						((android.view.HardwareCanvas)canvas).drawHardwareLayer(layer, 0, 0, child.mLayerPaint
							);
						layerRendered = true;
					}
					else
					{
						int scrollX = hasDisplayList ? 0 : sx;
						int scrollY = hasDisplayList ? 0 : sy;
						canvas.saveLayer(scrollX, scrollY, scrollX + cr - cl, scrollY + cb - ct, child.mLayerPaint
							, android.graphics.Canvas.HAS_ALPHA_LAYER_SAVE_FLAG | android.graphics.Canvas.CLIP_TO_LAYER_SAVE_FLAG
							);
					}
				}
				if (!layerRendered)
				{
					if (!hasDisplayList)
					{
						// Fast path for layouts with no backgrounds
						if ((child.mPrivateFlags & SKIP_DRAW) == SKIP_DRAW)
						{
							child.mPrivateFlags &= ~DIRTY_MASK;
							child.dispatchDraw(canvas);
						}
						else
						{
							child.draw(canvas);
						}
					}
					else
					{
						child.mPrivateFlags &= ~DIRTY_MASK;
						((android.view.HardwareCanvas)canvas).drawDisplayList(displayList, cr - cl, cb - 
							ct, null);
					}
				}
			}
			else
			{
				if (cache != null)
				{
					child.mPrivateFlags &= ~DIRTY_MASK;
					android.graphics.Paint cachePaint;
					if (layerType == LAYER_TYPE_NONE)
					{
						cachePaint = mCachePaint;
						if (alpha < 1.0f)
						{
							cachePaint.setAlpha((int)(alpha * 255));
							mGroupFlags |= FLAG_ALPHA_LOWER_THAN_ONE;
						}
						else
						{
							if ((flags & FLAG_ALPHA_LOWER_THAN_ONE) == FLAG_ALPHA_LOWER_THAN_ONE)
							{
								cachePaint.setAlpha(255);
								mGroupFlags &= ~FLAG_ALPHA_LOWER_THAN_ONE;
							}
						}
					}
					else
					{
						cachePaint = child.mLayerPaint;
						cachePaint.setAlpha((int)(alpha * 255));
					}
					canvas.drawBitmap(cache, 0.0f, 0.0f, cachePaint);
				}
			}
			canvas.restoreToCount(restoreTo);
			if (a != null && !more)
			{
				if (!hardwareAccelerated && !a.getFillAfter())
				{
					child.onSetAlpha(255);
				}
				finishAnimatingView(child, a);
			}
			if (more && hardwareAccelerated)
			{
				// invalidation is the trigger to recreate display lists, so if we're using
				// display lists to render, force an invalidate to allow the animation to
				// continue drawing another frame
				invalidate(true);
				if (a.hasAlpha() && (child.mPrivateFlags & ALPHA_SET) == ALPHA_SET)
				{
					// alpha animations should cause the child to recreate its display list
					child.invalidate(true);
				}
			}
			child.mRecreateDisplayList = false;
			return more;
		}