protected virtual void onPenLineJoinChanged(PenLineJoin join) { if (penLineJoinChanged != null) { penLineJoinChanged(join); } }
/// <summary> /// Returns whether or not an enumeration instance a valid value. /// This method is designed to be used with ValidateValueCallback, and thus /// matches it's prototype. /// </summary> /// <param name="valueObject"> /// Enumeration value to validate. /// </param> /// <returns> 'true' if the enumeration contains a valid value, 'false' otherwise. </returns> public static bool IsPenLineJoinValid(object valueObject) { PenLineJoin value = (PenLineJoin)valueObject; return((value == PenLineJoin.Miter) || (value == PenLineJoin.Bevel) || (value == PenLineJoin.Round)); }
private MIL_PEN_JOIN GetInternalJoinType(PenLineJoin join) { Debug.Assert((MIL_PEN_JOIN)PenLineJoin.Miter == MIL_PEN_JOIN.MilPenJoinMiter); Debug.Assert((MIL_PEN_JOIN)PenLineJoin.Bevel == MIL_PEN_JOIN.MilPenJoinBevel); Debug.Assert((MIL_PEN_JOIN)PenLineJoin.Round == MIL_PEN_JOIN.MilPenJoinRound); return((MIL_PEN_JOIN)join); }
private static void OnStrokeLineJoinChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { LineIndicatorBase indicator = d as LineIndicatorBase; PenLineJoin newValue = (PenLineJoin)e.NewValue; indicator.renderer.strokeShape.StrokeLineJoin = newValue; indicator.OnStrokeLineJoinChanged(newValue); }
/// <summary> /// Initializes a new instance of the <see cref="Pen"/> class. /// </summary> /// <param name="color">The stroke color.</param> /// <param name="thickness">The stroke thickness.</param> /// <param name="dashStyle">The dash style.</param> /// <param name="lineCap">Specifies the type of graphic shape to use on both ends of a line.</param> /// <param name="lineJoin">The line join.</param> /// <param name="miterLimit">The miter limit.</param> public Pen( uint color, double thickness = 1.0, DashStyle dashStyle = null, PenLineCap lineCap = PenLineCap.Flat, PenLineJoin lineJoin = PenLineJoin.Miter, double miterLimit = 10.0) : this(new SolidColorBrush(color), thickness, dashStyle, lineCap, lineJoin, miterLimit) { }
public static T Shape <T>(this T shape, Stretch aspect, Brush fill, Brush stroke, DoubleCollection doubleCollection, double offSet, PenLineCap penLineCap, PenLineJoin penLineJoin, double strokeThickness) where T : Shape { return(shape.Aspect(aspect).Fill(fill) .Stroke(stroke).StrokeDashArray(doubleCollection) .StrokeDashOffset(offSet).StrokeLineCap(penLineCap) .StrokeLineJoin(penLineJoin).StrokeThickness(strokeThickness)); }
public StrokeStyle() { Thickness = 1; StrokeColor = Brushes.Black; DashStyle = null; DashCap = PenLineCap.Flat; StartLineCap = PenLineCap.Flat; EndLineCap = PenLineCap.Flat; LineJoin = PenLineJoin.Miter; }
public static d2.LineJoin ToGdiPlus(this PenLineJoin me) { switch (me) { case PenLineJoin.Bevel: return(d2.LineJoin.Bevel); case PenLineJoin.Round: return(d2.LineJoin.Round); } return(d2.LineJoin.Miter); }
/// <inheritdoc/> public void DrawPolygon(IList <Point> points, Color fillColor, Color strokeColor, double thickness, PenLineJoin lineJoin, ICollection <double> dashArray, double dashOffset, bool aliased, bool isHitTestVisible) { var polygon = Create <Polygon>(isHitTestVisible); polygon.Fill = GetBrush(fillColor); SetStroke(polygon, strokeColor, thickness, lineJoin, dashArray, dashOffset, false); polygon.Points = ToPointCollection(points, aliased); }
public StrokeStyle(Brush strokeColor, double thickness, PenLineCap startLineCap, PenLineCap endLineCap, PenLineJoin lineJoin) : this() { StrokeColor = strokeColor; Thickness = thickness; StartLineCap = startLineCap; EndLineCap = endLineCap; LineJoin = lineJoin; }
/// <inheritdoc/> public void DrawLine(Point p1, Point p2, Color strokeColor, double thickness, PenLineJoin lineJoin, ICollection <double> dashArray, double dashOffset, bool aliased, bool isHitTestVisible) { var line = Create <Line>(isHitTestVisible); SetStroke(line, strokeColor, thickness, lineJoin, dashArray, dashOffset, aliased); line.X1 = p1.X; line.Y1 = p1.Y; line.X2 = p2.X; line.Y2 = p2.Y; }
public CanvasStyle(CanvasPath path, Brush fill, Brush stroke, double strokeWidth, PenLineJoin strokeLineJoin, PenLineCap lineCap, float strokeMiterLimit, double globalAlpha) { _path = path; _fill = fill; _stroke = stroke; _strokeWidth = strokeWidth; _strokeLineJoin = strokeLineJoin; _lineCap = lineCap; _globalAlpha = globalAlpha; _strokeMiterLimit = strokeMiterLimit; }
public StrokeStyle(Brush strokeColor, double thickness, PenLineCap startLineCap, PenLineCap endLineCap, PenLineJoin lineJoin, DashStyle dashStyle, PenLineCap dashCap) : this() { StrokeColor = strokeColor; Thickness = thickness; StartLineCap = startLineCap; EndLineCap = endLineCap; LineJoin = lineJoin; DashStyle = dashStyle; DashCap = dashCap; }
void RenderCore(DrawingContext context, IBrush background, IBrush borderBrush, BoxShadows boxShadows, double borderDashOffset, PenLineCap borderLineCap, PenLineJoin borderLineJoin, AvaloniaList <double> borderDashArray) { if (_useComplexRendering) { var backgroundGeometry = _backgroundGeometryCache; if (backgroundGeometry != null) { context.DrawGeometry(background, null, backgroundGeometry); } var borderGeometry = _borderGeometryCache; if (borderGeometry != null) { context.DrawGeometry(borderBrush, null, borderGeometry); } } else { var borderThickness = _borderThickness.Top; IPen pen = null; ImmutableDashStyle?dashStyle = null; if (borderDashArray != null && borderDashArray.Count > 0) { dashStyle = new ImmutableDashStyle(borderDashArray, borderDashOffset); } if (borderBrush != null && borderThickness > 0) { pen = new ImmutablePen( borderBrush.ToImmutable(), borderThickness, dashStyle, borderLineCap, borderLineJoin); } var rect = new Rect(_size); if (!MathUtilities.IsZero(borderThickness)) { rect = rect.Deflate(borderThickness * 0.5); } var rrect = new RoundedRect(rect, _cornerRadius.TopLeft, _cornerRadius.TopRight, _cornerRadius.BottomRight, _cornerRadius.BottomLeft); context.PlatformImpl.DrawRectangle(background, pen, rrect, boxShadows); } }
/// <inheritdoc/> public void DrawRectangle(Rect rect, Color fillColor, Color strokeColor, double thickness, PenLineJoin lineJoin, ICollection <double> dashArray, double dashOffset, bool isHitTestVisible) { var rectangle = Create <Rectangle>(isHitTestVisible, rect.Left, rect.Top); rectangle.Fill = GetBrush(fillColor); SetStroke(rectangle, strokeColor, thickness, lineJoin, dashArray, dashOffset, false); rectangle.Height = rect.Height; rectangle.Width = rect.Width; Canvas.SetLeft(rectangle, rect.Left); Canvas.SetTop(rectangle, rect.Top); }
/// <inheritdoc/> public void DrawPolyline(IList <Point> points, Color strokeColor, double thickness, PenLineJoin lineJoin, ICollection <double> dashArray, double dashOffset, bool aliased, bool isHitTestVisible) { if (thickness < BalancedLineDrawingThicknessLimit) { DrawPolylineBalanced(points, strokeColor, thickness, lineJoin, dashArray, aliased, isHitTestVisible); } var polyline = Create <Polyline>(isHitTestVisible); SetStroke(polyline, strokeColor, thickness, lineJoin, dashArray, dashOffset, aliased); polyline.Points = ToPointCollection(points, aliased); }
public PenX3D WithLineJoin(PenLineJoin lineJoin) { if (!(lineJoin == _lineJoin)) { var result = (PenX3D)MemberwiseClone(); result._lineJoin = lineJoin; return(result); } else { return(this); } }
public static Pen GetPen(double thickness, PenLineJoin lineJoin = PenLineJoin.Bevel) { if (lineJoin == PenLineJoin.Bevel) { return(GetPen(bevelLock, bevelPens, thickness, lineJoin)); } else if (lineJoin == PenLineJoin.Miter) { return(GetPen(miterLock, miterPens, thickness, lineJoin)); } else { return(GetPen(roundLock, roundPens, thickness, lineJoin)); } }
/// <summary> /// Initializes a new instance of the <see cref="Pen"/> class. /// </summary> /// <param name="brush">The brush used to draw.</param> /// <param name="thickness">The stroke thickness.</param> /// <param name="dashStyle">The dash style.</param> /// <param name="lineCap">The line cap.</param> /// <param name="lineJoin">The line join.</param> /// <param name="miterLimit">The miter limit.</param> public Pen( IBrush brush, double thickness = 1.0, DashStyle dashStyle = null, PenLineCap lineCap = PenLineCap.Flat, PenLineJoin lineJoin = PenLineJoin.Miter, double miterLimit = 10.0) { Brush = brush; Thickness = thickness; LineCap = lineCap; LineJoin = lineJoin; MiterLimit = miterLimit; DashStyle = dashStyle; }
public static Pen GetPen(double thickness, PenLineJoin lineJoin = PenLineJoin.Bevel) { if (lineJoin == PenLineJoin.Bevel) { return GetPen(bevelLock, bevelPens, thickness, lineJoin); } else if (lineJoin == PenLineJoin.Miter) { return GetPen(miterLock, miterPens, thickness, lineJoin); } else { return GetPen(roundLock, roundPens, thickness, lineJoin); } }
static Pen GetPen(object lockObj, Dictionary<double, Pen> penDictionary, double thickness, PenLineJoin lineJoin, Brush brush=null) { lock (lockObj) { thickness = Math.Round(thickness, 1); if (!penDictionary.ContainsKey(thickness)) { Pen pen = new Pen(brush ?? Brushes.Black, thickness); pen.LineJoin = lineJoin; pen.Freeze(); penDictionary.Add(thickness, pen); } return penDictionary[thickness]; } }
/// <summary> /// Initializes a new instance of the <see cref="Pen"/> class. /// </summary> /// <param name="color">The stroke color.</param> /// <param name="thickness">The stroke thickness.</param> public Pen( uint color, double thickness = 1.0, DashStyle dashStyle = null, PenLineCap dashCap = PenLineCap.Flat, PenLineCap startLineCap = PenLineCap.Flat, PenLineCap endLineCap = PenLineCap.Flat, PenLineJoin lineJoin = PenLineJoin.Miter, double miterLimit = 10.0) { Brush = new SolidColorBrush(color); Thickness = thickness; StartLineCap = startLineCap; EndLineCap = endLineCap; LineJoin = lineJoin; MiterLimit = miterLimit; DashStyle = dashStyle; DashCap = dashCap; }
/// <summary> /// Initializes a new instance of the <see cref="Pen"/> class. /// </summary> /// <param name="brush">The brush used to draw.</param> /// <param name="thickness">The stroke thickness.</param> public Pen( Brush brush, double thickness = 1.0, DashStyle dashStyle = null, PenLineCap dashCap = PenLineCap.Flat, PenLineCap startLineCap = PenLineCap.Flat, PenLineCap endLineCap = PenLineCap.Flat, PenLineJoin lineJoin = PenLineJoin.Miter, double miterLimit = 10.0) { Brush = brush; Thickness = thickness; StartLineCap = startLineCap; EndLineCap = endLineCap; LineJoin = lineJoin; MiterLimit = miterLimit; DashStyle = dashStyle; DashCap = dashCap; }
public static void DrawLine(this DrawingContext drawingContext, Point[] points, double width, Color color, PenLineCap startCap, PenLineCap endCap, PenLineJoin lineJoin, DashStyle dashStyle) { var pen = new Pen(new SolidColorBrush(color), width) { DashStyle = dashStyle, LineJoin = lineJoin, StartLineCap = PenLineCap.Round, EndLineCap = PenLineCap.Round }; for (var i = 1; i < points.Length; i++) { drawingContext.DrawLine(pen, points[i - 1], points[i]); } }
public void Render(DrawingContext context, Size finalSize, Thickness borderThickness, CornerRadius cornerRadius, IBrush background, IBrush borderBrush, BoxShadows boxShadows, double borderDashOffset = 0, PenLineCap borderLineCap = PenLineCap.Flat, PenLineJoin borderLineJoin = PenLineJoin.Miter, AvaloniaList <double> borderDashArray = null) { if (_size != finalSize || _borderThickness != borderThickness || _cornerRadius != cornerRadius || !_initialized) { Update(finalSize, borderThickness, cornerRadius); } RenderCore(context, background, borderBrush, boxShadows, borderDashOffset, borderLineCap, borderLineJoin, borderDashArray); }
void SetStrokeLineJoin() { PenLineJoin winLineJoin = Element.StrokeLineJoin; CGLineJoin iosLineJoin = CGLineJoin.Miter; switch (winLineJoin) { case PenLineJoin.Miter: iosLineJoin = CGLineJoin.Miter; break; case PenLineJoin.Bevel: iosLineJoin = CGLineJoin.Bevel; break; case PenLineJoin.Round: iosLineJoin = CGLineJoin.Round; break; } Control.DrawingLayer.SetStrokeLineJoin(iosLineJoin); }
/// <inheritdoc/> public void DrawEllipse(Point point, Size size, Color fillColor, Color strokeColor, double thickness, PenLineJoin lineJoin, ICollection <double> dashArray, double dashOffset, bool isHitTestVisible) { point.Offset(-size.Width / 2, -size.Height / 2); var rect = new Rect(point, size); var ellipse = Create <Ellipse>(isHitTestVisible, rect.Left, rect.Top); ellipse.Fill = GetBrush(fillColor); SetStroke(ellipse, strokeColor, thickness, lineJoin, dashArray, dashOffset, false); ellipse.Height = rect.Height; ellipse.Width = rect.Width; Canvas.SetLeft(ellipse, rect.Left); Canvas.SetTop(ellipse, rect.Top); }
/// <summary> /// Initializes a new instance of the <see cref="Pen"/> class. /// </summary> /// <param name="brush">The brush used to draw.</param> /// <param name="thickness">The stroke thickness.</param> /// <param name="dashStyle">The dash style.</param> /// <param name="lineCap">The line cap.</param> /// <param name="lineJoin">The line join.</param> /// <param name="miterLimit">The miter limit.</param> public ImmutablePen( IBrush brush, double thickness = 1.0, ImmutableDashStyle dashStyle = null, PenLineCap lineCap = PenLineCap.Flat, PenLineJoin lineJoin = PenLineJoin.Miter, double miterLimit = 10.0) { Debug.Assert(!(brush is IMutableBrush)); Brush = brush; Thickness = thickness; LineCap = lineCap; LineJoin = lineJoin; MiterLimit = miterLimit; DashStyle = dashStyle; }
public static SKStrokeJoin ToSkia(this PenLineJoin penLinejoin) { switch (penLinejoin) { case PenLineJoin.Miter: return(SKStrokeJoin.Mitter); case PenLineJoin.Bevel: return(SKStrokeJoin.Bevel); case PenLineJoin.Round: return(SKStrokeJoin.Round); default: throw new ArgumentOutOfRangeException(nameof(penLinejoin), penLinejoin, null); } }
public static sd.LineJoin ToDx(this PenLineJoin lineJoin) { switch (lineJoin) { case PenLineJoin.Miter: return(sd.LineJoin.MiterOrBevel); case PenLineJoin.Bevel: return(sd.LineJoin.Bevel); case PenLineJoin.Round: return(sd.LineJoin.Round); default: throw new NotSupportedException(); } }
private void SetStroke([NotNull] Shape shape, Color color, double thickness, PenLineJoin lineJoin, ICollection <double> dashArray, double dashOffset, bool aliased) { shape.Stroke = GetBrush(color); shape.StrokeThickness = thickness; shape.StrokeLineJoin = lineJoin; if (dashArray != null) { shape.StrokeDashArray = new DoubleCollection(dashArray); shape.StrokeDashOffset = dashOffset; } if (aliased) { shape.SetValue(RenderOptions.EdgeModeProperty, EdgeMode.Aliased); shape.SnapsToDevicePixels = true; } }
public static ag.Paint.Join ToAndroid(this PenLineJoin value) { switch (value) { case PenLineJoin.Miter: return(ag.Paint.Join.Miter); case PenLineJoin.Bevel: return(ag.Paint.Join.Bevel); case PenLineJoin.Round: return(ag.Paint.Join.Round); default: throw new NotSupportedException(); } }
public static swm.PenLineJoin ToWpf(this PenLineJoin value) { switch (value) { case PenLineJoin.Miter: return(swm.PenLineJoin.Miter); case PenLineJoin.Bevel: return(swm.PenLineJoin.Bevel); case PenLineJoin.Round: return(swm.PenLineJoin.Round); default: throw new NotSupportedException(); } }
/// <summary> /// Initializes a new instance of the <see cref="Pen"/> class. /// </summary> /// <param name="color">The stroke color.</param> /// <param name="thickness">The stroke thickness.</param> /// <param name="dashStyle">The dash style.</param> /// <param name="dashCap">The dash cap.</param> /// <param name="startLineCap">The start line cap.</param> /// <param name="endLineCap">The end line cap.</param> /// <param name="lineJoin">The line join.</param> /// <param name="miterLimit">The miter limit.</param> public Pen( uint color, double thickness = 1.0, DashStyle dashStyle = null, PenLineCap dashCap = PenLineCap.Flat, PenLineCap startLineCap = PenLineCap.Flat, PenLineCap endLineCap = PenLineCap.Flat, PenLineJoin lineJoin = PenLineJoin.Miter, double miterLimit = 10.0) { Brush = new SolidColorBrush(color); Thickness = thickness; StartLineCap = startLineCap; EndLineCap = endLineCap; LineJoin = lineJoin; MiterLimit = miterLimit; DashStyle = dashStyle; DashCap = dashCap; }
/// <summary> /// Initializes a new instance of the <see cref="Pen"/> class. /// </summary> /// <param name="brush">The brush used to draw.</param> /// <param name="thickness">The stroke thickness.</param> /// <param name="dashStyle">The dash style.</param> /// <param name="dashCap">The dash cap.</param> /// <param name="startLineCap">The start line cap.</param> /// <param name="endLineCap">The end line cap.</param> /// <param name="lineJoin">The line join.</param> /// <param name="miterLimit">The miter limit.</param> public Pen( Brush brush, double thickness = 1.0, DashStyle dashStyle = null, PenLineCap dashCap = PenLineCap.Flat, PenLineCap startLineCap = PenLineCap.Flat, PenLineCap endLineCap = PenLineCap.Flat, PenLineJoin lineJoin = PenLineJoin.Miter, double miterLimit = 10.0) { Brush = brush; Thickness = thickness; DashCap = dashCap; StartLineCap = startLineCap; EndLineCap = endLineCap; LineJoin = lineJoin; MiterLimit = miterLimit; DashStyle = dashStyle; }
/// <summary> /// Pen - Initializes the brush from the parameters. /// </summary> /// <param name="brush"> The Pen's Brush. </param> /// <param name="thickness"> The Pen's thickness. </param> /// <param name="startLineCap"> The PenLineCap which applies to the start of the stroke. </param> /// <param name="endLineCap"> The PenLineCap which applies to the end of the stroke. </param> /// <param name="dashCap"> The PenDashCap which applies to the ends of each dash. </param> /// <param name="lineJoin"> The PenLineJoin. </param> /// <param name="miterLimit"> The miter limit. </param> /// <param name="dashStyle"> The dash style. </param> internal Pen( Brush brush, double thickness, PenLineCap startLineCap, PenLineCap endLineCap, PenLineCap dashCap, PenLineJoin lineJoin, double miterLimit, DashStyle dashStyle) { Thickness = thickness; StartLineCap = startLineCap; EndLineCap = endLineCap; DashCap = dashCap; LineJoin = lineJoin; MiterLimit = miterLimit; Brush = brush; DashStyle = dashStyle; }
public void SetLineJoin(Pen widget, PenLineJoin lineJoin) { throw new NotImplementedException(); }
private MIL_PEN_JOIN GetInternalJoinType(PenLineJoin join) { Debug.Assert((MIL_PEN_JOIN)PenLineJoin.Miter == MIL_PEN_JOIN.MilPenJoinMiter); Debug.Assert((MIL_PEN_JOIN)PenLineJoin.Bevel == MIL_PEN_JOIN.MilPenJoinBevel); Debug.Assert((MIL_PEN_JOIN)PenLineJoin.Round == MIL_PEN_JOIN.MilPenJoinRound); return (MIL_PEN_JOIN)join; }
public void DrawPolygons(IList<IList<Point>> polygons, Color fill, Color stroke, double thickness = 1, double[] dashArray = null, PenLineJoin lineJoin = PenLineJoin.Miter, bool aliased = false) { foreach (var p in polygons) this.DrawPolygon(p, fill, stroke, thickness, dashArray, lineJoin, aliased); }
public void SetLineJoin(Pen widget, PenLineJoin lineJoin) { widget.ToPenData().LineJoin = lineJoin; }
public PenX3D WithLineJoin(PenLineJoin lineJoin) { if (!(lineJoin == _lineJoin)) { var result = (PenX3D)this.MemberwiseClone(); result._lineJoin = lineJoin; return result; } else { return this; } }
public static void DrawCircles(this IDrawingContext renderer, IList<Point> points, double radius, Color fillColor, Color strokeColor, double thickness = 1.0, PenLineJoin lineJoin = PenLineJoin.Miter, ICollection<double> dashArray = null, double dashOffset = 0, bool isHitTestVisible = false) { renderer.DrawEllipses(points, radius, radius, fillColor, strokeColor, thickness, lineJoin, dashArray, dashOffset, isHitTestVisible); }
public StrokeStyle(Brush strokeColor, double thickness, PenLineJoin lineJoin) : this() { StrokeColor = strokeColor; Thickness = thickness; LineJoin = lineJoin; }
public void SetLineJoin (Pen widget, PenLineJoin lineJoin) { ((swm.Pen)widget.ControlObject).LineJoin = lineJoin.ToWpf (); }
public void SetLineJoin(Pen widget, PenLineJoin lineJoin) { widget.ToAndroid().StrokeJoin = lineJoin.ToAndroid(); }
/// <summary> /// Initialization that is needed only once per straigth line (not once per dash). /// </summary> /// <param name="crossSection">The cross section of the pen that is used to draw the line.</param> /// <param name="thickness1">Thickness1 of the pen.</param> /// <param name="thickness2">Thickness2 of the pen.</param> /// <param name="lineJoin">The LineJoin property of the pen.</param> /// <param name="miterLimit">The MiterLimit property of the pen.</param> /// <param name="startCap">The start cap to be used for this polyline segment.</param> /// <param name="endCap">The end cap to be used for this polyline segment.</param> public void Initialize( ICrossSectionOfLine crossSection, double thickness1, double thickness2, PenLineJoin lineJoin, double miterLimit, ILineCap startCap, ILineCap endCap) { this._crossSection = crossSection; this._crossSectionVertexCount = crossSection.NumberOfVertices; this._crossSectionNormalCount = crossSection.NumberOfNormals; this._crossSectionMaximalDistanceFromCenter = _crossSection.GetMaximalDistanceFromCenter(); this._crossSectionPartsTriangleIndices = new Dictionary<Tuple<int, int>, int[]>(); this._lineJoin = lineJoin; this._miterLimit = miterLimit; this._miterLimitDotThreshold = Math.Cos(Math.PI - 2 * Math.Asin(1 / miterLimit)); this._dashStartCap = startCap; this._dashStartCapBaseInsetAbsolute = null == _dashStartCap ? 0 : _dashStartCap.GetAbsoluteBaseInset(thickness1, thickness2); this._dashEndCap = endCap; this._dashEndCapBaseInsetAbsolute = null == _dashEndCap ? 0 : _dashEndCap.GetAbsoluteBaseInset(thickness1, thickness2); _positionsTransformedStartCurrent = new PointD3D[_crossSectionVertexCount]; _positionsTransformedEndCurrent = new PointD3D[_crossSectionVertexCount]; _positionsTransformedStartNext = new PointD3D[_crossSectionVertexCount]; _normalsTransformedCurrent = new VectorD3D[_crossSectionNormalCount]; _normalsTransformedNext = new VectorD3D[_crossSectionNormalCount]; _crossSectionRotatedVertices = new VectorD2D[_crossSectionVertexCount]; _startCapCOS = new PolylinePointD3DAsClass(); _endCapCOS = new PolylinePointD3DAsClass(); }
public void SetLineJoin (Pen widget, PenLineJoin lineJoin) { ((PenObject)widget.ControlObject).LineJoin = lineJoin.ToCairo (); }
/// <summary> /// Converts the graphics path to an array of vertices using TriangleList. /// </summary> /// <param name="points">The points of the line.</param> /// <param name="thickness">The thickness of the line.</param> /// <param name="close">True if we should connect the first and last point.</param> /// <param name="zCoord">Z coordinate of the returned vertices.</param> /// <param name="lineJoin">The PenLineJoin to use.</param> /// <param name="verts">The generated verts.</param> public static void TriangulateStroke_TriangleList(PointF[] points, float thickness, bool close, float zCoord, PenLineJoin lineJoin, out PositionColoredTextured[] verts) { verts = null; PointF[] pathPoints = AdjustPoints(points); if (pathPoints.Length <= 0) return; int pointCount; if (close) pointCount = pathPoints.Length; else pointCount = pathPoints.Length - 1; int pointsLength = pathPoints.Length; List<PositionColoredTextured> vertList = new List<PositionColoredTextured>(); PointF[] lastLine = new PointF[] { PointF.Empty, PointF.Empty }; if (close) GetLastLine(pathPoints, out lastLine); for (int i = 0; i < pointCount; i++) { PointF currentPoint = pathPoints[i]; PointF nextPoint = GetNextPoint(pathPoints, i, pointsLength); PointF movedCurrent = PointF.Empty; PointF movedNext = PointF.Empty; MoveVector(currentPoint, nextPoint, thickness, ref movedCurrent, ref movedNext); if (lastLine[0] != PointF.Empty && lastLine[1] != PointF.Empty) { // We move the original line by the needed thickness. PointF movedLast0 = PointF.Empty; PointF movedLast1 = PointF.Empty; MoveVector(lastLine[0], lastLine[1], thickness, ref movedLast0, ref movedLast1); // StrokeLineJoin implementation switch (lineJoin) { case PenLineJoin.Round: // We fallback to the Miter because we don't support the Round line join yet. case PenLineJoin.Miter: // We need to calculate the intersection of the 2 moved lines (Line A: movedCurrent/movedNext and Line B: movedLast0/movedLast1) PointF intersection; if (LineIntersect(movedCurrent, movedNext, movedLast0, movedLast1, out intersection)) { vertList.Add(new PositionColoredTextured { Position = new Vector3(currentPoint.X, currentPoint.Y, zCoord) }); vertList.Add(new PositionColoredTextured { Position = new Vector3(movedCurrent.X, movedCurrent.Y, zCoord) }); vertList.Add(new PositionColoredTextured { Position = new Vector3(intersection.X, intersection.Y, zCoord) }); vertList.Add(new PositionColoredTextured { Position = new Vector3(currentPoint.X, currentPoint.Y, zCoord) }); vertList.Add(new PositionColoredTextured { Position = new Vector3(movedLast1.X, movedLast1.Y, zCoord) }); vertList.Add(new PositionColoredTextured { Position = new Vector3(intersection.X, intersection.Y, zCoord) }); } break; case PenLineJoin.Bevel: // This is currently not the exact WPF "Bevel" implementation, we only insert a simple triangle between the line ends. vertList.Add(new PositionColoredTextured { Position = new Vector3(currentPoint.X, currentPoint.Y, zCoord) }); vertList.Add(new PositionColoredTextured { Position = new Vector3(movedCurrent.X, movedCurrent.Y, zCoord) }); vertList.Add(new PositionColoredTextured { Position = new Vector3(movedLast1.X, movedLast1.Y, zCoord) }); break; } } vertList.Add(new PositionColoredTextured { Position = new Vector3(currentPoint.X, currentPoint.Y, zCoord) }); vertList.Add(new PositionColoredTextured { Position = new Vector3(nextPoint.X, nextPoint.Y, zCoord) }); vertList.Add(new PositionColoredTextured { Position = new Vector3(movedCurrent.X, movedCurrent.Y, zCoord) }); vertList.Add(new PositionColoredTextured { Position = new Vector3(nextPoint.X, nextPoint.Y, zCoord) }); vertList.Add(new PositionColoredTextured { Position = new Vector3(movedNext.X, movedNext.Y, zCoord) }); vertList.Add(new PositionColoredTextured { Position = new Vector3(movedCurrent.X, movedCurrent.Y, zCoord) }); lastLine = new PointF[] { currentPoint, nextPoint }; } verts = vertList.ToArray(); }
public void DrawLine(IList<Point> points, Color stroke, double thickness = 1, double[] dashArray = null, PenLineJoin lineJoin = PenLineJoin.Miter, bool aliased = false) { using (var paint = new Paint()) { paint.StrokeWidth = (float)thickness; paint.Color = stroke; paint.AntiAlias = !aliased; var pts = new float[(points.Count - 1) * 4]; int j = 0; for (int i = 0; i + 1 < points.Count; i++) { pts[j++] = (float)points[i].X; pts[j++] = (float)points[i].Y; pts[j++] = (float)points[i + 1].X; pts[j++] = (float)points[i + 1].Y; } canvas.DrawLines(pts, paint); } }
public void DrawLineSegments(IList<Point> points, Color stroke, double thickness = 1, double[] dashArray = null, PenLineJoin lineJoin = PenLineJoin.Miter, bool aliased = false) { using (var paint = new Paint()) { paint.StrokeWidth = (float)thickness; paint.Color = stroke; paint.AntiAlias = !aliased; var pts = new float[points.Count * 2]; int i = 0; foreach (var p in points) { pts[i++] = (float)p.X; pts[i++] = (float)p.Y; } canvas.DrawLines(pts, paint); } }
public static void DrawCircle(this IDrawingContext renderer, Point point, double radius, Color fillColor, Color strokeColor, double thickness = 1.0, PenLineJoin lineJoin = PenLineJoin.Miter, ICollection<double> dashArray = null, double dashOffset = 0, bool isHitTestVisible = false) { var diameter = radius*2; renderer.DrawEllipse(point, new Size(diameter, diameter), fillColor, strokeColor, thickness, lineJoin, dashArray, dashOffset, isHitTestVisible); }
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); } } } }
public void SetLineJoin (Pen widget, PenLineJoin lineJoin) { widget.ToSD ().LineJoin = lineJoin.ToSD (); }
public PenX3D( IMaterial material, ICrossSectionOfLine crossSection, PenLineJoin lineJoin, double miterLimit, ILineCap lineStartCap, ILineCap lineEndCap, IDashPattern dashPattern, ILineCap dashStartCap, bool dashStartCapSuppressionIfSpaceInsufficient, ILineCap dashEndCap, bool dashEndCapSuppressionIfSpaceInsufficient) { if (!(miterLimit >= 1)) throw new ArgumentOutOfRangeException(nameof(miterLimit), "must be >= 1"); if (null == dashPattern) throw new ArgumentNullException(nameof(dashPattern)); _material = material; _crossSection = crossSection; _lineJoin = lineJoin; _miterLimit = miterLimit; _lineStartCap = lineStartCap; _lineEndCap = lineEndCap; _dashPattern = dashPattern; _dashStartCap = dashStartCap; _dashStartCapSuppressionIfSpaceInsufficient = dashStartCapSuppressionIfSpaceInsufficient; _dashEndCap = dashEndCap; _dashEndCapSuppressionIfSpaceInsufficient = dashEndCapSuppressionIfSpaceInsufficient; }