public static void parse(SVGProperties pSVGProperties, Canvas pCanvas, SVGPaint pSVGPaint, RectF pRect) {
float x = pSVGProperties.getFloatAttribute(SVGConstants.ATTRIBUTE_X, 0f);
float y = pSVGProperties.getFloatAttribute(SVGConstants.ATTRIBUTE_Y, 0f);
float width = pSVGProperties.getFloatAttribute(SVGConstants.ATTRIBUTE_WIDTH, 0f);
float height = pSVGProperties.getFloatAttribute(SVGConstants.ATTRIBUTE_HEIGHT, 0f);
pRect.Set(x, y, x + width, y + height);
float? rX = pSVGProperties.getFloatAttribute(SVGConstants.ATTRIBUTE_RADIUS_X);
float? rY = pSVGProperties.getFloatAttribute(SVGConstants.ATTRIBUTE_RADIUS_Y);
bool rXSpecified = rX != null && rX >= 0;
bool rYSpecified = rY != null && rY >= 0;
bool rounded = rXSpecified || rYSpecified;
float rx;
float ry;
if(rXSpecified && rYSpecified) {
rx = Math.Min(rX.Value, width * 0.5f);
ry = Math.Min(rY.Value, height * 0.5f);
} else if(rXSpecified) {
ry = rx = Math.Min(rX.Value, width * 0.5f);
} else if(rYSpecified) {
rx = ry = Math.Min(rY.Value, height * 0.5f);
} else {
rx = 0;
ry = 0;
}
bool fill = pSVGPaint.setFill(pSVGProperties);
if (fill) {
if(rounded) {
pCanvas.DrawRoundRect(pRect, rx, ry, pSVGPaint.getPaint());
} else {
pCanvas.DrawRect(pRect, pSVGPaint.getPaint());
}
}
bool stroke = pSVGPaint.setStroke(pSVGProperties);
if (stroke) {
if(rounded) {
pCanvas.DrawRoundRect(pRect, rx, ry, pSVGPaint.getPaint());
} else {
pCanvas.DrawRect(pRect, pSVGPaint.getPaint());
}
}
if(fill || stroke) {
pSVGPaint.ensureComputedBoundsInclude(x, y, width, height);
}
}
/// <Docs>The Canvas to which the View is rendered.</Docs>
/// <summary>
/// Draw the specified canvas.
/// </summary>
/// <param name="canvas">Canvas.</param>
public override void Draw (Canvas canvas)
{
try
{
var element = Element as RoundCornerView;
var cornerRadius = (float)element.CornerRadius*Resources.DisplayMetrics.Density;
// Paint rounded rect itself
canvas.Save();
var paint = new Paint();
paint.AntiAlias = true;
var strokeWidth = (((float)element.BorderWidth)*Resources.DisplayMetrics.Density);
paint.StrokeWidth = strokeWidth;
if(element.BackgroundColor != Xamarin.Forms.Color.Transparent)
{
paint.SetStyle(Paint.Style.Fill);
paint.Color = element.BackgroundColor.ToAndroid();
canvas.DrawRoundRect(new RectF(0, 0, Width, Height), cornerRadius, cornerRadius, paint);
}
if(element.BorderColor != Xamarin.Forms.Color.Transparent)
{
paint.SetStyle(Paint.Style.Stroke);
paint.Color = element.BorderColor.ToAndroid();
canvas.DrawRoundRect(new RectF(0, 0, Width, Height), cornerRadius, cornerRadius, paint);
}
//Properly dispose
paint.Dispose();
canvas.Restore();
// Create clip path
var path = new Path();
path.AddRoundRect(new RectF(0.0f + (strokeWidth/2), 0.0f + (strokeWidth/2),
Width - (strokeWidth/2), Height - (strokeWidth/2)), cornerRadius, cornerRadius, Path.Direction.Cw);
canvas.Save();
canvas.ClipPath(path);
// Do base drawing
for(var i=0; i<ChildCount; i++)
GetChildAt(i).Draw(canvas);
canvas.Restore();
path.Dispose();
}
catch (Exception)
{
}
}
void OnElementSizeChanged(object sender, EventArgs e)
{
var elem = sender as View;
if (elem == null)
return;
var density = Resources.System.DisplayMetrics.Density;
using (var imageBitmap = Bitmap.CreateBitmap((int)((elem.Width + 2) * density), (int)((elem.Height + 1) * density), Bitmap.Config.Argb8888))
using (var canvas = new Canvas(imageBitmap))
using (var paint = new Paint() { Dither = false, Color = Xamarin.Forms.Color.White.ToAndroid(), AntiAlias = true })
{
paint.Hinting = PaintHinting.On;
paint.Flags = PaintFlags.AntiAlias;
paint.SetStyle(Paint.Style.Stroke);
paint.StrokeWidth = 2 * density;
var height = (float)elem.Height;
canvas.DrawRoundRect(new RectF(density, density, (float)(elem.Width) * density, (float)(height) * density), height * density / 2, height * density / 2, paint);
canvas.Density = (int)density;
Container.Background = new BitmapDrawable(imageBitmap);
}
}
// If you would like to create a circle of the image set pixels to half the width of the image.
internal static Bitmap GetRoundedCornerBitmap(Bitmap bitmap, int pixels)
{
Bitmap output = null;
try
{
output = Bitmap.CreateBitmap(bitmap.Width, bitmap.Height, Bitmap.Config.Argb8888);
Canvas canvas = new Canvas(output);
Color color = new Color(66, 66, 66);
Paint paint = new Paint();
Rect rect = new Rect(0, 0, bitmap.Width, bitmap.Height);
RectF rectF = new RectF(rect);
float roundPx = pixels;
paint.AntiAlias = true;
canvas.DrawARGB(0, 0, 0, 0);
paint.Color = color;
canvas.DrawRoundRect(rectF, roundPx, roundPx, paint);
paint.SetXfermode(new PorterDuffXfermode(PorterDuff.Mode.SrcIn));
canvas.DrawBitmap(bitmap, rect, rect, paint);
}
catch (System.Exception err)
{
System.Console.WriteLine ("GetRoundedCornerBitmap Error - " + err.Message);
}
return output;
}
protected override void OnDraw(Canvas canvas)
{
Android.Graphics.Drawable.Drawable drawable = GetDrawable();
if (drawable is BitmapDrawable)
{
RectF rectF = new RectF(drawable.GetBounds());
int restoreCount = canvas.SaveLayer(rectF, null, Canvas.AllSaveFlag);
GetImageMatrix().MapRect(rectF);
Paint paint = ((BitmapDrawable)drawable).GetPaint();
paint.SetAntiAlias(true);
paint.SetColor(unchecked((int)(0xff000000)));
canvas.DrawARGB(0, 0, 0, 0);
canvas.DrawRoundRect(rectF, Radius, Radius, paint);
Xfermode restoreMode = paint.GetXfermode();
paint.SetXfermode(new PorterDuffXfermode(PorterDuff.Mode.SrcIn));
base.OnDraw(canvas);
// Restore paint and canvas
paint.SetXfermode(restoreMode);
canvas.RestoreToCount(restoreCount);
}
else
{
base.OnDraw(canvas);
}
}
public static Bitmap ToRounded(Bitmap source, float rad)
{
int size = Math.Min(source.Width, source.Height);
int dx = (source.Width - size) / 2;
int dy = (source.Height - size) / 2;
Bitmap bitmap = Bitmap.CreateBitmap(size, size, Bitmap.Config.Argb8888);
using (Canvas canvas = new Canvas(bitmap))
using (Paint paint = new Paint())
using (BitmapShader shader = new BitmapShader(source, Shader.TileMode.Clamp, Shader.TileMode.Clamp))
using (Matrix matrix = new Matrix())
{
if (dx != 0 || dy != 0)
{
// source isn't square, move viewport to centre
matrix.SetTranslate(-dx, -dy);
shader.SetLocalMatrix(matrix);
}
paint.SetShader(shader);
paint.AntiAlias = true;
RectF rectF = new RectF(0, 0, size, size);
canvas.DrawRoundRect(rectF, rad, rad, paint);
return bitmap;
}
}
protected virtual void HandleShapeDraw (Canvas canvas)
{
// We need to account for offsetting the coordinates based on the padding
var x = GetX () + Resize (this.ShapeView.Padding.Left);
var y = GetY () + Resize (this.ShapeView.Padding.Top);
switch (ShapeView.ShapeType) {
case ShapeType.Box:
HandleStandardDraw (canvas, p => {
var rect = new RectF (x, y, x + this.Width, y + this.Height);
if (ShapeView.CornerRadius > 0) {
var cr = Resize (ShapeView.CornerRadius);
canvas.DrawRoundRect (rect, cr, cr, p);
} else {
canvas.DrawRect (rect, p);
}
});
break;
case ShapeType.Circle:
HandleStandardDraw (canvas, p => canvas.DrawCircle (x + this.Width / 2, y + this.Height / 2, (this.Width - 10) / 2, p));
break;
case ShapeType.CircleIndicator:
HandleStandardDraw (canvas, p => canvas.DrawCircle (x + this.Width / 2, y + this.Height / 2, (this.Width - 10) / 2, p), drawFill: false);
HandleStandardDraw (canvas, p => canvas.DrawArc (new RectF (x, y, x + this.Width, y + this.Height), QuarterTurnCounterClockwise, 360 * (ShapeView.IndicatorPercentage / 100), false, p), ShapeView.StrokeWidth + 3, false);
break;
}
}
public override void Draw(Canvas canvas)
{
RoundedBoxView rbv = (RoundedBoxView)this.Element;
Rect rc = new Rect();
GetDrawingRect(rc);
Rect interior = rc;
interior.Inset((int)rbv.StrokeThickness, (int)rbv.StrokeThickness);
// The shadow is fairly pointless on Android as the bounds are clipped. You can add support
// if you need to, but it is best to not do something like that on the Native interface
#region Drawing the Shadow
// if (rbv.HasShadow) {
// Paint shadowPaint = new Paint () {
// Color = Xamarin.Forms.Color.FromRgba(0.0, 0.0, 0.0, 0.5).ToAndroid (),
// AntiAlias = true
// };
//
// var shadowOffset = 5.0;
//
// var shadowRect = new Rect (rc);
// shadowRect.Offset ((int)shadowOffset, (int)shadowOffset);
//
// canvas.DrawRoundRect(
// new RectF(shadowRect), (float)rbv.CornerRadius, (float)rbv.CornerRadius, shadowPaint);
// }
#endregion
Paint p = new Paint() {
Color = rbv.Color.ToAndroid(),
AntiAlias = true,
};
canvas.DrawRoundRect(new RectF(interior), (float)rbv.CornerRadius, (float)rbv.CornerRadius, p);
p.Color = rbv.Stroke.ToAndroid();
p.StrokeWidth = (float)rbv.StrokeThickness;
p.SetStyle(Paint.Style.Stroke);
canvas.DrawRoundRect(new RectF(rc), (float)rbv.CornerRadius, (float)rbv.CornerRadius, p);
}
void DrawOutline(ACanvas canvas, int width, int height, float cornerRadius, float outlineWidth)
{
using (var paint = new Paint {
AntiAlias = true
})
using (var rect = new RectF(0, 0, width, height))
{
paint.StrokeWidth = outlineWidth;
paint.SetStyle(Paint.Style.Fill);
paint.Color = _frame.OutlineColor.ToAndroid();
canvas.DrawRoundRect(rect, cornerRadius, cornerRadius, paint);
// This will "carve out" the center where our background layer will go. Therefore we maintain the proper background color/transparency.
using (var clearXfer = new PorterDuffXfermode(PorterDuff.Mode.Clear))
{
paint.SetXfermode(clearXfer);
rect.Left = outlineWidth; rect.Top = outlineWidth; rect.Right = width - outlineWidth; rect.Bottom = height - outlineWidth;
canvas.DrawRoundRect(rect, cornerRadius, cornerRadius, paint);
}
}
}
void DrawBackground(ACanvas canvas, int width, int height, float cornerRadius, float outlineWidth, bool pressed)
{
using (var paint = new Paint {
AntiAlias = true
})
using (var rect = new RectF(outlineWidth, outlineWidth, width - outlineWidth, height - outlineWidth))
{
paint.SetStyle(Paint.Style.Fill);
paint.Color = _frame.BackgroundColor.ToAndroid();
canvas.DrawRoundRect(rect, cornerRadius, cornerRadius, paint);
}
}
public override void Draw(Canvas canvas)
{
RoundedGrid rg = (RoundedGrid)this.Element;
Rect rc = new Rect ();
GetDrawingRect (rc);
Rect interior = rc;
interior.Inset((int)rg.StrokeThickness, (int)rg.StrokeThickness);
Paint p = new Paint () {
Color = rg.BackgroundColor.ToAndroid(),
AntiAlias = true
};
canvas.DrawRoundRect (new RectF (interior), (float)rg.CornerRadius, (float)rg.CornerRadius, p);
p.Color = rg.Stroke.ToAndroid ();
p.StrokeWidth = (float)rg.StrokeThickness;
p.SetStyle(Paint.Style.Stroke);
canvas.DrawRoundRect(new RectF(rc), (float)rg.CornerRadius, (float)rg.CornerRadius, p);
}
public override void Draw(Android.Graphics.Canvas canvas)
{
var box = Element as RoundedBoxView;
var rect = new Rect();
var paint = new Paint()
{
Color = box.BorderColor.ToAndroid(),
AntiAlias = true,
};
paint.SetStyle(Paint.Style.Fill);
GetDrawingRect(rect);
var radius = (float)(rect.Width() / box.Width * box.CornerRadius);
canvas.DrawRoundRect(new RectF(rect), radius, radius, paint);
rect.Top = rect.Top + Convert.ToInt32(box.BorderSize);
rect.Bottom = rect.Bottom - Convert.ToInt32(box.BorderSize);
rect.Left = rect.Left + Convert.ToInt32(box.BorderSize);
rect.Right = rect.Right - Convert.ToInt32(box.BorderSize);
paint.Color = box.BackgroundColor.ToAndroid();
canvas.DrawRoundRect(new RectF(rect), radius, radius, paint);
}
public static Bitmap GetRoundedCornerBitmap(this Bitmap bitmap, int roundPixelSize)
{
Bitmap output = Bitmap.CreateBitmap(bitmap.Width, bitmap.Height, Bitmap.Config.Argb8888);
var canvas = new Canvas(output);
var paint = new Paint();
var rect = new Rect(0, 0, bitmap.Width, bitmap.Height);
var rectF = new RectF(rect);
var roundPx = roundPixelSize;
paint.AntiAlias = true;
canvas.DrawRoundRect(rectF,roundPx,roundPx, paint);
paint.SetXfermode(new PorterDuffXfermode(PorterDuff.Mode.SrcIn));
canvas.DrawBitmap(bitmap, rect, rect, paint);
return output;
}
public override void Draw(Canvas canvas)
{
var box = Element as RoundedBox;
var rect = new Rect();
var paint = new Paint() {
Color = box.BackgroundColor.ToAndroid(),
AntiAlias = true,
};
GetDrawingRect(rect);
var radius = (float)(rect.Width() / box.Width * box.CornerRadius);
canvas.DrawRoundRect(new RectF(rect), radius, radius, paint);
}
public static Bitmap GetRoundedCornerBitmap(this Bitmap bitmap, int? roundPixelSize = null)
{
var chooseSize = bitmap.Width > bitmap.Height ? bitmap.Height : bitmap.Width;
roundPixelSize = roundPixelSize ?? (int)Application.Context.Resources.GetDimension(Resource.Dimension.RoundedCorners);
var output = Bitmap.CreateBitmap(chooseSize, chooseSize, Bitmap.Config.Argb8888);
var canvas = new Canvas(output);
var paint = new Paint();
var rect = new Rect(0, 0, chooseSize, chooseSize);
var rectF = new RectF(rect);
var roundPx = roundPixelSize.Value;
paint.AntiAlias = true;
canvas.DrawRoundRect(rectF, roundPx, roundPx, paint);
paint.SetXfermode(new PorterDuffXfermode(PorterDuff.Mode.SrcIn));
canvas.DrawBitmap(bitmap, rect, rect, paint);
return output;
}
public override void Draw(Canvas canvas)
{
var box = Element as CustomRoundedBox;
var rect = new Rect();
var paint = new Paint
{
AntiAlias = true,
};
paint.SetARGB((int)box.BackgroundColor.A, (int)box.BackgroundColor.R, (int)box.BackgroundColor.G, (int)box.BackgroundColor.B);
GetDrawingRect(rect);
var radius = (float)(rect.Width() / box.Width * box.CornerRadius);
canvas.DrawRoundRect(new RectF(rect), radius, radius, paint);
}
protected override Bitmap Transform(Bitmap source)
{
int width = source.Width;
int height = source.Height;
Bitmap bitmap = Bitmap.CreateBitmap(width, height, Bitmap.Config.Argb8888);
Canvas canvas = new Canvas(bitmap);
Paint paint = new Paint();
paint.AntiAlias = true;
paint.SetShader(new BitmapShader(source, Shader.TileMode.Clamp, Shader.TileMode.Clamp));
canvas.DrawRoundRect(new RectF(margin, margin, width - margin, height - margin), radius, radius, paint);
source.Recycle();
return bitmap;
}
public override void Draw(Canvas canvas)
{
var box = Element as RoundedBox;
var rect = new Rect();
var androidColor = box.BackgroundColor.ToAndroid();
var paint = new Paint()
{
AntiAlias = true,
};
paint.SetARGB(Convert.ToInt32(box.Opacity * 255), (int)androidColor.R, (int)androidColor.G, (int)androidColor.B);
GetDrawingRect(rect);
var radius = (float)(rect.Width() / box.Width * box.CornerRadius);
canvas.DrawRoundRect(new RectF(rect), radius, radius, paint);
}
public override void Draw (Canvas canvas)
{
child.Draw (canvas);
if (count <= 0)
return;
badgePaint.Alpha = textPaint.Alpha = alpha;
badgeBounds.Set (0, 0, Bounds.Width () / 2, Bounds.Height () / 2);
canvas.DrawRoundRect (badgeBounds, 8, 8, badgePaint);
textPaint.TextSize = (8 * badgeBounds.Height ()) / 10;
var text = count.ToString ();
textPaint.GetTextBounds (text, 0, text.Length, txtBounds);
canvas.DrawText (
text,
badgeBounds.CenterX (),
badgeBounds.Bottom - (badgeBounds.Height () - txtBounds.Height ()) / 2 - 1,
textPaint
);
}
protected override void DrawRightThumb(Android.Graphics.Canvas p0, float x1, float y1, float x2, float y2)
{
float density = Context.Resources.DisplayMetrics.Density;
Paint paint = new Paint();
paint.AntiAlias = true;
RectF rounderRectF = new RectF(x2 - (1.66f * density), y2 - (3.33f * density), x2 + (16.66f * density), y2 + (16.66f * density));
paint.Color = (Color.ParseColor("#5f6872"));
p0.DrawRoundRect(rounderRectF, 7, 7, paint);
Path path = new Path();
path.MoveTo(x2, y2 - (16.66f * density));
path.LineTo(x2, y2);
path.LineTo(x2 + (16.66f * density), y2 - (2 * density));
path.Close();
p0.DrawPath(path, paint);
paint.StrokeWidth = (3.33f * density);
p0.DrawLine(x1, y1, x2, y2, paint);
SetRightThumbBounds(new RectF(x2 - 25, y1 - 25, x2 + 25, y2 + 25));
}
public static Bitmap ToRounded(Bitmap source, float rad, double cropWidthRatio, double cropHeightRatio)
{
double sourceWidth = source.Width;
double sourceHeight = source.Height;
double desiredWidth = sourceWidth;
double desiredHeight = sourceHeight;
double desiredRatio = cropWidthRatio / cropHeightRatio;
double currentRatio = sourceWidth / sourceHeight;
if (currentRatio > desiredRatio)
desiredWidth = (cropWidthRatio * sourceHeight / cropHeightRatio);
else if (currentRatio < desiredRatio)
desiredHeight = (cropHeightRatio * sourceWidth / cropWidthRatio);
float cropX = (float)((sourceWidth - desiredWidth) / 2);
float cropY = (float)((sourceHeight - desiredHeight) / 2);
if (rad == 0)
rad = (float)(Math.Min(desiredWidth, desiredHeight) / 2);
Bitmap bitmap = Bitmap.CreateBitmap((int)desiredWidth, (int)desiredHeight, Bitmap.Config.Argb8888);
using (Canvas canvas = new Canvas(bitmap))
using (Paint paint = new Paint())
using (BitmapShader shader = new BitmapShader(source, Shader.TileMode.Clamp, Shader.TileMode.Clamp))
using (Matrix matrix = new Matrix())
{
if (cropX != 0 || cropY != 0)
{
matrix.SetTranslate(-cropX, -cropY);
shader.SetLocalMatrix(matrix);
}
paint.SetShader(shader);
paint.AntiAlias = true;
RectF rectF = new RectF(0, 0, (int)desiredWidth, (int)desiredHeight);
canvas.DrawRoundRect(rectF, rad, rad, paint);
return bitmap;
}
}
void RedRaw(View view)
{
var density = Resources.System.DisplayMetrics.Density;
using (var imageBitmap = Bitmap.CreateBitmap((int)(view.Width * density), (int)(view.Height * density), Bitmap.Config.Argb8888))
using (var canvas = new Canvas(imageBitmap))
using (var paint = new Paint() { Dither = false, Color = view.BackgroundColor.ToAndroid(), AntiAlias = true })
{
paint.Hinting = PaintHinting.On;
paint.Flags = PaintFlags.AntiAlias;
var height = (float)view.Height;
canvas.DrawRoundRect(new RectF(0, 0, (float)view.Width * density, height * density), height * density / 2, height * density / 2, paint);
canvas.Density = (int)density;
Container.Background = new BitmapDrawable(imageBitmap);
}
}
protected override void Draw(Canvas canvas, Rect bounds)
{
int saveCount = canvas.Save();
RectF arcBounds = mCurrentBounds;
arcBounds.Set(bounds);
//draw draw gas tube
mPaint.Color = new Color(mGasTubeColor);
mPaint.SetStyle(Paint.Style.Stroke);
mPaint.StrokeWidth = mStrokeWidth;
canvas.DrawPath(CreateGasTubePath(mGasTubeBounds), mPaint);
//draw balloon
mPaint.Color = new Color(mBalloonColor);
mPaint.SetStyle(Paint.Style.FillAndStroke);
canvas.DrawPath(CreateBalloonPath(mBalloonBounds, mProgress), mPaint);
//draw progress
mPaint.Color = new Color(mGasTubeColor);
mPaint.TextSize = mTextSize;
mPaint.StrokeWidth = mStrokeWidth / 5.0f;
canvas.DrawText(mProgressText, arcBounds.CenterX() - mProgressBounds.Width() / 2.0f, mGasTubeBounds.CenterY() + mProgressBounds.Height() / 2.0f, mPaint);
//draw cannula
mPaint.Color = new Color(mCannulaColor);
mPaint.SetStyle(Paint.Style.Stroke);
mPaint.StrokeWidth = mStrokeWidth;
canvas.DrawPath(CreateCannulaHeadPath(mCannulaBounds), mPaint);
mPaint.SetStyle(Paint.Style.Fill);
canvas.DrawPath(CreateCannulaBottomPath(mCannulaBounds), mPaint);
//draw pipe body
mPaint.Color = new Color(mPipeBodyColor);
mPaint.SetStyle(Paint.Style.Fill);
canvas.DrawRoundRect(mPipeBodyBounds, mRectCornerRadius, mRectCornerRadius, mPaint);
canvas.RestoreToCount(saveCount);
}
private void drawHuePanel(Canvas canvas)
{
/*
* Drawn with hw acceleration, very fast.
*/
//long start = SystemClock.elapsedRealtime();
RectF rect = mHueRect;
if (BORDER_WIDTH_PX > 0)
{
mBorderPaint.Color = new Color((int)mBorderColor);
canvas.DrawRect(rect.Left - BORDER_WIDTH_PX,
rect.Top - BORDER_WIDTH_PX,
rect.Right + BORDER_WIDTH_PX,
rect.Bottom + BORDER_WIDTH_PX,
mBorderPaint);
}
if (mHueShader == null)
{
//The hue shader has either not yet been created or the view has been resized.
mHueShader = new LinearGradient(0, 0, 0, rect.Height(), buildHueColorArray(), null, Shader.TileMode.Clamp);
mHuePaint.SetShader(mHueShader);
}
canvas.DrawRect(rect, mHuePaint);
float rectHeight = 4 * mDensity / 2;
Point p = hueToPoint(mHue);
RectF r = new RectF
{
Left = rect.Left - RECTANGLE_TRACKER_OFFSET,
Right = rect.Right + RECTANGLE_TRACKER_OFFSET,
Top = p.Y - rectHeight,
Bottom = p.Y + rectHeight
};
canvas.DrawRoundRect(r, 2, 2, mHueAlphaTrackerPaint);
//Log.d("mColorPicker", "Draw Time Hue: " + (SystemClock.elapsedRealtime() - start) + "ms");
}
public override void Draw(Canvas canvas)
{
if (_mOval)
{
if (_mBorderWidth > 0)
{
canvas.DrawOval(_mDrawableRect, _mBitmapPaint);
canvas.DrawOval(_mBorderRect, _mBorderPaint);
}
else
{
canvas.DrawOval(_mDrawableRect, _mBitmapPaint);
}
}
else
{
if (_mBorderWidth > 0)
{
canvas.DrawRoundRect(_mDrawableRect, Math.Max(_mCornerRadius, 0),
Math.Max(_mCornerRadius, 0), _mBitmapPaint);
canvas.DrawRoundRect(_mBorderRect, _mCornerRadius, _mCornerRadius, _mBorderPaint);
}
else
{
canvas.DrawRoundRect(_mDrawableRect, _mCornerRadius, _mCornerRadius, _mBitmapPaint);
}
}
}
private void drawHuePanel(Canvas canvas){
/*
* Drawn with hw acceleration, very fast.
*/
//long start = SystemClock.elapsedRealtime();
RectF rect = mHueRect;
if(BORDER_WIDTH_PX > 0) {
//TODO: Cross check the color setting
byte[] byteArr = BitConverter.GetBytes (mBorderColor);
mBorderPaint.Color = Color.Argb (byteArr [0], byteArr [1], byteArr [2], byteArr [3]);
// mBorderPaint.Color = mBorderColor;
canvas.DrawRect(rect.Left - BORDER_WIDTH_PX,
rect.Top - BORDER_WIDTH_PX,
rect.Right + BORDER_WIDTH_PX,
rect.Bottom + BORDER_WIDTH_PX,
mBorderPaint);
}
if (mHueShader == null) {
//The hue shader has either not yet been created or the view has been resized.
mHueShader = new LinearGradient(0, 0, 0, rect.Height(), buildHueColorArray(), null, Android.Graphics.Shader.TileMode.Clamp);
mHuePaint.SetShader(mHueShader);
}
canvas.DrawRect(rect, mHuePaint);
float rectHeight = 4 * mDensity / 2;
Point p = hueToPoint(mHue);
RectF r = new RectF();
r.Left = rect.Left - RECTANGLE_TRACKER_OFFSET;
r.Right = rect.Right + RECTANGLE_TRACKER_OFFSET;
r.Top = p.Y - rectHeight;
r.Bottom = p.Y + rectHeight;
canvas.DrawRoundRect(r, 2, 2, mHueAlphaTrackerPaint);
//Log.d("mColorPicker", "Draw Time Hue: " + (SystemClock.elapsedRealtime() - start) + "ms");
}
//--------------------------------------------------------------
// PROTECTED METHODS
//--------------------------------------------------------------
protected bool InitializeUI()
{
_buttonLayout.SetMinimumHeight(Math.Max(_positiveButton.Height, _negativeButton.Height));
// Initialize background
if(_root.Width <= 0 || _root.Height <= 0)
return false;
if(_backgroundImage != null)
{
_backgroundImage.Recycle();
_backgroundImage.Dispose();
}
_backgroundImage = Bitmap.CreateBitmap(_root.Width, _root.Height, Bitmap.Config.Argb8888);
Canvas canvas = new Canvas(_backgroundImage);
Rect local = new Rect();
_root.GetLocalVisibleRect(local);
RectF bounds = new RectF(local);
bounds.Top += Builder.StrokeBorderWidth/2;
bounds.Left += Builder.StrokeBorderWidth/2;
bounds.Right -= Builder.StrokeBorderWidth/2;
bounds.Bottom -= Builder.StrokeBorderWidth/2;
// Background fill paint
Paint fillBackPaint = new Paint();
fillBackPaint.Color = Builder.FillColor;
fillBackPaint.AntiAlias = true;
// Background stroke paint
Paint strokeBackPaint = new Paint();
strokeBackPaint.Color = Builder.StrokeColor;
strokeBackPaint.SetStyle(Paint.Style.Stroke);
strokeBackPaint.StrokeWidth = Builder.StrokeBorderWidth;
strokeBackPaint.AntiAlias = true;
canvas.DrawRoundRect(bounds, Builder.RadiusOut, Builder.RadiusOut, strokeBackPaint);
canvas.DrawRoundRect(bounds, Builder.RadiusIn, Builder.RadiusIn, fillBackPaint);
_root.SetBackgroundDrawable(new BitmapDrawable(_backgroundImage));
canvas.Dispose();
strokeBackPaint.Dispose();
fillBackPaint.Dispose();
return true;
}
/// <Docs>The Canvas to which the View is rendered.</Docs>
/// <summary>
/// Draw the specified canvas.
/// </summary>
/// <param name="canvas">Canvas to draw onto.</param>
public override void Draw(Canvas canvas)
{
BadgeImage image = (BadgeImage)Element;
// Set color of icon
if (Control.Drawable != null)
{
if (image.Selected)
{
Control.Drawable.SetColorFilter(filterColor);
}
else
{
Control.Drawable.SetColorFilter(filterGray);
}
}
base.Draw(canvas);
if (image.Number > 0)
{
using (Paint paint = new Paint())
{
paint.Color = image.Selected ? Xamarin.Forms.Color.Red.ToAndroid() : Xamarin.Forms.Color.Gray.ToAndroid();
paint.StrokeWidth = 0f;
paint.SetStyle(Paint.Style.FillAndStroke);
// Calc text size
paint.TextSize = (int)this.DipToPixel(16);
paint.FakeBoldText = true;
string text = image.Number.ToString();
Rect textBounds = new Rect(0, 0, 0, 0);
paint.GetTextBounds(text, 0, text.Length, textBounds);
float textWidth = paint.MeasureText(text);
float textHeight = textBounds.Height();
float badgeWidth = textWidth + this.DipToPixel(9);
float badgeHeight = textHeight + this.DipToPixel(9);
if (badgeWidth < badgeHeight)
{
badgeWidth = badgeHeight;
}
double offsetX = (image.Bounds.Width - image.Bounds.Width) / 2;
double offsetY = (image.Bounds.Height - image.Bounds.Height) / 2;
float left = this.DipToPixel(image.Bounds.Width) - badgeWidth;
float top = 1;
float right = left + badgeWidth;
float bottom = top + badgeHeight;
float radius = (badgeHeight / 2f) - 1f;
using (Path path = new Path())
{
canvas.DrawRoundRect(new RectF(left, top, left + badgeWidth, top + badgeHeight), radius, radius, paint);
paint.Color = Xamarin.Forms.Color.White.ToAndroid();
canvas.DrawText(image.Number.ToString(), left + ((badgeWidth - textWidth) / 2) - 1, bottom - ((badgeHeight - textHeight) / 2), paint);
}
}
}
}
private void setBackground()
{
LinearLayout player2layout = FindViewById<LinearLayout>(Resource.Id.player2layout);
if(_player2background != null)
{
_player2background.Recycle();
_player2background.Dispose();
}
// Create image
_player2background = Bitmap.CreateBitmap(player2layout.Width, player2layout.Height, Bitmap.Config.Argb8888);
Canvas backCanvas = new Canvas(_player2background);
// Background stroke paint
float strokeBorderWidth = (FindViewById<ButtonStroked>(Resource.Id.buttonMoveLeft)).Settings.StrokeBorderWidth;
int padding = (int)strokeBorderWidth/2 + Utils.GetPixelsFromDP(this, 5);
player2layout.SetPadding(padding, 0, 0, padding);
Paint strokeBackPaint = new Paint();
strokeBackPaint.Color = Utils.getAndroidColor(TetrisColor.Red);
strokeBackPaint.SetStyle(Paint.Style.Stroke);
strokeBackPaint.StrokeWidth = strokeBorderWidth/2;
strokeBackPaint.AntiAlias = true;
// Get rectangle
Rect local = new Rect();
player2layout.GetLocalVisibleRect(local);
RectF bounds = new RectF(local);
bounds.Left += strokeBorderWidth/2;
bounds.Bottom -= strokeBorderWidth/2;
bounds.Top -= strokeBorderWidth;
bounds.Right += strokeBorderWidth;
// Actually draw background
int radiusIn = (FindViewById<ButtonStroked>(Resource.Id.buttonMoveLeft)).Settings.RadiusIn;
int radiusOut = (FindViewById<ButtonStroked>(Resource.Id.buttonMoveLeft)).Settings.RadiusOut;
backCanvas.DrawRoundRect(bounds, radiusOut, radiusOut, strokeBackPaint);
// Use it as background
player2layout.SetBackgroundDrawable(new BitmapDrawable(_player2background));
backCanvas.Dispose();
strokeBackPaint.Dispose();
}
public override void Draw (Canvas canvas)
{
canvas.DrawRoundRect (bounds, radius, radius, paint);
}
public override void Draw (Canvas canvas)
{
canvas.DrawRoundRect (mRect, mCornerRadius, mCornerRadius, strokePaint);
canvas.DrawRoundRect (mRect, mCornerRadius, mCornerRadius, paint);
}
/// <summary>
/// Reshapes the image.
/// </summary>
/// <param name="sourceBitmap">The source bitmap.</param>
private void ReshapeImage(Bitmap sourceBitmap)
{
if (sourceBitmap == null) return;
using (var sourceRect = GetScaledRect(sourceBitmap.Height, sourceBitmap.Width))
using (var rect = this.GetTargetRect(sourceBitmap.Height, sourceBitmap.Width))
using (var output = Bitmap.CreateBitmap(rect.Width(), rect.Height(), Bitmap.Config.Argb8888))
using (var canvas = new Canvas(output))
using (var paint = new Paint())
using (var rectF = new RectF(rect))
{
var roundRx = rect.Width() / 2;
var roundRy = rect.Height() / 2;
paint.AntiAlias = true;
canvas.DrawARGB(0, 0, 0, 0);
paint.Color = Android.Graphics.Color.ParseColor("#ff424242");
canvas.DrawRoundRect(rectF, roundRx, roundRy, paint);
paint.SetXfermode(new PorterDuffXfermode(PorterDuff.Mode.SrcIn));
canvas.DrawBitmap(sourceBitmap, sourceRect, rect, paint);
//this.DrawBorder(canvas, rect.Width(), rect.Height());
this.Control.SetImageBitmap(output);
// Forces the internal method of InvalidateMeasure to be called.
this.Element.WidthRequest = this.Element.WidthRequest;
}
}
private void drawAlphaPanel(Canvas canvas) {
/*
* Will be drawn with hw acceleration, very fast.
*/
if(!mShowAlphaPanel || mAlphaRect == null || mAlphaPattern == null) return;
RectF rect = mAlphaRect;
if(BORDER_WIDTH_PX > 0){
//TODO: cross check the color
byte[] byteArr = BitConverter.GetBytes (mBorderColor);
mBorderPaint.Color = Color.Argb (byteArr [0], byteArr [1], byteArr [2], byteArr [3]);
// mBorderPaint.Color = mBorderColor;
canvas.DrawRect(rect.Left - BORDER_WIDTH_PX,
rect.Top - BORDER_WIDTH_PX,
rect.Right + BORDER_WIDTH_PX,
rect.Bottom + BORDER_WIDTH_PX,
mBorderPaint);
}
mAlphaPattern.Draw(canvas);
float[] hsv = new float[]{mHue,mSat,mVal};
Color color = Color.HSVToColor(hsv);
Color acolor = Color.HSVToColor(0, hsv);
mAlphaShader = new LinearGradient(rect.Left, rect.Top, rect.Right, rect.Top,
color, acolor, Android.Graphics.Shader.TileMode.Clamp);
mAlphaPaint.SetShader(mAlphaShader);
canvas.DrawRect(rect, mAlphaPaint);
if(mAlphaSliderText != null && !mAlphaSliderText.Equals("")){
canvas.DrawText(mAlphaSliderText, rect.CenterX(), rect.CenterY() + 4 * mDensity, mAlphaTextPaint);
}
float rectWidth = 4 * mDensity / 2;
Point p = alphaToPoint(mAlpha);
RectF r = new RectF();
r.Left = p.X - rectWidth;
r.Right = p.X + rectWidth;
r.Top = rect.Top - RECTANGLE_TRACKER_OFFSET;
r.Bottom = rect.Bottom + RECTANGLE_TRACKER_OFFSET;
canvas.DrawRoundRect(r, 2, 2, mHueAlphaTrackerPaint);
}
public static Bitmap ToRounded(Bitmap source, float rad, double cropWidthRatio, double cropHeightRatio, double borderSize, string borderHexColor)
{
double sourceWidth = source.Width;
double sourceHeight = source.Height;
double desiredWidth = sourceWidth;
double desiredHeight = sourceHeight;
double desiredRatio = cropWidthRatio / cropHeightRatio;
double currentRatio = sourceWidth / sourceHeight;
if (currentRatio > desiredRatio)
desiredWidth = (cropWidthRatio * sourceHeight / cropHeightRatio);
else if (currentRatio < desiredRatio)
desiredHeight = (cropHeightRatio * sourceWidth / cropWidthRatio);
float cropX = (float)((sourceWidth - desiredWidth) / 2d);
float cropY = (float)((sourceHeight - desiredHeight) / 2d);
if (rad == 0)
rad = (float)(Math.Min(desiredWidth, desiredHeight) / 2d);
else
rad = (float)(rad * (desiredWidth + desiredHeight) / 2d / 500d);
Bitmap bitmap = Bitmap.CreateBitmap((int)desiredWidth, (int)desiredHeight, Bitmap.Config.Argb8888);
using (Canvas canvas = new Canvas(bitmap))
using (Paint paint = new Paint())
using (BitmapShader shader = new BitmapShader(source, Shader.TileMode.Clamp, Shader.TileMode.Clamp))
using (Matrix matrix = new Matrix())
{
if (cropX != 0 || cropY != 0)
{
matrix.SetTranslate(-cropX, -cropY);
shader.SetLocalMatrix(matrix);
}
paint.SetShader(shader);
paint.AntiAlias = true;
RectF rectF = new RectF(0f, 0f, (float)desiredWidth, (float)desiredHeight);
canvas.DrawRoundRect(rectF, rad, rad, paint);
if (borderSize > 0d)
{
borderSize = (borderSize * (desiredWidth + desiredHeight) / 2d / 500d);
paint.Color = borderHexColor.ToColor(); ;
paint.SetStyle(Paint.Style.Stroke);
paint.StrokeWidth = (float)borderSize;
paint.SetShader(null);
RectF borderRectF = new RectF((float)(0d + borderSize/2d), (float)(0d + borderSize/2d),
(float)(desiredWidth - borderSize/2d), (float)(desiredHeight - borderSize/2d));
canvas.DrawRoundRect(borderRectF, rad, rad, paint);
}
return bitmap;
}
}
private static Bitmap GetRoundedCornerBitmap(Bitmap bitmap, int roundPixels, Rect srcRect, Rect destRect, int width,
int height)
{
Bitmap output = Bitmap.CreateBitmap(width, height, Bitmap.Config.Argb8888);
Canvas canvas = new Canvas(output);
Paint paint = new Paint();
RectF destRectF = new RectF(destRect);
paint.AntiAlias = true;
canvas.DrawARGB(0, 0, 0, 0);
paint.Color = Color.Argb(0xFF, 0x00, 0x00, 0x00);
canvas.DrawRoundRect(destRectF, roundPixels, roundPixels, paint);
paint.SetXfermode(new PorterDuffXfermode(PorterDuff.Mode.SrcIn));
canvas.DrawBitmap(bitmap, srcRect, destRectF, paint);
return output;
}
