protected override void OnDraw(Shape shape, Android.Graphics.Canvas canvas, Paint paint) { var height = canvas.ClipBounds.Bottom; var width = canvas.ClipBounds.Right; if (noChild) { var borderHeight = (int)(this.borderThickness.Top + this.borderThickness.Bottom); var borderWidth = (int)(this.borderThickness.Left + this.borderThickness.Right); height = borderHeight > 0 ? borderHeight : canvas.ClipBounds.Bottom; width = borderWidth > 0 ? borderWidth : canvas.ClipBounds.Right; } shape.Resize(width, height); shape.Draw(canvas, strokepaint); var pathInner = new Path(); var rect = new RectF( (float)(borderThickness.Left), (float)(borderThickness.Top), (float)(canvas.ClipBounds.Right - borderThickness.Right), (float)(canvas.ClipBounds.Bottom - borderThickness.Bottom)); pathInner.AddRoundRect(rect, cornerRadiusArray, Path.Direction.Cw); if (!noChild) { var clearPaint = new Paint(); clearPaint.SetXfermode(new PorterDuffXfermode(PorterDuff.Mode.Clear)); canvas.DrawPath(pathInner, clearPaint); } canvas.DrawPath(pathInner, fillpaint); }
protected override bool DrawChild(Canvas canvas, View child, long drawingTime) { try { var radius = Math.Min(Width, Height) / 2; var borderThickness = (float)((CircleImage)Element).BorderThickness; int strokeWidth = 0; if (borderThickness > 0) { var logicalDensity = Xamarin.Forms.Forms.Context.Resources.DisplayMetrics.Density; strokeWidth = (int)Math.Ceiling(borderThickness * logicalDensity + .5f); } radius -= strokeWidth / 2; var path = new Path(); path.AddCircle(Width / 2.0f, Height / 2.0f, radius, Path.Direction.Ccw); canvas.Save(); canvas.ClipPath(path); var paint = new Paint(); paint.AntiAlias = true; paint.SetStyle(Paint.Style.Fill); paint.Color = ((CircleImage)Element).FillColor.ToAndroid(); canvas.DrawPath(path, paint); paint.Dispose(); var result = base.DrawChild(canvas, child, drawingTime); canvas.Restore(); path = new Path(); path.AddCircle((float) Width / 2, (float) Height / 2, radius, Path.Direction.Ccw); if (strokeWidth > 0.0f) { paint = new Paint {AntiAlias = true, StrokeWidth = strokeWidth}; paint.SetStyle(Paint.Style.Stroke); paint.Color = ((CircleImage)Element).BorderColor.ToAndroid(); canvas.DrawPath(path, paint); paint.Dispose(); } path.Dispose(); return result; } catch (Exception ex) { System.Diagnostics.Debug.WriteLine("Unable to create circle image: " + ex); } return base.DrawChild(canvas, child, drawingTime); }
private void DrawBorder(ACanvas canvas, CorneredContentView control) { if (control.BorderThickness > 0) { float borderThickness = this.Context.ToPixels(control.BorderThickness); float halfBorderThickness = borderThickness / 2; using (Paint paint = new Paint { AntiAlias = true }) using (Path.Direction direction = Path.Direction.Cw) using (Paint.Style style = Paint.Style.Stroke) using (RectF rect = new RectF(!control.HasShadow ? -halfBorderThickness : halfBorderThickness, !control.HasShadow ? -halfBorderThickness : halfBorderThickness, !control.HasShadow ? canvas.Width + halfBorderThickness : canvas.Width - halfBorderThickness, !control.HasShadow ? canvas.Height + halfBorderThickness : canvas.Height - halfBorderThickness)) { Path path = new Path(); path.AddRoundRect(rect, this.GetRadii(control), direction); paint.Color = control.BorderColor.ToAndroid(); paint.StrokeCap = Paint.Cap.Square; paint.StrokeWidth = borderThickness; paint.SetStyle(style); canvas.DrawPath(path, paint); } } }
void DrawOutline(Android.Graphics.Canvas canvas, int width, int height) { if (this.Element is FrameApp) { int strokeWidth = (int)TypedValue.ApplyDimension(ComplexUnitType.Dip, 1, Context.Resources.DisplayMetrics); using (var paint = new Paint { AntiAlias = true }) using (var path = new Path()) using (Path.Direction direction = Path.Direction.Cw) using (Paint.Style style = Paint.Style.Stroke) using (var rect = new RectF(strokeWidth + strokeWidth / 2, strokeWidth + strokeWidth / 2, width - strokeWidth - strokeWidth / 2, height - strokeWidth - strokeWidth / 2)) { if (this.Element.CornerRadius > 0) { float rx = this.Context.ToPixels(this.Element.CornerRadius); float ry = this.Context.ToPixels(this.Element.CornerRadius); path.AddRoundRect(rect, rx, ry, direction); } else { path.AddRect(rect, direction); } paint.StrokeWidth = strokeWidth; //set outline stroke paint.SetStyle(style); paint.Color = (this.Element as FrameApp).BorderColor.ToAndroid(); canvas.DrawPath(path, paint); } } }
private void DrawStroke(Canvas canvas) { var stroke = Stroke; if (!HasStroke || stroke is ImageBrush) { return; } var strokeThickness = PhysicalStrokeThickness; using (var strokePaint = new Paint(stroke.GetStrokePaint(_drawArea))) { SetStrokeDashEffect(strokePaint); if (_drawArea.HasZeroArea()) { //Draw the stroke as a fill because the shape has no area strokePaint.SetStyle(Paint.Style.Fill); canvas.DrawCircle((float)(strokeThickness / 2), (float)(strokeThickness / 2), (float)(strokeThickness / 2), strokePaint); } else { strokePaint.StrokeWidth = (float)strokeThickness; canvas.DrawPath(_path, strokePaint); } } }
protected override bool DrawChild(Android.Graphics.Canvas canvas, Android.Views.View child, long drawingTime) { try { var element = (RoundedImage)Element; var radius = Math.Min(Width, Height) / 2; var strokeWidth = 10; radius -= strokeWidth / 2; var path = new Path(); path.AddCircle(Width / 2, Height / 2, radius, Path.Direction.Ccw); canvas.Save(); canvas.ClipPath(path); var result = base.DrawChild(canvas, child, drawingTime); canvas.Restore(); path = new Path(); path.AddCircle(Width / 2, Height / 2, radius, Path.Direction.Ccw); var paint = new Paint(); paint.AntiAlias = true; paint.StrokeWidth = (float)element.BorderWidth; paint.SetStyle(Paint.Style.Stroke); paint.Color = element.BorderColor.ToAndroid(); canvas.DrawPath(path, paint); paint.Dispose(); path.Dispose(); return(result); } catch (Exception ex) { Console.WriteLine(ex.Message); } return(base.DrawChild(canvas, child, drawingTime)); }
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; } }
protected override void OnDraw (Canvas canvas) { drawCanvas = canvas; canvas.DrawBitmap(canvasBitmap, 0, 0, canvasPaint); canvas.DrawPath(drawPath, drawPaint); }
void DrawOutline(ACanvas canvas, int width, int height, Thickness cornerRadius) { var borderThickness = _convertToPixels(_pancake.BorderThickness); var halfBorderThickness = borderThickness / 2; // TODO: This doesn't look entirely right yet when using it with rounded corners. using (var paint = new Paint { AntiAlias = true }) using (var path = new Path()) using (Path.Direction direction = Path.Direction.Cw) using (Paint.Style style = Paint.Style.Stroke) using (var rect = new RectF(halfBorderThickness, halfBorderThickness, width - halfBorderThickness, height - halfBorderThickness)) { float topLeft = _convertToPixels(cornerRadius.Left); float topRight = _convertToPixels(cornerRadius.Top); float bottomRight = _convertToPixels(cornerRadius.Right); float bottomLeft = _convertToPixels(cornerRadius.Bottom); path.AddRoundRect(rect, new float[] { topLeft, topLeft, topRight, topRight, bottomRight, bottomRight, bottomLeft, bottomLeft }, direction); if (_pancake.BorderIsDashed) { paint.SetPathEffect(new DashPathEffect(new float[] { 10, 20 }, 0)); } paint.StrokeCap = Paint.Cap.Round; paint.StrokeWidth = borderThickness; paint.SetStyle(style); paint.Color = _pancake.BorderColor.ToAndroid(); canvas.DrawPath(path, paint); } }
protected override void OnDraw (Canvas canvas) { if (this.currentPath == null || this.currentPath.IsEmpty) return; canvas.DrawPath (this.currentPath, this.currentPaint); }
private void DrawBorder(ACanvas canvas, PancakeView control) { var borderThickness = Context.ToPixels(control.BorderThickness); var halfBorderThickness = borderThickness / 2; // TODO: This doesn't look entirely right yet when using it with rounded corners. using (var paint = new Paint { AntiAlias = true }) using (var path = new Path()) using (Path.Direction direction = Path.Direction.Cw) using (Paint.Style style = Paint.Style.Stroke) using (var rect = new RectF(control.DrawBorderOnOutside && !control.HasShadow ? -halfBorderThickness : halfBorderThickness, control.DrawBorderOnOutside && !control.HasShadow ? -halfBorderThickness : halfBorderThickness, control.DrawBorderOnOutside && !control.HasShadow ? canvas.Width + halfBorderThickness : canvas.Width - halfBorderThickness, control.DrawBorderOnOutside && !control.HasShadow ? canvas.Height + halfBorderThickness : canvas.Height - halfBorderThickness)) { path.AddRoundRect(rect, GetRadii(control), direction); if (control.BorderIsDashed) { paint.SetPathEffect(new DashPathEffect(new float[] { 10, 20 }, 0)); } paint.StrokeCap = Paint.Cap.Square; paint.StrokeWidth = borderThickness; paint.SetStyle(style); paint.Color = control.BorderColor.ToAndroid(); canvas.DrawPath(path, paint); } }
void DrawBackground(ACanvas canvas, int width, int height, float cornerRadius, bool pressed) { using (var paint = new Paint { AntiAlias = true }) using (var path = new APath()) using (APath.Direction direction = APath.Direction.Cw) using (Paint.Style style = Paint.Style.Fill) using (var rect = new RectF(0, 0, width, height)) { float rx = _convertToPixels(cornerRadius); float ry = _convertToPixels(cornerRadius); path.AddRoundRect(rect, rx, ry, direction); paint.SetStyle(style); if (!Brush.IsNullOrEmpty(_frame.Background)) { Brush background = _frame.Background; paint.UpdateBackground(background, height, width); } else { global::Android.Graphics.Color color = _frame.BackgroundColor.ToAndroid(); paint.Color = color; } canvas.DrawPath(path, paint); } }
protected override bool DrawChild(Canvas canvas, global::Android.Views.View child, long drawingTime) { try { var radius = Math.Min(Width, Height) / 2; var strokeWidth = 10; radius -= strokeWidth / 2; //Create path to clip var path = new Path(); path.AddCircle(Width / 2, Height / 2, radius, Path.Direction.Ccw); canvas.Save(); canvas.ClipPath(path); var result = base.DrawChild(canvas, child, drawingTime); canvas.Restore(); // Create path for circle border path = new Path(); path.AddCircle(Width / 2, Height / 2, radius, Path.Direction.Ccw); var paint = new Paint(); paint.AntiAlias = true; paint.StrokeWidth = 5; paint.SetStyle(Paint.Style.Stroke); paint.Color = global::Android.Graphics.Color.White; canvas.DrawPath(path, paint); //Properly dispose paint.Dispose(); path.Dispose(); return result; } catch (Exception ex) { Console.WriteLine("Unable to create circle image: " + ex); } return base.DrawChild(canvas, child, drawingTime); }
void DrawBackground(ACanvas canvas, int width, int height, CornerRadius cornerRadius, bool pressed) { using (Paint paint = new Paint { AntiAlias = true }) using (Path.Direction direction = Path.Direction.Cw) using (Paint.Style style = Paint.Style.Fill) { Path path = new Path(); using (RectF rect = new RectF(0, 0, width, height)) { float topLeft = this._convertToPixels(cornerRadius.TopLeft); float topRight = this._convertToPixels(cornerRadius.TopRight); float bottomRight = this._convertToPixels(cornerRadius.BottomRight); float bottomLeft = this._convertToPixels(cornerRadius.BottomLeft); if (!this._corneredContentView.HasShadow) { path.AddRoundRect(rect, new float[] { topLeft, topLeft, topRight, topRight, bottomRight, bottomRight, bottomLeft, bottomLeft }, direction); } else { path.AddRoundRect(rect, new float[] { topLeft, topLeft, topLeft, topLeft, topLeft, topLeft, topLeft, topLeft }, direction); } } global::Android.Graphics.Color color = this._corneredContentView.BackgroundColor.ToAndroid(); paint.SetStyle(style); paint.Color = color; canvas.DrawPath(path, paint); } }
void DrawBackground(ACanvas canvas, int width, int height, float cornerRadius, bool pressed) { using (var paint = new Paint { AntiAlias = true }) using (var path = new Path()) using (Path.Direction direction = Path.Direction.Cw) using (Paint.Style style = Paint.Style.Fill) using (var rect = new RectF( _bounds + _boundsDiff + _contentBounds, _bounds + _boundsDiff + _contentBounds, width - (_bounds + _boundsDiff + _contentBounds), height - (_bounds + _boundsDiff + _contentBounds))) { float rx = _convertToPixels(cornerRadius); float ry = _convertToPixels(cornerRadius); path.AddRoundRect(rect, rx, ry, direction); global::Android.Graphics.Color color = _frame.BackgroundColor.ToAndroid(); paint.SetStyle(style); paint.Color = color; canvas.DrawPath(path, paint); } }
void DrawOutline(ACanvas canvas, int width, int height, float cornerRadius) { using (var paint = new Paint { AntiAlias = true }) using (var path = new Path()) using (Path.Direction direction = Path.Direction.Cw) using (Paint.Style style = Paint.Style.Stroke) using (var rect = new RectF(left: _bounds, top: _bounds, right: width - _bounds, bottom: height - _bounds)) using (var innerRect = new RectF( left: _bounds + _boundsDiff, top: _bounds + _boundsDiff, right: width - (_bounds + _boundsDiff), bottom: height - (_bounds + _boundsDiff))) { float rx = _convertToPixels(cornerRadius); float ry = _convertToPixels(cornerRadius); path.AddRoundRect(rect, rx, ry, direction); path.AddRoundRect(innerRect, rx, ry, direction); paint.StrokeWidth = _frameThickness; paint.SetStyle(style); paint.Color = _frame.BorderColor.ToAndroid(); canvas.DrawPath(path, paint); } }
public void parse(SVGProperties pSVGProperties, Canvas pCanvas, SVGPaint pSVGPaint) { Path path = this.parse(pSVGProperties); bool fill = pSVGPaint.setFill(pSVGProperties); if (fill) { pCanvas.DrawPath(path, pSVGPaint.getPaint()); } bool stroke = pSVGPaint.setStroke(pSVGProperties); if (stroke) { pCanvas.DrawPath(path, pSVGPaint.getPaint()); } if(fill || stroke) { pSVGPaint.ensureComputedBoundsInclude(path); } }
protected override void OnDraw(Canvas canvas) { base.OnDraw(canvas); DrawPaint.Color = CurrentLineColor; canvas.DrawBitmap(CanvasBitmap, 0, 0, CanvasPaint); canvas.DrawPath(DrawPath, DrawPaint); }
protected override void OnDraw(Android.Graphics.Canvas canvas) { var rect = new Rect(); this.GetDrawingRect(rect); Paint paint; // circleDotFill if (Element.Active) { RectF circleDotFillRect = new RectF( rect.Left + 1f, rect.Top + 1f, rect.Right - 1f, rect.Bottom - 1f); Path circleDotFillPath = new Path(); circleDotFillPath.AddOval(circleDotFillRect, Path.Direction.Cw); paint = new Paint(PaintFlags.AntiAlias); paint.SetStyle(Paint.Style.Fill); paint.Color = Element.FillColor.ToAndroid(); canvas.DrawPath(circleDotFillPath, paint); } // circleDotStroke RectF circleDotStrokeRect = new RectF( rect.Left + 1f, rect.Top + 1f, rect.Right - 1f, rect.Bottom - 1f); Path circleDotStrokePath = new Path(); circleDotStrokePath.AddOval(circleDotStrokeRect, Path.Direction.Cw); paint = new Paint(PaintFlags.AntiAlias); paint.StrokeWidth = 2.5f; paint.StrokeMiter = 10f; canvas.Save(); paint.SetStyle(Paint.Style.Stroke); paint.Color = Element.StrokeColor.ToAndroid(); canvas.DrawPath(circleDotStrokePath, paint); canvas.Restore(); }
private void ShowPath(Canvas canvas, int x, int y, Path.FillType ft, Paint paint) { canvas.Save(); canvas.Translate(x, y); canvas.ClipRect(0, 0, 120, 120); canvas.DrawColor(Color.White); mPath.SetFillType(ft); canvas.DrawPath(mPath, paint); canvas.Restore(); }
protected override void OnDraw(Android.Graphics.Canvas canvas) { var rect = new Rect(); this.GetDrawingRect(rect); Paint paint; var halfThickness = Element.StrokeThickness / 2f; var ellipseRect = new RectF( rect.Left + halfThickness, rect.Top + halfThickness, rect.Right - halfThickness, rect.Bottom - halfThickness); // circleDotFill if (Element.Fill.A != 0) { var circleDotFillPath = new Path(); circleDotFillPath.AddOval(ellipseRect, Path.Direction.Cw); paint = new Paint(PaintFlags.AntiAlias); paint.SetStyle(Paint.Style.Fill); paint.Color = Element.Fill.ToAndroid(); canvas.DrawPath(circleDotFillPath, paint); } // circleDotStroke Path circleDotStrokePath = new Path(); circleDotStrokePath.AddOval(ellipseRect, Path.Direction.Cw); 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(circleDotStrokePath, paint); canvas.Restore(); }
protected override void Draw(Canvas canvas, Rect bounds) { int saveCount = canvas.Save(); RectF arcBounds = mTempBounds; arcBounds.Set(bounds); mPaint.Color = new Color(mColor); mPaint.SetStyle(Paint.Style.Stroke); canvas.DrawPath(CreateLeftEyeCircle(arcBounds, mLeftEyeCircleOffsetY), mPaint); canvas.DrawPath(CreateRightEyeCircle(arcBounds, mRightEyeCircleOffsetY), mPaint); mPaint.SetStyle(Paint.Style.Fill); //create left eye ball canvas.DrawOval(CreateLeftEyeBall(arcBounds, mLeftEyeBallOffsetY), mPaint); //create right eye ball canvas.DrawOval(CreateRightEyeBall(arcBounds, mRightEyeBallOffsetY), mPaint); canvas.RestoreToCount(saveCount); }
protected override void OnDraw (Canvas canvas) { base.OnDraw (canvas); float l = 0; float t = Height - PaddingBottom - DipToPixels (Context, 217); float r = Width - PaddingRight; float b = Height - DipToPixels (Context, 60); canvas.DrawRect (l, t, r, b, boxPaint); canvas.DrawPath (path, pathPaint); }
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 DrawBackground(ACanvas canvas, Path path, bool pressed) { using (var paint = new Paint { AntiAlias = true }) using (var style = Paint.Style.Fill) { paint.SetStyle(style); paint.Color = _frame.BackgroundColor.ToAndroid(); canvas.DrawPath(path, paint); } }
public static void parse(SVGProperties pSVGProperties, Canvas pCanvas, SVGPaint pSVGPaint) { var points = pSVGProperties.GetStringAttribute(SVGConstants.ATTRIBUTE_POINTS).ParseFloats (); if (points != null) { if (points.Length >= 2) { Path path = SVGPolylineParser.parse(points); bool fill = pSVGPaint.setFill(pSVGProperties); if (fill) { pCanvas.DrawPath(path, pSVGPaint.getPaint()); } bool stroke = pSVGPaint.setStroke(pSVGProperties); if (stroke) { pCanvas.DrawPath(path, pSVGPaint.getPaint()); } if(fill || stroke) { pSVGPaint.ensureComputedBoundsInclude(path); } } } }
/// <summary> /// Redraws the child. /// </summary> protected override bool DrawChild(Canvas canvas, global::Android.Views.View child, long drawingTime) { try { var radius = (float)((RoundedImage)Element).BorderRadius; var stroke = (float)((RoundedImage)Element).BorderThickness; var delta = (float)stroke / 2.0f; if (radius < 0) { radius = Math.Min(Width, Height) / 2.0f; } radius -= delta; // Clip with rounded rect var path = new Path(); path.AddRoundRect(new RectF(delta, delta, Width - stroke, Height - stroke), radius, radius, Path.Direction.Ccw); canvas.Save(); canvas.ClipPath(path); path.Dispose(); var result = base.DrawChild(canvas, child, drawingTime); canvas.Restore(); // Add stroke for smoother border path = new Path(); path.AddRoundRect(new RectF(delta, delta, Width - stroke, Height - stroke), radius, radius, Path.Direction.Ccw); var paint = new Paint(); paint.AntiAlias = true; paint.StrokeWidth = stroke; paint.SetStyle(Paint.Style.Stroke); paint.Color = ((RoundedImage)Element).BorderColor.ToAndroid(); canvas.DrawPath(path, paint); paint.Dispose(); // Clean up path.Dispose(); return result; } catch (Exception ex) { System.Diagnostics.Debug.WriteLine("Unable to create circle image: " + ex); } return base.DrawChild(canvas, child, drawingTime); }
protected override void Draw(Canvas canvas, Rect bounds) { int SaveCount = canvas.Save(); RectF arcBounds = mCurrentBounds; arcBounds.Set(bounds); //Draw background canvas.DrawColor(new Color(mCurrentBackgroundColor)); //Draw reveal circle if (mRevealCircleRadius > 0) { mPaint.Color = new Color(mCurrentBackgroundColor == mBackgroundColor ? mBackgroundDeepColor : mBackgroundColor); canvas.DrawCircle(arcBounds.CenterX(), arcBounds.CenterY(), mRevealCircleRadius, mPaint); } //Draw mother oval mPaint.Color = new Color(mCurrentOvalColor); int motherSaveCount = canvas.Save(); canvas.Rotate(mRotateDegrees, mMotherPosition[0], mMotherPosition[1]); canvas.DrawPath(CreateMotherPath(), mPaint); canvas.DrawPath(CreateLinkPath(), mPaint); canvas.RestoreToCount(motherSaveCount); int childSaveCount = canvas.Save(); canvas.Rotate(mRotateDegrees, mChildPosition[0], mChildPosition[1]); canvas.DrawPath(CreateChildPath(), mPaint); canvas.RestoreToCount(childSaveCount); canvas.RestoreToCount(SaveCount); // canvas.DrawPath(mMotherMovePath, mPaint); // canvas.DrawPath(mChildMovePath, mPaint); // canvas.DrawLine(mMotherPosition[0], mMotherPosition[1], mChildPosition[0], mChildPosition[1], mPaint); }
void DrawBackground(ACanvas canvas, int width, int height, CornerRadius cornerRadius) { using (var paint = new Paint { AntiAlias = true }) using (Path.Direction direction = Path.Direction.Cw) using (Paint.Style style = Paint.Style.Fill) { var path = new Path(); if (_pancake.Sides != 4) { path = DrawingExtensions.CreatePolygonPath(width, height, _pancake.Sides, _pancake.CornerRadius.TopLeft, _pancake.OffsetAngle); } else { float topLeft = _convertToPixels(cornerRadius.TopLeft); float topRight = _convertToPixels(cornerRadius.TopRight); float bottomRight = _convertToPixels(cornerRadius.BottomRight); float bottomLeft = _convertToPixels(cornerRadius.BottomLeft); path = DrawingExtensions.CreateRoundedRectPath(width, height, topLeft, topRight, bottomRight, bottomLeft); } if (_pancake.BackgroundGradientStops != null && _pancake.BackgroundGradientStops.Any()) { // A range of colors is given. Let's add them. var orderedStops = _pancake.BackgroundGradientStops.OrderBy(x => x.Offset).ToList(); var colors = orderedStops.Select(x => x.Color.ToAndroid().ToArgb()).ToArray(); var locations = orderedStops.Select(x => x.Offset).ToArray(); var shader = new LinearGradient((float)(canvas.Width * _pancake.BackgroundGradientStartPoint.X), (float)(canvas.Height * _pancake.BackgroundGradientStartPoint.Y), (float)(canvas.Width * _pancake.BackgroundGradientEndPoint.X), (float)(canvas.Height * _pancake.BackgroundGradientEndPoint.Y), colors, locations, Shader.TileMode.Clamp); paint.SetShader(shader); } else { global::Android.Graphics.Color color = _pancake.BackgroundColor.ToAndroid(); paint.SetStyle(style); paint.Color = color; } canvas.DrawPath(path, paint); } }
private void DrawBackground(ACanvas canvas, int width, int height, CornerRadius cornerRadius, bool pressed) { using (var paint = new Paint { AntiAlias = true }) using (var path = PolygonUitls.RegularPolygonPath(width, height, _polygonFrame.Sides, _polygonFrame.CornerRadius, 0, _polygonFrame.OffsetAngle)) using (Paint.Style style = Paint.Style.Fill) { global::Android.Graphics.Color color = _polygonFrame.BackgroundColor.ToAndroid(); paint.SetStyle(style); paint.Color = color; canvas.DrawPath(path, paint); } }
void DrawOutline(ACanvas canvas, Path path) { using (var paint = new Paint { AntiAlias = true }) using (Path.Direction direction = Path.Direction.Cw) using (Paint.Style style = Paint.Style.Stroke) { paint.StrokeWidth = 1; paint.SetStyle(style); paint.Color = _frame.OutlineColor.ToAndroid(); canvas.DrawPath(path, paint); } }
void DrawBackground(ACanvas canvas, Path path, bool pressed) { using (var paint = new Paint { AntiAlias = true }) using (Path.Direction direction = Path.Direction.Cw) using (Paint.Style style = Paint.Style.Fill) { global::Android.Graphics.Color color = _frame.InnerBackground.ToAndroid(); paint.SetStyle(style); paint.Color = color; canvas.DrawPath(path, paint); } }
void DrawBackground(ACanvas canvas, int width, int height, CornerRadius cornerRadius, bool pressed) { using (var paint = new Paint { AntiAlias = true }) using (var path = new Path()) using (Path.Direction direction = Path.Direction.Cw) using (Paint.Style style = Paint.Style.Fill) using (var rect = new RectF(0, 0, width, height)) { float topLeft = _convertToPixels(cornerRadius.TopLeft); float topRight = _convertToPixels(cornerRadius.TopRight); float bottomRight = _convertToPixels(cornerRadius.BottomRight); float bottomLeft = _convertToPixels(cornerRadius.BottomLeft); if (!_pancake.HasShadow) { path.AddRoundRect(rect, new float[] { topLeft, topLeft, topRight, topRight, bottomRight, bottomRight, bottomLeft, bottomLeft }, direction); } else { path.AddRoundRect(rect, new float[] { topLeft, topLeft, topLeft, topLeft, topLeft, topLeft, topLeft, topLeft }, direction); } if (_pancake.BackgroundGradientStartColor != default(Xamarin.Forms.Color) && _pancake.BackgroundGradientEndColor != default(Xamarin.Forms.Color)) { var angle = _pancake.BackgroundGradientAngle / 360.0; // Calculate the new positions based on angle between 0-360. var a = width * Math.Pow(Math.Sin(2 * Math.PI * ((angle + 0.75) / 2)), 2); var b = height * Math.Pow(Math.Sin(2 * Math.PI * ((angle + 0.0) / 2)), 2); var c = width * Math.Pow(Math.Sin(2 * Math.PI * ((angle + 0.25) / 2)), 2); var d = height * Math.Pow(Math.Sin(2 * Math.PI * ((angle + 0.5) / 2)), 2); var shader = new LinearGradient(width - (float)a, (float)b, width - (float)c, (float)d, _pancake.BackgroundGradientStartColor.ToAndroid(), _pancake.BackgroundGradientEndColor.ToAndroid(), Shader.TileMode.Clamp); paint.SetShader(shader); } else { global::Android.Graphics.Color color = _pancake.BackgroundColor.ToAndroid(); paint.SetStyle(style); paint.Color = color; } canvas.DrawPath(path, paint); } }
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)); }
protected void DrawFill(Android.Graphics.Canvas canvas, Windows.Foundation.Rect fillArea, Android.Graphics.Path fillPath) { if (!fillArea.HasZeroArea()) { var imageBrushFill = Fill as ImageBrush; if (imageBrushFill != null) { imageBrushFill.ScheduleRefreshIfNeeded(fillArea, Invalidate); imageBrushFill.DrawBackground(canvas, fillArea, fillPath); } else { var fill = Fill ?? SolidColorBrushHelper.Transparent; var fillPaint = fill.GetFillPaint(fillArea); canvas.DrawPath(fillPath, fillPaint); } } }
protected override bool DrawChild(Canvas canvas, global::Android.Views.View child, long drawingTime) { try { // Extract properties var source = (CircularImage)Element; var borderWidth = source.BorderWidth; var borderColor = source.BorderColor.ToAndroid(); var radius = Math.Min(Width, Height) / 2; var strokeWidth = 10; radius -= strokeWidth / 2; //Create path to clip var path = new Path(); path.AddCircle(Width / 2, Height / 2, radius, Path.Direction.Ccw); canvas.Save(); canvas.ClipPath(path); var result = base.DrawChild(canvas, child, drawingTime); canvas.Restore(); // Create path for circle border path = new Path(); path.AddCircle(Width / 2, Height / 2, radius, Path.Direction.Ccw); var paint = new Paint(); paint.AntiAlias = true; paint.StrokeWidth = borderWidth; paint.SetStyle(Paint.Style.Stroke); paint.Color = borderColor; canvas.DrawPath(path, paint); //Properly dispose paint.Dispose(); path.Dispose(); return result; } catch (Exception ex) { System.Diagnostics.Debug.WriteLine("Unable to create circle image: " + ex); } return base.DrawChild(canvas, child, drawingTime); }
private void DrawFill(Canvas canvas) { if (_drawArea.HasZeroArea()) { return; } if (Fill is ImageBrush imageBrushFill) { imageBrushFill.ScheduleRefreshIfNeeded(_drawArea, Invalidate); imageBrushFill.DrawBackground(canvas, _drawArea, _path); } else { var fill = Fill ?? SolidColorBrushHelper.Transparent; var fillPaint = fill.GetFillPaint(_drawArea); canvas.DrawPath(_path, fillPaint); } }
private void DrawOutline(ACanvas canvas, Path path) { using (var paint = new Paint { AntiAlias = true }) using (var style = Paint.Style.Stroke) { paint.StrokeWidth = (float)_frame.StrokeThickness; paint.SetStyle(style); paint.Color = _frame.BorderColor.ToAndroid(); if (_frame.StrokeDashLength > 0 && _frame.StrokeDashGap > 0) { paint.SetPathEffect(new DashPathEffect(new[] { (float)_frame.StrokeDashLength, (float)_frame.StrokeDashGap }, 0)); } canvas.DrawPath(path, paint); } }
void DrawOutline(ACanvas canvas, int width, int height, float cornerRadius) { using (var paint = new Paint { AntiAlias = true }) using (var path = new Path()) using (Path.Direction direction = Path.Direction.Cw) using (Paint.Style style = Paint.Style.Stroke) using (var rect = new RectF(0, 0, width, height)) { float rx = Forms.Context.ToPixels(cornerRadius); float ry = Forms.Context.ToPixels(cornerRadius); path.AddRoundRect(rect, rx, ry, direction); paint.StrokeWidth = element.OutlineWidth; //set outline stroke paint.SetStyle(style); paint.Color = element.OutlineColor.ToAndroid(); //paint.Color = Color.ParseColor("#A7AE22");//set outline color //_frame.OutlineColor.ToAndroid(); canvas.DrawPath(path, paint); } }
void DrawOutline(ACanvas canvas, int width, int height) { using (var paint = new Paint { AntiAlias = true }) using (var path = new Path()) using (Path.Direction direction = Path.Direction.Cw) using (Paint.Style style = Paint.Style.Stroke) using (var rect = new RectF(0, 0, width, height)) { float rx = Forms.Context.ToPixels(_frame.CornerRadius); float ry = Forms.Context.ToPixels(_frame.CornerRadius); path.AddRoundRect(rect, rx, ry, direction); paint.StrokeWidth = Forms.Context.ToPixels(_frame.BorderWidth); paint.SetStyle(style); paint.Color = _frame.BorderColor.ToAndroid(); canvas.DrawPath(path, paint); } }
void DrawOutline(ACanvas canvas, int width, int height, float cornerRadius) { using (var paint = new Paint { AntiAlias = true }) using (var path = new Path()) using (Path.Direction direction = Path.Direction.Cw) using (Paint.Style style = Paint.Style.Stroke) using (var rect = new RectF(0, 0, width, height)) { float rx = Forms.Context.ToPixels(cornerRadius); float ry = Forms.Context.ToPixels(cornerRadius); path.AddRoundRect(rect, rx, ry, direction); paint.StrokeWidth = 2f; paint.SetStyle(style); paint.Color = Color.ParseColor("#4CAF50"); canvas.DrawPath(path, paint); } }
protected override bool DrawChild(Android.Graphics.Canvas canvas, Android.Views.View child, long drawingTime) { try { var radius = Math.Min(Width, Height) / 2; var strokeWidth = 10; radius -= strokeWidth / 2; //Create path to clip var path = new Path(); path.AddCircle(Width / 2, Height / 2, radius, Path.Direction.Ccw); canvas.Save(); canvas.ClipPath(path); var result = base.DrawChild(canvas, child, drawingTime); canvas.Restore(); // Create path for circle border path = new Path(); path.AddCircle(Width / 2, Height / 2, radius, Path.Direction.Ccw); var paint = new Paint(); paint.AntiAlias = true; paint.StrokeWidth = 5; paint.SetStyle(Paint.Style.Stroke); paint.Color = global::Android.Graphics.Color.White; canvas.DrawPath(path, paint); //Properly dispose paint.Dispose(); path.Dispose(); return(result); } catch (Exception) { } return(base.DrawChild(canvas, child, drawingTime)); }
/// <summary> /// /// </summary> /// <param name="canvas"></param> /// <param name="child"></param> /// <param name="drawingTime"></param> /// <returns></returns> protected override bool DrawChild(Canvas canvas, global::Android.Views.View child, long drawingTime) { try { var radius = Math.Min(Width, Height) / 2; var strokeWidth = 10; radius -= strokeWidth / 2; Path path = new Path(); path.AddCircle(Width / 2, Height / 2, radius, Path.Direction.Ccw); canvas.Save(); canvas.ClipPath(path); var result = base.DrawChild(canvas, child, drawingTime); canvas.Restore(); path = new Path(); path.AddCircle(Width / 2, Height / 2, radius, Path.Direction.Ccw); var paint = new Paint(); paint.AntiAlias = true; paint.StrokeWidth = ((CircleImage)Element).BorderThickness; paint.SetStyle(Paint.Style.Stroke); paint.Color = ((CircleImage)Element).BorderColor.ToAndroid(); canvas.DrawPath(path, paint); paint.Dispose(); path.Dispose(); return result; } catch (Exception ex) { System.Diagnostics.Debug.WriteLine("Unable to create circle image: " + ex); } return base.DrawChild(canvas, child, drawingTime); }
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); }
protected override bool DrawChild(Canvas canvas, global::Android.Views.View child, long drawingTime) { try { var radius = Math.Min(Width, Height) / 2; var strokeWidth = 10; radius -= strokeWidth / 2; Path path = new Path(); path.AddCircle(Width / 2, Height / 2, radius, Path.Direction.Ccw); canvas.Save(); canvas.ClipPath(path); var result = base.DrawChild(canvas, child, drawingTime); canvas.Restore(); path = new Path(); path.AddCircle(Width / 2, Height / 2, radius, Path.Direction.Ccw); var paint = new Paint(); paint.AntiAlias = true; paint.StrokeWidth = 5; paint.SetStyle(Paint.Style.Stroke); paint.Color = global::Android.Graphics.Color.White; canvas.DrawPath(path, paint); paint.Dispose(); path.Dispose(); return result; } catch (Exception ex) { } return base.DrawChild(canvas, child, drawingTime); }
protected override void OnDraw (Canvas canvas) { base.OnDraw (canvas); var width = canvas.Width; var height = canvas.Height; // Center the canvas canvas.Translate (width / 2f, height / 2f); if (slicePath.IsEmpty) { if (startAngle == 0 && endAngle == 360) { slicePath.AddCircle (0, 0, radius - thickness, Path.Direction.Cw); slicePath.AddCircle (0, 0, radius, Path.Direction.Ccw); slicePath.Close (); } else { // Inner arc rect.Set (-radius + thickness, -radius + thickness, radius - thickness, radius - thickness); slicePath.ArcTo (rect, -90 + startAngle, endAngle - startAngle); // Outer arc rect.Set (-radius, -radius, radius, radius); slicePath.ArcTo (rect, -90 + endAngle, startAngle - endAngle); slicePath.Close (); } } canvas.DrawPath (slicePath, slicePaint); }
private void DrawTriangle(Canvas c, float startAngle, float sweepAngle, Rect bounds) { if (mShowArrow) { if (mArrow == null) { mArrow = new Path(); mArrow.SetFillType(Path.FillType.EvenOdd); } else { mArrow.Reset(); } float x = (float)(RingCenterRadius * Math.Cos(0) + bounds.ExactCenterX()); float y = (float)(RingCenterRadius * Math.Sin(0) + bounds.ExactCenterY()); mArrow.MoveTo(0, 0); mArrow.LineTo((mArrowWidth) * mArrowScale, 0); mArrow.LineTo(((mArrowWidth) * mArrowScale / 2), (mArrowHeight * mArrowScale)); mArrow.Offset(x - ((mArrowWidth) * mArrowScale / 2), y); mArrow.Close(); mArrowPaint.Color = mColors[mColorIndex]; c.Rotate(startAngle + (sweepAngle < 0 ? 0 : sweepAngle) - ARROW_OFFSET_ANGLE, bounds.ExactCenterX(), bounds.ExactCenterY()); c.DrawPath(mArrow, mArrowPaint); } }
protected override void OnDraw (Canvas canvas) { base.OnDraw (canvas); // Clear screen to pink. paint.Color = new Color (255, 204, 204); canvas.DrawPaint (paint); // Overall transforms to shift (0, 0) to center and scale. canvas.Translate (this.Width / 2, this.Height / 2); float scale = Math.Min (this.Width, this.Height) / 2.0f / 100; canvas.Scale (scale, scale); // Attributes for tick marks. paint.Color = Color.Black; paint.StrokeCap = Paint.Cap.Round; paint.SetStyle (Paint.Style.Stroke); // Set line dash to draw tick marks for every minute. paint.StrokeWidth = 3; paint.SetPathEffect (minuteTickDashEffect); canvas.DrawPath (tickMarks, paint); // Set line dash to draw tick marks for every hour. paint.StrokeWidth = 6; paint.SetPathEffect (hourTickDashEffect); canvas.DrawPath (tickMarks, paint); // Set attributes common to all clock hands. Color strokeColor = Color.Black; Color fillColor = Color.Blue; paint.StrokeWidth = 2; paint.SetPathEffect (null); // Draw hour hand. canvas.Save (); canvas.Rotate (this.hourAngle); paint.Color = fillColor; paint.SetStyle (Paint.Style.Fill); canvas.DrawPath (hourHand, paint); paint.Color = strokeColor; paint.SetStyle (Paint.Style.Stroke); canvas.DrawPath (hourHand, paint); canvas.Restore (); // Draw minute hand. canvas.Save (); canvas.Rotate (this.minuteAngle); paint.Color = fillColor; paint.SetStyle (Paint.Style.Fill); canvas.DrawPath (minuteHand, paint); paint.Color = strokeColor; paint.SetStyle (Paint.Style.Stroke); canvas.DrawPath (minuteHand, paint); canvas.Restore (); // Draw second hand. canvas.Save (); canvas.Rotate (this.secondAngle); paint.Color = strokeColor; paint.SetStyle (Paint.Style.Stroke); canvas.DrawPath (secondHand, paint); canvas.Restore (); }
private void DrawStrokesOnCanvas (Canvas canvas, Color strokeColor, Color fillColor, bool shouldCrop, RectF croppedRectangle = null) { canvas.DrawColor (fillColor); paint.Color = strokeColor; foreach (var path in paths) { var tempPath = path; if (shouldCrop) { tempPath = new Path (path); var translate = new Matrix (); translate.SetTranslate (-croppedRectangle.Left, -croppedRectangle.Top); tempPath.Transform (translate); } canvas.DrawPath (tempPath, paint); tempPath = null; } paint.Color = this.strokeColor; }
void DrawHexagon (Canvas canvas) { // The extra padding is to avoid edges being clipped var padding = (int)TypedValue.ApplyDimension (ComplexUnitType.Dip, 8, Resources.DisplayMetrics); var halfHeight = (Height - padding) / 2; var side = (Width - padding) / 2; var foo = (int)Math.Sqrt (side * side - halfHeight * halfHeight); var path = hexagon ?? (hexagon = new Path ()); hexagon.Reset (); path.MoveTo (Width / 2, padding / 2); path.RLineTo (-side / 2, 0); path.RLineTo (-foo, halfHeight); path.RLineTo (foo, halfHeight); path.RLineTo (side, 0); path.RLineTo (foo, -halfHeight); path.RLineTo (-foo, -halfHeight); path.Close (); var m = transformationMatrix ?? (transformationMatrix = new Matrix ()); m.Reset (); var centerX = Width / 2; var centerY = Height / 2; m.PostRotate (Rotation, centerX, centerY); m.PostScale (ScaleX, ScaleY, centerX, centerY); path.Transform (m); if (hexagonPaint == null) { hexagonPaint = new Paint { Color = new Android.Graphics.Color (0x22, 0x76, 0xB9), AntiAlias = true, }; hexagonPaint.SetPathEffect (new CornerPathEffect (30)); } canvas.DrawPath (path, hexagonPaint); }
protected override void OnDraw(Canvas canvas) { Paint paint = mPaint; canvas.DrawColor (Color.White); paint.AntiAlias = true; paint.Color = Color.Black; paint.SetStyle (Paint.Style.Fill); int w = canvas.Width; int h = canvas.Height; int cx = w / 2; int cy = h / 2; canvas.Translate (cx, cy); if (compass.mValues != null) canvas.Rotate (-compass.mValues[0]); canvas.DrawPath (mPath, mPaint); }
protected override void OnDraw(Canvas canvas) { canvas.DrawColor(Color.Transparent); paint.Reset(); paint.AntiAlias = true; float midX, midY, radius, innerRadius; path.Reset(); float currentAngle = 270; float currentSweep; float totalValue = 0; float padding = 2; midX = Width / 2; midY = Height/2; if (midX < midY){ radius = midX; } else { radius = midY; } radius -= padding; innerRadius = radius - thickness; foreach (PieSlice slice in slices) { totalValue += slice.getValue(); } int count = 0; foreach (PieSlice slice in slices) { Path p = new Path(); paint.Color = slice.getColor (); currentSweep = (slice.getValue()/totalValue)*(360); p.ArcTo(new RectF(midX-radius, midY-radius, midX+radius, midY+radius), currentAngle+padding, currentSweep - padding); p.ArcTo(new RectF(midX-innerRadius, midY-innerRadius, midX+innerRadius, midY+innerRadius), (currentAngle+padding) + (currentSweep - padding), -(currentSweep-padding)); p.Close (); slice.setPath(p); slice.setRegion(new Region((int)(midX-radius), (int)(midY-radius), (int)(midX+radius), (int)(midY+radius))); canvas.DrawPath(p, paint); if (indexSelected == count && listener != null){ path.Reset(); paint.Color = slice.getColor (); paint.Color = Color.ParseColor ("#33B5E5"); paint.Alpha=100; if (slices.Count > 1) { path.ArcTo(new RectF(midX-radius-(padding*2), midY-radius-(padding*2), midX+radius+(padding*2), midY+radius+(padding*2)), currentAngle, currentSweep+padding); path.ArcTo(new RectF(midX-innerRadius+(padding*2), midY-innerRadius+(padding*2), midX+innerRadius-(padding*2), midY+innerRadius-(padding*2)), currentAngle + currentSweep + padding, -(currentSweep + padding)); path.Close(); } else { path.AddCircle(midX, midY, radius+padding, Android.Graphics.Path.Direction.Cw); } canvas.DrawPath(path, paint); paint.Alpha=255; } currentAngle = currentAngle+currentSweep; count++; } }
void DrawCross (Canvas canvas) { var smallSegment = Width / 6; var path = cross ?? (cross = new Path ()); cross.Reset (); path.MoveTo (0, 0); path.RLineTo (smallSegment, 0); path.LineTo (Width / 2, Height / 2); path.LineTo (Width - smallSegment, 0); path.RLineTo (smallSegment, 0); path.LineTo (Width / 2 + smallSegment, Height / 2); path.LineTo (Width, Height); path.RLineTo (-smallSegment, 0); path.LineTo (Width / 2, Height / 2); path.LineTo (smallSegment, Height); path.RLineTo (-smallSegment, 0); path.LineTo (Width / 2 - smallSegment, Height / 2); path.Close (); if (crossPaint == null) { crossPaint = new Paint { AntiAlias = true, Color = Android.Graphics.Color.White }; } canvas.DrawPath (path, crossPaint); }
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; } }
protected override void OnDraw(Canvas canvas) { // draw grid lines mPaint.Color = new Color(255, 0, 0); mPaint.StrokeWidth = 1; for ( float y = GRID_GAP; y < canvas.Height; y += GRID_GAP) { gridpath.Reset (); gridpath.MoveTo (0, y); gridpath.LineTo (canvas.Width, y); canvas.DrawPath(gridpath, mPaint); } mPaint.Color = new Color(0, 0, 255); mPaint.StrokeWidth = 3; // draw strokes foreach(var aMPathList in mPathList) { canvas.DrawPath(aMPathList, mPaint); } canvas.DrawPath(mPath, mPaint); }
public void Draw(Canvas canvas) { if (Hidden) { return; } canvas.Save(); if (!Focused) { outlinePaint.Color = Color.White; canvas.DrawRect(DrawRect, outlinePaint); } 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(); path.AddRect(new RectF(DrawRect), Path.Direction.Cw); canvas.ClipPath(path, Region.Op.Difference); canvas.DrawRect(viewDrawingRect, focusPaint); canvas.Restore(); canvas.DrawPath(path, outlinePaint); if (mode == ModifyMode.Grow) { int left = DrawRect.Left + 1; int right = DrawRect.Right + 1; int top = DrawRect.Top + 4; int bottom = DrawRect.Bottom + 3; int widthWidth = resizeDrawableWidth.IntrinsicWidth / 2; int widthHeight = resizeDrawableWidth.IntrinsicHeight / 2; int heightHeight = resizeDrawableHeight.IntrinsicHeight / 2; int heightWidth = resizeDrawableHeight.IntrinsicWidth / 2; int xMiddle = DrawRect.Left + ((DrawRect.Right - DrawRect.Left) / 2); int yMiddle = DrawRect.Top + ((DrawRect.Bottom - DrawRect.Top) / 2); resizeDrawableWidth.SetBounds(left - widthWidth, yMiddle - widthHeight, left + widthWidth, yMiddle + widthHeight); resizeDrawableWidth.Draw(canvas); resizeDrawableWidth.SetBounds(right - widthWidth, yMiddle - widthHeight, right + widthWidth, yMiddle + widthHeight); resizeDrawableWidth.Draw(canvas); resizeDrawableHeight.SetBounds(xMiddle - heightWidth, top - heightHeight, xMiddle + heightWidth, top + heightHeight); resizeDrawableHeight.Draw(canvas); resizeDrawableHeight.SetBounds(xMiddle - heightWidth, bottom - heightHeight, xMiddle + heightWidth, bottom + heightHeight); resizeDrawableHeight.Draw(canvas); } } }
protected override void OnDraw(Canvas canvas) { base.OnDraw(canvas); if(null == _viewPager) return; var count = _viewPager.Adapter.Count; if(0 == count) return; if(-1 == _currentPage && _viewPager != null) _currentPage = _viewPager.CurrentItem; var bounds = CalculateAllBounds(_paintText); var boundsSize = bounds.Count; if(_currentPage >= boundsSize) { CurrentItem = boundsSize - 1; return; } var countMinusOne = count - 1; var halfWidth = Width / 2f; var leftClip = Left + ClipPadding; var right = Left + Width; var rightClip = right - ClipPadding; var height = Height; var left = Left; var page = _currentPage; float offsetPercent; if(_pageOffset <= 0.5) offsetPercent = _pageOffset; else { page += 1; offsetPercent = 1 - _pageOffset; } var currentSelected = (offsetPercent <= SelectionFadePercentage); var currentBold = (offsetPercent <= BoldFadePercentage); var selectedPercent = (SelectionFadePercentage - offsetPercent) / SelectionFadePercentage; //Verify if the current view must be clipped to the screen var curPageBound = bounds[_currentPage]; var curPageWidth = curPageBound.Right - curPageBound.Left; if(curPageBound.Left < leftClip) ClipViewOnTheLeft(curPageBound, curPageWidth, left); if(curPageBound.Right > rightClip) ClipViewOnTheRight(curPageBound, curPageWidth, right); //Left view is starting from the current position if(_currentPage > 0) { for(var i = _currentPage - 1; i >= 0; i--) { var bound = bounds[i]; //Is left side outside the screen? if(bound.Left < leftClip) { var w = bound.Right - bound.Left; //Clip to the left screen side ClipViewOnTheLeft(bound, w, left); var rightBound = bounds[i + 1]; //Except if there is an intersection with the right view if(bound.Right + TitlePadding > rightBound.Left) { bound.Left = (int)(rightBound.Left - w - TitlePadding); bound.Right = bound.Left + w; } } } } //Right view is starting from the current position if(_currentPage < countMinusOne) { for(var i = _currentPage + 1; i < count; i++) { var bound = bounds[i]; //Is right side outside the screen? if(bound.Right > rightClip) { var w = bound.Right - bound.Left; //Clip to the right screen side ClipViewOnTheRight(bound, w, Right); var leftBound = bounds[i - 1]; //Except if there is an intersection with the left view if(bound.Left - TitlePadding < leftBound.Right) { bound.Left = (int)(leftBound.Right + TitlePadding); bound.Right = bound.Left + w; } } } } //Now draw views! var colorTextAlpha = _colorText >> 24; for(var i = 0; i < count; i++) { //Get the title var bound = bounds[i]; //Only if one side is visible if((bound.Left > left && bound.Left < right) || (bound.Right > left && bound.Right < right)) { var currentPage = (i == page); var pageTitle = GetTitle(i); //Only set bold if we are within bounds _paintText.FakeBoldText = currentPage && currentBold && _boldText; //Draw text as unselected _paintText.Color = _colorText; if(currentPage && currentSelected) //Fade out/in unselected text as the selected text fades in/out _paintText.Alpha = colorTextAlpha - (int)(colorTextAlpha * selectedPercent); //Except if there is an intersection with the right view if(i < boundsSize - 1) { var rightBound = bounds[i + 1]; if(bound.Right + TitlePadding > rightBound.Left) { var w = bound.Right - bound.Left; bound.Left = (int)(rightBound.Left - w - TitlePadding); bound.Right = bound.Left + w; } } canvas.DrawText(pageTitle, 0, pageTitle.Length, bound.Left, bound.Bottom + TopPadding, _paintText); //If we are within the selected bound draw the selected text if(currentPage && currentSelected) { _paintText.Color = _colorSelected; _paintText.Alpha = (int)((_colorSelected >> 24) * selectedPercent); canvas.DrawText(pageTitle, 0, pageTitle.Length, bound.Left, bound.Bottom + TopPadding, _paintText); } } } //If we want the line on the top change height to zero and invert line height to trick the drawing code var footerLineHeight = _footerLineHeight; var footerIndicatorLineHeight = _footerIndicatorHeight; if(_linePosition == LinePosition.Top) { height = 0; footerLineHeight = -footerLineHeight; footerIndicatorLineHeight = -footerIndicatorLineHeight; } //Draw the footer line _path.Reset(); _path.MoveTo(0, height - footerLineHeight / 2f); _path.MoveTo(Width, height - footerLineHeight / 2f); _path.Close(); canvas.DrawPath(_path, _paintFooterLine); var heightMinusLine = height - footerLineHeight; switch(_footerIndicatorStyle) { case IndicatorStyle.Triangle: _path.Reset(); _path.MoveTo(halfWidth, heightMinusLine - footerIndicatorLineHeight); _path.LineTo(halfWidth + footerIndicatorLineHeight, heightMinusLine); _path.LineTo(halfWidth - footerIndicatorLineHeight, heightMinusLine); _path.Close(); canvas.DrawPath(_path, _paintFooterIndicator); break; case IndicatorStyle.Underline: if(!currentSelected || page >= boundsSize) break; var underlineBounds = bounds[page]; var rightPlusPadding = underlineBounds.Right + _footerIndicatorUnderlinePadding; var leftMinusPadding = underlineBounds.Left - _footerIndicatorUnderlinePadding; var heightMinusLineMinusIndicator = heightMinusLine - footerIndicatorLineHeight; _path.Reset(); _path.MoveTo(leftMinusPadding, heightMinusLine); _path.LineTo(rightPlusPadding, heightMinusLine); _path.LineTo(rightPlusPadding, heightMinusLineMinusIndicator); _path.LineTo(leftMinusPadding, heightMinusLineMinusIndicator); _path.Close(); _paintFooterIndicator.Alpha = (int)(0xFF * selectedPercent); canvas.DrawPath(_path, _paintFooterIndicator); _paintFooterIndicator.Alpha = 0xFF; break; } }
/// <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); }
public static Bitmap Draw(int width, int height, double direction) { if(width == 0 || height == 0) return null; int w2 = width / 2; int h2 = height / 2; Paint light = new Paint(PaintFlags.AntiAlias); Paint dark = new Paint(PaintFlags.AntiAlias); Paint black = new Paint(PaintFlags.AntiAlias); light.Color = new Color(128, 0, 0, 255); light.StrokeWidth = 0f; light.SetStyle(Paint.Style.FillAndStroke); dark.Color = new Color(255, 0, 0, 255); dark.StrokeWidth = 0f; dark.SetStyle(Paint.Style.FillAndStroke); black.Color = new Color(0, 0, 0, 255); black.StrokeWidth = 0f; black.SetStyle(Paint.Style.Stroke); // Values of direction are between 0° and 360°, but for drawing we need -180° to +180° direction -= 180; double rad1 = direction / 180.0 * Math.PI; double rad2 = (direction + 180.0 + 30.0) / 180.0 * Math.PI; double rad3 = (direction + 180.0 - 30.0) / 180.0 * Math.PI; double rad4 = (direction + 180.0) / 180.0 * Math.PI; PointF p1 = new PointF((float) (w2 + w2 * Math.Sin (rad1)), (float) (h2 + h2 * Math.Cos (rad1))); PointF p2 = new PointF((float) (w2 + w2 * Math.Sin (rad2)), (float) (h2 + h2 * Math.Cos (rad2))); PointF p3 = new PointF((float) (w2 + w2 * Math.Sin (rad3)), (float) (h2 + h2 * Math.Cos (rad3))); PointF p4 = new PointF((float) (w2 + width / 3 * Math.Sin (rad4)), (float) (h2 + height / 3 * Math.Cos (rad4))); Bitmap b = Bitmap.CreateBitmap(width, height, Bitmap.Config.Argb8888); using(Canvas c = new Canvas(b)) { int cx = c.Width / 2 - 1; int cy = c.Height / 2 - 1; global::Android.Graphics.Path path1 = new global::Android.Graphics.Path (); global::Android.Graphics.Path path2 = new global::Android.Graphics.Path (); global::Android.Graphics.Path path3 = new global::Android.Graphics.Path (); path1.MoveTo (p1.X,p1.Y); path1.LineTo (p2.X,p2.Y); path1.LineTo (p4.X,p4.Y); path1.LineTo (p1.X,p1.Y); path2.MoveTo (p1.X,p1.Y); path2.LineTo (p3.X,p3.Y); path2.LineTo (p4.X,p4.Y); path2.LineTo (p1.X,p1.Y); path3.MoveTo (p1.X,p1.Y); path3.LineTo (p2.X,p2.Y); path3.LineTo (p4.X,p4.Y); path3.LineTo (p1.X,p1.Y); path3.LineTo (p3.X,p3.Y); path3.LineTo (p4.X,p4.Y); light.Color = new Color (128, 0, 0, 255); dark.Color = new Color (255, 0, 0, 255); black.Color = new Color (0, 0, 0, 255); c.DrawPath (path1, light); c.DrawPath (path2, dark); c.DrawPath (path3, black); } return b; }
protected virtual void DrawLineCore(IGeometry line, Paint linePaint, Rect imageRegion, Rect clipBounds, BoundingBox screenBox, MapView mapView, Canvas canvas) { var projection = mapView.Projection; List<GeoPoint> data = Simplify(mapView, ((LineString) line).Vertices); if (Rect.Intersects(imageRegion, clipBounds)) { //long start = System.CurrentTimeMillis(); _path.Reset(); Point currentPoint = null; Point nextPoint = null; for (int i = 0; i < data.Count; i++) { var currentGeoPoint = data[i]; if (!screenBox.Contains(currentGeoPoint)) { if (i + 1 < data.Count) { currentPoint = projection.ToPixels(currentGeoPoint, currentPoint); var nextGeoPoint = data[i + 1]; if (screenBox.Contains(nextGeoPoint)) { nextPoint = projection.ToPixels(nextGeoPoint, null); DrawLine(nextPoint, currentPoint); } } } else { currentPoint = projection.ToPixels(currentGeoPoint, currentPoint); if (ShowPoints) { if (PointPaint == null) { PointPaint = CreatePointPaint(); } canvas.DrawCircle(currentPoint.X, currentPoint.Y, PointPaint.StrokeWidth, PointPaint); } GeoPoint nextGeoPoint = null; if (data.Count > i + 1) { nextGeoPoint = (GeoPoint) data[i + 1]; } if (nextGeoPoint != null) { nextPoint = projection.ToPixels(nextGeoPoint, null); DrawLine(currentPoint, nextPoint); } } } if (_path.IsEmpty) { for (int i = 0; i < data.Count; i++) { GeoPoint currentGeoPoint = data[i]; GeoPoint nextGeoPoint = null; if (data.Count > i + 1) { nextGeoPoint = data[i + 1]; } if (nextGeoPoint != null) { currentPoint = projection.ToPixels(currentGeoPoint, null); nextPoint = projection.ToPixels(nextGeoPoint, null); DrawLine(currentPoint, nextPoint); } } } //long end = System.currentTimeMillis(); #if DEBUG //Log.Debug("com.mapquest.android.maps.lineoverlay", "Time to process shapepoints: " + (float)(end - start) / 1000.0F + "; no. of points: " + data.Count); #endif canvas.DrawPath(_path, LinePaint); #if DEBUG //Log.Debug("com.mapquest.android.maps.lineoverlay", "Time to draw path shapepoints: " + (float)(System.currentTimeMillis() - end) / 1000.0F + "; no. of points: " + data.Count); #endif } }