public PenDialog(int p, LineCap lineCap) { InitializeComponent(); penSizeNumericUpDown.Value = p; //switch (lineCap) //{ // case LineCap.AnchorMask: // { // penStyleNumericUpDown.Value = 1; // } // break; // case LineCap.ArrowAnchor: // { // penStyleNumericUpDown.Value = 2; // } // break; // case LineCap.Custom: // { // penStyleNumericUpDown.Value = 3; // } // break; // case LineCap.DiamondAnchor: // { // penStyleNumericUpDown.Value = 4; // } // break; // case LineCap.Flat: // { // penStyleNumericUpDown.Value = 5; // } // break; // case LineCap.NoAnchor: // { // penStyleNumericUpDown.Value = 6; // } // break; // case LineCap.Round: // { // penStyleNumericUpDown.Value = 7; // } // break; // case LineCap.Square: // { // penStyleNumericUpDown.Value = 8; // } // break; // case LineCap.SquareAnchor: // { // penStyleNumericUpDown.Value = 9; // } // break; // case LineCap.Triangle: // { // penStyleNumericUpDown.Value = 10; // } // break; //} }
public LineFunction () { Width = 1; Color = "#FFFFFF"; Opacity = 1.0m; LineCap = LineCap.Butt; }
private void Configure() { _joinType = LineJoinType.Round; _startCap = LineCap.Round; _endCap = LineCap.Round; _decorations = new CopyList<ILineDecoration>(); }
// Set/get line caps: start, end, and dash // Line cap and join APIs by using LineCap and LineJoin enums. public GpStatus SetLineCap(LineCap startCap, LineCap endCap, DashCap dashCap) { return SetStatus(NativeMethods.GdipSetPenLineCap197819(nativePen, startCap, endCap, dashCap)); }
private void _SetBaseCap(LineCap baseCap) { int status = SafeNativeMethods.Gdip.GdipSetCustomLineCapBaseCap(new HandleRef(this, (IntPtr) this.nativeCap), baseCap); if (status != 0) { throw SafeNativeMethods.Gdip.StatusException(status); } }
public CustomLineCap(GraphicsPath fillPath, GraphicsPath strokePath, LineCap baseCap, float baseInset) { this.fillPath = fillPath; this.strokePath = strokePath; this.baseCap = baseCap; this.baseInset = baseInset; }
public void Ctor_InvalidLineCap_ReturnsFlat(LineCap baseCap) { using (GraphicsPath fillPath = new GraphicsPath()) using (GraphicsPath strokePath = new GraphicsPath()) using (CustomLineCap customLineCap = new CustomLineCap(fillPath, strokePath, baseCap, 0f)) { Assert.Equal(LineCap.Flat, customLineCap.BaseCap); } }
public void BaseCap_SetThenGet_Success(LineCap baseCap) { using (GraphicsPath strokePath = new GraphicsPath()) using (CustomLineCap customLineCap = new CustomLineCap(null, strokePath)) { customLineCap.BaseCap = baseCap; Assert.Equal(baseCap, customLineCap.BaseCap); } }
public LineRenderElement(Vector from, Vector to, int width, Color color) { DrawPen = new Pen(color, width); StartPoint = from; EndPoint = to; Width = width; EndCap = LineCap.NoAnchor; StartCap = LineCap.NoAnchor; }
/// <include file='doc\CustomLineCap.uex' path='docs/doc[@for="CustomLineCap.GetStrokeCaps"]/*' /> /// <devdoc> /// Gets the caps used to start and end lines. /// </devdoc> public void GetStrokeCaps(out LineCap startCap, out LineCap endCap) { int status = SafeNativeMethods.GdipGetCustomLineCapStrokeCaps(new HandleRef(this, nativeCap), out startCap, out endCap); if (status != SafeNativeMethods.Ok) { throw SafeNativeMethods.StatusException(status); } }
private void _SetBaseCap(LineCap baseCap) { int status = SafeNativeMethods.GdipSetCustomLineCapBaseCap(new HandleRef(this, nativeCap), baseCap); if (status != SafeNativeMethods.Ok) { throw SafeNativeMethods.StatusException(status); } }
/// <include file='doc\CustomLineCap.uex' path='docs/doc[@for="CustomLineCap.SetStrokeCaps"]/*' /> /// <devdoc> /// Sets the caps used to start and end lines. /// </devdoc> public void SetStrokeCaps(LineCap startCap, LineCap endCap) { int status = SafeNativeMethods.Gdip.GdipSetCustomLineCapStrokeCaps(new HandleRef(this, nativeCap), startCap, endCap); if (status != SafeNativeMethods.Gdip.Ok) { throw SafeNativeMethods.Gdip.StatusException(status); } }
public void BaseCap_Set_InvalidLineCap_ThrowsArgumentException(LineCap baseCap) { using (GraphicsPath strokePath = new GraphicsPath()) using (CustomLineCap customLineCap = new CustomLineCap(null, strokePath)) { AssertExtensions.Throws <ArgumentException>(null, () => customLineCap.BaseCap = baseCap); Assert.Equal(LineCap.Flat, customLineCap.BaseCap); } }
public static void drawLines(NvgContext vg, float x, float y, float w, float h, float t) { int i, j; float pad = 5.0f, s = w / 9.0f - pad * 2; float[] pts = new float[4 * 2]; float fx, fy; LineCap[] joins = new LineCap[] { LineCap.Miter, LineCap.Round, LineCap.Bevel }; LineCap[] caps = new LineCap[] { LineCap.Butt, LineCap.Round, LineCap.Square }; vg.Save(); pts[0] = -s * 0.25f + (float)Math.Cos(t * 0.3f) * s * 0.5f; pts[1] = (float)Math.Sin(t * 0.3f) * s * 0.5f; pts[2] = -s * 0.25f; pts[3] = 0; pts[4] = s * 0.25f; pts[5] = 0; pts[6] = s * 0.25f + (float)Math.Cos(-t * 0.3f) * s * 0.5f; pts[7] = (float)Math.Sin(-t * 0.3f) * s * 0.5f; for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) { fx = x + s * 0.5f + (i * 3 + j) / 9.0f * w + pad; fy = y - s * 0.5f + pad; vg.LineCap(caps[i]); vg.LineJoin(joins[j]); vg.StrokeWidth(s * 0.3f); vg.StrokeColor(new Color(0, 0, 0, 160)); vg.BeginPath(); vg.MoveTo(fx + pts[0], fy + pts[1]); vg.LineTo(fx + pts[2], fy + pts[3]); vg.LineTo(fx + pts[4], fy + pts[5]); vg.LineTo(fx + pts[6], fy + pts[7]); vg.Stroke(); vg.LineCap(LineCap.Butt); vg.LineJoin(LineCap.Bevel); vg.StrokeWidth(1.0f); vg.StrokeColor(new Color(0, 192, 255, 255)); vg.BeginPath(); vg.MoveTo(fx + pts[0], fy + pts[1]); vg.LineTo(fx + pts[2], fy + pts[3]); vg.LineTo(fx + pts[4], fy + pts[5]); vg.LineTo(fx + pts[6], fy + pts[7]); vg.Stroke(); } } vg.Restore(); }
public CustomLineCap(GraphicsPath fillPath, GraphicsPath strokePath, LineCap baseCap, float baseInset) { IntPtr zero = IntPtr.Zero; int status = SafeNativeMethods.Gdip.GdipCreateCustomLineCap(new HandleRef(fillPath, (fillPath == null) ? IntPtr.Zero : fillPath.nativePath), new HandleRef(strokePath, (strokePath == null) ? IntPtr.Zero : strokePath.nativePath), baseCap, baseInset, out zero); if (status != 0) { throw SafeNativeMethods.Gdip.StatusException(status); } this.SetNativeLineCap(zero); }
/// <summary>Creates a <see cref="Pen" /> from the <see cref="Image" />.</summary> /// <param name="image">The image.</param> /// <param name="width">The width.</param> /// <param name="startCap">The start cap.</param> /// <param name="endCap">The end cap.</param> /// <returns>The <see cref="Pen" />.</returns> public static Pen ToPen(this Image image, float width = 1, LineCap startCap = LineCap.Custom, LineCap endCap = LineCap.Custom) { using (TextureBrush _textureBrush = new TextureBrush(image)) { return(new Pen(_textureBrush, width) { StartCap = startCap, EndCap = endCap }); } }
private Pen() { //Color = Color.White; Alignment = PenAlignment.Center; MiterLimit = 10f; JoinLimit = (float)(Math.PI / 8); _startCap = LineCap.Flat; _endCap = LineCap.Flat; }
public void Deserialize(BinaryFormatter bf, Stream s) { version = (int)bf.Deserialize(s); _baseColor = (Color)bf.Deserialize(s); _highlightColor = (Color)bf.Deserialize(s); _alpha = (int)bf.Deserialize(s); _startCap = (LineCap)bf.Deserialize(s); _endCap = (LineCap)bf.Deserialize(s); _lineJoin = (LineJoin)bf.Deserialize(s); _width = (float)bf.Deserialize(s); }
/// <summary> /// 在原有波形上添加一条线 /// 不可动态循环 /// </summary> /// <param name="listX">X轴</param> /// <param name="listY">Y轴</param> /// <param name="listColor">线条颜色</param> /// <param name="listWidth">线条宽度</param> /// <param name="listLineJoin">线条连接点</param> /// <param name="listLineCap">线条起始线帽</param> /// <param name="listDrawStyle">线条样式</param> public void f_AddPix(ref List<float> listX, ref List<float> listY, Color listColor, int listWidth, LineJoin listLineJoin, LineCap listLineCap, DrawStyle listDrawStyle) { //装载 _listX.Add(listX); _listY.Add(listY); _listColor.Add(listColor); _listWidth.Add(listWidth); _listLineJoin.Add(listLineJoin); _listLineCap.Add(listLineCap); _listDrawStyle.Add(listDrawStyle); }
public void SetLineAk(LineCap l, bool end) { if (end) { _lineEnd = l; } else { _lineStart = l; } }
private static void GetEndCap(EndCap ec, out LineCap endcaps, out DashCap dashcaps) { switch (ec) { case EndCap.Flat: endcaps = LineCap.Flat; dashcaps = DashCap.Flat; break; case EndCap.Square: endcaps = LineCap.Square; dashcaps = DashCap.Flat; break; default: endcaps = LineCap.Round; dashcaps = DashCap.Round; break; } }
public void SetLineCap(LineCap startCap, LineCap endCap, DashCap dashCap) { if (isModifiable) { Status status = SafeNativeMethods.Gdip.GdipSetPenLineCap197819(nativeObject, startCap, endCap, dashCap); SafeNativeMethods.Gdip.CheckStatus(status); } else { throw new ArgumentException("This Pen object can't be modified."); } }
private void setLineCap(java.awt.BasicStroke s) { try { LineCap plc = J2C.ConvertLineCap(s.getEndCap()); pen.SetLineCap(plc, plc, pen.DashCap); } catch (ArgumentException aex) { Console.WriteLine(aex.StackTrace); } }
public void SetLineCap(LineCap startCap, LineCap endCap, DashCap dashCap) { if (isModifiable) { Status status = GDIPlus.GdipSetPenLineCap197819(nativeObject, startCap, endCap, dashCap); GDIPlus.CheckStatus(status); } else { throw new ArgumentException(Locale.GetText("This Pen object can't be modified.")); } }
public void SetThenGetStrokeCaps_Success(LineCap startCap, LineCap endCap) { using (GraphicsPath strokePath = new GraphicsPath()) using (CustomLineCap customLineCap = new CustomLineCap(null, strokePath)) { customLineCap.SetStrokeCaps(startCap, endCap); customLineCap.GetStrokeCaps(out LineCap retrievedStartCap, out LineCap retrievedEndCap); Assert.Equal(startCap, retrievedStartCap); Assert.Equal(endCap, retrievedEndCap); } }
/// <summary> /// Constructor for MacOSX Optimized Progress /// </summary> /// <param name="MacOSX_Optimized_m_Interval">The mac osx optimized m interval.</param> /// <param name="MacOSX_Optimized_m_StartAngle">The mac osx optimized m start angle.</param> /// <param name="MacOSX_Optimized_m_AngleIncrement">The mac osx optimized m angle increment.</param> /// <param name="MacOSX_Optimized_m_SpokesCount">The mac osx optimized m spokes count.</param> /// <param name="macOSX_Max_Spokes">The mac osx maximum spokes.</param> /// <param name="MacOSX_Optimized_startCap">The mac osx optimized start cap.</param> /// <param name="MacOSX_Optimized_endCap">The mac osx optimized end cap.</param> /// <param name="_automatic">The automatic.</param> /// <param name="MacOSX_Optimized_m_Rotation">The mac osx optimized m rotation.</param> /// <param name="macOSX_Optimized_tick_Color">Color of the mac osx optimized tick.</param> public ProgressInput( //ProgressType progressType, //ProgressBar solidBars, int MacOSX_Optimized_m_Interval, float MacOSX_Optimized_m_StartAngle, float MacOSX_Optimized_m_AngleIncrement, int MacOSX_Optimized_m_SpokesCount, int macOSX_Max_Spokes, LineCap MacOSX_Optimized_startCap, LineCap MacOSX_Optimized_endCap, MacOSX_automatic _automatic, ZeroitThematicProgress.MacOSX_Direction MacOSX_Optimized_m_Rotation, Color macOSX_Optimized_tick_Color ) : this( //ProgressType.Bar, //CircularProgress.ZeroitProgressBarCircular, ProgressBar.IPMacOSXOptimized, //ProgressIndicator.MacOSXOptimized, SmoothingMode.HighQuality, TextRenderingHint.AntiAlias, PeaceAnimatorEasing.BounceEaseIn, transparencyEasingType.BounceEaseIn, ZeroitThematicProgress.HatchBrushType.ForwardDiagonal, false, false, false, false, false, "%", Color.FromArgb(254, 84, 84), Color.DeepPink, 0, 100, 5000, 10, 10, 270 ) { //this.progressType = progressType; //this.solidBars = solidBars; this.MacOSX_Optimized_m_Interval = MacOSX_Optimized_m_Interval; this.MacOSX_Optimized_m_StartAngle = MacOSX_Optimized_m_StartAngle; this.MacOSX_Optimized_m_AngleIncrement = MacOSX_Optimized_m_AngleIncrement; this.MacOSX_Optimized_m_SpokesCount = MacOSX_Optimized_m_SpokesCount; this.macOSX_Max_Spokes = macOSX_Max_Spokes; this.MacOSX_Optimized_startCap = MacOSX_Optimized_startCap; this.MacOSX_Optimized_endCap = MacOSX_Optimized_endCap; this._automatic = _automatic; this.MacOSX_Optimized_m_Rotation = MacOSX_Optimized_m_Rotation; this.macOSX_Optimized_tick_Color = macOSX_Optimized_tick_Color; }
public StrokeMath() { m_width = 0.5; m_width_abs = 0.5; m_width_eps = 0.5 / 1024.0; m_width_sign = 1; m_miter_limit = 4.0; m_inner_miter_limit = 1.01; m_approx_scale = 1.0; m_line_cap = LineCap.Butt; m_line_join = LineJoin.Miter; m_inner_join = InnerJoin.Miter; }
public void DrawLine(PointF p1, PointF p2, Color color, float width, LineCap startCap = LineCap.Flat, LineCap endCap = LineCap.Flat) { var tempWidth = pen.Width; var tempStartCap = pen.StartCap; var tempEndCap = pen.EndCap; SetPenConfig(width, startCap, endCap); DrawLine(p1, p2, color); SetPenConfig(tempWidth, tempStartCap, tempEndCap); }
public CustomLineCap(GraphicsPath fillPath, GraphicsPath strokePath, LineCap baseCap, float baseInset) { IntPtr fill = IntPtr.Zero; IntPtr stroke = IntPtr.Zero; if (fillPath != null) fill = fillPath.nativePath; if (strokePath != null) stroke = strokePath.nativePath; Status status = GDIPlus.GdipCreateCustomLineCap (fill, stroke, baseCap, baseInset, out nativeObject); GDIPlus.CheckStatus (status); }
/// <summary> /// 清空原有数据并加载一条波形数据 /// </summary> /// <param name="listX">X轴</param> /// <param name="listY">Y轴</param> /// <param name="listColor">线条颜色</param> /// <param name="listWidth">线条宽度</param> /// <param name="listLineJoin">线条连接点</param> /// <param name="listLineCap">线条起始线帽</param> /// <param name="listDrawStyle">线条样式</param> public void f_LoadOnePix(ref List<float> listX, ref List<float> listY, Color listColor, int listWidth, LineJoin listLineJoin, LineCap listLineCap,DrawStyle listDrawStyle) { //重新初始化 f_ClearAllPix(); //装载 _listX.Add(listX); _listY.Add(listY); _listColor.Add(listColor); _listWidth.Add(listWidth); _listLineJoin.Add(listLineJoin); _listLineCap.Add(listLineCap); _listDrawStyle.Add(listDrawStyle); }
public DrawEllipse(int x, int y, int width, int height, Color lineColor, Color fillColor, bool filled, int lineWidth, DrawingPens.PenType penType, LineCap endCap) { Rectangle = new Rectangle(x, y, width, height); Center = new Point(x + (width / 2), y + (height / 2)); TipText = String.Format("Ellipse Center @ {0}, {1}", Center.X, Center.Y); Color = lineColor; FillColor = fillColor; Filled = filled; PenWidth = lineWidth; PenType = penType; EndCap = endCap; Initialize(); }
public BaseLine(Color color, DashStyle dashStyle,float thickness, LineCap startLineCap, LineCap endLineCap, DashCap dashLineCap) { if (color == Color.White) { this.color = Color.Black; } this.color = color; this.dashStyle = dashStyle; this.thickness = thickness; this.startLineCap = startLineCap; this.endLineCap = endLineCap; this.dashLineCap = dashLineCap; }
/** * Set/get line caps: start, end, and dash */ /// <include file='doc\Pen.uex' path='docs/doc[@for="Pen.SetLineCap"]/*' /> /// <devdoc> /// <para> /// Sets the values that determine the style of /// cap used to end lines drawn by this <see cref='System.Drawing.Pen'/>. /// </para> /// </devdoc> public void SetLineCap(LineCap startCap, LineCap endCap, DashCap dashCap) { if (immutable) { throw new ArgumentException(SR.GetString(SR.CantChangeImmutableObjects, "Pen")); } int status = SafeNativeMethods.GdipSetPenLineCap197819(new HandleRef(this, nativePen), (int)startCap, (int)endCap, (int)dashCap); if (status != SafeNativeMethods.Ok) { throw SafeNativeMethods.StatusException(status); } }
// Map the cap style from "System.Drawing" to "Xsharp". private static CapStyle MapCapStyle(LineCap style) { switch(style) { case LineCap.Square: return CapStyle.CapProjecting; case LineCap.Flat: return CapStyle.CapButt; case LineCap.Round: default: return CapStyle.CapRound; } }
public void Deserialize(BinaryFormatter bf, Stream s) { version = (int)bf.Deserialize(s); _dashStyle = (DashStyle)bf.Deserialize(s); _width = (float)bf.Deserialize(s); _startCap = (LineCap)bf.Deserialize(s); _endCap = (LineCap)bf.Deserialize(s); _lineJoin = (LineJoin)bf.Deserialize(s); _dashCap = (DashCap)bf.Deserialize(s); _isPiple = (bool)bf.Deserialize(s); _brushData.Deserialize(bf, s); _pipleData.Deserialize(bf, s); }
public Pen(Brush brush, float width) { _brush = (Brush)brush.Clone();; _width = width; _dashStyle = DashStyle.Solid; _startCap = LineCap.Flat; _dashCap = DashCap.Flat; _endCap = LineCap.Flat; _alignment = PenAlignment.Center; _lineJoin = LineJoin.Miter; _miterLimit = 10f; _transform = new Matrix(); }
public StrokeMath() { _width = 0.5; _width_abs = 0.5; _width_eps = 0.5 / 1024.0; _width_sign = 1; _miter_limit = 4.0; _inner_miter_limit = 1.01; _approx_scale = 1.0; _line_cap = LineCap.Butt; _line_join = LineJoin.Miter; _inner_join = InnerJoin.Miter; }
// Methods public Stroke() { this.pen = Pens.Black; this.brush = new SolidColor(Color.Empty); this.strokeColor = Color.Empty; this.Width = 1f; this.Linecap = LineCap.Square; this.Linejoin = LineJoin.Miter; this.MiterLimit = 4; this.DashArray = null; this.DashOffset = 0f; this.Opacity = 1f; }
public Pen (Brush brush, float width) { _brush = (Brush)brush.Clone();; _width = width; _dashStyle = DashStyle.Solid; _startCap = LineCap.Flat; _dashCap = DashCap.Flat; _endCap = LineCap.Flat; _alignment = PenAlignment.Center; _lineJoin = LineJoin.Miter; _miterLimit = 10f; _transform = new Matrix(); }
public DrawPolygon(int x1, int y1, int x2, int y2, Color lineColor, int lineWidth, DrawingPens.PenType penType, LineCap endCap) { pointArray = new ArrayList(); pointArray.Add(new Point(x1, y1)); pointArray.Add(new Point(x2, y2)); Color = lineColor; PenWidth = lineWidth; PenType = penType; EndCap = endCap; LoadCursor(); Initialize(); }
public void SetLineCap(LineCap startCap, LineCap endCap, System.Drawing.Drawing2D.DashCap dashCap) { if (this.immutable) { throw new ArgumentException(System.Drawing.SR.GetString("CantChangeImmutableObjects", new object[] { "Pen" })); } int status = SafeNativeMethods.Gdip.GdipSetPenLineCap197819(new HandleRef(this, this.NativePen), (int)startCap, (int)endCap, (int)dashCap); if (status != 0) { throw SafeNativeMethods.Gdip.StatusException(status); } }
[InlineData(LineCap.Custom + 1, LineCap.Flat)] // Above valid enum range public void SetStrokeCaps_InvalidLineCap_ThrowsArgumentException(LineCap startCap, LineCap endCap) { using (GraphicsPath strokePath = new GraphicsPath()) using (CustomLineCap customLineCap = new CustomLineCap(null, strokePath)) { AssertExtensions.Throws <ArgumentException>(null, () => customLineCap.SetStrokeCaps(startCap, endCap)); // start and end cap should be unchanged. customLineCap.GetStrokeCaps(out LineCap retrievedStartCap, out LineCap retrievedEndCap); Assert.Equal(LineCap.Flat, retrievedStartCap); Assert.Equal(LineCap.Flat, retrievedEndCap); } }
public Stroke(ISvgBrush brush) { this.pen = brush.Pen; //this.brush = new SolidColor(pen.Color); this.strokeColor = pen.Color; this.Width = 1f; this.Linecap = LineCap.Square; this.Linejoin = LineJoin.Miter; this.MiterLimit = 4; this.DashArray = null; this.DashOffset = 0f; this.Opacity = 1f; this.brush = brush.Clone(); }
public CustomLineCap( GraphicsPath fillPath, GraphicsPath strokePath, LineCap baseCap, float baseInset ) { nativeCap = new GpCustomLineCap(); GpPath nativeFillPath = null; GpPath nativeStrokePath = null; if (fillPath != null) nativeFillPath = fillPath.nativePath; if (strokePath != null) nativeStrokePath = strokePath.nativePath; lastResult = NativeMethods.GdipCreateCustomLineCap( nativeFillPath, nativeStrokePath, baseCap, baseInset, out nativeCap); }
/// <summary> /// Creates a new set of cartographic lines that together form a line with a border. Since a compound /// pen is used, it is possible to use this to create a transparent line with just two border parts. /// </summary> /// <param name="fillColor">The fill color for the line</param> /// <param name="borderColor">The border color of the line</param> /// <param name="width">The width of the entire line</param> /// <param name="dash">The dash pattern to use</param> /// <param name="caps">The style of the start and end caps</param> public LineSymbolizer(Color fillColor, Color borderColor, double width, DashStyle dash, LineCap caps) { _strokes = new CopyList<IStroke>(); ICartographicStroke bs = new CartographicStroke(borderColor); bs.Width = width; bs.StartCap = caps; bs.EndCap = caps; bs.DashStyle = dash; bs.CompoundArray = new[]{0F, 0.2F, 0.8F, 1F}; _strokes.Add(bs); ICartographicStroke cs = new CartographicStroke(fillColor); cs.Width = width; cs.StartCap = caps; cs.EndCap = caps; cs.DashStyle = dash; cs.Width = width - 2; cs.CompoundArray = new[]{.2F, .8F}; _strokes.Add(cs); }
/// <summary> /// Creates a new <see cref="ShapeStyle"/> instance. /// </summary> /// <param name="name">The shape style name.</param> /// <param name="sa">The stroke color alpha channel.</param> /// <param name="sr">The stroke color red channel.</param> /// <param name="sg">The stroke color green channel.</param> /// <param name="sb">The stroke color blue channel.</param> /// <param name="fa">The fill color alpha channel.</param> /// <param name="fr">The fill color red channel.</param> /// <param name="fg">The fill color green channel.</param> /// <param name="fb">The fill color blue channel.</param> /// <param name="thickness">The stroke thickness.</param> /// <param name="textStyle">The text style.</param> /// <param name="lineStyle">The line style.</param> /// <param name="startArrowStyle">The start arrow style.</param> /// <param name="endArrowStyle">The end arrow style.</param> /// <param name="lineCap">The line cap.</param> /// <param name="dashes">The line dashes.</param> /// <param name="dashOffset">The line dash offset.</param> /// <returns>The new instance of the <see cref="ShapeStyle"/> class.</returns> public static ShapeStyle Create(string name = "", byte sa = 0xFF, byte sr = 0x00, byte sg = 0x00, byte sb = 0x00, byte fa = 0xFF, byte fr = 0x00, byte fg = 0x00, byte fb = 0x00, double thickness = 2.0, TextStyle textStyle = null, LineStyle lineStyle = null, ArrowStyle startArrowStyle = null, ArrowStyle endArrowStyle = null, LineCap lineCap = LineCap.Round, string dashes = default(string), double dashOffset = 0.0) { var style = new ShapeStyle() { Name = name, Stroke = ArgbColor.Create(sa, sr, sg, sb), Fill = ArgbColor.Create(fa, fr, fg, fb), Thickness = thickness, LineCap = lineCap, Dashes = dashes, DashOffset = dashOffset, LineStyle = lineStyle ?? LineStyle.Create("Line"), TextStyle = textStyle ?? TextStyle.Create("Text") }; style.StartArrowStyle = startArrowStyle ?? ArrowStyle.Create("Start", style); style.EndArrowStyle = endArrowStyle ?? ArrowStyle.Create("End", style); return style; }
/// <summary> /// Creates a new set of cartographic lines that together form a line with a border. Since a compound /// pen is used, it is possible to use this to create a transparent line with just two border parts. /// </summary> /// <param name="fillColor">The fill color for the line</param> /// <param name="borderColor">The border color of the line</param> /// <param name="width">The width of the entire line</param> /// <param name="dash">The dash pattern to use</param> /// <param name="startCap">The style of the start cap</param> /// <param name="endCap">The style of the end cap</param> public LineSymbolizer(Color fillColor, Color borderColor, double width, DashStyle dash, LineCap startCap, LineCap endCap) { _strokes = new CopyList<IStroke>(); ICartographicStroke bs = new CartographicStroke(borderColor) { Width = width, StartCap = startCap, EndCap = endCap, DashStyle = dash, }; _strokes.Add(bs); ICartographicStroke cs = new CartographicStroke(fillColor) { StartCap = startCap, EndCap = endCap, DashStyle = dash, Width = width - 2, }; _strokes.Add(cs); }
private static void DeserializeLineCap(SerializationInfo info, string label, out LineCap lineCap, out CustomLineCap customLineCap) { lineCap = (LineCap)info.GetInt32(label + "Cap"); customLineCap = null; if (lineCap != LineCap.Custom) return; customLineCap = (CustomLineCap)info.GetValue("Custom" + label + "Cap", typeof(CustomLineCap)); }
private static void SerializeLineCap(SerializationInfo info, string label, LineCap lineCap, CustomLineCap customLineCap) { if (lineCap == LineCap.Custom) { if (CustomEndCapSerializable(customLineCap)) { info.AddValue(label + "Cap", (int)lineCap); info.AddValue("Custom" + label + "Cap", customLineCap); } else info.AddValue(label+"Cap", (int)LineCap.Round); } else info.AddValue(label+"Cap", (int)lineCap); }
///<summary> /// Creates a new DrawableStrokeLineCap instance. ///</summary> ///<param name="lineCap">The line cap.</param> public DrawableStrokeLineCap(LineCap lineCap) { LineCap = lineCap; }
public CustomLineCap(GraphicsPath fillPath, GraphicsPath strokePath, LineCap baseCap, float baseInset) {}
public CustomLineCap(GraphicsPath fillPath, GraphicsPath strokePath, LineCap baseCap) : this(fillPath, strokePath, baseCap, 0) {}
/// <include file='doc\CustomLineCap.uex' path='docs/doc[@for="CustomLineCap.GetStrokeCaps"]/*' /> /// <devdoc> /// Gets the caps used to start and end lines. /// </devdoc> public void GetStrokeCaps(out LineCap startCap, out LineCap endCap) { int status = SafeNativeMethods.Gdip.GdipGetCustomLineCapStrokeCaps(new HandleRef(this, nativeCap), out startCap, out endCap); if (status != SafeNativeMethods.Gdip.Ok) throw SafeNativeMethods.Gdip.StatusException(status); }
public CustomLineCap(GraphicsPath fillPath, GraphicsPath strokePath, LineCap baseCap, float baseInset) { throw new NotImplementedException(); }
// Set the line capabilities. public void SetLineCap(LineCap startCap, LineCap endCap, DashCap dashCap) { Dispose(); this.startCap = startCap; this.endCap = endCap; this.dashCap = dashCap; }
public static extern GpStatus GdipCreateCustomLineCap(GpPath fillPath, GpPath strokePath, LineCap baseCap, float baseInset, out GpCustomLineCap customCap);
public void SetStrokeCaps(LineCap startCap, LineCap endCap) { throw new NotImplementedException(); }