public StrokeStyle(Brush strokeColor, DashStyle dashStyle, PenLineCap dashCap)
: this()
{
StrokeColor = strokeColor;
DashStyle = dashStyle;
DashCap = dashCap;
}
protected virtual void onPenLineCapChanged(PenLineCap cap)
{
if (penLineCapChanged != null)
{
penLineCapChanged(cap);
}
}
public void SetLineCap(Pen widget, PenLineCap lineCap)
{
var pen = widget.ToAndroid();
pen.StrokeCap = lineCap.ToSD();
SetDashStyle(widget, widget.DashStyle);
}
public void SetLineCap(Pen widget, PenLineCap lineCap)
{
var swmpen = (swm.Pen)widget.ControlObject;
swmpen.EndLineCap = swmpen.StartLineCap = swmpen.DashCap = lineCap.ToWpf();
SetDashStyle(widget, widget.DashStyle);
}
public void SetLineCap (Pen widget, PenLineCap lineCap)
{
var pen = widget.ToSD ();
pen.StartCap = pen.EndCap = lineCap.ToSD ();
pen.DashCap = lineCap == PenLineCap.Round ? sd2.DashCap.Round : sd2.DashCap.Flat;
SetDashStyle (widget, widget.DashStyle);
}
/// <summary>
/// Handles changes to the TickStyle property.
/// </summary>
/// <param name="d">SprocketControl</param>
/// <param name="e">DependencyProperty changed event arguments</param>
private static void OnTickStyleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
SprocketControl sprocket = (SprocketControl)d;
PenLineCap oldTickStyle = (PenLineCap)e.OldValue;
PenLineCap newTickStyle = sprocket.TickStyle;
sprocket.OnTickStyleChanged(oldTickStyle, newTickStyle);
}
public StrokeStyle(Brush strokeColor, double thickness, PenLineCap startLineCap, PenLineCap endLineCap)
: this()
{
StrokeColor = strokeColor;
Thickness = thickness;
StartLineCap = startLineCap;
EndLineCap = endLineCap;
}
public StrokeStyle(Brush strokeColor, double thickness, DashStyle dashStyle, PenLineCap dashCap)
: this()
{
StrokeColor = strokeColor;
DashStyle = dashStyle;
DashCap = dashCap;
Thickness = thickness;
}
/// <summary>
/// Handles changes to the TickStyle property.
/// </summary>
/// <param name="d">SprocketControl</param>
/// <param name="e">DependencyProperty changed event arguments</param>
private static void OnTickStyleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
WaitingControlCom waiting = (WaitingControlCom)d;
PenLineCap oldTickStyle = (PenLineCap)e.OldValue;
PenLineCap newTickStyle = waiting.TickStyle;
waiting.OnTickStyleChanged(oldTickStyle, newTickStyle);
}
public void SetLineCap(Pen widget, PenLineCap lineCap)
{
var pen = widget.ToSD();
pen.StartCap = pen.EndCap = lineCap.ToSD();
pen.DashCap = lineCap == PenLineCap.Round ? sd2.DashCap.Round : sd2.DashCap.Flat;
SetDashStyle(widget, widget.DashStyle);
}
internal WpfPen RealizeWpfPen()
{
#if !SILVERLIGHT
if (_dirty || !_dirty) // TODOWPF: XPen is frozen by design, WPF Pen can change
{
//if (_wpfPen == null)
_wpfPen = new WpfPen(new SolidColorBrush(_color.ToWpfColor()), _width);
//else
//{
// _wpfPen.Brush = new SolidColorBrush(_color.ToWpfColor());
// _wpfPen.Thickness = _width;
//}
PenLineCap lineCap = XConvert.ToPenLineCap(_lineCap);
_wpfPen.StartLineCap = lineCap;
_wpfPen.EndLineCap = lineCap;
_wpfPen.LineJoin = XConvert.ToPenLineJoin(_lineJoin);
if (_dashStyle == XDashStyle.Custom)
{
// TODOWPF: does not work in all cases
_wpfPen.DashStyle = new System.Windows.Media.DashStyle(_dashPattern, _dashOffset);
}
else
{
switch (_dashStyle)
{
case XDashStyle.Solid:
_wpfPen.DashStyle = DashStyles.Solid;
break;
case XDashStyle.Dash:
//_wpfPen.DashStyle = DashStyles.Dash;
_wpfPen.DashStyle = new System.Windows.Media.DashStyle(new double[] { 2, 2 }, 0);
break;
case XDashStyle.Dot:
//_wpfPen.DashStyle = DashStyles.Dot;
_wpfPen.DashStyle = new System.Windows.Media.DashStyle(new double[] { 0, 2 }, 1.5);
break;
case XDashStyle.DashDot:
//_wpfPen.DashStyle = DashStyles.DashDot;
_wpfPen.DashStyle = new System.Windows.Media.DashStyle(new double[] { 2, 2, 0, 2 }, 0);
break;
case XDashStyle.DashDotDot:
//_wpfPen.DashStyle = DashStyles.DashDotDot;
_wpfPen.DashStyle = new System.Windows.Media.DashStyle(new double[] { 2, 2, 0, 2, 0, 2 }, 0);
break;
}
}
}
#else
_wpfPen = new System.Windows.Media.Pen();
_wpfPen.Brush = new SolidColorBrush(_color.ToWpfColor());
_wpfPen.Thickness = _width;
#endif
return(_wpfPen);
}
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
if (values[0] is double progress && progress > 0)
{
PenLineCap cap = (PenLineCap)values[1];
return(cap);
}
return(PenLineCap.Flat);
}
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));
}
/// <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)
{
}
private MIL_PEN_CAP GetInternalCapType(PenLineCap cap)
{
Debug.Assert((MIL_PEN_CAP)PenLineCap.Flat == MIL_PEN_CAP.MilPenCapFlat);
Debug.Assert((MIL_PEN_CAP)PenLineCap.Square == MIL_PEN_CAP.MilPenCapSquare);
Debug.Assert((MIL_PEN_CAP)PenLineCap.Round == MIL_PEN_CAP.MilPenCapRound);
Debug.Assert((MIL_PEN_CAP)PenLineCap.Triangle == MIL_PEN_CAP.MilPenCapTriangle);
return((MIL_PEN_CAP)cap);
}
public void SetLineCap (Pen widget, PenLineCap lineCap)
{
var pen = widget.ToSD ();
// get dash style before changing cap
var dashStyle = widget.DashStyle;
pen.StartCap = pen.EndCap = lineCap.ToSD ();
pen.DashCap = lineCap == PenLineCap.Round ? sd2.DashCap.Round : sd2.DashCap.Flat;
SetDashStyle (widget, dashStyle);
}
/// <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 IsPenLineCapValid(object valueObject)
{
PenLineCap value = (PenLineCap)valueObject;
return((value == PenLineCap.Flat) ||
(value == PenLineCap.Square) ||
(value == PenLineCap.Round) ||
(value == PenLineCap.Triangle));
}
public static void LineCaps(GradientMode gradientMode, PenLineCap lineCap)
{
using var app = Application.AttachOrLaunch("Gu.Wpf.Geometry.Demo.exe", WindowName);
var window = app.MainWindow;
_ = window.FindComboBox("LineCap").Select(lineCap.ToString());
_ = window.FindComboBox("GradientMode").Select(gradientMode.ToString());
ImageAssert.AreEqual($"Images\\GradientPathLineCapsWindow\\{TestImage.Current}\\{gradientMode}_{lineCap}.png", window.FindGroupBox("Path"), TestImage.OnFail);
}
public void SetLineCap(Pen widget, PenLineCap lineCap)
{
var pen = widget.ToSD();
// get dash style before changing cap
var dashStyle = widget.DashStyle;
pen.StartCap = pen.EndCap = lineCap.ToSD();
pen.DashCap = lineCap == PenLineCap.Round ? sd2.DashCap.Round : sd2.DashCap.Flat;
SetDashStyle(widget, dashStyle);
}
/// <summary>
/// Constructor.
/// </summary>
public VisualElementFormat(Brush BackgroundBrush, Brush LineBrush, double LineThickness = DEFAULT_LINE_THICKNESS, double Opacity = 1.0,
DashStyle LineDash = null, PenLineCap LineCap = PenLineCap.Round, PenLineJoin LineJoin = PenLineJoin.Miter)
{
this.MainBackground = BackgroundBrush.NullDefault(Brushes.WhiteSmoke);
this.LineBrush = LineBrush ?? Brushes.Black;
this.Opacity = Opacity;
this.LineThickness = LineThickness;
this.LineDash = LineDash ?? DashStyles.Solid;
}
public static d2.DashCap ToDashCap(this PenLineCap me)
{
switch (me)
{
case PenLineCap.Round: return(d2.DashCap.Round);
case PenLineCap.Triangle: return(d2.DashCap.Triangle);
}
return(d2.DashCap.Flat);
}
public void Reset()
{
Type = NativeBrushType.Solid;
Opacity = 1f;
Color = 0;
Stroke = false;
StrokeThickness = 1;
GradientStopCount = 0;
StrokeDashCount = 0;
StrokeLineCap = PenLineCap.Flat;
}
public void Reset()
{
Type = NativeBrushType.Solid;
Opacity = 1f;
Color = 0;
Stroke = false;
StrokeThickness = 1;
GradientStopCount = 0;
StrokeDashCount = 0;
StrokeLineCap = PenLineCap.Flat;
}
public StrokeStyle(Brush strokeColor, double thickness, PenLineCap startLineCap, PenLineCap endLineCap,
PenLineJoin lineJoin, DashStyle dashStyle)
: this()
{
StrokeColor = strokeColor;
Thickness = thickness;
StartLineCap = startLineCap;
EndLineCap = endLineCap;
LineJoin = lineJoin;
DashStyle = dashStyle;
}
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);
}
}
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 static d2.LineCap ToGdiPlus(this PenLineCap me)
{
switch (me)
{
case PenLineCap.Square: return(d2.LineCap.Square);
case PenLineCap.Round: return(d2.LineCap.Round);
case PenLineCap.Triangle: return(d2.LineCap.Triangle);
}
return(d2.LineCap.Flat);
}
void DrawLineCap(DrawingContext dc, Point point, Vector vector,
PenLineCap startLineCap, PenLineCap endLineCap)
{
if (startLineCap == PenLineCap.Flat && endLineCap == PenLineCap.Flat)
{
return;
}
// Construct really tiny horizontal line
vector.Normalize();
double angle = Math.Atan2(vector.Y, vector.X);
RotateTransform rotate = new RotateTransform(-180 * angle / Math.PI, point.X, point.Y);
Point point1 = rotate.Transform(point);
Point point2 = rotate.Transform(point + 0.25 * vector);
// Construct pen for that line
Pen pen = new Pen()
{
Thickness = StrokeThickness,
StartLineCap = startLineCap,
EndLineCap = endLineCap
};
pen.Freeze();
// Why don't I just call dc.DrawLine at this point? Well, to avoid gaps between
// the tetragons, I had to draw them with an 'outlinePenWidth' pen based on the
// same brush as the fill. If I just called dc.DrawLine here, the caps would
// look a little smaller than the line, so....
LineGeometry lineGeo = new LineGeometry(point1, point2);
PathGeometry pathGeo = lineGeo.GetWidenedPathGeometry(pen);
Brush brush = null;
if (GradientMode == GradientMode.Perpendicular)
{
brush = new LinearGradientBrush(GradientStops, new Point(0, 0), new Point(0, 1));
(brush as LinearGradientBrush).ColorInterpolationMode = ColorInterpolationMode;
}
else
{
double offset = endLineCap == PenLineCap.Flat ? 0 : 1;
brush = new SolidColorBrush(GetColorFromGradientStops(offset));
brush.Freeze();
}
pen = new Pen(brush, outlinePenWidth);
pen.Freeze();
rotate.Angle = 180 * angle / Math.PI;
dc.PushTransform(rotate);
dc.DrawGeometry(brush, pen, pathGeo);
dc.Pop();
}
SKStrokeCap convertCap(PenLineCap cap)
{
if (cap == PenLineCap.Flat)
{
return(SKStrokeCap.Butt);
}
else if (cap == PenLineCap.Round)
{
return(SKStrokeCap.Round);
}
return(SKStrokeCap.Square);
}
public static DrawingImage GetImage(sdd.DashCap val)
{
double height = 1;
double width = 2;
PenLineCap dashCap = PenLineCap.Flat;
switch (val)
{
default:
case sdd.DashCap.Flat:
dashCap = PenLineCap.Flat;
break;
case sdd.DashCap.Round:
dashCap = PenLineCap.Round;
break;
case sdd.DashCap.Triangle:
dashCap = PenLineCap.Triangle;
break;
}
//
// Create the Geometry to draw.
//
var drawingGroup = new DrawingGroup();
var geometryDrawing = new GeometryDrawing()
{
Geometry = new RectangleGeometry(new Rect(0, 0, width, height))
};
geometryDrawing.Pen = new Pen(Brushes.Transparent, 0);
drawingGroup.Children.Add(geometryDrawing);
geometryDrawing = new GeometryDrawing()
{
Geometry = new LineGeometry(new Point(0, height / 2), new Point(width, height / 2))
};
geometryDrawing.Pen = new Pen(Brushes.Black, height / 5)
{
DashCap = dashCap, DashStyle = DashStyles.Dash
};
drawingGroup.Children.Add(geometryDrawing);
var geometryImage = new DrawingImage(drawingGroup);
// Freeze the DrawingImage for performance benefits.
geometryImage.Freeze();
return(geometryImage);
}
internal BaseStrokeContent(LottieDrawable lottieDrawable, BaseLayer layer, PenLineCap cap, PenLineJoin join, AnimatableIntegerValue opacity, AnimatableFloatValue width, IList <AnimatableFloatValue> dashPattern, AnimatableFloatValue offset)
{
_lottieDrawable = lottieDrawable;
Paint.Style = Paint.PaintStyle.Stroke;
Paint.StrokeCap = cap;
Paint.StrokeJoin = join;
_opacityAnimation = opacity.CreateAnimation();
_widthAnimation = width.CreateAnimation();
if (offset == null)
{
_dashPatternOffsetAnimation = null;
}
else
{
_dashPatternOffsetAnimation = offset.CreateAnimation();
}
_dashPatternAnimations = new List <IBaseKeyframeAnimation <float?> >(dashPattern.Count);
_dashPatternValues = new double[dashPattern.Count];
for (var i = 0; i < dashPattern.Count; i++)
{
_dashPatternAnimations.Add(dashPattern[i].CreateAnimation());
}
layer.AddAnimation(_opacityAnimation);
layer.AddAnimation(_widthAnimation);
for (var i = 0; i < _dashPatternAnimations.Count; i++)
{
layer.AddAnimation(_dashPatternAnimations[i]);
}
if (_dashPatternOffsetAnimation != null)
{
layer.AddAnimation(_dashPatternOffsetAnimation);
}
_opacityAnimation.ValueChanged += OnValueChanged;
_widthAnimation.ValueChanged += OnValueChanged;
for (var i = 0; i < dashPattern.Count; i++)
{
_dashPatternAnimations[i].ValueChanged += OnValueChanged;
}
if (_dashPatternOffsetAnimation != null)
{
_dashPatternOffsetAnimation.ValueChanged += OnValueChanged;
}
}
internal FlattenedFigure(PathFigure figure, PenLineCap startLineCap, PenLineCap endLineCap, double strokeThickness)
{
var lines = GetLines(figure);
if (!lines.Any())
{
this.Segments = EmptySegments;
return;
}
var segments = new List <FlattenedSegment>(lines.Count);
switch (startLineCap)
{
case PenLineCap.Flat:
break;
case PenLineCap.Square:
case PenLineCap.Round:
case PenLineCap.Triangle:
segments.Add(FlattenedSegment.CreateStartLineCap(lines[0], startLineCap, strokeThickness));
break;
default:
throw new ArgumentOutOfRangeException(nameof(startLineCap), startLineCap, "Unknown line cap.");
}
for (int i = 0; i < lines.Count; i++)
{
segments.Add(FlattenedSegment.Create(lines.ElementAtOrDefault(i - 1), lines[i], lines.ElementAtOrDefault(i + 1), strokeThickness));
}
switch (endLineCap)
{
case PenLineCap.Flat:
break;
case PenLineCap.Square:
case PenLineCap.Round:
case PenLineCap.Triangle:
segments.Add(FlattenedSegment.CreateEndLineCap(lines[lines.Count - 1], endLineCap, strokeThickness));
break;
default:
throw new ArgumentOutOfRangeException(nameof(endLineCap), endLineCap, "Unknown line cap.");
}
this.Segments = segments;
this.TotalLength = this.Segments.Sum(x => x.Line.Length);
}
private void DrawLineCap(
DrawingContext dc,
Line line,
PenLineCap startLineCap,
PenLineCap endLineCap)
{
if (startLineCap == PenLineCap.Flat && endLineCap == PenLineCap.Flat)
{
return;
}
var point = endLineCap == PenLineCap.Flat ? line.StartPoint : line.EndPoint;
// Construct really tiny horizontal line
var angle = Math.Atan2(line.Direction.Y, line.Direction.X);
var rotate = new RotateTransform(-180 * angle / Math.PI, point.X, point.Y);
var point1 = rotate.Transform(point);
var point2 = rotate.Transform(point + 0.25 * line.Direction);
// Construct pen for that line
var pen = new Pen()
{
Thickness = this.StrokeThickness, StartLineCap = startLineCap, EndLineCap = endLineCap
};
// Why don't I just call dc.DrawLine at this point? Well, to avoid gaps between
// the tetragons, I had to draw them with an 'outlinePenWidth' pen based on the
// same brush as the fill. If I just called dc.DrawLine here, the caps would
// look a little smaller than the line, so....
var lineGeo = new LineGeometry(point1, point2);
var pathGeo = lineGeo.GetWidenedPathGeometry(pen);
Brush brush;
if (this.GradientMode == GradientMode.Perpendicular)
{
brush = new LinearGradientBrush(this.GradientStops, new Point(0, 0), new Point(0, 1));
((LinearGradientBrush)brush).ColorInterpolationMode = this.ColorInterpolationMode;
}
else
{
double offset = endLineCap == PenLineCap.Flat ? 0 : 1;
brush = new SolidColorBrush(this.GradientStops.GetColorAt(offset, this.ColorInterpolationMode));
}
pen = new Pen(brush, 0);
rotate.Angle = 180 * angle / Math.PI;
dc.PushTransform(rotate);
dc.DrawGeometry(brush, pen, pathGeo);
dc.Pop();
}
/// <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;
}
/// <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 SetLineCap (Pen widget, PenLineCap lineCap)
{
((PenObject)widget.ControlObject).LineCap = lineCap.ToCairo ();
}
public StrokeStyle(Brush strokeColor, DashStyle dashStyle, PenLineCap dashCap)
: this()
{
StrokeColor = strokeColor;
DashStyle = dashStyle;
DashCap = dashCap;
}
public StrokeStyle(Brush strokeColor, double thickness, DashStyle dashStyle, PenLineCap dashCap)
: this()
{
StrokeColor = strokeColor;
DashStyle = dashStyle;
DashCap = dashCap;
Thickness = thickness;
}
public void SetLineCap(Pen widget, PenLineCap lineCap)
{
throw new NotImplementedException();
}
public StrokeStyle(Brush strokeColor, double thickness, PenLineCap startLineCap, PenLineCap endLineCap,
PenLineJoin lineJoin)
: this()
{
StrokeColor = strokeColor;
Thickness = thickness;
StartLineCap = startLineCap;
EndLineCap = endLineCap;
LineJoin = lineJoin;
}
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;
}
CreateFrozenPen
(
Brush oBrush,
Double dThickness,
DashStyle oDashStyle,
PenLineCap eLineCap
)
{
Debug.Assert(oBrush != null);
Debug.Assert(dThickness > 0);
Debug.Assert(oDashStyle != null);
// AssertValid();
Pen oPen = new Pen(oBrush, dThickness);
oPen.DashStyle = oDashStyle;
oPen.StartLineCap = eLineCap;
oPen.EndLineCap = eLineCap;
WpfGraphicsUtil.FreezeIfFreezable(oPen);
return (oPen);
}
/// <summary>
/// Provides derived classes an opportunity to handle changes to the TickStyle property.
/// </summary>
/// <param name="oldTickStyle">Old Value</param>
/// <param name="newTickStyle">New Value</param>
protected virtual void OnTickStyleChanged(PenLineCap oldTickStyle, PenLineCap newTickStyle)
{
InvalidateVisual();
}
private MIL_PEN_CAP GetInternalCapType(PenLineCap cap)
{
Debug.Assert((MIL_PEN_CAP)PenLineCap.Flat == MIL_PEN_CAP.MilPenCapFlat);
Debug.Assert((MIL_PEN_CAP)PenLineCap.Square == MIL_PEN_CAP.MilPenCapSquare);
Debug.Assert((MIL_PEN_CAP)PenLineCap.Round == MIL_PEN_CAP.MilPenCapRound);
Debug.Assert((MIL_PEN_CAP)PenLineCap.Triangle == MIL_PEN_CAP.MilPenCapTriangle);
return (MIL_PEN_CAP)cap;
}
public void SetLineCap(Pen widget, PenLineCap lineCap)
{
var pen = widget.ToAndroid();
pen.StrokeCap = lineCap.ToSD();
SetDashStyle(widget, widget.DashStyle);
}
public void DrawLine(CMember line, SolidColorBrush color, PenLineCap startCap, PenLineCap endCap, double thickness, Canvas imageCanvas)
{
Line myLine = new Line();
myLine.Stretch = Stretch.Fill;
myLine.Stroke = color;
myLine.X1 = line.NodeStart.X;
myLine.X2 = line.NodeEnd.X;
myLine.Y1 = line.NodeStart.Z;
myLine.Y2 = line.NodeEnd.Z;
myLine.StrokeThickness = thickness;
myLine.StrokeStartLineCap = startCap;
myLine.StrokeEndLineCap = endCap;
myLine.HorizontalAlignment = HorizontalAlignment.Left;
myLine.VerticalAlignment = VerticalAlignment.Center;
Canvas.SetTop(myLine, line.NodeStart.Z);
Canvas.SetLeft(myLine, line.NodeStart.X);
imageCanvas.Children.Add(myLine);
}
public void SetLineCap (Pen widget, PenLineCap lineCap)
{
var swmpen = (swm.Pen)widget.ControlObject;
swmpen.EndLineCap = swmpen.StartLineCap = swmpen.DashCap = lineCap.ToWpf ();
SetDashStyle (widget, widget.DashStyle);
}
public void SetLineCap(Pen widget, PenLineCap lineCap)
{
widget.ToPenData().LineCap = lineCap;
}
