public override void Draw(Android.Graphics.Canvas canvas)
{
base.Draw(canvas);
var rect = new RectF(0,0,300,300);
switch (TheShape)
{
case Shape.Circle:
canvas.DrawOval(rect, new Paint() { Color = Color.Aqua });
break;
case Shape.Square:
canvas.DrawRect(rect, new Paint() { Color = Color.Red });
break;
case Shape.Triangle:
var path = new Path();
path.MoveTo(rect.CenterX(), 0);
path.LineTo(0, rect.Height());
path.LineTo(rect.Width(), rect.Height());
path.Close();
var paint = new Paint() {Color = Color.Magenta};
paint.SetStyle(Paint.Style.Fill);
canvas.DrawPath(path, paint);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public Transition(RectF srcRect, RectF dstRect, long duration, IInterpolator interpolator) {
if (!MathUtils.HaveSameAspectRatio(srcRect, dstRect)) {
throw new IncompatibleRatioException();
}
_mSrcRect = srcRect;
_mDstRect = dstRect;
_mDuration = duration;
_mInterpolator = interpolator;
// Precomputes a few variables to avoid doing it in onDraw().
_mWidthDiff = dstRect.Width() - srcRect.Width();
_mHeightDiff = dstRect.Height() - srcRect.Height();
_mCenterXDiff = dstRect.CenterX() - srcRect.CenterX();
_mCenterYDiff = dstRect.CenterY() - srcRect.CenterY();
}
protected override void Draw(Canvas canvas, Rect bounds)
{
RectF arcBounds = mTempBounds;
arcBounds.Set(bounds);
arcBounds.Inset(mStrokeInset, mStrokeInset);
mCurrentBounds.Set(arcBounds);
int saveCount = canvas.Save();
//draw circle trim
float startAngle = (mStartTrim + mRotation) * 360;
float endAngle = (mEndTrim + mRotation) * 360;
float sweepAngle = endAngle - startAngle;
if (sweepAngle != 0)
{
mPaint.Color = new Color(mColor);
mPaint.SetStyle(Paint.Style.Stroke);
canvas.DrawArc(arcBounds, startAngle, sweepAngle, false, mPaint);
}
//draw water wave
if (mWaveProgress < 1.0f)
{
var nColor = new Color(mColor);
mPaint.Color = Color.Argb((int)(Color.GetAlphaComponent(mColor) * (1.0f - mWaveProgress)), Color.GetRedComponent(mColor), Color.GetGreenComponent(mColor), Color.GetBlueComponent(mColor));
mPaint.SetStyle(Paint.Style.Stroke);
float radius = Math.Min(arcBounds.Width(), arcBounds.Height()) / 2.0f;
canvas.DrawCircle(arcBounds.CenterX(), arcBounds.CenterY(), radius * (1.0f + mWaveProgress), mPaint);
}
//draw ball bounce
if (mPathMeasure != null)
{
mPaint.Color = new Color(mBallColor);
mPaint.SetStyle(Paint.Style.Fill);
canvas.DrawCircle(mCurrentPosition[0], mCurrentPosition[1], mSkipBallSize * mScale, mPaint);
}
canvas.RestoreToCount(saveCount);
}
protected override void Draw(Canvas canvas, Rect bounds)
{
int saveCount = canvas.Save();
mTempBounds.Set(bounds);
mTempBounds.Inset(mStrokeInset, mStrokeInset);
mCurrentBounds.Set(mTempBounds);
float outerCircleRadius = Math.Min(mTempBounds.Height(), mTempBounds.Width()) / 2.0f;
float interCircleRadius = outerCircleRadius / 2.0f;
float centerRingWidth = interCircleRadius - mStrokeWidth / 2;
mPaint.SetStyle(Paint.Style.Stroke);
mPaint.Color = new Color(mColor);
mPaint.StrokeWidth = mStrokeWidth;
canvas.DrawCircle(mTempBounds.CenterX(), mTempBounds.CenterY(), outerCircleRadius, mPaint);
mPaint.SetStyle(Paint.Style.Fill);
canvas.DrawCircle(mTempBounds.CenterX(), mTempBounds.CenterY(), interCircleRadius * mScale, mPaint);
if (mRotation != 0)
{
mPaint.Color = new Color(mArcColor);
mPaint.SetStyle(Paint.Style.Stroke);
//strokeWidth / 2.0f + mStrokeWidth / 2.0f is the center of the inter circle width
mTempBounds.Inset(centerRingWidth / 2.0f + mStrokeWidth / 2.0f, centerRingWidth / 2.0f + mStrokeWidth / 2.0f);
mPaint.StrokeWidth = centerRingWidth;
canvas.DrawArc(mTempBounds, RING_START_ANGLE, mRotation, false, mPaint);
}
mPaint.Color = new Color(mColor);
mPaint.SetStyle(Paint.Style.Fill);
for (int i = 0; i < NUM_POINTS; i++)
{
canvas.Rotate(i * DANCE_INTERVAL_ANGLE, POINT_X[i], POINT_Y[i]);
RectF rectF = new RectF(POINT_X[i] - mDanceBallRadius - mShapeChangeWidth / 2.0f, POINT_Y[i] - mDanceBallRadius - mShapeChangeHeight / 2.0f, POINT_X[i] + mDanceBallRadius + mShapeChangeWidth / 2.0f, POINT_Y[i] + mDanceBallRadius + mShapeChangeHeight / 2.0f);
canvas.DrawOval(rectF, mPaint);
canvas.Rotate(-i * DANCE_INTERVAL_ANGLE, POINT_X[i], POINT_Y[i]);
}
canvas.RestoreToCount(saveCount);
}
/// <summary>
/// Coordinates are approximate, you have better cooperate with the designer's design draft
/// </summary>
private Path CreateBalloonPath(RectF balloonRect, float progress)
{
Path path = new Path();
path.MoveTo(balloonRect.CenterX(), balloonRect.Bottom);
float progressWidth = balloonRect.Width() * progress;
float progressHeight = balloonRect.Height() * progress;
//draw left half
float leftIncrementX1 = progressWidth * -0.48f;
float leftIncrementY1 = progressHeight * 0.75f;
float leftIncrementX2 = progressWidth * -0.03f;
float leftIncrementY2 = progressHeight * -1.6f;
float leftIncrementX3 = progressWidth * 0.9f;
float leftIncrementY3 = progressHeight * -1.0f;
path.CubicTo(balloonRect.Left + balloonRect.Width() * 0.25f + leftIncrementX1, balloonRect.CenterY() - balloonRect.Height() * 0.4f + leftIncrementY1, balloonRect.Left - balloonRect.Width() * 0.20f + leftIncrementX2, balloonRect.CenterY() + balloonRect.Height() * 1.15f + leftIncrementY2, balloonRect.Left - balloonRect.Width() * 0.4f + leftIncrementX3, balloonRect.Bottom + leftIncrementY3);
// the results of the left final transformation
// path.cubicTo(balloonRect.left - balloonRect.width() * 0.13f, balloonRect.CenterY() + balloonRect.height() * 0.35f,
// balloonRect.left - balloonRect.width() * 0.23f, balloonRect.CenterY() - balloonRect.height() * 0.45f,
// balloonRect.left + balloonRect.width() * 0.5f, balloonRect.bottom － balloonRect.height());
//draw right half
float rightIncrementX1 = progressWidth * 1.51f;
float rightIncrementY1 = progressHeight * -0.05f;
float rightIncrementX2 = progressWidth * 0.03f;
float rightIncrementY2 = progressHeight * 0.5f;
float rightIncrementX3 = 0.0f;
float rightIncrementY3 = 0.0f;
path.CubicTo(balloonRect.Left - balloonRect.Width() * 0.38f + rightIncrementX1, balloonRect.CenterY() - balloonRect.Height() * 0.4f + rightIncrementY1, balloonRect.Left + balloonRect.Width() * 1.1f + rightIncrementX2, balloonRect.CenterY() - balloonRect.Height() * 0.15f + rightIncrementY2, balloonRect.Left + balloonRect.Width() * 0.5f + rightIncrementX3, balloonRect.Bottom + rightIncrementY3);
// the results of the right final transformation
// path.cubicTo(balloonRect.left + balloonRect.width() * 1.23f, balloonRect.CenterY() - balloonRect.height() * 0.45f,
// balloonRect.left + balloonRect.width() * 1.13f, balloonRect.CenterY() + balloonRect.height() * 0.35f,
// balloonRect.left + balloonRect.width() * 0.5f, balloonRect.bottom);
return(path);
}
droidGraphics.Matrix ComputeStretchMatrix()
{
droidGraphics.Matrix matrix = new droidGraphics.Matrix();
// Get the drawable bounds decreased by stroke thickness
droidGraphics.RectF drawableBounds = new droidGraphics.RectF(drawable.Bounds);
float halfStrokeWidth = drawable.Paint.StrokeWidth / 2;
drawableBounds.Left += halfStrokeWidth;
drawableBounds.Top += halfStrokeWidth;
drawableBounds.Right -= halfStrokeWidth;
drawableBounds.Bottom -= halfStrokeWidth;
switch (stretch)
{
case Stretch.None:
break;
case Stretch.Fill:
matrix.SetRectToRect(pathFillBounds, drawableBounds, droidGraphics.Matrix.ScaleToFit.Fill);
break;
case Stretch.Uniform:
matrix.SetRectToRect(pathFillBounds, drawableBounds, droidGraphics.Matrix.ScaleToFit.Center);
break;
case Stretch.UniformToFill:
float widthScale = drawableBounds.Width() / pathFillBounds.Width();
float heightScale = drawableBounds.Height() / pathFillBounds.Height();
float maxScale = Math.Max(widthScale, heightScale);
matrix.SetScale(maxScale, maxScale);
matrix.PostTranslate(drawableBounds.Left - maxScale * pathFillBounds.Left,
drawableBounds.Top - maxScale * pathFillBounds.Top);
break;
}
return(matrix);
}
Bitmap GetImage (Color strokeColor, Color fillColor, System.Drawing.SizeF size, float scale,
bool shouldCrop = true, bool keepAspectRatio = true)
{
if (size.Width == 0 || size.Height == 0 || scale <= 0)
return null;
float uncroppedScale;
RectF croppedRectangle = new RectF ();
System.Drawing.PointF [] cachedPoints;
if (shouldCrop && (cachedPoints = Points).Any ()) {
croppedRectangle = getCroppedRectangle (cachedPoints);
if (croppedRectangle.Left >= 5)
croppedRectangle.Left -= 5;
if (croppedRectangle.Right <= size.Width - 5)
croppedRectangle.Right += 5;
if (croppedRectangle.Top >= 5)
croppedRectangle.Top -= 5;
if (croppedRectangle.Bottom <= size.Height - 5)
croppedRectangle.Bottom += 5;
float scaleX = (croppedRectangle.Right - croppedRectangle.Left) / Width;
float scaleY = (croppedRectangle.Bottom - croppedRectangle.Top) / Height;
uncroppedScale = 1 / Math.Max (scaleX, scaleY);
} else {
uncroppedScale = scale;
}
Bitmap image;
if (keepAspectRatio)
image = Bitmap.CreateBitmap ((int)size.Width, (int)size.Height,
Bitmap.Config.Argb8888);
else
image = Bitmap.CreateBitmap ((int)(croppedRectangle.Width () * uncroppedScale), (int)(croppedRectangle.Height () * uncroppedScale),
Bitmap.Config.Argb8888);
Canvas canvas = new Canvas (image);
canvas.Scale (uncroppedScale, uncroppedScale);
DrawStrokesOnCanvas (canvas, strokeColor, fillColor, shouldCrop, croppedRectangle);
return image;
}
public static XIR.Rectangle RemoteRepresentation(this AG.RectF rectangle)
=> new XIR.Rectangle(
rectangle.Left,
rectangle.Top,
rectangle.Width(),
rectangle.Height());
public static RectangleF ToEto(this ag.RectF rect)
{
return(new RectangleF(rect.Left, rect.Top, rect.Width(), rect.Height()));
}
public void Setup(Matrix m, Rect imageRect, RectF cropRect, bool maintainAspectRatio)
{
matrix = new Matrix(m);
this.cropRect = cropRect;
this.imageRect = new RectF(imageRect);
this.maintainAspectRatio = maintainAspectRatio;
initialAspectRatio = cropRect.Width() / cropRect.Height();
DrawRect = computeLayout();
focusPaint.SetARGB(125, 50, 50, 50);
noFocusPaint.SetARGB(125, 50, 50, 50);
outlinePaint.StrokeWidth = 3;
outlinePaint.SetStyle(Paint.Style.Stroke);
outlinePaint.AntiAlias = true;
mode = ModifyMode.None;
init();
}
// Grows the cropping rectange by (dx, dy) in image space.
private void growBy(float dx, float dy)
{
if (maintainAspectRatio)
{
if (dx != 0)
{
dy = dx / initialAspectRatio;
}
else if (dy != 0)
{
dx = dy * initialAspectRatio;
}
}
// Don't let the cropping rectangle grow too fast.
// Grow at most half of the difference between the image rectangle and
// the cropping rectangle.
RectF r = new RectF(cropRect);
if (dx > 0F && r.Width() + 2 * dx > imageRect.Width())
{
float adjustment = (imageRect.Width() - r.Width()) / 2F;
dx = adjustment;
if (maintainAspectRatio)
{
dy = dx / initialAspectRatio;
}
}
if (dy > 0F && r.Height() + 2 * dy > imageRect.Height())
{
float adjustment = (imageRect.Height() - r.Height()) / 2F;
dy = adjustment;
if (maintainAspectRatio)
{
dx = dy * initialAspectRatio;
}
}
r.Inset(-dx, -dy);
// Don't let the cropping rectangle shrink too fast.
float widthCap = 25F;
if (r.Width() < widthCap)
{
r.Inset(-(widthCap - r.Width()) / 2F, 0F);
}
float heightCap = maintainAspectRatio
? (widthCap / initialAspectRatio)
: widthCap;
if (r.Height() < heightCap)
{
r.Inset(0F, -(heightCap - r.Height()) / 2F);
}
// Put the cropping rectangle inside the image rectangle.
if (r.Left < imageRect.Left)
{
r.Offset(imageRect.Left - r.Left, 0F);
}
else if (r.Right > imageRect.Right)
{
r.Offset(-(r.Right - imageRect.Right), 0);
}
if (r.Top < imageRect.Top)
{
r.Offset(0F, imageRect.Top - r.Top);
}
else if (r.Bottom > imageRect.Bottom)
{
r.Offset(0F, -(r.Bottom - imageRect.Bottom));
}
cropRect.Set(r);
DrawRect = computeLayout();
context.Invalidate();
}
Bitmap GetImage (Color strokeColor, Color fillColor, System.Drawing.SizeF size, float scale,
bool shouldCrop = true)
{
if (size.Width == 0 || size.Height == 0 || scale <= 0)
return null;
float uncroppedScale;
System.Drawing.SizeF uncroppedSize;
RectF croppedRectangle;
if (shouldCrop && Points.Count () != 0) {
croppedRectangle = getCroppedRectangle ();
float scaleX = (croppedRectangle.Right - croppedRectangle.Left) / Width;
float scaleY = (croppedRectangle.Bottom - croppedRectangle.Top) / Height;
uncroppedScale = 1 / Math.Max (scaleX, scaleY);
//uncroppedScale = 1 / getScaleFromSize (croppedRectangle.Size, Bounds);
uncroppedSize = getSizeFromScale (uncroppedScale, size.Width, size.Height);
} else {
uncroppedScale = scale;
uncroppedSize = size;
}
Bitmap image = Bitmap.CreateBitmap ((int)uncroppedSize.Width, (int)uncroppedSize.Height,
Bitmap.Config.Argb8888);
Canvas canvas = new Canvas (image);
canvas.Scale (uncroppedScale, uncroppedScale);
DrawStrokesOnCanvas (canvas, strokeColor, fillColor);
if (shouldCrop && Points.Count () != 0) {
croppedRectangle = getCroppedRectangle ();
RectF scaledRectangle = new RectF (croppedRectangle.Left * uncroppedScale,
croppedRectangle.Top * uncroppedScale,
croppedRectangle.Right * uncroppedScale,
croppedRectangle.Bottom * uncroppedScale);
if (scaledRectangle.Left >= 5)
scaledRectangle.Left -= 5;
if (scaledRectangle.Right <= uncroppedSize.Width - 5)
scaledRectangle.Right += 5;
if (scaledRectangle.Top >= 5)
scaledRectangle.Top -= 5;
if (scaledRectangle.Bottom <= uncroppedSize.Height - 5)
scaledRectangle.Bottom += 5;
image = Bitmap.CreateBitmap (image,
(int) scaledRectangle.Left,
(int) scaledRectangle.Top,
(int) scaledRectangle.Width (),
(int) scaledRectangle.Height ());
}
return image;
}
internal static float GetRectRatio(RectF rect)
{
return rect.Width() / rect.Height();
}
public override void Draw (Canvas canvas)
{
base.Draw (canvas);
if (!scaled) {
density = Resources.DisplayMetrics.Density;
padding *= density;
lineWidth *= density;
fontSize *= density;
scaled = true;
}
_highTemps = null;
_lowTemps = null;
_hourlyTemps = null;
if (Forecasts.Count == 0 || Hourly.Count == 0) return;
graphRect = new RectF (padding, padding, canvas.Width - padding, canvas.Height - padding);// CGRect (rect.X + padding, rect.Y + padding, rect.Width - (padding * 2), rect.Height - (padding * 2));
var days = Hourly.GroupBy (h => h.FCTTIME.mday).Select (g => g.First ().FCTTIME.weekday_name_abbrev).ToList ();
var dayCount = hourly ? days.Count : Forecasts.Count;
var xAxisScale = (graphRect.Width () + padding / 2) / dayCount;
inset = xAxisScale / 2;
var highest = (float)(hourly ? HourlyTemps.Max () : HighTemps.Max ());
var lowest = (float)(hourly ? HourlyTemps.Min () : LowTemps.Min ());
scaleHigh = (float)Math.Round (highest, MidpointRounding.AwayFromZero);
scaleLow = lowest < 0 ? (float)Math.Round (lowest, MidpointRounding.AwayFromZero) : (float)Math.Round (lowest);
var rangePadding = Settings.UomTemperature.IsImperial () ? scalePadding : (scalePadding / 2);
scaleHigh += rangePadding;
scaleLow -= rangePadding;
scaleRange = scaleHigh - scaleLow;
var scaleIncrement = scaleRange / dividerCount;
scaleX = (graphRect.Width () - inset) / (hourly ? HourlyTemps.Count : Forecasts.Count);
scaleY = graphRect.Height () / dividerCount;
float x, y;
var white = Color.White;
// Draw x and y axis
var paint = new Paint ();
paint.Color = white;
paint.StrokeWidth = 1;
using (Path path = new Path ()) {
path.MoveTo (graphRect.Left, graphRect.Top);
path.LineTo (graphRect.Left, graphRect.Bottom);
path.LineTo (graphRect.Right, graphRect.Bottom);
paint.SetStyle (Paint.Style.Stroke);
canvas.DrawPath (path, paint);
}
Color translucentBlack = Color.Argb (20, 0, 0, 0);
paint.Color = translucentBlack;
paint.SetStyle (Paint.Style.Fill);
// Draw horizontal gridlines
for (int i = 1; i < dividerCount; i += 2) {
y = graphRect.Bottom - ((i + 1) * scaleY);
using (RectF grid = new RectF (padding, y, graphRect.Right, y + scaleY))
canvas.DrawRect (grid, paint);
}
drawLines (canvas, paint);
float labelPadding = 6 * density;
float yStep = scaleLow;
// Draw y-axis labels
for (int i = dividerCount; i >= 0; i--) {
y = padding + (i * scaleY);
var step = Math.Round (yStep).ToString ();
drawLabel (canvas, graphRect.Left - labelPadding, y, Paint.Align.Right, step, true);
yStep += scaleIncrement;
}
// Draw x-axis labels
for (int i = 0; i < dayCount; i++) {
x = padding + (i * xAxisScale);
drawLabel (canvas, x, graphRect.Bottom + labelPadding, Paint.Align.Left, hourly ? days [i] : Forecasts [i]?.date?.weekday_short);
}
}
droidGraphics.LinearGradient CreateLinearGradient(LinearGradientBrush xamBrush,
droidGraphics.RectF pathBounds,
droidGraphics.Matrix stretchMatrix)
{
if (Path == null)
{
return(null);
}
int[] colors = new int[xamBrush.GradientStops.Count];
float[] offsets = new float[xamBrush.GradientStops.Count];
for (int index = 0; index < xamBrush.GradientStops.Count; index++)
{
colors[index] = ConvertColor(xamBrush.GradientStops[index].Color);
offsets[index] = (float)xamBrush.GradientStops[index].Offset;
}
droidGraphics.Shader.TileMode tilemode = droidGraphics.Shader.TileMode.Clamp;
switch (xamBrush.SpreadMethod)
{
case GradientSpreadMethod.Pad:
tilemode = droidGraphics.Shader.TileMode.Clamp;
break;
case GradientSpreadMethod.Refect:
tilemode = droidGraphics.Shader.TileMode.Mirror;
break;
case GradientSpreadMethod.Repeat:
tilemode = droidGraphics.Shader.TileMode.Repeat;
break;
}
// pathBounds has already been stretched
using (droidGraphics.RectF xformedBounds = new droidGraphics.RectF(pathBounds))
{
if (xamBrush.Transform != null)
{
// But the brush transform offsets needs to be stretched
droidGraphics.Matrix transform = xamBrush.Transform.GetNativeObject() as droidGraphics.Matrix;
float[] stretchValues = new float[9];
stretchMatrix.GetValues(stretchValues);
float[] transformValues = new float[9];
transform.GetValues(transformValues);
// Scale x-offset by stretch
transformValues[2] *= stretchValues[0];
// Scale y-offset by stretch
transformValues[5] *= stretchValues[4];
using (droidGraphics.Matrix matx = new droidGraphics.Matrix())
{
matx.SetValues(transformValues);
float[] a2 = new float[9];
matx.GetValues(a2);
matx.MapRect(xformedBounds);
}
}
return(new droidGraphics.LinearGradient((float)xamBrush.StartPoint.X * xformedBounds.Width() + xformedBounds.Left,
(float)xamBrush.StartPoint.Y * xformedBounds.Height() + xformedBounds.Top,
(float)xamBrush.EndPoint.X * xformedBounds.Width() + xformedBounds.Left,
(float)xamBrush.EndPoint.Y * xformedBounds.Height() + xformedBounds.Top,
colors, offsets, tilemode));
}
}
/**
* Generates a random rect that can be fully contained within {@code drawableBounds} and
* has the same aspect ratio of {@code viewportRect}. The dimensions of this random rect
* won't be higher than the largest rect with the same aspect ratio of {@code viewportRect}
* that {@code drawableBounds} can contain. They also won't be lower than the dimensions
* of this upper rect limit weighted by {@code MIN_RECT_FACTOR}.
* @param drawableBounds the bounds of the drawable that will be zoomed and panned.
* @param viewportRect the bounds of the view that the drawable will be shown.
* @return an arbitrary generated rect with the same aspect ratio of {@code viewportRect}
* that will be contained within {@code drawableBounds}.
*/
private RectF GenerateRandomRect(RectF drawableBounds, RectF viewportRect)
{
float drawableRatio = MathUtils.GetRectRatio(drawableBounds);
float viewportRectRatio = MathUtils.GetRectRatio(viewportRect);
RectF maxCrop;
if (drawableRatio > viewportRectRatio)
{
float r = (drawableBounds.Height() / viewportRect.Height()) * viewportRect.Width();
float b = drawableBounds.Height();
maxCrop = new RectF(0, 0, r, b);
}
else
{
float r = drawableBounds.Width();
float b = (drawableBounds.Width() / viewportRect.Width()) * viewportRect.Height();
maxCrop = new RectF(0, 0, r, b);
}
float randomFloat = MathUtils.Truncate((float)_mRandom.NextDouble(), 2);
float factor = MIN_RECT_FACTOR + ((1 - MIN_RECT_FACTOR) * randomFloat);
float width = factor * maxCrop.Width();
float height = factor * maxCrop.Height();
int widthDiff = (int)(drawableBounds.Width() - width);
int heightDiff = (int)(drawableBounds.Height() - height);
int left = widthDiff > 0 ? _mRandom.Next(widthDiff) : 0;
int top = heightDiff > 0 ? _mRandom.Next(heightDiff) : 0;
return new RectF(left, top, left + width, top + height);
}
protected internal override void ComputeRender(float renderProgress)
{
float radius = Math.Min(mCurrentBounds.Height(), mCurrentBounds.Width()) / 2.0f;
//the origin coordinate is the centerLeft of the field mCurrentBounds
float originCoordinateX = mCurrentBounds.Left;
float originCoordinateY = mCurrentBounds.Top + radius;
if (renderProgress <= BALL_FORWARD_END_ENTER_DURATION_OFFSET && renderProgress > BALL_FORWARD_START_ENTER_DURATION_OFFSET)
{
float ballForwardEnterProgress = (renderProgress - BALL_FORWARD_START_ENTER_DURATION_OFFSET) / (BALL_FORWARD_END_ENTER_DURATION_OFFSET - BALL_FORWARD_START_ENTER_DURATION_OFFSET);
mShapeChangeHeight = (0.5f - ballForwardEnterProgress) * mDanceBallRadius / 2.0f;
mShapeChangeWidth = -mShapeChangeHeight;
//y = k(x - r)--> k = tan(angle)
//(x - r)^2 + y^2 = r^2
// compute crossover point --> (k(x -r)) ^ 2 + (x - )^2 = r^2
// so x --> [r + r / sqrt(k ^ 2 + 1), r - r / sqrt(k ^ 2 + 1)]
for (int i = 0; i < NUM_POINTS; i++)
{
float k = (float)Math.Tan((DANCE_START_ANGLE + DANCE_INTERVAL_ANGLE * i) / 360.0f * (2.0f * Math.PI));
// progress[-1, 1]
float progress = (ACCELERATE_INTERPOLATOR.GetInterpolation(ballForwardEnterProgress) / 2.0f - 0.5f) * 2.0f * DIRECTION[i];
POINT_X[i] = (float)(radius + progress * (radius / Math.Sqrt(Math.Pow(k, 2.0f) + 1.0f)));
POINT_Y[i] = k * (POINT_X[i] - radius);
POINT_X[i] += originCoordinateX;
POINT_Y[i] += originCoordinateY;
}
}
if (renderProgress <= RING_FORWARD_END_ROTATE_DURATION_OFFSET && renderProgress > RING_FORWARD_START_ROTATE_DURATION_OFFSET)
{
float forwardRotateProgress = (renderProgress - RING_FORWARD_START_ROTATE_DURATION_OFFSET) / (RING_FORWARD_END_ROTATE_DURATION_OFFSET - RING_FORWARD_START_ROTATE_DURATION_OFFSET);
mRotation = DEGREE_360 * MATERIAL_INTERPOLATOR.GetInterpolation(forwardRotateProgress);
}
if (renderProgress <= CENTER_CIRCLE_FORWARD_END_SCALE_DURATION_OFFSET && renderProgress > CENTER_CIRCLE_FORWARD_START_SCALE_DURATION_OFFSET)
{
float centerCircleScaleProgress = (renderProgress - CENTER_CIRCLE_FORWARD_START_SCALE_DURATION_OFFSET) / (CENTER_CIRCLE_FORWARD_END_SCALE_DURATION_OFFSET - CENTER_CIRCLE_FORWARD_START_SCALE_DURATION_OFFSET);
if (centerCircleScaleProgress <= 0.5f)
{
mScale = 1.0f + DECELERATE_INTERPOLATOR.GetInterpolation(centerCircleScaleProgress * 2.0f) * 0.2f;
}
else
{
mScale = 1.2f - ACCELERATE_INTERPOLATOR.GetInterpolation((centerCircleScaleProgress - 0.5f) * 2.0f) * 0.2f;
}
}
if (renderProgress <= BALL_FORWARD_END_EXIT_DURATION_OFFSET && renderProgress > BALL_FORWARD_START_EXIT_DURATION_OFFSET)
{
float ballForwardExitProgress = (renderProgress - BALL_FORWARD_START_EXIT_DURATION_OFFSET) / (BALL_FORWARD_END_EXIT_DURATION_OFFSET - BALL_FORWARD_START_EXIT_DURATION_OFFSET);
mShapeChangeHeight = (ballForwardExitProgress - 0.5f) * mDanceBallRadius / 2.0f;
mShapeChangeWidth = -mShapeChangeHeight;
for (int i = 0; i < NUM_POINTS; i++)
{
float k = (float)Math.Tan((DANCE_START_ANGLE + DANCE_INTERVAL_ANGLE * i) / 360.0f * (2.0f * Math.PI));
float progress = (DECELERATE_INTERPOLATOR.GetInterpolation(ballForwardExitProgress) / 2.0f) * 2.0f * DIRECTION[i];
POINT_X[i] = (float)(radius + progress * (radius / Math.Sqrt(Math.Pow(k, 2.0f) + 1.0f)));
POINT_Y[i] = k * (POINT_X[i] - radius);
POINT_X[i] += originCoordinateX;
POINT_Y[i] += originCoordinateY;
}
}
if (renderProgress <= RING_REVERSAL_END_ROTATE_DURATION_OFFSET && renderProgress > RING_REVERSAL_START_ROTATE_DURATION_OFFSET)
{
float scaledTime = (renderProgress - RING_REVERSAL_START_ROTATE_DURATION_OFFSET) / (RING_REVERSAL_END_ROTATE_DURATION_OFFSET - RING_REVERSAL_START_ROTATE_DURATION_OFFSET);
mRotation = DEGREE_360 * MATERIAL_INTERPOLATOR.GetInterpolation(scaledTime) - 360;
}
else if (renderProgress > RING_REVERSAL_END_ROTATE_DURATION_OFFSET)
{
mRotation = 0.0f;
}
if (renderProgress <= BALL_REVERSAL_END_ENTER_DURATION_OFFSET && renderProgress > BALL_REVERSAL_START_ENTER_DURATION_OFFSET)
{
float ballReversalEnterProgress = (renderProgress - BALL_REVERSAL_START_ENTER_DURATION_OFFSET) / (BALL_REVERSAL_END_ENTER_DURATION_OFFSET - BALL_REVERSAL_START_ENTER_DURATION_OFFSET);
mShapeChangeHeight = (0.5f - ballReversalEnterProgress) * mDanceBallRadius / 2.0f;
mShapeChangeWidth = -mShapeChangeHeight;
for (int i = 0; i < NUM_POINTS; i++)
{
float k = (float)Math.Tan((DANCE_START_ANGLE + DANCE_INTERVAL_ANGLE * i) / 360.0f * (2.0f * Math.PI));
float progress = (0.5f - ACCELERATE_INTERPOLATOR.GetInterpolation(ballReversalEnterProgress) / 2.0f) * 2.0f * DIRECTION[i];
POINT_X[i] = (float)(radius + progress * (radius / Math.Sqrt(Math.Pow(k, 2.0f) + 1.0f)));
POINT_Y[i] = k * (POINT_X[i] - radius);
POINT_X[i] += originCoordinateX;
POINT_Y[i] += originCoordinateY;
}
}
if (renderProgress <= CENTER_CIRCLE_REVERSAL_END_SCALE_DURATION_OFFSET && renderProgress > CENTER_CIRCLE_REVERSAL_START_SCALE_DURATION_OFFSET)
{
float centerCircleScaleProgress = (renderProgress - CENTER_CIRCLE_REVERSAL_START_SCALE_DURATION_OFFSET) / (CENTER_CIRCLE_REVERSAL_END_SCALE_DURATION_OFFSET - CENTER_CIRCLE_REVERSAL_START_SCALE_DURATION_OFFSET);
if (centerCircleScaleProgress <= 0.5f)
{
mScale = 1.0f + DECELERATE_INTERPOLATOR.GetInterpolation(centerCircleScaleProgress * 2.0f) * 0.2f;
}
else
{
mScale = 1.2f - ACCELERATE_INTERPOLATOR.GetInterpolation((centerCircleScaleProgress - 0.5f) * 2.0f) * 0.2f;
}
}
if (renderProgress <= BALL_REVERSAL_END_EXIT_DURATION_OFFSET && renderProgress > BALL_REVERSAL_START_EXIT_DURATION_OFFSET)
{
float ballReversalExitProgress = (renderProgress - BALL_REVERSAL_START_EXIT_DURATION_OFFSET) / (BALL_REVERSAL_END_EXIT_DURATION_OFFSET - BALL_REVERSAL_START_EXIT_DURATION_OFFSET);
mShapeChangeHeight = (ballReversalExitProgress - 0.5f) * mDanceBallRadius / 2.0f;
mShapeChangeWidth = -mShapeChangeHeight;
for (int i = 0; i < NUM_POINTS; i++)
{
float k = (float)Math.Tan((DANCE_START_ANGLE + DANCE_INTERVAL_ANGLE * i) / 360.0f * (2.0f * Math.PI));
float progress = (0.0f - DECELERATE_INTERPOLATOR.GetInterpolation(ballReversalExitProgress) / 2.0f) * 2.0f * DIRECTION[i];
POINT_X[i] = (float)(radius + progress * (radius / Math.Sqrt(Math.Pow(k, 2.0f) + 1.0f)));
POINT_Y[i] = k * (POINT_X[i] - radius);
POINT_X[i] += originCoordinateX;
POINT_Y[i] += originCoordinateY;
}
}
}
/// <summary>
/// Center as much as possible in one or both axis. Centering is
/// defined as follows: if the image is scaled down below the
/// view's dimensions then center it (literally). If the image
/// is scaled larger than the view and is translated out of view
/// then translate it back into view (i.e. eliminate black bars).
/// </summary>
protected void Center(bool horizontal, bool vertical)
{
//return;
if (bitmapDisplayed.Bitmap == null)
{
return;
}
Matrix m = GetImageViewMatrix();
RectF rect = new RectF(0, 0,
bitmapDisplayed.Bitmap.Width,
bitmapDisplayed.Bitmap.Height);
m.MapRect(rect);
float height = rect.Height();
float width = rect.Width();
float deltaX = 0, deltaY = 0;
if (vertical)
{
int viewHeight = Height;
if (height < viewHeight)
{
deltaY = (viewHeight - height) / 2 - rect.Top;
}
else if (rect.Top > 0)
{
deltaY = -rect.Top;
}
else if (rect.Bottom < viewHeight)
{
deltaY = Height - rect.Bottom;
}
}
if (horizontal)
{
int viewWidth = _width; //Width;
if (width < viewWidth)
{
deltaX = (viewWidth - width) / 2 - rect.Left;
}
else if (rect.Left > 0)
{
deltaX = -rect.Left;
}
else if (rect.Right < viewWidth)
{
deltaX = viewWidth - rect.Right;
}
}
PostTranslate(deltaX, deltaY);
ImageMatrix = GetImageViewMatrix();
}