private Path CreateCannulaHeadPath(RectF cannulaRect)
{
Path path = new Path();
path.MoveTo(cannulaRect.Left, cannulaRect.Top);
path.LineTo(cannulaRect.Right, cannulaRect.Top);
path.MoveTo(cannulaRect.CenterX(), cannulaRect.Top);
path.LineTo(cannulaRect.CenterX(), cannulaRect.Bottom - 0.833f * cannulaRect.Width());
return(path);
}
private void AndroidDrawPath(GraphicsPath p)
{
var path = new Android.Graphics.Path();
float d = density;
for (int i = 0; i < p._segments.Count; i++)
{
{
var ln = p._segments[i] as GraphicsPath._LineSegment;
if (ln != null)
{
if (i == 0)
{
path.MoveTo(ln.x1 * d, ln.y1 * d);
}
else
{
path.LineTo(ln.x1 * d, ln.y1 * d);
}
path.LineTo(ln.x2 * d, ln.y2 * d);
continue;
}
}
{
var bz = p._segments[i] as GraphicsPath._BezierSegment;
if (bz != null)
{
if (i == 0)
{
path.MoveTo(bz.x1 * d, bz.y1 * d);
}
else
{
path.LineTo(bz.x1 * d, bz.y1 * d);
}
path.CubicTo(
bz.x2 * d, bz.y2 * d,
bz.x3 * d, bz.y3 * d,
bz.x4 * d, bz.y4 * d);
continue;
}
}
}
if (p._closed)
{
path.Close();
}
canvas.DrawPath(path, paint);
}
private Path CreateMotherMovePath()
{
Path path = new Path();
float CenterX = mCurrentBounds.CenterX();
float CenterY = mCurrentBounds.CenterY();
float currentPathLength = 0.0f;
path.MoveTo(CenterX, CenterY);
//forward top left
path.QuadTo(CenterX - mMotherOvalHalfWidth * 2.0f, CenterY, CenterX - mMotherOvalHalfWidth * 2.0f, CenterY - mMotherOvalHalfHeight);
mStageMotherForwardTopLeftLength = GetRestLength(path, currentPathLength);
currentPathLength += mStageMotherForwardTopLeftLength;
//backward top left
path.QuadTo(CenterX - mMotherOvalHalfWidth * 1.0f, CenterY - mMotherOvalHalfHeight, CenterX, CenterY);
mStageMotherBackwardTopLeftLength = GetRestLength(path, currentPathLength);
currentPathLength += mStageMotherBackwardTopLeftLength;
//forward bottom left
path.QuadTo(CenterX, CenterY + mMotherOvalHalfHeight, CenterX - mMotherOvalHalfWidth / 2, CenterY + mMotherOvalHalfHeight * 1.1f);
mStageMotherForwardBottomLeftLength = GetRestLength(path, currentPathLength);
currentPathLength += mStageMotherForwardBottomLeftLength;
//backward bottom left
path.QuadTo(CenterX - mMotherOvalHalfWidth / 2, CenterY + mMotherOvalHalfHeight * 0.6f, CenterX, CenterY);
mStageMotherBackwardBottomLeftLength = GetRestLength(path, currentPathLength);
return(path);
}
public override void Draw(Canvas canvas)
{
paint = new Android.Graphics.Paint();
paint.SetStyle(Android.Graphics.Paint.Style.Stroke);
paint.StrokeCap = Android.Graphics.Paint.Cap.Round;
paint.StrokeJoin = Android.Graphics.Paint.Join.Round;
if (_paths == null)
{
return;
}
foreach (var pathFromModel in _paths)
{
if (pathFromModel?.Points == null || pathFromModel.Points.Count < 2)
{
continue;
}
paint.SetARGB(255, pathFromModel.Color.Red, pathFromModel.Color.Green, pathFromModel.Color.Blue);
paint.StrokeWidth = pathFromModel.LineWidth;
var path = new Android.Graphics.Path();
path.MoveTo(pathFromModel.Points[0].X, pathFromModel.Points[0].Y);
for (int i = 1; i < pathFromModel.Points.Count; i++)
{
path.LineTo(pathFromModel.Points[i].X, pathFromModel.Points[i].Y);
}
canvas.DrawPath(path, paint);
}
}
protected void DrawShape(Canvas canvas)
{
Paint paint = new Paint();
paint.Color = Color;
switch (Shape)
{
case ShapeEnum.RectangleShape:
canvas.DrawRect(0, 0, ShapeWidth, ShapeHeight, paint);
break;
case ShapeEnum.OvalShape:
canvas.DrawOval(new RectF(0, 0, ShapeWidth, ShapeHeight), paint);
break;
case ShapeEnum.TriangleShape:
Path path = new Path();
path.MoveTo(ShapeWidth / 2, 0);
path.LineTo(ShapeWidth, ShapeHeight);
path.LineTo(0,ShapeHeight);
path.Close();
canvas.DrawPath(path, paint);
break;
default:
canvas.DrawCircle(ShapeWidth / 2, ShapeHeight / 2, ShapeWidth / 2, paint);
break;
}
}
void CreatePath()
{
droidGraphics.Path path = null;
if (points != null && points.Count > 1)
{
path = new droidGraphics.Path();
path.SetFillType(fillType);
path.MoveTo(pixelsPerDip * (float)points[0].X,
pixelsPerDip * (float)points[0].Y);
for (int index = 1; index < points.Count; index++)
{
path.LineTo(pixelsPerDip * (float)points[index].X,
pixelsPerDip * (float)points[index].Y);
}
if (this is PolygonDrawableView)
{
path.Close();
}
}
Path = path;
}
void CreatePath()
{
droidGraphics.Path path = new droidGraphics.Path();
path.MoveTo(x1, y1);
path.LineTo(x2, y2);
Path = path;
}
private void FillPolygon(Canvas canvas, Point3[] points, Color color)
{
if (points.Length == 0)
{
return;
}
Android.Graphics.Path p = new Android.Graphics.Path();
Point3 p3 = points[0];
p.MoveTo((float)p3.X, (float)p3.Y);
for (int i = 1; i < points.Length; i++)
{
p3 = points[i];
p.LineTo((float)p3.X, (float)p3.Y);
}
Paint pnt = new Paint()
{
Color = color
};
canvas.DrawPath(p, pnt);
pnt.SetStyle(Paint.Style.Stroke);
pnt.Color = Color.Black;
pnt.StrokeWidth = 2;
pnt.StrokeMiter = 1.5f;
canvas.DrawPath(p, pnt);
}
public override bool OnTouchEvent(MotionEvent e)
{
float currentX = e.GetX();
float currentY = e.GetY();
switch (e.Action)
{
case MotionEventActions.Down:
path.MoveTo(currentX, currentY);
previousX = currentX;
previouxY = currentY;
return(true);
case MotionEventActions.Move:
case MotionEventActions.Up:
for (int i = 0; i < e.HistorySize; i++)
{
float historicalX = e.GetHistoricalX(i);
float historicalY = e.GetHistoricalY(i);
path.LineTo(historicalX, historicalY);
}
path.LineTo(currentX, currentY);
Invalidate();
previousX = currentX;
previouxY = currentY;
return(true);
default:
return(false);
}
}
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();
}
}
private void touch_start(float x, float y)
{
mPath.Reset();
mPath.MoveTo(x, y);
mX = x;
mY = y;
}
public override bool OnTouchEvent(MotionEvent e)
{
var touchX = e.GetX();
var touchY = e.GetY();
switch (e.Action)
{
case MotionEventActions.Down:
DrawPath.MoveTo(touchX, touchY);
break;
case MotionEventActions.Move:
DrawPath.LineTo(touchX, touchY);
break;
case MotionEventActions.Up:
DrawCanvas.DrawPath(DrawPath, DrawPaint);
DrawPath.Reset();
break;
default:
return(false);
}
Invalidate();
return(true);
}
private void DrawCurrentStroke(Canvas _canvas)
{
if (currentStroke != null && currentStroke.Points.Count > 0)
{
double lastX = currentStroke.Points[0].X;
double lastY = currentStroke.Points[0].Y;
var paint = new Paint()
{
Color = new Color((byte)(currentStroke.StrokeColor.R * 255.0), (byte)(currentStroke.StrokeColor.G * 255.0), (byte)(currentStroke.StrokeColor.B * 255.0), (byte)(currentStroke.StrokeColor.A * 255.0)),
StrokeWidth = (float)currentStroke.Thickness * metrics.Density,
AntiAlias = true,
StrokeCap = Paint.Cap.Round,
};
paint.SetStyle(Paint.Style.Stroke);
var path = new Android.Graphics.Path();
path.MoveTo((float)currentStroke.Points[0].X, (float)currentStroke.Points[0].Y);
foreach (var p in currentStroke.Points)
{
path.LineTo((float)p.X, (float)p.Y);
}
_canvas.DrawPath(path, paint);
}
}
protected override void OnDraw(Android.Graphics.Canvas canvas)
{
var rect = new RectF(0, 0, 300, 300);
switch (Shape)
{
case Shape.Circle:
canvas.DrawOval(rect, new Paint() { Color = Color.CornflowerBlue });
break;
case Shape.Square:
canvas.DrawRect(rect, new Paint() { Color = Color.Crimson });
break;
case Shape.Triangle:
var path = new Path();
path.MoveTo(rect.CenterX(), rect.Top);
path.LineTo(rect.Left, rect.Bottom);
path.LineTo(rect.Right, rect.Bottom);
path.Close();
var paint = new Paint() {Color = Color.Crimson};
paint.Color = Color.Gold;
paint.SetStyle(Paint.Style.Fill);
canvas.DrawPath(path, paint);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public Stream GetArcPartFromSquareImage(Stream ms, int partNumber, int nbParts)
{
Stream result = null;
using (Bitmap bitmap = BitmapFactory.DecodeStream(ms))
{
int diameter = bitmap.Width; // (int)(AvatarSize * GetDensity());
float arcAngle = 360 / nbParts;
float arcStart = 90 + (partNumber - 1) * arcAngle;
if (nbParts > 2)
{
arcStart += (180 / nbParts);
}
float deltaX = (float)(diameter / 2 - ((diameter * Math.Cos(DegreeToRadian(arcStart + arcAngle / 2)) + diameter) / 2)) / 2;
float deltaY = (float)(diameter / 2 - ((diameter * Math.Sin(DegreeToRadian(arcStart + arcAngle / 2)) + diameter) / 2)) / 2;
float startX = (float)((diameter * Math.Cos(DegreeToRadian(arcStart)) + diameter) / 2);
float startY = (float)((diameter * Math.Sin(DegreeToRadian(arcStart)) + diameter) / 2);
//float endX = (float)((diameter * Math.Cos(DegreeToRadian(arcStart + arcAngle)) + diameter) / 2);
//float endY = (float)((diameter * Math.Sin(DegreeToRadian(arcStart + arcAngle)) + diameter) / 2);
using (Bitmap temp = Bitmap.CreateBitmap(diameter, diameter, Bitmap.Config.Argb8888))
{
// First we get the bitmap part (we translate using deltaX/Y to have the center of the avatar)
using (BitmapShader shader = new BitmapShader(bitmap, Shader.TileMode.Clamp, Shader.TileMode.Clamp))
{
using (Paint paint = new Paint(PaintFlags.AntiAlias))
{
paint.SetShader(shader);
using (Android.Graphics.Path path = new Android.Graphics.Path())
{
using (Canvas canvas = new Canvas(temp))
{
path.MoveTo(diameter / 2 + deltaX, diameter / 2 + deltaY);
path.LineTo(startX + deltaX, startY + deltaY);
path.AddArc(deltaX, deltaY, diameter + deltaX, diameter + deltaY, arcStart, arcAngle);
path.LineTo(diameter / 2 + deltaX, diameter / 2 + deltaY);
canvas.DrawPath(path, paint);
//canvas.DrawArc(deltaX, deltaY, deltaX + diameter, deltaY + diameter, arcStart, arcAngle, true, paint);
}
}
}
}
// Now we translate back to have correct layout
result = GetTranslated(GetStreamFromBitmap(temp), -deltaX, -deltaY);
temp.Recycle();
}
bitmap.Recycle();
}
return(result);
}
protected override Android.Graphics.Path GetPath()
{
var output = new Android.Graphics.Path();
output.MoveTo(ViewHelper.LogicalToPhysicalPixels(X1), ViewHelper.LogicalToPhysicalPixels(Y1));
output.LineTo(ViewHelper.LogicalToPhysicalPixels(X2), ViewHelper.LogicalToPhysicalPixels(Y2));
return(output);
}
private Path CreateGasTubePath(RectF gasTubeRect)
{
Path path = new Path();
path.MoveTo(gasTubeRect.Left, gasTubeRect.Top);
path.LineTo(gasTubeRect.Left, gasTubeRect.Bottom);
path.LineTo(gasTubeRect.Right, gasTubeRect.Bottom);
path.LineTo(gasTubeRect.Right, gasTubeRect.Top);
return(path);
}
internal static Path parse(float[] pPoints) {
Path path = new Path();
path.MoveTo(pPoints[0], pPoints[1]);
for (int i = 2; i < pPoints.Length; i += 2) {
float x = pPoints[i];
float y = pPoints[i + 1];
path.LineTo(x, y);
}
return path;
}
public void Initialize()
{
_minuteHand = new Path();
_minuteHand.MoveTo(0, 10);
_minuteHand.LineTo(0, -55);
_minuteHand.Close();
_secondHand = new Path();
_secondHand.MoveTo(0, -80);
_secondHand.LineTo(0, 15);
_secondHand.Close();
}
private void DrawStrokes(Canvas _canvas, List <Abstractions.Stroke> strokes, Bitmap backgroundBitmap, Abstractions.Color backgroundColor, Abstractions.Scaling backgroundScaling, int Width, int Height, float scale)
{
if (backgroundColor != null)
{
_canvas.DrawColor(new Color((byte)(backgroundColor.R * 255f), (byte)(backgroundColor.G * 255f), (byte)(backgroundColor.B * 255f)), PorterDuff.Mode.Src);
}
float deviceOrientation = 0;//TODO
//TODO check the replacement for canvas.Save
_canvas.Save(SaveFlags.Matrix);
_canvas.Translate(_canvas.Width / 2f, _canvas.Height / 2f);
_canvas.Rotate(deviceOrientation);
_canvas.Translate(-(_canvas.Width / 2f), -(_canvas.Height / 2f));
if (backgroundBitmap != null)
{
switch (backgroundScaling)
{
case Abstractions.Scaling.Absolute_None:
case Abstractions.Scaling.Relative_None:
_canvas.DrawBitmap(backgroundBitmap, 0, 0, new Paint());
break;
case Abstractions.Scaling.Absolute_Fit:
case Abstractions.Scaling.Relative_Fit:
float backgroundScale = GetDrawingScale(backgroundScaling, backgroundBitmap, Width, Height);
_canvas.DrawBitmap(backgroundBitmap, new Rect(0, 0, backgroundBitmap.Width, backgroundBitmap.Height), new Rect(0, 0, (int)(backgroundBitmap.Width * backgroundScale), (int)(backgroundBitmap.Height * backgroundScale)), new Paint());
break;
case Abstractions.Scaling.Absolute_Fill:
case Abstractions.Scaling.Relative_Fill:
_canvas.DrawBitmap(backgroundBitmap, new Rect(0, 0, backgroundBitmap.Width, backgroundBitmap.Height), new Rect(0, 0, Width, Height), new Paint());
break;
}
}
foreach (var stroke in strokes)
{
var paint = CreatePaint(stroke.StrokeColor.R, stroke.StrokeColor.G, stroke.StrokeColor.B, stroke.StrokeColor.A, stroke.Thickness, metrics.Density);
var path = new Android.Graphics.Path();
path.MoveTo((float)stroke.Points[0].X * scale, (float)stroke.Points[0].Y * scale);
foreach (var p in stroke.Points)
{
path.LineTo((float)p.X * scale, (float)p.Y * scale);
}
_canvas.DrawPath(path, paint);
}
}
public static Bitmap GetHexagonShape(Bitmap scaleBitmapImage)
{
if (scaleBitmapImage == null)
{
return(null);
}
int targetWidth = 200;
int targetHeight = 200;
int drawnWidth = 140;
Bitmap targetBitmap = Bitmap.CreateBitmap(targetWidth, targetHeight, Bitmap.Config.Argb8888);
Canvas canvas = new Canvas(targetBitmap);
Android.Graphics.Path path = new Android.Graphics.Path();
//start top left
path.MoveTo(0, 0);
//move to middle top
path.LineTo(drawnWidth, 0);
//move to bottom right
path.LineTo(targetWidth, targetHeight - 0);
//move to bottom middle
path.LineTo(targetWidth - drawnWidth, targetHeight - 0);
//middle top left
path.MoveTo(0, 0);
canvas.ClipPath(path);
Bitmap sourceBitmap = scaleBitmapImage;
canvas.DrawBitmap(sourceBitmap, new Rect(0, 0, sourceBitmap.Width, sourceBitmap.Height), new Rect(0, 0, targetWidth, targetHeight), null);
return(targetBitmap);
}
/// <Docs>The Canvas to which the View is rendered.</Docs>
/// <summary>
/// BoxViewのカスタマイズはDrawで行う
/// </summary>
/// <param name="canvas">Canvas.</param>
public override void Draw(Android.Graphics.Canvas canvas)
{
// 2重に描画してしまうので、baseは描画しない
//base.Draw(canvas);
// ElementをキャストしてFormsで定義したCustomBoxViewを取得
var formsBox = (CustomBoxView)Element;
// Androidの描画はPaintを使用
using (var paint = new Paint())
{
// 塗りつぶし色の設定
paint.Color = formsBox.FillColor.ToAndroid();
// 吹き出し部分の設定
// パスの生成
var path = new Path();
// スタート地点の設定
path.MoveTo(0, 0);
// 経由地点の設定
path.LineTo(100, 10);
path.LineTo(100, 100);
// パスを繋げる
path.Close();
// 描画
canvas.DrawPath(path, paint);
// 角の丸い四角の設定
// 角丸の直径を決める
// widthとheightを比較して小さい方を基準にする
var minSize = Math.Min(Width, Height);
// 指定するのは直径なので、指定半径を2倍する
var diameter = formsBox.Radius * 2;
// 角丸の直径はminSize以下でなければならない
if (diameter > minSize)
diameter = minSize;
// 描画領域の設定
var rect = new RectF(0, 0, (float)Width, (float)Height);
//四角形描画
canvas.DrawRoundRect(rect, diameter, diameter, paint);
}
}
private Path CreateChildPath()
{
float bezierOffset = mChildOvalRadius * OVAL_BEZIER_FACTOR;
Path path = new Path();
path.MoveTo(mChildPosition[0], mChildPosition[1] - mChildOvalRadius);
//left_top arc
path.CubicTo(mChildPosition[0] - bezierOffset - mChildLeftXOffset, mChildPosition[1] - mChildOvalRadius, mChildPosition[0] - mChildOvalRadius - mChildLeftXOffset, mChildPosition[1] - bezierOffset + mChildLeftYOffset, mChildPosition[0] - mChildOvalRadius - mChildLeftXOffset, mChildPosition[1]);
//left_bottom arc
path.CubicTo(mChildPosition[0] - mChildOvalRadius - mChildLeftXOffset, mChildPosition[1] + bezierOffset - mChildLeftYOffset, mChildPosition[0] - bezierOffset - mChildLeftXOffset, mChildPosition[1] + mChildOvalRadius, mChildPosition[0], mChildPosition[1] + mChildOvalRadius);
//right_bottom arc
path.CubicTo(mChildPosition[0] + bezierOffset + mChildRightXOffset, mChildPosition[1] + mChildOvalRadius, mChildPosition[0] + mChildOvalRadius + mChildRightXOffset, mChildPosition[1] + bezierOffset - mChildRightYOffset, mChildPosition[0] + mChildOvalRadius + mChildRightXOffset, mChildPosition[1]);
//right_top arc
path.CubicTo(mChildPosition[0] + mChildOvalRadius + mChildRightXOffset, mChildPosition[1] - bezierOffset + mChildRightYOffset, mChildPosition[0] + bezierOffset + mChildRightXOffset, mChildPosition[1] - mChildOvalRadius, mChildPosition[0], mChildPosition[1] - mChildOvalRadius);
return(path);
}
public override bool OnTouchEvent(MotionEvent e)
{
base.OnTouchEvent(e);
float x = e.GetX();
float y = e.GetY();
switch (e.Action)
{
case MotionEventActions.Down:
path.MoveTo(x, y);
break;
case MotionEventActions.Move:
path.LineTo(x, y);
break;
}
Invalidate(); // view更新
return(true);
}
private void TouchMove(float x, float y)
{
var dx = (float)Math.Abs(x - _currentTouch.X);
var dy = (float)Math.Abs(y - _currentTouch.Y);
// add movement to stroke if outside the area of tolerence (a square with side length of TouchTolerance * 2, centered at currentTouch)
if (!(dx >= TouchTolerance) && !(dy >= TouchTolerance))
{
return;
}
if (_currentStroke.IsEmpty)
{
_currentStroke.MoveTo((float)_currentTouch.X, (float)_currentTouch.Y);
}
_currentStroke.QuadTo((float)_currentTouch.X,
(float)_currentTouch.Y,
(float)(x + _currentTouch.X) / 2,
(float)(y + _currentTouch.Y) / 2);
}
/// <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);
}
private Path CreateLinkPath()
{
Path path = new Path();
float bezierOffset = mMotherOvalHalfWidth * OVAL_BEZIER_FACTOR;
float distance = (float)Math.Sqrt(Math.Pow(mMotherPosition[0] - mChildPosition[0], 2.0f) + Math.Pow(mMotherPosition[1] - mChildPosition[1], 2.0f));
if (distance <= mMotherOvalHalfWidth + mChildOvalRadius * 1.2f && distance >= mMotherOvalHalfWidth - mChildOvalRadius * 1.2f)
{
float maxOffsetY = 2 * mChildOvalRadius * 1.2f;
float offsetRate = (distance - (mMotherOvalHalfWidth - mChildOvalRadius * 1.2f)) / maxOffsetY;
float mMotherOvalOffsetY = mMotherOvalHalfHeight - offsetRate * (mMotherOvalHalfHeight - mChildOvalRadius) * 0.85f;
mMotherOvalPath.AddOval(new RectF(mMotherPosition[0] - mMotherOvalHalfWidth, mMotherPosition[1] - mMotherOvalOffsetY, mMotherPosition[0] + mMotherOvalHalfWidth, mMotherPosition[1] + mMotherOvalOffsetY), Path.Direction.Cw);
float mMotherXOffset = distance - mMotherOvalHalfWidth + mChildOvalRadius;
float distanceUltraLeft = (float)Math.Sqrt(Math.Pow(mMotherPosition[0] - mMotherOvalHalfWidth - mChildPosition[0], 2.0f) + Math.Pow(mMotherPosition[1] - mChildPosition[1], 2.0f));
float distanceUltraRight = (float)Math.Sqrt(Math.Pow(mMotherPosition[0] + mMotherOvalHalfWidth - mChildPosition[0], 2.0f) + Math.Pow(mMotherPosition[1] - mChildPosition[1], 2.0f));
path.MoveTo(mMotherPosition[0], mMotherPosition[1] + mMotherOvalOffsetY);
if (distanceUltraRight < distanceUltraLeft)
{
//right_bottom arc
path.CubicTo(mMotherPosition[0] + bezierOffset + mMotherXOffset, mMotherPosition[1] + mMotherOvalOffsetY, mMotherPosition[0] + distance + mChildOvalRadius, mMotherPosition[1] + mChildOvalRadius * 1.5f, mMotherPosition[0] + distance + mChildOvalRadius, mMotherPosition[1]);
//right_top arc
path.CubicTo(mMotherPosition[0] + distance + mChildOvalRadius, mMotherPosition[1] - mChildOvalRadius * 1.5f, mMotherPosition[0] + bezierOffset + mMotherXOffset, mMotherPosition[1] - mMotherOvalOffsetY, mMotherPosition[0], mMotherPosition[1] - mMotherOvalOffsetY);
}
else
{
//left_bottom arc
path.CubicTo(mMotherPosition[0] - bezierOffset - mMotherXOffset, mMotherPosition[1] + mMotherOvalOffsetY, mMotherPosition[0] - distance - mChildOvalRadius, mMotherPosition[1] + mChildOvalRadius * 1.5f, mMotherPosition[0] - distance - mChildOvalRadius, mMotherPosition[1]);
//left_top arc
path.CubicTo(mMotherPosition[0] - distance - mChildOvalRadius, mMotherPosition[1] - mChildOvalRadius * 1.5f, mMotherPosition[0] - bezierOffset - mMotherXOffset, mMotherPosition[1] - mMotherOvalOffsetY, mMotherPosition[0], mMotherPosition[1] - mMotherOvalOffsetY);
}
path.LineTo(mMotherPosition[0], mMotherPosition[1] + mMotherOvalOffsetY);
}
return(path);
}
void Initialize ()
{
// Create Paint for all drawing
paint = new Paint ();
// All paths are based on 100-unit clock radius
// centered at (0, 0).
// Define circle for tick marks.
tickMarks = new Path ();
tickMarks.AddCircle (0, 0, 90, Path.Direction.Cw);
// Hour, minute, second hands defined to point straight up.
// Define hour hand.
hourHand = new Path ();
hourHand.MoveTo (0, -60);
hourHand.CubicTo (0, -30, 20, -30, 5, -20);
hourHand.LineTo (5, 0);
hourHand.CubicTo (5, 7.5f, -5, 7.5f, -5, 0);
hourHand.LineTo (-5, -20);
hourHand.CubicTo (-20, -30, 0, -30, 0, -60);
hourHand.Close ();
// Define minute hand.
minuteHand = new Path ();
minuteHand.MoveTo (0, -80);
minuteHand.CubicTo (0, -75, 0, -70, 2.5f, -60);
minuteHand.LineTo (2.5f, 0);
minuteHand.CubicTo (2.5f, 5, -2.5f, 5, -2.5f, 0);
minuteHand.LineTo (-2.5f, -60);
minuteHand.CubicTo (0, -70, 0, -75, 0, -80);
minuteHand.Close ();
// Define second hand.
secondHand = new Path ();
secondHand.MoveTo (0, 10);
secondHand.LineTo (0, -80);
}
protected override void OnDraw(Canvas canvas)
{
base.OnDraw(canvas);
var path = new Path();
path.MoveTo(_points[0].X, _points[0].Y);
for (var i = 1; i < _points.Length; i++)
{
path.LineTo(_points[i].X, _points[i].Y);
}
var paint = new Paint
{
Color = Color.White
};
// We can use Paint.Style.Stroke if we want to draw a "hollow" polygon,
// But then we had better set the .StrokeWidth property on the paint.
paint.SetStyle(Paint.Style.Fill);
canvas.DrawPath(path, paint);
}
private Path CreateChildMovePath()
{
Path path = new Path();
float CenterX = mCurrentBounds.CenterX();
float CenterY = mCurrentBounds.CenterY();
float currentPathLength = 0.0f;
//start
path.MoveTo(CenterX, CenterY);
//pre forward top left
path.LineTo(CenterX + mMotherOvalHalfWidth * 0.75f, CenterY);
mStageChildPreForwardTopLeftLength = GetRestLength(path, currentPathLength);
currentPathLength += mStageChildPreForwardTopLeftLength;
//forward top left
path.QuadTo(CenterX - mMotherOvalHalfWidth * 0.5f, CenterY, CenterX - mMotherOvalHalfWidth * 2.0f, CenterY - mMotherOvalHalfHeight);
mStageChildForwardTopLeftLength = GetRestLength(path, currentPathLength);
currentPathLength += mStageChildForwardTopLeftLength;
//pre backward top left
path.LineTo(CenterX - mMotherOvalHalfWidth * 2.0f + mMotherOvalHalfWidth * 0.2f, CenterY - mMotherOvalHalfHeight);
path.QuadTo(CenterX - mMotherOvalHalfWidth * 2.5f, CenterY - mMotherOvalHalfHeight * 2, CenterX - mMotherOvalHalfWidth * 1.5f, CenterY - mMotherOvalHalfHeight * 2.25f);
mStageChildPreBackwardTopLeftLength = GetRestLength(path, currentPathLength);
currentPathLength += mStageChildPreBackwardTopLeftLength;
//backward top left
path.QuadTo(CenterX - mMotherOvalHalfWidth * 0.2f, CenterY - mMotherOvalHalfHeight * 2.25f, CenterX, CenterY);
mStageChildBackwardTopLeftLength = GetRestLength(path, currentPathLength);
currentPathLength += mStageChildBackwardTopLeftLength;
//forward bottom left
path.CubicTo(CenterX, CenterY + mMotherOvalHalfHeight, CenterX - mMotherOvalHalfWidth, CenterY + mMotherOvalHalfHeight * 2.5f, CenterX - mMotherOvalHalfWidth * 1.5f, CenterY + mMotherOvalHalfHeight * 2.5f);
mStageChildForwardBottomLeftLength = GetRestLength(path, currentPathLength);
currentPathLength += mStageChildForwardBottomLeftLength;
//backward bottom left
path.CubicTo(CenterX - mMotherOvalHalfWidth * 2.0f, CenterY + mMotherOvalHalfHeight * 2.5f, CenterX - mMotherOvalHalfWidth * 3.0f, CenterY + mMotherOvalHalfHeight * 0.8f, CenterX, CenterY);
mStageChildBackwardBottomLeftLength = GetRestLength(path, currentPathLength);
return(path);
}
private Path Calculate(int size, Direction direction)
{
Point p1, p2, p3;
if (direction == Direction.Up)
{
p1 = new Point(0, size);
p2 = new Point(size, size);
p3 = new Point(size / 2, 0);
}
else
{
p1 = new Point(0, 0);
p2 = new Point(size, 0);
p3 = new Point(size / 2, size);
}
var path = new Path();
path.MoveTo(p1.X, p1.Y);
path.LineTo(p2.X, p2.Y);
path.LineTo(p3.X, p3.Y);
return path;
}
ObjectAnimator PrepareAnimation(View view, int multiplier)
{
var path = new Path();
var metrics = Resources.DisplayMetrics;
var tx = multiplier * (metrics.WidthPixels - view.PaddingRight);
var ty = -TypedValue.ApplyDimension(ComplexUnitType.Dip, 64, metrics);
path.MoveTo(tx, ty);
path.QuadTo(2 * tx / 3, 0, 0, 0);
view.TranslationX = tx;
view.TranslationY = ty;
var anim = ObjectAnimator.OfFloat(view, "translationX", "translationY", path);
anim.SetDuration(600);
anim.SetInterpolator(AnimationUtils.LoadInterpolator(this, Android.Resource.Interpolator.FastOutSlowIn));
return anim;
}
public override View OnCreateView (LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
{
// Inflate the interpolator_fragment layout
var v = inflater.Inflate (Resource.Layout.interpolator_fragment, container, false);
// Set up the "animate" button
// When it is clicked, the view is animatied with the options selected
var button = v.FindViewById<Button> (Resource.Id.animateButton);
button.Click += delegate {
// Interpolator selected in the spinner
var interpolator = interpolators [interpolatorSpinner.SelectedItemPosition];
// Duration selected in SeekBar
long duration = (long)durationSeekbar.Progress;
// Animation path is based on whether animating in or out
var path = isOut ? pathIn : pathOut;
// Log animation details
Log.Info (TAG, string.Format ("Starting animation: [{0} ms, {1}, {2}",
duration, interpolatorSpinner.SelectedItem.ToString (),
((isOut) ? "Out (growing)" : "In (shrinking)")));
// Start the animation with the selected options
StartAnimation(interpolator,duration,path);
// Toggle direction of the animation
isOut = !isOut;
};
durationLabel = v.FindViewById<TextView> (Resource.Id.durationLabel);
// Initialize the Interpolators programmatically by loading them from their XML definitions
// provided by the framework.
interpolators = new IInterpolator[]
{
AnimationUtils.LoadInterpolator(Activity,Android.Resource.Interpolator.Linear),
AnimationUtils.LoadInterpolator(Activity,Android.Resource.Interpolator.FastOutLinearIn),
AnimationUtils.LoadInterpolator(Activity,Android.Resource.Interpolator.FastOutSlowIn),
AnimationUtils.LoadInterpolator(Activity,Android.Resource.Interpolator.LinearOutSlowIn)
};
// Load names of interpolators
var interpolatorNames = Resources.GetStringArray (Resource.Array.interpolator_names);
// Set up the Spinner with the names of interpolators
interpolatorSpinner = v.FindViewById<Spinner> (Resource.Id.interpolatorSpinner);
var spinnerAdapter = new ArrayAdapter<string> (Activity, Android.Resource.Layout.SimpleSpinnerDropDownItem, interpolatorNames);
interpolatorSpinner.Adapter = spinnerAdapter;
// Set up SeekBar that defines the duration of the animation
durationSeekbar = v.FindViewById<SeekBar> (Resource.Id.durationSeek);
durationSeekbar.ProgressChanged+=delegate {
durationLabel.SetText(Resources.GetString(Resource.String.animation_duration,durationSeekbar.Progress),TextView.BufferType.Normal);
};
// Set default duration
durationSeekbar.Progress = INITIAL_DURATION_MS;
// Get the view that will be animated
view = v.FindViewById (Resource.Id.square);
// Path for the "in" animation
pathIn = new Path ();
pathIn.MoveTo (0.2f, 0.2f);
pathIn.LineTo (1f, 1f);
// Path for the "out" animation
pathOut = new Path ();
pathOut.MoveTo (1f, 1f);
pathOut.LineTo (0.2f, 0.2f);
return v;
}
public static APath AsAndroidPath(this PathF path)
{
var nativePath = new APath();
int pointIndex = 0;
int arcAngleIndex = 0;
int arcClockwiseIndex = 0;
foreach (var operation in path.PathOperations)
{
if (operation == PathOperation.MoveTo)
{
var point = path[pointIndex++];
nativePath.MoveTo(point.X, point.Y);
}
else if (operation == PathOperation.Line)
{
var point = path[pointIndex++];
nativePath.LineTo(point.X, point.Y);
}
else if (operation == PathOperation.Quad)
{
var controlPoint = path[pointIndex++];
var point = path[pointIndex++];
nativePath.QuadTo(controlPoint.X, controlPoint.Y, point.X, point.Y);
}
else if (operation == PathOperation.Cubic)
{
var controlPoint1 = path[pointIndex++];
var controlPoint2 = path[pointIndex++];
var point = path[pointIndex++];
nativePath.CubicTo(controlPoint1.X, controlPoint1.Y, controlPoint2.X, controlPoint2.Y, point.X,
point.Y);
}
else if (operation == PathOperation.Arc)
{
var topLeft = path[pointIndex++];
var bottomRight = path[pointIndex++];
var startAngle = path.GetArcAngle(arcAngleIndex++);
var endAngle = path.GetArcAngle(arcAngleIndex++);
var clockwise = path.IsArcClockwise(arcClockwiseIndex++);
while (startAngle < 0)
{
startAngle += 360;
}
while (endAngle < 0)
{
endAngle += 360;
}
var rect = new RectF(topLeft.X, topLeft.Y, bottomRight.X, bottomRight.Y);
var sweep = GraphicsOperations.GetSweep(startAngle, endAngle, clockwise);
startAngle *= -1;
if (!clockwise)
{
sweep *= -1;
}
nativePath.ArcTo(rect, startAngle, sweep);
}
else if (operation == PathOperation.Close)
{
nativePath.Close();
}
}
return(nativePath);
}
protected override void OnDraw(Canvas canvas)
{
base.OnDraw (canvas);
if (mViewPager == null) {
return;
}
int count = mViewPager.Adapter.Count;
if (count == 0) {
return;
}
//Calculate views bounds
var bounds = CalculateAllBounds(mPaintText);
int boundsSize = bounds.Count;
//Make sure we're on a page that still exists
if (mCurrentPage >= boundsSize) {
SetCurrentItem(boundsSize - 1);
return;
}
int countMinusOne = count - 1;
float halfWidth = Width / 2f;
int left = Left;
float leftClip = left + mClipPadding;
int width = Width;
int height = Height;
int right = left + width;
float rightClip = right - mClipPadding;
int page = mCurrentPage;
float offsetPercent;
if (mCurrentOffset <= halfWidth) {
offsetPercent = 1.0f * mCurrentOffset / width;
} else {
page += 1;
offsetPercent = 1.0f * (width - mCurrentOffset) / width;
}
bool currentSelected = (offsetPercent <= SELECTION_FADE_PERCENTAGE);
bool currentBold = (offsetPercent <= BOLD_FADE_PERCENTAGE);
float selectedPercent = (SELECTION_FADE_PERCENTAGE - offsetPercent) / SELECTION_FADE_PERCENTAGE;
//Verify if the current view must be clipped to the screen
RectF curPageBound = bounds[mCurrentPage];
float curPageWidth = curPageBound.Right - curPageBound.Left;
if (curPageBound.Left < leftClip) {
//Try to clip to the screen (left side)
ClipViewOnTheLeft(curPageBound, curPageWidth, left);
}
if (curPageBound.Right > rightClip) {
//Try to clip to the screen (right side)
ClipViewOnTheRight(curPageBound, curPageWidth, right);
}
//Left views starting from the current position
if (mCurrentPage > 0) {
for (int i = mCurrentPage - 1; i >= 0; i--) {
RectF bound = bounds[i];
//Is left side is outside the screen
if (bound.Left < leftClip) {
float w = bound.Right - bound.Left;
//Try to clip to the screen (left side)
ClipViewOnTheLeft(bound, w, left);
//Except if there's an intersection with the right view
RectF rightBound = bounds[i + 1];
//Intersection
if (bound.Right + mTitlePadding > rightBound.Left) {
bound.Left = rightBound.Left - w - mTitlePadding;
bound.Right = bound.Left + w;
}
}
}
}
//Right views starting from the current position
if (mCurrentPage < countMinusOne) {
for (int i = mCurrentPage + 1 ; i < count; i++) {
RectF bound = bounds[i];
//If right side is outside the screen
if (bound.Right > rightClip) {
float w = bound.Right - bound.Left;
//Try to clip to the screen (right side)
ClipViewOnTheRight(bound, w, right);
//Except if there's an intersection with the left view
RectF leftBound = bounds[i - 1];
//Intersection
if (bound.Left - mTitlePadding < leftBound.Right) {
bound.Left = leftBound.Right + mTitlePadding;
bound.Right = bound.Left + w;
}
}
}
}
//Now draw views
//int colorTextAlpha = mColorText >>> 24;
int colorTextAlpha = mColorText >> 24;
for (int i = 0; i < count; i++) {
//Get the title
RectF bound = bounds[i];
//Only if one side is visible
if ((bound.Left > left && bound.Left < right) || (bound.Right > left && bound.Right < right)) {
bool currentPage = (i == page);
//Only set bold if we are within bounds
mPaintText.FakeBoldText = (currentPage && currentBold && mBoldText);
//Draw text as unselected
mPaintText.Color = (mColorText);
if(currentPage && currentSelected) {
//Fade out/in unselected text as the selected text fades in/out
mPaintText.Alpha = (colorTextAlpha - (int)(colorTextAlpha * selectedPercent));
}
canvas.DrawText(mTitleProvider.GetTitle(i), bound.Left, bound.Bottom + mTopPadding, mPaintText);
//If we are within the selected bounds draw the selected text
if (currentPage && currentSelected) {
mPaintText.Color = mColorSelected;
mPaintText.Alpha = ((int)((mColorSelected >> 24) * selectedPercent));
canvas.DrawText(mTitleProvider.GetTitle(i), bound.Left, bound.Bottom + mTopPadding, mPaintText);
}
}
}
//Draw the footer line
mPath = new Path();
mPath.MoveTo(0, height - mFooterLineHeight / 2f);
mPath.LineTo(width, height - mFooterLineHeight / 2f);
mPath.Close();
canvas.DrawPath(mPath, mPaintFooterLine);
switch (mFooterIndicatorStyle) {
case IndicatorStyle.Triangle:
mPath = new Path();
mPath.MoveTo(halfWidth, height - mFooterLineHeight - mFooterIndicatorHeight);
mPath.LineTo(halfWidth + mFooterIndicatorHeight, height - mFooterLineHeight);
mPath.LineTo(halfWidth - mFooterIndicatorHeight, height - mFooterLineHeight);
mPath.Close();
canvas.DrawPath(mPath, mPaintFooterIndicator);
break;
case IndicatorStyle.Underline:
if (!currentSelected || page >= boundsSize) {
break;
}
RectF underlineBounds = bounds[page];
mPath = new Path();
mPath.MoveTo(underlineBounds.Left - mFooterIndicatorUnderlinePadding, height - mFooterLineHeight);
mPath.LineTo(underlineBounds.Right + mFooterIndicatorUnderlinePadding, height - mFooterLineHeight);
mPath.LineTo(underlineBounds.Right + mFooterIndicatorUnderlinePadding, height - mFooterLineHeight - mFooterIndicatorHeight);
mPath.LineTo(underlineBounds.Left - mFooterIndicatorUnderlinePadding, height - mFooterLineHeight - mFooterIndicatorHeight);
mPath.Close();
mPaintFooterIndicator.Alpha = ((int)(0xFF * selectedPercent));
canvas.DrawPath(mPath, mPaintFooterIndicator);
mPaintFooterIndicator.Alpha = (0xFF);
break;
}
}
public void DrawPolygon(IList<Point> points, Color fill, Color stroke, double thickness = 1, double[] dashArray = null, PenLineJoin lineJoin = PenLineJoin.Miter, bool aliased = false)
{
using (var paint = new Paint())
{
paint.AntiAlias = !aliased;
paint.StrokeWidth = (float)thickness;
using (var path = new Path())
{
path.MoveTo((float)points[0].X, (float)points[0].Y);
for (int i = 1; i <= points.Count; i++)
{
path.LineTo((float)points[i % points.Count].X, (float)points[i % points.Count].Y);
}
if (fill != null)
{
paint.SetStyle(Paint.Style.Fill);
paint.Color = fill;
canvas.DrawPath(path, paint);
}
if (stroke != null)
{
paint.SetStyle(Paint.Style.Stroke);
paint.Color = stroke;
canvas.DrawPath(path, paint);
}
}
}
}
private void DrawGraphics(Canvas canvas)
{
if (!(PointsCloud.x || PointsCloud.y || PointsCloud.z || PointsCloud.v))
return;
Paint mPaint = new Paint();
mPaint.Dither = true;
mPaint.SetStyle (Paint.Style.Stroke);
mPaint.Color = Color.White;
mPaint.StrokeJoin = Paint.Join.Bevel;
mPaint.StrokeCap = Paint.Cap.Round;
mPaint.StrokeWidth = 3;
Path x = new Path ();
Path y = new Path ();
Path z = new Path ();
Path v = new Path ();
// max min
DateTime MaxX = PointsCloud.MaxX;
DateTime MinX = PointsCloud.MinX;
// разметка вертикальные линии
if (MaxX.Equals (MinX))
return;
//
List<Point> d = points.GetVisible ();
for (int i = 0; i<d.Count; i++) {
Point cur = d.ElementAt(i);
if (PointsCloud.x) {
if (i == 0) x.MoveTo(ConvertXtoX(canvas, cur.GetTime()),
ConvertYtoY(canvas, cur.x));
else x.LineTo(ConvertXtoX(canvas, cur.GetTime()),
ConvertYtoY(canvas, cur.x));
}
if (PointsCloud.y) {
if (i == 0) y.MoveTo(ConvertXtoX(canvas, cur.GetTime()),
ConvertYtoY(canvas, cur.y));
else y.LineTo(ConvertXtoX(canvas, cur.GetTime()),
ConvertYtoY(canvas, cur.y));
}
if (PointsCloud.z) {
if (i == 0) z.MoveTo(ConvertXtoX(canvas, cur.GetTime()),
ConvertYtoY(canvas, cur.z));
else z.LineTo(ConvertXtoX(canvas, cur.GetTime()),
ConvertYtoY(canvas, cur.z));
}
if (PointsCloud.v) {
if (i == 0) v.MoveTo(ConvertXtoX(canvas, cur.GetTime()),
ConvertYtoY(canvas, cur.v));
else v.LineTo(ConvertXtoX(canvas, cur.GetTime()),
ConvertYtoY(canvas, cur.v));
}
}
mPaint.Color = Color.Yellow;
if (PointsCloud.x) canvas.DrawPath (x, mPaint);
mPaint.Color = Color.Green;
if (PointsCloud.y) canvas.DrawPath (y, mPaint);
mPaint.Color = Color.White;
if (PointsCloud.z) canvas.DrawPath (z, mPaint);
mPaint.Color = Color.Red;
if (PointsCloud.v) canvas.DrawPath (v, mPaint);
}
public DrawerArrowDrawable(Resources resources, Boolean rounded1) {
rounded = rounded1;
float density = resources.DisplayMetrics.Density;
float strokeWidthPixel = STROKE_WIDTH_DP * density;
halfStrokeWidthPixel = strokeWidthPixel / 2;
linePaint = new Paint(Android.Graphics.PaintFlags.SubpixelText | Android.Graphics.PaintFlags.AntiAlias);
linePaint.StrokeCap=rounded ? Android.Graphics.Paint.Cap.Round : Android.Graphics.Paint.Cap.Butt;
linePaint.Color=Android.Graphics.Color.Black;
linePaint.SetStyle (Android.Graphics.Paint.Style.Stroke);
linePaint.StrokeWidth=strokeWidthPixel;
int dimen = (int) (DIMEN_DP * density);
bounds = new Rect(0, 0, dimen, dimen);
Path first, second;
JoinedPath joinedA, joinedB;
// Top
first = new Path();
first.MoveTo(5.042f, 20f);
first.RCubicTo(8.125f, -16.317f, 39.753f, -27.851f, 55.49f, -2.765f);
second = new Path();
second.MoveTo(60.531f, 17.235f);
second.RCubicTo(11.301f, 18.015f, -3.699f, 46.083f, -23.725f, 43.456f);
scalePath(first, density);
scalePath(second, density);
joinedA = new JoinedPath(first, second);
first = new Path();
first.MoveTo(64.959f, 20f);
first.RCubicTo(4.457f, 16.75f, 1.512f, 37.982f, -22.557f, 42.699f);
second = new Path();
second.MoveTo(42.402f, 62.699f);
second.CubicTo(18.333f, 67.418f, 8.807f, 45.646f, 8.807f, 32.823f);
scalePath(first, density);
scalePath(second, density);
joinedB = new JoinedPath(first, second);
topLine = new BridgingLine(joinedA, joinedB);
// Middle
first = new Path();
first.MoveTo(5.042f, 35f);
first.CubicTo(5.042f, 20.333f, 18.625f, 6.791f, 35f, 6.791f);
second = new Path();
second.MoveTo(35f, 6.791f);
second.RCubicTo(16.083f, 0f, 26.853f, 16.702f, 26.853f, 28.209f);
scalePath(first, density);
scalePath(second, density);
joinedA = new JoinedPath(first, second);
first = new Path();
first.MoveTo(64.959f, 35f);
first.RCubicTo(0f, 10.926f, -8.709f, 26.416f, -29.958f, 26.416f);
second = new Path();
second.MoveTo(35f, 61.416f);
second.RCubicTo(-7.5f, 0f, -23.946f, -8.211f, -23.946f, -26.416f);
scalePath(first, density);
scalePath(second, density);
joinedB = new JoinedPath(first, second);
middleLine = new BridgingLine(joinedA, joinedB);
// Bottom
first = new Path();
first.MoveTo(5.042f, 50f);
first.CubicTo(2.5f, 43.312f, 0.013f, 26.546f, 9.475f, 17.346f);
second = new Path();
second.MoveTo(9.475f, 17.346f);
second.RCubicTo(9.462f, -9.2f, 24.188f, -10.353f, 27.326f, -8.245f);
scalePath(first, density);
scalePath(second, density);
joinedA = new JoinedPath(first, second);
first = new Path();
first.MoveTo(64.959f, 50f);
first.RCubicTo(-7.021f, 10.08f, -20.584f, 19.699f, -37.361f, 12.74f);
second = new Path();
second.MoveTo(27.598f, 62.699f);
second.RCubicTo(-15.723f, -6.521f, -18.8f, -23.543f, -18.8f, -25.642f);
scalePath(first, density);
scalePath(second, density);
joinedB = new JoinedPath(first, second);
bottomLine = new BridgingLine(joinedA, joinedB);
}
internal void Draw(Canvas canvas, bool isRound)
{
if (Hidden)
{
return;
}
canvas.Save();
var resizerPaint = new Paint { Color = new Color(255, 255, 255, 200) };
//if (!Focused)
//{
// outlinePaint.Color = Color.White;
// canvas.DrawRect(DrawRect, outlinePaint);
// //canvas.DrawCircle(DrawRect.CenterX(), DrawRect.CenterY(), DrawRect.Width(), resizerPaint);
//}
//else
//{
Rect viewDrawingRect = new Rect();
context.GetDrawingRect(viewDrawingRect);
outlinePaint.Color = Color.White;// new Color(0XFF, 0xFF, 0x8A, 0x00);
focusPaint.Color = new Color(50, 50, 50, 125);
Path path = new Path();
if (isRound)
{
path.AddCircle(DrawRect.CenterX(), DrawRect.CenterY(), DrawRect.Width() / 2, Path.Direction.Cw);
canvas.ClipPath(path, Region.Op.Difference);
canvas.DrawCircle(viewDrawingRect.CenterX(), viewDrawingRect.CenterY(), viewDrawingRect.Width(), focusPaint);
}
else
{
path.AddRect(new RectF(DrawRect), Path.Direction.Cw);
canvas.ClipPath(path, Region.Op.Difference);
canvas.DrawRect(viewDrawingRect, focusPaint);
}
//canvas.ClipPath(path, Region.Op.Difference);
//if (isRound)
// canvas.DrawCircle(viewDrawingRect.CenterX(), viewDrawingRect.CenterY(), viewDrawingRect.Width(), focusPaint);
//else
// canvas.DrawRect(viewDrawingRect, focusPaint);
canvas.Restore();
canvas.DrawPath(path, outlinePaint);
var resizerTriangle = new Path();
var resizerOffset = 4;
var triangleSize = resizerSize + resizerOffset;
resizerTriangle.MoveTo(DrawRect.Right - resizerOffset, DrawRect.Bottom - triangleSize);
resizerTriangle.LineTo(DrawRect.Right - resizerOffset, DrawRect.Bottom - resizerOffset);
resizerTriangle.LineTo(DrawRect.Right - triangleSize, DrawRect.Bottom - resizerOffset);
resizerPaint.SetStyle(Paint.Style.Fill);
canvas.DrawPath(resizerTriangle, resizerPaint);
if (isRound)
{
// Draw the rectangle around the round cropper
var roundCropperRectangle = new Path();
roundCropperRectangle.MoveTo(DrawRect.Left, DrawRect.Top);
roundCropperRectangle.LineTo(DrawRect.Right, DrawRect.Top);
roundCropperRectangle.LineTo(DrawRect.Right, DrawRect.Bottom);
roundCropperRectangle.LineTo(DrawRect.Left, DrawRect.Bottom);
roundCropperRectangle.LineTo(DrawRect.Left, DrawRect.Top);
resizerPaint.SetStyle(Paint.Style.Stroke);
canvas.DrawPath(roundCropperRectangle, resizerPaint);
}
}
protected override void OnDraw(Canvas ca) {
if (fullImage == null || shouldUpdate) {
fullImage = Bitmap.CreateBitmap (Width, Height, Bitmap.Config.Argb8888);
Canvas canvas = new Canvas(fullImage);
String max = (int)maxY+"";// used to display max
String min = (int)minY+"";// used to display min
paint.Reset ();
Path path = new Path();
float bottomPadding = 1, topPadding = 0;
float sidePadding = 10;
if (this.showMinAndMax)
sidePadding = txtPaint.MeasureText(max);
float usableHeight = Height - bottomPadding - topPadding;
float usableWidth = Width - sidePadding*2;
float lineSpace = usableHeight/10;
int lineCount = 0;
foreach (Line line in lines) {
int count = 0;
float lastXPixels = 0, newYPixels;
float lastYPixels = 0, newXPixels;
float maxYd = getMaxY ();
float minYd = getMinY();
float maxXd = getMaxX();
float minXd = getMinX();
if (lineCount == lineToFill){
paint.Color = Color.White;
paint.Alpha = 30;
paint.StrokeWidth = 2;
for (int i = 10; i-Width < Height; i = i+20){
canvas.DrawLine(i, Height-bottomPadding, 0, Height-bottomPadding-i, paint);
}
paint.Reset();
paint.SetXfermode (new PorterDuffXfermode (Android.Graphics.PorterDuff.Mode.Clear));
foreach (LinePoint p in line.getPoints()) {
float yPercent = (p.getY()-minY)/(maxYd - minYd);
float xPercent = (p.getX()-minX)/(maxXd - minXd);
if (count == 0){
lastXPixels = sidePadding + (xPercent*usableWidth);
lastYPixels = Height - bottomPadding - (usableHeight*yPercent);
path.MoveTo(lastXPixels, lastYPixels);
} else {
newXPixels = sidePadding + (xPercent*usableWidth);
newYPixels = Height - bottomPadding - (usableHeight*yPercent);
path.LineTo(newXPixels, newYPixels);
Path pa = new Path();
pa.MoveTo(lastXPixels, lastYPixels);
pa.LineTo(newXPixels, newYPixels);
pa.LineTo(newXPixels, 0);
pa.LineTo(lastXPixels, 0);
pa.Close();
canvas.DrawPath(pa, paint);
lastXPixels = newXPixels;
lastYPixels = newYPixels;
}
count++;
}
path.Reset();
path.MoveTo(0, Height-bottomPadding);
path.LineTo(sidePadding, Height-bottomPadding);
path.LineTo(sidePadding, 0);
path.LineTo(0, 0);
path.Close();
canvas.DrawPath(path, paint);
path.Reset();
path.MoveTo(Width, Height-bottomPadding);
path.LineTo(Width-sidePadding, Height-bottomPadding);
path.LineTo(Width-sidePadding, 0);
path.LineTo(Width, 0);
path.Close();
canvas.DrawPath(path, paint);
}
lineCount++;
}
paint.Reset();
paint.Color = Color.White;
//paint.setColor(this.gridColor);
paint.Alpha = 50;
paint.AntiAlias = true;
canvas.DrawLine(sidePadding, Height - bottomPadding, Width, Height-bottomPadding, paint);
if(this.showHorizontalGrid1)
for(int i=1;i<=10;i++)
{
canvas.DrawLine(sidePadding, Height - bottomPadding-(i*lineSpace), Width, Height-bottomPadding-(i*lineSpace), paint);
}
paint.Alpha = 255;
foreach (Line line in lines) {
int count = 0;
float lastXPixels = 0, newYPixels;
float lastYPixels = 0, newXPixels;
float maxYd = getMaxY();
float minYd = getMinY();
float maxXd = getMaxX();
float minXd = getMinX();
paint.Color = Color.Yellow;
//paint.setColor(line.getColor());
paint.StrokeWidth = 6;
foreach (LinePoint p in line.getPoints()) {
float yPercent = (p.getY()-minY)/(maxYd - minYd);
float xPercent = (p.getX()-minX)/(maxXd - minXd);
if (count == 0){
lastXPixels = sidePadding + (xPercent*usableWidth);
lastYPixels = Height - bottomPadding - (usableHeight*yPercent);
} else {
newXPixels = sidePadding + (xPercent*usableWidth);
newYPixels = Height - bottomPadding - (usableHeight*yPercent);
canvas.DrawLine(lastXPixels, lastYPixels, newXPixels, newYPixels, paint);
lastXPixels = newXPixels;
lastYPixels = newYPixels;
}
count++;
}
}
int pointCount = 0;
foreach (Line line in lines) {
float maxYd = getMaxY();
float minYd = getMinY();
float maxXd = getMaxX();
float minXd = getMinX();
paint.Color = Color.Yellow;
//paint.setColor(line.getColor());
paint.StrokeWidth = 6;
paint.StrokeCap = Paint.Cap.Round;
if (line.isShowingPoints()){
foreach (LinePoint p in line.getPoints()) {
float yPercent = (p.getY()-minYd)/(maxYd - minYd);
float xPercent = (p.getX()-minXd)/(maxXd - minXd);
float xPixels = sidePadding + (xPercent*usableWidth);
float yPixels = Height - bottomPadding - (usableHeight*yPercent);
paint.Color = Color.Gray;
canvas.DrawCircle(xPixels, yPixels, 10, paint);
paint.Color = Color.White;
canvas.DrawCircle(xPixels, yPixels, 5, paint);
Path path2 = new Path();
path2.AddCircle(xPixels, yPixels, 30, Android.Graphics.Path.Direction.Cw);
p.setPath(path2);
p.setRegion(new Region((int)(xPixels-30), (int)(yPixels-30), (int)(xPixels+30), (int)(yPixels+30)));
if (indexSelected == pointCount && listener != null){
paint.Color=Color.ParseColor("#33B5E5");
paint.Alpha = 100;
canvas.DrawPath(p.getPath(), paint);
paint.Alpha = 255;
}
pointCount++;
}
}
}
shouldUpdate = false;
if (this.showMinAndMax) {
ca.DrawText(max, 0, txtPaint.TextSize, txtPaint);
ca.DrawText(min,0,this.Height,txtPaint);
}
}
ca.DrawBitmap(fullImage, 0, 0, null);
}
public static Bitmap ToTransformedCorners(Bitmap source, double topLeftCornerSize, double topRightCornerSize, double bottomLeftCornerSize, double bottomRightCornerSize,
CornerTransformType cornersTransformType, 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);
}
topLeftCornerSize = topLeftCornerSize * (desiredWidth + desiredHeight) / 2 / 100;
topRightCornerSize = topRightCornerSize * (desiredWidth + desiredHeight) / 2 / 100;
bottomLeftCornerSize = bottomLeftCornerSize * (desiredWidth + desiredHeight) / 2 / 100;
bottomRightCornerSize = bottomRightCornerSize * (desiredWidth + desiredHeight) / 2 / 100;
float cropX = (float)((sourceWidth - desiredWidth) / 2);
float cropY = (float)((sourceHeight - 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())
using (var path = new Path())
{
if (cropX != 0 || cropY != 0)
{
matrix.SetTranslate(-cropX, -cropY);
shader.SetLocalMatrix(matrix);
}
paint.SetShader(shader);
paint.AntiAlias = true;
// TopLeft
if (cornersTransformType.HasFlag(CornerTransformType.TopLeftCut))
{
path.MoveTo(0, (float)topLeftCornerSize);
path.LineTo((float)topLeftCornerSize, 0);
}
else if (cornersTransformType.HasFlag(CornerTransformType.TopLeftRounded))
{
path.MoveTo(0, (float)topLeftCornerSize);
path.QuadTo(0, 0, (float)topLeftCornerSize, 0);
}
else
{
path.MoveTo(0, 0);
}
// TopRight
if (cornersTransformType.HasFlag(CornerTransformType.TopRightCut))
{
path.LineTo((float)(desiredWidth - topRightCornerSize), 0);
path.LineTo((float)desiredWidth, (float)topRightCornerSize);
}
else if (cornersTransformType.HasFlag(CornerTransformType.TopRightRounded))
{
path.LineTo((float)(desiredWidth - topRightCornerSize), 0);
path.QuadTo((float)desiredWidth, 0, (float)desiredWidth, (float)topRightCornerSize);
}
else
{
path.LineTo((float)desiredWidth ,0);
}
// BottomRight
if (cornersTransformType.HasFlag(CornerTransformType.BottomRightCut))
{
path.LineTo((float)desiredWidth, (float)(desiredHeight - bottomRightCornerSize));
path.LineTo((float)(desiredWidth - bottomRightCornerSize), (float)desiredHeight);
}
else if (cornersTransformType.HasFlag(CornerTransformType.BottomRightRounded))
{
path.LineTo((float)desiredWidth, (float)(desiredHeight - bottomRightCornerSize));
path.QuadTo((float)desiredWidth, (float)desiredHeight, (float)(desiredWidth - bottomRightCornerSize), (float)desiredHeight);
}
else
{
path.LineTo((float)desiredWidth, (float)desiredHeight);
}
// BottomLeft
if (cornersTransformType.HasFlag(CornerTransformType.BottomLeftCut))
{
path.LineTo((float)bottomLeftCornerSize, (float)desiredHeight);
path.LineTo(0, (float)(desiredHeight - bottomLeftCornerSize));
}
else if (cornersTransformType.HasFlag(CornerTransformType.BottomLeftRounded))
{
path.LineTo((float)bottomLeftCornerSize, (float)desiredHeight);
path.QuadTo(0, (float)desiredHeight, 0, (float)(desiredHeight - bottomLeftCornerSize));
}
else
{
path.LineTo(0, (float)desiredHeight);
}
path.Close();
canvas.DrawPath(path, paint);
return bitmap;
}
}
public void BeginFigure(float x, float y)
{
path.MoveTo(x, y);
}
public object ConvertToNative(Geometry geometry)
{
// TODO: Can we keep this object around and reset it?
droidGraphics.Path path = new droidGraphics.Path();
// TODO: Might we also save a non-transformed path and a transformed path? -- No, that fails for GeometryGroup
// Determine what type of Geometry we're dealing with
if (geometry is LineGeometry)
{
LineGeometry lineGeometry = geometry as LineGeometry;
path.MoveTo(PixelsPerDip * (float)lineGeometry.StartPoint.X,
PixelsPerDip * (float)lineGeometry.StartPoint.Y);
path.LineTo(PixelsPerDip * (float)lineGeometry.EndPoint.X,
PixelsPerDip * (float)lineGeometry.EndPoint.Y);
}
else if (geometry is RectangleGeometry)
{
Rect rect = (geometry as RectangleGeometry).Rect;
path.AddRect(PixelsPerDip * (float)rect.Left,
PixelsPerDip * (float)rect.Top,
PixelsPerDip * (float)rect.Right,
PixelsPerDip * (float)rect.Bottom,
droidGraphics.Path.Direction.Cw); // TODO: Check for compatibility!
}
else if (geometry is EllipseGeometry)
{
EllipseGeometry ellipseGeometry = geometry as EllipseGeometry;
path.AddOval(new droidGraphics.RectF(
PixelsPerDip * (float)(ellipseGeometry.Center.X - ellipseGeometry.RadiusX),
PixelsPerDip * (float)(ellipseGeometry.Center.Y - ellipseGeometry.RadiusY),
PixelsPerDip * (float)(ellipseGeometry.Center.X + ellipseGeometry.RadiusX),
PixelsPerDip * (float)(ellipseGeometry.Center.Y + ellipseGeometry.RadiusY)),
droidGraphics.Path.Direction.Cw); // TODO: Check for compatibility!
}
else if (geometry is GeometryGroup)
{
GeometryGroup geometryGroup = geometry as GeometryGroup;
SetFillRule(path, geometryGroup.FillRule);
foreach (Geometry child in geometryGroup.Children)
{
droidGraphics.Path childPath = ConvertToNative(child) as droidGraphics.Path;
path.AddPath(childPath);
}
}
else if (geometry is PathGeometry)
{
PathGeometry pathGeometry = geometry as PathGeometry;
SetFillRule(path, pathGeometry.FillRule);
foreach (PathFigure pathFigure in pathGeometry.Figures)
{
path.MoveTo(PixelsPerDip * (float)pathFigure.StartPoint.X,
PixelsPerDip * (float)pathFigure.StartPoint.Y);
Point lastPoint = pathFigure.StartPoint;
foreach (PathSegment pathSegment in pathFigure.Segments)
{
// LineSegment
if (pathSegment is LineSegment)
{
LineSegment lineSegment = pathSegment as LineSegment;
path.LineTo(PixelsPerDip * (float)lineSegment.Point.X,
PixelsPerDip * (float)lineSegment.Point.Y);
lastPoint = lineSegment.Point;
}
// PolylineSegment
else if (pathSegment is PolyLineSegment)
{
PolyLineSegment polylineSegment = pathSegment as PolyLineSegment;
PointCollection points = polylineSegment.Points;
for (int i = 0; i < points.Count; i++)
{
path.LineTo(PixelsPerDip * (float)points[i].X,
PixelsPerDip * (float)points[i].Y);
}
lastPoint = points[points.Count - 1];
}
// BezierSegment
else if (pathSegment is BezierSegment)
{
BezierSegment bezierSegment = pathSegment as BezierSegment;
path.CubicTo(PixelsPerDip * (float)bezierSegment.Point1.X, PixelsPerDip * (float)bezierSegment.Point1.Y,
PixelsPerDip * (float)bezierSegment.Point2.X, PixelsPerDip * (float)bezierSegment.Point2.Y,
PixelsPerDip * (float)bezierSegment.Point3.X, PixelsPerDip * (float)bezierSegment.Point3.Y);
lastPoint = bezierSegment.Point3;
}
// PolyBezierSegment
else if (pathSegment is PolyBezierSegment)
{
PolyBezierSegment polyBezierSegment = pathSegment as PolyBezierSegment;
PointCollection points = polyBezierSegment.Points;
for (int i = 0; i < points.Count; i += 3)
{
path.CubicTo(PixelsPerDip * (float)points[i + 0].X, PixelsPerDip * (float)points[i + 0].Y,
PixelsPerDip * (float)points[i + 1].X, PixelsPerDip * (float)points[i + 1].Y,
PixelsPerDip * (float)points[i + 2].X, PixelsPerDip * (float)points[i + 2].Y);
}
lastPoint = points[points.Count - 1];
}
// QuadraticBezierSegment
else if (pathSegment is QuadraticBezierSegment)
{
QuadraticBezierSegment bezierSegment = pathSegment as QuadraticBezierSegment;
path.QuadTo(PixelsPerDip * (float)bezierSegment.Point1.X, PixelsPerDip * (float)bezierSegment.Point1.Y,
PixelsPerDip * (float)bezierSegment.Point2.X, PixelsPerDip * (float)bezierSegment.Point2.Y);
lastPoint = bezierSegment.Point2;
}
// PolyQuadraticBezierSegment
else if (pathSegment is PolyQuadraticBezierSegment)
{
PolyQuadraticBezierSegment polyBezierSegment = pathSegment as PolyQuadraticBezierSegment;
PointCollection points = polyBezierSegment.Points;
for (int i = 0; i < points.Count; i += 2)
{
path.QuadTo(PixelsPerDip * (float)points[i + 0].X, PixelsPerDip * (float)points[i + 0].Y,
PixelsPerDip * (float)points[i + 1].X, PixelsPerDip * (float)points[i + 1].Y);
}
lastPoint = points[points.Count - 1];
}
// ArcSegment
else if (pathSegment is ArcSegment)
{
ArcSegment arcSegment = pathSegment as ArcSegment;
List <Point> points = new List <Point>();
Xamarin.Forms.Shapes.Shapes.FlattenArc(points,
lastPoint,
arcSegment.Point,
arcSegment.Size.Width,
arcSegment.Size.Height,
arcSegment.RotationAngle,
arcSegment.IsLargeArc,
arcSegment.SweepDirection == SweepDirection.Counterclockwise,
1);
for (int i = 0; i < points.Count; i++)
{
path.LineTo(PixelsPerDip * (float)points[i].X,
PixelsPerDip * (float)points[i].Y);
}
lastPoint = points[points.Count - 1];
}
}
if (pathFigure.IsClosed)
{
path.Close();
}
}
}
// Apply transform
if (geometry.Transform != null)
{
path.Transform((droidGraphics.Matrix)geometry.Transform.GetNativeObject());
}
return(path);
}
protected override void OnDraw(Canvas canvas)
{
base.OnDraw(canvas);
switch(mShape)
{
case Shape.TRIANGLE:
{
if (mIsLoading)
{
mAnimPercent += 0.1611113f;
Path path = new Path();
path.MoveTo(RelativeXFromView(0.5f),
RelativeYFromView(0.5f));
if (mAnimPercent >= 1)
{
mShape = Shape.CIRCLE;
mIsLoading = false;
mAnimPercent = 1;
}
float controlX = mControlX - RelativeXFromView(mAnimPercent * triangle2Circle) * genhao3;
float controlY = mControlY - RelativeYFromView(mAnimPercent * triangle2Circle);
path.QuadTo(RelativeXFromView(1) - controlX, controlY, RelativeXFromView(0.5f + genhao3 / 4),
RelativeYFromView(0.75f));
path.QuadTo(RelativeXFromView(0.5f), RelativeYFromView(0.75f + 2 * mAnimPercent * triangle2Circle),
RelativeXFromView(0.5f - genhao3 / 4), RelativeYFromView(0.75f));
path.QuadTo(controlX, controlY, RelativeXFromView(0.5f), RelativeYFromView(0f));
path.Close();
canvas.DrawPath(path, mPaint);
Invalidate();
}
else
{
Path path = new Path();
mPaint.Color = Resources.GetColor(Resource.Color.triangle);
path.MoveTo(RelativeXFromView(0.5f), RelativeYFromView(0f));
path.LineTo(RelativeXFromView(1), RelativeYFromView(genhao3 / 2f));
path.LineTo(RelativeXFromView(0), RelativeYFromView(genhao3 / 2f));
mControlX = RelativeXFromView(0.5f - genhao3 / 8f);
mControlY = RelativeYFromView(3 / 8f);
mAnimPercent = 0;
path.Close();
canvas.DrawPath(path, mPaint);
}
}
break;
case Shape.CIRCLE:
{
if(mIsLoading)
{
float magicNumber = mMagicNumber + mAnimPercent;
mAnimPercent += 0.12f;
if(magicNumber + mAnimPercent > 1.9f)
{
mShape = Shape.RECT;
mIsLoading = false;
}
Path path = new Path();
path.MoveTo(RelativeXFromView(0.5f), RelativeYFromView(0f));
path.CubicTo(RelativeXFromView(0.5f + magicNumber / 2), RelativeYFromView(0f),
RelativeXFromView(1), RelativeYFromView(0.5f - magicNumber / 2),
RelativeXFromView(1f), RelativeYFromView(0.5f));
path.CubicTo(RelativeXFromView(1), RelativeXFromView(0.5f + magicNumber / 2),
RelativeXFromView(0.5f + mMagicNumber / 2), RelativeYFromView(1f),
RelativeXFromView(0.5f), RelativeYFromView(1f));
path.CubicTo(RelativeXFromView(0.5f - magicNumber / 2), RelativeXFromView(1f),
RelativeXFromView(0), RelativeYFromView(0.5f + magicNumber / 2),
RelativeXFromView(0f), RelativeYFromView(0.5f));
path.CubicTo(RelativeXFromView(0f), RelativeXFromView(0.5f - magicNumber / 2),
RelativeXFromView(0.5f - magicNumber / 2), RelativeYFromView(0),
RelativeXFromView(0.5f), RelativeYFromView(0f));
path.Close();
canvas.DrawPath(path, mPaint);
Invalidate();
}
else
{
mPaint.Color = Resources.GetColor(Resource.Color.circle);
Path path = new Path();
float magicNumber = mMagicNumber;
path.MoveTo(RelativeXFromView(0.5f), RelativeYFromView(0f));
path.CubicTo(RelativeXFromView(0.5f + magicNumber / 2), 0,
RelativeXFromView(1), RelativeYFromView(magicNumber / 2),
RelativeXFromView(1f), RelativeYFromView(0.5f));
path.CubicTo(
RelativeXFromView(1), RelativeXFromView(0.5f + magicNumber / 2),
RelativeXFromView(0.5f + magicNumber / 2), RelativeYFromView(1f),
RelativeXFromView(0.5f), RelativeYFromView(1f));
path.CubicTo(RelativeXFromView(0.5f - magicNumber / 2), RelativeXFromView(1f),
RelativeXFromView(0), RelativeYFromView(0.5f + magicNumber / 2),
RelativeXFromView(0f), RelativeYFromView(0.5f));
path.CubicTo(RelativeXFromView(0f), RelativeXFromView(0.5f - magicNumber / 2),
RelativeXFromView(0.5f - magicNumber / 2), RelativeYFromView(0),
RelativeXFromView(0.5f), RelativeYFromView(0f));
mAnimPercent = 0;
path.Close();
canvas.DrawPath(path, mPaint);
}
}
break;
case Shape.RECT:
{
if(mIsLoading)
{
mAnimPercent += 0.15f;
if(mAnimPercent >= 1)
{
mShape = Shape.TRIANGLE;
mIsLoading = false;
mAnimPercent = 1;
}
Path path = new Path();
path.MoveTo(RelativeXFromView(0.5f * mAnimPercent), 0);
path.LineTo(RelativeYFromView(1 - 0.5f * mAnimPercent), 0);
float distanceX = (mControlX) * mAnimPercent;
float distanceY = (RelativeYFromView(1f) - mControlY) * mAnimPercent;
path.LineTo(RelativeXFromView(1f) - distanceX, RelativeYFromView(1f) - distanceY);
path.LineTo(RelativeXFromView(0f) + distanceX, RelativeYFromView(1f) - distanceY);
path.Close();
canvas.DrawPath(path, mPaint);
Invalidate();
}
else
{
mPaint.Color = Resources.GetColor(Resource.Color.rect);
mControlX = RelativeXFromView(0.5f - genhao3 / 4);
mControlY = RelativeYFromView(0.75f);
Path path = new Path();
path.MoveTo(RelativeXFromView(0f), RelativeYFromView(0f));
path.LineTo(RelativeXFromView(1f), RelativeYFromView(0f));
path.LineTo(RelativeXFromView(1f), RelativeYFromView(1f));
path.LineTo(RelativeXFromView(0f), RelativeYFromView(1f));
path.Close();
mAnimPercent = 0;
canvas.DrawPath(path, mPaint);
}
}
break;
}
}
private void DrawDecart(Canvas canvas)
{
canvas.DrawColor (Color.Black);
Paint mPaint = new Paint();
mPaint.Dither = true;
mPaint.SetStyle (Paint.Style.Stroke);
mPaint.Color = Color.White;
mPaint.StrokeJoin = Paint.Join.Bevel;
mPaint.StrokeCap = Paint.Cap.Round;
mPaint.StrokeWidth = 3;
Path path = null;
// оси
path = new Path ();
path.MoveTo (MarginL, MarginU);
path.LineTo (MarginL, canvas.Height-MarginB);
canvas.DrawPath (path, mPaint);
// max min
DateTime MaxX = PointsCloud.MaxX;
DateTime MinX = PointsCloud.MinX;
// разметка вертикальные линии
if (MaxX.Equals (MinX))
return;
double totalMills = (MaxX - MinX).TotalMilliseconds;
int totalPixs = (canvas.Width - MarginL - MarginR);
int delta = Convert.ToInt32(System.Math.Ceiling(1/((totalPixs * 1000 / totalMills) / 96)));
DateTime next = MinX;
next = next.AddMilliseconds (-next.Millisecond);
next = next.AddSeconds (1);
mPaint.StrokeWidth = 1;
while (next.CompareTo(MaxX)<0) {
double a = (next - MinX).TotalMilliseconds;
double b = a / totalMills;
double c = b * totalPixs;
int pix = Convert.ToInt32 (c);
mPaint.SetStyle (Paint.Style.Stroke);
canvas.DrawLine (MarginL + pix, MarginU, MarginL + pix, canvas.Height-MarginB, mPaint);
mPaint.TextSize = 20;
mPaint.SetStyle(Paint.Style.Fill);
canvas.DrawText (next.ToLongTimeString(),
MarginL + pix , canvas.Height-MarginB + MarginB/2, mPaint );
next = next.AddSeconds (delta);
}
if (!(PointsCloud.x || PointsCloud.y || PointsCloud.z || PointsCloud.v))
return;
double MaxY = PointsCloud.MaxY;
double MinY = PointsCloud.MinY;
double totalDiff = MaxY - MinY;
totalPixs = (canvas.Height - MarginU - MarginB);
delta = Convert.ToInt32(System.Math.Ceiling(1/((totalPixs / totalDiff) / 96)));
if (totalDiff != 0) {
double nextY = MaxY;
nextY = Convert.ToDouble (System.Math.Ceiling (nextY));
while (nextY>MinY) {
double a = (MaxY - nextY);
double b = a / totalDiff;
double c = b * totalPixs;
int pix = Convert.ToInt32 (c);
mPaint.SetStyle (Paint.Style.Stroke);
canvas.DrawLine (MarginL, MarginU + pix, canvas.Width - MarginR, MarginU + pix, mPaint);
mPaint.TextSize = 20;
mPaint.SetStyle(Paint.Style.Fill);
canvas.DrawText (nextY.ToString(),
0 , MarginU + pix, mPaint );
nextY = nextY - delta;
}
}
}
public void DrawPath(IEnumerable <PathOperation> ops, Pen pen = null, BaseBrush brush = null)
{
using (var path = new Path())
{
var bb = new BoundingBoxBuilder();
foreach (var op in ops)
{
var moveTo = op as MoveTo;
if (moveTo != null)
{
var start = moveTo.Start;
var end = moveTo.End;
path.MoveTo((float)start.X, (float)start.Y);
bb.Add(start);
bb.Add(end);
continue;
}
var lineTo = op as LineTo;
if (lineTo != null)
{
var start = lineTo.Start;
var end = lineTo.End;
path.LineTo((float)start.X, (float)start.Y);
path.LineTo((float)end.X, (float)end.Y);
bb.Add(start);
bb.Add(end);
continue;
}
var at = op as ArcTo;
if (at != null)
{
var p = at.Point;
path.LineTo((float)p.X, (float)p.Y);
bb.Add(p);
continue;
}
var curveTo = op as CurveTo;
if (curveTo != null)
{
var end = curveTo.End;
var firstControlPoint = curveTo.FirstControlPoint;
var secondControlPoint = curveTo.SecondControlPoint;
path.CubicTo((float)firstControlPoint.X, (float)firstControlPoint.Y, (float)secondControlPoint.X,
(float)secondControlPoint.Y, (float)end.X, (float)end.Y);
bb.Add(firstControlPoint);
bb.Add(secondControlPoint);
bb.Add(end);
continue;
}
var cp = op as ClosePath;
if (cp != null)
{
path.Close();
continue;
}
throw new NotSupportedException("Path Op " + op);
}
var frame = bb.BoundingBox;
if (brush != null)
{
var solidBrush = brush as SolidBrush;
if (solidBrush != null)
{
path.SetFillType(GetPathFillType(((SolidBrush)brush).FillMode));
}
var brushPaint = GetBrushPaint(brush, frame);
graphics.DrawPath(path, brushPaint);
}
if (pen != null)
{
var penPaint = GetPenPaint(pen);
graphics.DrawPath(path, penPaint);
}
}
}
private void DrawLineChart(Canvas canvas) {
var path = new Path ();
var current = 0;
var labelYPos = (float)chartPixelHeight + PaddingTop + PaddingBottom + 20f;
foreach (var point in _chartPoints) {
if (current == 0) {
path.MoveTo (point.X, point.Y);
} else {
path.LineTo (point.X, point.Y);
}
canvas.DrawText (xLabels [current], point.X, labelYPos, _xLabelPaint);
current++;
}
paint.SetStyle (Paint.Style.Stroke);
paint.StrokeWidth = 4f;
paint.Color = Color.ParseColor (RSColors.PURPLE_4);
paint.AntiAlias = true;
canvas.DrawPath (path, paint);
_xLabelPaint.Color = Color.ParseColor (RSColors.RS_LIGHT_GRAY);
canvas.DrawText ("Year", Width / 2, labelYPos + 45.0f, _xLabelPaint);
}
Path GetPolyPath(Polygon poly)
{
var p = poly.Tag as Path;
if (p == null) {
p = new Path ();
p.MoveTo (poly.Points[0].X, poly.Points[0].Y);
for (var i = 1; i < poly.Points.Count; i++) {
var pt = poly.Points[i];
p.LineTo (pt.X, pt.Y);
}
p.LineTo (poly.Points[0].X, poly.Points[0].Y);
poly.Tag = p;
}
return p;
}
public static APath ToAPath(this Geometry geometry, Context context)
{
APath path = new APath();
float density = context.Resources.DisplayMetrics.Density;
if (geometry is LineGeometry)
{
LineGeometry lineGeometry = geometry as LineGeometry;
path.MoveTo(
density * (float)lineGeometry.StartPoint.X,
density * (float)lineGeometry.StartPoint.Y);
path.LineTo(
density * (float)lineGeometry.EndPoint.X,
density * (float)lineGeometry.EndPoint.Y);
}
else if (geometry is RectangleGeometry)
{
FormsRectangle rect = (geometry as RectangleGeometry).Rect;
path.AddRect(
density * (float)rect.Left,
density * (float)rect.Top,
density * (float)rect.Right,
density * (float)rect.Bottom,
APath.Direction.Cw);
}
else if (geometry is EllipseGeometry)
{
EllipseGeometry ellipseGeometry = geometry as EllipseGeometry;
path.AddOval(new RectF(
density * (float)(ellipseGeometry.Center.X - ellipseGeometry.RadiusX),
density * (float)(ellipseGeometry.Center.Y - ellipseGeometry.RadiusY),
density * (float)(ellipseGeometry.Center.X + ellipseGeometry.RadiusX),
density * (float)(ellipseGeometry.Center.Y + ellipseGeometry.RadiusY)),
APath.Direction.Cw);
}
else if (geometry is GeometryGroup)
{
GeometryGroup geometryGroup = geometry as GeometryGroup;
path.SetFillType(geometryGroup.FillRule == FillRule.Nonzero ? APath.FillType.Winding : APath.FillType.EvenOdd);
foreach (Geometry child in geometryGroup.Children)
{
APath childPath = child.ToAPath(context);
path.AddPath(childPath);
}
}
else if (geometry is PathGeometry)
{
PathGeometry pathGeometry = geometry as PathGeometry;
path.SetFillType(pathGeometry.FillRule == FillRule.Nonzero ? APath.FillType.Winding : APath.FillType.EvenOdd);
foreach (PathFigure pathFigure in pathGeometry.Figures)
{
path.MoveTo(
density * (float)pathFigure.StartPoint.X,
density * (float)pathFigure.StartPoint.Y);
Point lastPoint = pathFigure.StartPoint;
foreach (PathSegment pathSegment in pathFigure.Segments)
{
// LineSegment
if (pathSegment is LineSegment)
{
LineSegment lineSegment = pathSegment as LineSegment;
path.LineTo(
density * (float)lineSegment.Point.X,
density * (float)lineSegment.Point.Y);
lastPoint = lineSegment.Point;
}
// PolylineSegment
else if (pathSegment is PolyLineSegment)
{
PolyLineSegment polylineSegment = pathSegment as PolyLineSegment;
PointCollection points = polylineSegment.Points;
for (int i = 0; i < points.Count; i++)
{
path.LineTo(
density * (float)points[i].X,
density * (float)points[i].Y);
}
lastPoint = points[points.Count - 1];
}
// BezierSegment
else if (pathSegment is BezierSegment)
{
BezierSegment bezierSegment = pathSegment as BezierSegment;
path.CubicTo(
density * (float)bezierSegment.Point1.X, density * (float)bezierSegment.Point1.Y,
density * (float)bezierSegment.Point2.X, density * (float)bezierSegment.Point2.Y,
density * (float)bezierSegment.Point3.X, density * (float)bezierSegment.Point3.Y);
lastPoint = bezierSegment.Point3;
}
// PolyBezierSegment
else if (pathSegment is PolyBezierSegment)
{
PolyBezierSegment polyBezierSegment = pathSegment as PolyBezierSegment;
PointCollection points = polyBezierSegment.Points;
if (points.Count >= 3)
{
for (int i = 0; i < points.Count; i += 3)
{
path.CubicTo(
density * (float)points[i + 0].X, density * (float)points[i + 0].Y,
density * (float)points[i + 1].X, density * (float)points[i + 1].Y,
density * (float)points[i + 2].X, density * (float)points[i + 2].Y);
}
}
lastPoint = points[points.Count - 1];
}
// QuadraticBezierSegment
else if (pathSegment is QuadraticBezierSegment)
{
QuadraticBezierSegment bezierSegment = pathSegment as QuadraticBezierSegment;
path.QuadTo(
density * (float)bezierSegment.Point1.X, density * (float)bezierSegment.Point1.Y,
density * (float)bezierSegment.Point2.X, density * (float)bezierSegment.Point2.Y);
lastPoint = bezierSegment.Point2;
}
// PolyQuadraticBezierSegment
else if (pathSegment is PolyQuadraticBezierSegment)
{
PolyQuadraticBezierSegment polyBezierSegment = pathSegment as PolyQuadraticBezierSegment;
PointCollection points = polyBezierSegment.Points;
if (points.Count >= 2)
{
for (int i = 0; i < points.Count; i += 2)
{
path.QuadTo(
density * (float)points[i + 0].X, density * (float)points[i + 0].Y,
density * (float)points[i + 1].X, density * (float)points[i + 1].Y);
}
}
lastPoint = points[points.Count - 1];
}
// ArcSegment
else if (pathSegment is ArcSegment)
{
ArcSegment arcSegment = pathSegment as ArcSegment;
List <Point> points = new List <Point>();
GeometryHelper.FlattenArc(
points,
lastPoint,
arcSegment.Point,
arcSegment.Size.Width,
arcSegment.Size.Height,
arcSegment.RotationAngle,
arcSegment.IsLargeArc,
arcSegment.SweepDirection == SweepDirection.CounterClockwise,
1);
for (int i = 0; i < points.Count; i++)
{
path.LineTo(
density * (float)points[i].X,
density * (float)points[i].Y);
}
if (points.Count > 0)
{
lastPoint = points[points.Count - 1];
}
}
}
if (pathFigure.IsClosed)
{
path.Close();
}
}
}
return(path);
}
//Allow the user to import an array of points to be used to draw a signature in the view, with new
//lines indicated by a System.Drawing.PointF.Empty in the array.
public void LoadPoints (System.Drawing.PointF[] loadedPoints)
{
if (loadedPoints == null || loadedPoints.Count () == 0)
return;
var startIndex = 0;
var emptyIndex = loadedPoints.ToList ().IndexOf (System.Drawing.PointF.Empty);
if (emptyIndex == -1)
emptyIndex = loadedPoints.Count ();
//Clear any existing paths or points.
paths = new List<Path> ();
points = new List<System.Drawing.PointF[]> ();
do {
//Create a new path and set the line options
currentPath = new Path ();
currentPoints = new List<System.Drawing.PointF> ();
//Move to the first point and add that point to the current_points array.
currentPath.MoveTo (loadedPoints [startIndex].X, loadedPoints [startIndex].Y);
currentPoints.Add (loadedPoints [startIndex]);
//Iterate through the array until an empty point (or the end of the array) is reached,
//adding each point to the current_path and to the current_points array.
for (var i = startIndex + 1; i < emptyIndex; i++) {
currentPath.LineTo (loadedPoints [i].X, loadedPoints [i].Y);
currentPoints.Add (loadedPoints [i]);
}
//Add the current_path and current_points list to their respective Lists before
//starting on the next line to be drawn.
paths.Add (currentPath);
points.Add (currentPoints.ToArray ());
//Obtain the indices for the next line to be drawn.
startIndex = emptyIndex + 1;
if (startIndex < loadedPoints.Count () - 1) {
emptyIndex = loadedPoints.ToList ().IndexOf (System.Drawing.PointF.Empty,
startIndex);
if (emptyIndex == -1)
emptyIndex = loadedPoints.Count ();
} else
emptyIndex = startIndex;
} while (startIndex < emptyIndex);
DrawStrokes ();
//Display the clear button.
lblClear.Visibility = ViewStates.Visible;
Invalidate ();
}
/// <summary>
/// Implement this to do your drawing.
/// </summary>
/// <param name="canvas">the canvas on which the background will be drawn</param>
/// <since version="Added in API level 1" />
/// <remarks>
/// <para tool="javadoc-to-mdoc">Implement this to do your drawing.</para>
/// <para tool="javadoc-to-mdoc">
/// <format type="text/html">
/// <a href="http://developer.android.com/reference/android/view/View.html#onDraw(android.graphics.Canvas)"
/// target="_blank">
/// [Android Documentation]
/// </a>
/// </format>
/// </para>
/// </remarks>
protected override void OnDraw(Canvas canvas)
{
base.OnDraw(canvas);
var r = new Rect(0, 0, canvas.Width, canvas.Height);
var dAdjustedThicnkess = (float)Thickness * _dm;
var paint = new Paint { Color = StrokeColor, StrokeWidth = dAdjustedThicnkess, AntiAlias = true };
paint.SetStyle(Paint.Style.Stroke);
switch (StrokeType)
{
case StrokeType.Dashed:
paint.SetPathEffect(new DashPathEffect(new[] { 6 * _dm, 2 * _dm }, 0));
break;
case StrokeType.Dotted:
paint.SetPathEffect(new DashPathEffect(new[] { dAdjustedThicnkess, dAdjustedThicnkess }, 0));
break;
}
var thicknessOffset = (dAdjustedThicnkess) / 2.0f;
var p = new Path();
if (Orientation == SeparatorOrientation.Horizontal)
{
p.MoveTo(0, thicknessOffset);
p.LineTo(r.Width(), thicknessOffset);
}
else
{
p.MoveTo(thicknessOffset, 0);
p.LineTo(thicknessOffset, r.Height());
}
canvas.DrawPath(p, paint);
}
Path smoothedPathWithGranularity (int granularity, out List<System.Drawing.PointF> smoothedPoints)
{
List<System.Drawing.PointF> pointsArray = currentPoints;
smoothedPoints = new List<System.Drawing.PointF> ();
//Not enough points to smooth effectively, so return the original path and points.
if (pointsArray.Count < 4) {
smoothedPoints = pointsArray;
return currentPath;
}
//Create a new bezier path to hold the smoothed path.
Path smoothedPath = new Path ();
//Duplicate the first and last points as control points.
pointsArray.Insert (0, pointsArray [0]);
pointsArray.Add (pointsArray [pointsArray.Count - 1]);
//Add the first point
smoothedPath.MoveTo (pointsArray [0].X, pointsArray [0].Y);
smoothedPoints.Add (pointsArray [0]);
for (var index = 1; index < pointsArray.Count - 2; index++) {
System.Drawing.PointF p0 = pointsArray [index - 1];
System.Drawing.PointF p1 = pointsArray [index];
System.Drawing.PointF p2 = pointsArray [index + 1];
System.Drawing.PointF p3 = pointsArray [index + 2];
//Add n points starting at p1 + dx/dy up until p2 using Catmull-Rom splines
for (var i = 1; i < granularity; i++) {
float t = (float)i * (1f / (float)granularity);
float tt = t * t;
float ttt = tt * t;
//Intermediate point
System.Drawing.PointF mid = new System.Drawing.PointF ();
mid.X = 0.5f * (2f * p1.X + (p2.X - p0.X) * t +
(2f * p0.X - 5f * p1.X + 4f * p2.X - p3.X) * tt +
(3f * p1.X - p0.X - 3f * p2.X + p3.X) * ttt);
mid.Y = 0.5f * (2 * p1.Y + (p2.Y - p0.Y) * t +
(2 * p0.Y - 5 * p1.Y + 4 * p2.Y - p3.Y) * tt +
(3 * p1.Y - p0.Y - 3 * p2.Y + p3.Y) * ttt);
smoothedPath.LineTo (mid.X, mid.Y);
smoothedPoints.Add (mid);
}
//Add p2
smoothedPath.LineTo (p2.X, p2.Y);
smoothedPoints.Add (p2);
}
//Add the last point
System.Drawing.PointF last = pointsArray [pointsArray.Count - 1];
smoothedPath.LineTo (last.X, last.Y);
smoothedPoints.Add (last);
return smoothedPath;
}
public void DrawPath(IEnumerable<PathOperation> ops, Pen pen = null, BaseBrush brush = null)
{
using (var path = new Path())
{
var bb = new BoundingBoxBuilder();
foreach (var op in ops)
{
var moveTo = op as MoveTo;
if (moveTo != null)
{
var start = moveTo.Start;
var end = moveTo.End;
path.MoveTo((float) start.X, (float) start.Y);
bb.Add(start);
bb.Add(end);
continue;
}
var lineTo = op as LineTo;
if (lineTo != null)
{
var start = lineTo.Start;
var end = lineTo.End;
path.LineTo((float) start.X, (float) start.Y);
path.LineTo((float) end.X, (float) end.Y);
bb.Add(start);
bb.Add(end);
continue;
}
var at = op as ArcTo;
if (at != null)
{
var p = at.Point;
path.LineTo((float) p.X, (float) p.Y);
bb.Add(p);
continue;
}
var curveTo = op as CurveTo;
if (curveTo != null)
{
var end = curveTo.End;
var firstControlPoint = curveTo.FirstControlPoint;
var secondControlPoint = curveTo.SecondControlPoint;
path.CubicTo((float) firstControlPoint.X, (float) firstControlPoint.Y, (float) secondControlPoint.X,
(float) secondControlPoint.Y, (float) end.X, (float) end.Y);
bb.Add(firstControlPoint);
bb.Add(secondControlPoint);
bb.Add(end);
continue;
}
var cp = op as ClosePath;
if (cp != null)
{
path.Close();
continue;
}
throw new NotSupportedException("Path Op " + op);
}
var frame = bb.BoundingBox;
if (brush != null)
{
var solidBrush = brush as SolidBrush;
if (solidBrush != null)
{
path.SetFillType(GetPathFillType(((SolidBrush)brush).FillMode));
}
var brushPaint = GetBrushPaint(brush, frame);
graphics.DrawPath(path, brushPaint);
}
if (pen != null)
{
var penPaint = GetPenPaint(pen);
graphics.DrawPath(path, penPaint);
}
}
}
protected override void OnDraw(Canvas canvas)
{
try
{
base.OnDraw(canvas);
}
catch (Java.Lang.Exception)
{
return;
}
canvas.DrawColor(Color.Black);
if (IsSideBeyondCube(RotatingSide))
{
RotateSide(canvas, RotatingSide, rotatorAngle);
DrawCubeWithoutRotating(canvas);
}
else
{
DrawCubeWithoutRotating(canvas);
RotateSide(canvas, RotatingSide, rotatorAngle);
}
if (curFormula.Length > 15)
{
canvas.DrawText(
(new string(curFormula.Take(curFormula.Length / 2).ToArray())).Replace('z', '\''),
Width / 2,
Height / 8,
textPaint);
canvas.DrawText(
(new string(curFormula.Skip(curFormula.Length / 2).ToArray())).Replace('z', '\''),
Width / 2,
Height / 8 + tsize + 5,
textPaint);
}
else
{
canvas.DrawText(
curFormula.Replace('z', '\''),
Width / 2,
Height / 8 + tsize / 2,
textPaint);
}
if (onPause)
{
Android.Graphics.Path p = new Android.Graphics.Path();
p.MoveTo(Width / 20, Height * 17 / 20);
p.LineTo(Width / 8, Height * 18 / 20);
p.LineTo(Width / 20, Height * 19 / 20);
canvas.DrawPath(p, new Paint()
{
Color = Color.Aquamarine, StrokeWidth = 10
});
}
else
{
canvas.DrawLine(Width / 20, Height * 17 / 20, Width / 20, Height * 19 / 20, new Paint()
{
Color = Color.Aquamarine, StrokeWidth = 10
});
canvas.DrawLine(Width / 8, Height * 17 / 20, Width / 8, Height * 19 / 20, new Paint()
{
Color = Color.Aquamarine, StrokeWidth = 10
});
}
canvas.DrawText(textSpeed, Width * 7 / 8, Height * 18 / 20, textPaint);
//canvas.DrawRect(Width * 9/11, Height * 5 / 11, Width, Height * 7 / 11, new Paint() { Color = Color.AliceBlue });
/*
* camera = new Point3()
* {
* x = (float)(System.Math.Cos(AlphaAngle) * System.Math.Cos(BetaAngle)) * 10 * Size,
* y = (float)(-System.Math.Sin(AlphaAngle) * System.Math.Cos(BetaAngle)) * 10 * Size,
* z = (float)(-System.Math.Sin(BetaAngle)) * 10 * Size
* };
*
* canvas.DrawCircle((float)camera.X, (float)camera.Y, 10, new Paint() { Color = Color.White });
*/
/*
* canvas.DrawCircle((float)TestPoints[0].X, (float)TestPoints[0].Y, 10, new Paint() { Color = Color.Red });
* canvas.DrawCircle((float)TestPoints[1].X, (float)TestPoints[1].Y, 10, new Paint() { Color = Color.Green });
* canvas.DrawCircle((float)TestPoints[2].X, (float)TestPoints[2].Y, 10, new Paint() { Color = Color.Blue });
*/
try
{
SetImageBitmap(bm);
}
catch { }
}
private static void drawPolygonInCanvas(Canvas canvas, PointF[] polygon, Color color)
{
var path = new Path();
// Set the first point, that the drawing will start from.
path.MoveTo(polygon[0].X, polygon[0].Y);
for (var i = 1; i < polygon.Length; i++)
{
// Draw a line from the previous point in the path to the new point.
path.LineTo(polygon[i].X, polygon[i].Y);
}
Paint paint = new Paint {
AntiAlias = true,
Color = color
};
paint.SetStyle(Paint.Style.Fill);
canvas.DrawPath(path, paint);
paint.Dispose();
}
/// <summary>
/// Gets the equilateral triangle.
/// </summary>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <returns>Path.</returns>
private Path GetEquilateralTriangle(int width, int height)
{
PointF p1, p2, p3;
if(_arrowDirection == ArrowDirection.LEFT)
{
p1 = new PointF(0, (height) / 2);
p2 = new PointF(width, 0);
p3 = new PointF(width, height);
} else
{
p1 = new PointF(width, height / 2);
p2 = new PointF(0, 0);
p3 = new PointF(0, height);
}
Path path = new Path();
path.MoveTo(p1.X, p1.Y);
path.LineTo(p2.X, p2.Y);
path.LineTo(p3.X, p3.Y);
return path;
}
public override bool OnTouchEvent (MotionEvent e)
{
float touchX = e.GetX ();
float touchY = e.GetY ();
System.Drawing.PointF touch = new System.Drawing.PointF (touchX, touchY);
switch (e.Action) {
case MotionEventActions.Down:
lastX = touchX;
lastY = touchY;
//Create a new path and move to the touched point.
currentPath = new Path();
currentPath.MoveTo (touchX, touchY);
//Clear the list of points then add the touched point
currentPoints.Clear ();
currentPoints.Add (touch);
//Display the clear button
lblClear.Visibility = ViewStates.Visible;
return true;
case MotionEventActions.Move:
handleTouch (e);
canvasView.Invalidate(
(int) (dirtyRect.Left - 1),
(int) (dirtyRect.Top - 1),
(int) (dirtyRect.Right + 1),
(int) (dirtyRect.Bottom + 1));
break;
case MotionEventActions.Up:
handleTouch (e);
currentPath = smoothedPathWithGranularity (20, out currentPoints);
//Add the current path and points to their respective lists.
paths.Add (currentPath);
points.Add (currentPoints.ToArray ());
DrawStrokes ();
canvasView.Invalidate ();
break;
default:
return false;
}
lastX = touchX;
lastY = touchY;
return true;
}
private void DrawStrokes()
{
if (canvas == null)
{
return;
}
//TODO check the replacement for canvas.Save
canvas.Save(SaveFlags.Matrix);
canvas.Translate(canvas.Width / 2f, canvas.Height / 2f);
canvas.Rotate(deviceOrientation);
canvas.Translate(-(canvas.Width / 2f), -(canvas.Height / 2f));
canvas.DrawColor(new Color((byte)(BackgroundColor.R * 255), (byte)(BackgroundColor.G * 255), (byte)(BackgroundColor.B * 255), (byte)(BackgroundColor.A * 255)), PorterDuff.Mode.Src);
if (backgroundBitmap != null)
{
float scale = GetDrawingScale();
float offsetX = (Width - backgroundBitmap.Width * scale) / 2.0f;
float offsetY = (Height - backgroundBitmap.Height * scale) / 2.0f;
canvas.Translate(offsetX, offsetY);
switch (backgroundScaling)
{
case Abstractions.Scaling.Absolute_None:
case Abstractions.Scaling.Relative_None:
canvas.DrawBitmap(backgroundBitmap, 0, 0, new Paint());
break;
case Abstractions.Scaling.Absolute_Fit:
case Abstractions.Scaling.Relative_Fit:
canvas.DrawBitmap(backgroundBitmap, new Rect(0, 0, backgroundBitmap.Width, backgroundBitmap.Height), new Rect(0, 0, (int)(backgroundBitmap.Width * scale), (int)(backgroundBitmap.Height * scale)), new Paint());
break;
case Abstractions.Scaling.Absolute_Fill:
case Abstractions.Scaling.Relative_Fill:
canvas.DrawBitmap(backgroundBitmap, new Rect(0, 0, backgroundBitmap.Width, backgroundBitmap.Height), new Rect(0, 0, (int)(Width * scale), (int)(Height * scale)), new Paint());
break;
}
}
if (Strokes == null)
{
Strokes = new List <Abstractions.Stroke>();
}
foreach (var stroke in Strokes)
{
double lastX = stroke.Points[0].X;
double lastY = stroke.Points[0].Y;
var paint = new Paint()
{
Color = new Color((byte)(stroke.StrokeColor.R * 255.0), (byte)(stroke.StrokeColor.G * 255.0), (byte)(stroke.StrokeColor.B * 255.0), (byte)(stroke.StrokeColor.A * 255.0)),
StrokeWidth = (float)stroke.Thickness * metrics.Density,
AntiAlias = true,
StrokeCap = Paint.Cap.Round,
};
paint.SetStyle(Paint.Style.Stroke);
var path = new Android.Graphics.Path();
path.MoveTo((float)stroke.Points[0].X, (float)stroke.Points[0].Y);
foreach (var p in stroke.Points)
{
path.LineTo((float)p.X, (float)p.Y);
}
canvas.DrawPath(path, paint);
}
canvas.Restore();
}
protected override void OnDraw(Canvas canvas)
{
var rect = new Rect();
this.GetDrawingRect(rect);
var path = new Android.Graphics.Path();
var lastPoint = new PointF();
foreach (var command in PathDataParser.Parse(Element.Data))
{
switch (command.Type)
{
case PathDataParser.CommandType.MoveTo:
lastPoint = new PointF(command.Arguments[0], command.Arguments[1]);
path.MoveTo(lastPoint.X, lastPoint.Y);
break;
case PathDataParser.CommandType.LineTo:
lastPoint = new PointF(command.Arguments[0], command.Arguments[1]);
path.LineTo(lastPoint.X, lastPoint.Y);
break;
case PathDataParser.CommandType.LineHor:
lastPoint = new PointF(command.Arguments[0], lastPoint.Y);
path.LineTo(lastPoint.X, lastPoint.Y);
break;
case PathDataParser.CommandType.LineVer:
lastPoint = new PointF(lastPoint.X, command.Arguments[0]);
path.LineTo(lastPoint.X, lastPoint.Y);
break;
case PathDataParser.CommandType.RelativeLineHor:
lastPoint = new PointF(command.Arguments[0] + lastPoint.X, lastPoint.Y);
path.LineTo(lastPoint.X, lastPoint.Y);
break;
case PathDataParser.CommandType.RelativeLineVer:
lastPoint = new PointF(lastPoint.X, lastPoint.Y + command.Arguments[0]);
path.LineTo(lastPoint.X, lastPoint.Y);
break;
case PathDataParser.CommandType.RelativeLineTo:
lastPoint = new PointF(lastPoint.X + command.Arguments[0], lastPoint.Y + command.Arguments[1]);
path.LineTo(lastPoint.X, lastPoint.Y);
break;
case PathDataParser.CommandType.RelativeMoveTo:
lastPoint = new PointF(lastPoint.X + command.Arguments[0], lastPoint.Y + command.Arguments[1]);
path.MoveTo(lastPoint.X, lastPoint.Y);
break;
case PathDataParser.CommandType.QBezier:
path.QuadTo(command.Arguments[0], command.Arguments[1],
command.Arguments[2], command.Arguments[3]);
lastPoint = new PointF(command.Arguments[2], command.Arguments[3]);
break;
case PathDataParser.CommandType.Bezier:
path.CubicTo(
command.Arguments[0], command.Arguments[1],
command.Arguments[2], command.Arguments[3],
command.Arguments[4], command.Arguments[5]);
lastPoint = new PointF(command.Arguments[4], command.Arguments[5]);
break;
case PathDataParser.CommandType.RelativeBezier:
var p1 = new PointF(lastPoint.X + command.Arguments[0], lastPoint.Y + command.Arguments[1]);
var p2 = new PointF(p1.X + command.Arguments[2], p1.Y + command.Arguments[3]);
lastPoint = new PointF(p2.X + command.Arguments[4], p2.Y + command.Arguments[5]);
path.CubicTo(p1.X, p1.Y, p2.X, p2.Y, lastPoint.X, lastPoint.Y);
break;
case PathDataParser.CommandType.Close:
path.Close();
break;
}
}
var paint = new Paint(PaintFlags.AntiAlias);
paint.StrokeWidth = Element.StrokeThickness;
paint.StrokeMiter = 10f;
canvas.Save();
paint.SetStyle(Paint.Style.Stroke);
paint.Color = Element.Stroke.ToAndroid();
canvas.DrawPath(path, paint);
canvas.Restore();
}
public override void Draw(Canvas canvas)
{
var w = width / (Count - 2);
var path = new Path ();
path.MoveTo (0, height - u1 [0]);
for (int i = 1; i < Count; i += 3) {
path.CubicTo (i * w, height - u1 [Math.Min (Count - 1, i)],
(i + 1) * w, height - u1 [Math.Min (Count - 1, i + 1)],
(i + 2) * w, height - u1 [Math.Min (Count - 1, i + 2)]);
}
path.LineTo (width, height);
path.LineTo (0, height);
path.Close ();
canvas.DrawPath (path, paint);
if (bubblesEnabled)
DrawBubbles (canvas, w);
}
