/// <summary>
/// Load Content and initialize unmanaged resources.
/// </summary>
public override void LoadContent()
{
base.LoadContent();
_dashStyle = new StrokeStyle(Surface.Factory2D,
new StrokeStyleProperties()
{
DashCap = CapStyle.Flat, DashStyle = DashStyle.Custom, DashOffset = 10f, LineJoin = LineJoin.MiterOrBevel, MiterLimit = 2f
}, new float[] { 2, 2 });
_dotDashStyle = new StrokeStyle(Surface.Factory2D,
new StrokeStyleProperties()
{
DashCap = CapStyle.Flat, DashStyle = DashStyle.Custom, DashOffset = 10f, LineJoin = LineJoin.MiterOrBevel, MiterLimit = 2f
}, new float[] { 3, 2, 1, 2 });
_solidStyle = new StrokeStyle(Surface.Factory2D,
new StrokeStyleProperties()
{
DashCap = CapStyle.Flat, DashStyle = DashStyle.Solid, LineJoin = LineJoin.MiterOrBevel, MiterLimit = 2f
});
var font = Surface.Fonts.GetTextFormat(MM_Repository.OverallDisplay.NetworkMapFont);
textLayoutNormallyOpen = new TextLayout(Surface.FactoryDirectWrite, "N.O.", font, 40, 40);
textLayoutTieLine = new TextLayout(Surface.FactoryDirectWrite, "Tie", font, 40, 40);
if (LineFlow != null)
{
LineFlow.Dispose();
}
LineFlow = new PathGeometry(Surface.Factory2D);
using (GeometrySink sink = LineFlow.Open())
{
RawVector2 p0 = new RawVector2 {
X = 0f, Y = 0f
};
RawVector2 p1 = new RawVector2 {
X = -1f, Y = 1.0f
};
RawVector2 p2 = new RawVector2 {
X = -1f, Y = -1.0f
};
sink.BeginFigure(p0, FigureBegin.Filled);
sink.AddLine(p1);
sink.AddLine(p2);
sink.EndFigure(FigureEnd.Closed);
// Note that Close() and Dispose() are not equivalent like they are for
// some other IDisposable() objects.
sink.Close();
}
}
public override void Draw(RenderTarget target)
{
SolidColorBrush brush = new SolidColorBrush(target, Color.RawColor);
var pathGeometry = new PathGeometry(target.Factory);
var geometrySink = pathGeometry.Open();
if (_points.Count > 0)
{
geometrySink.BeginFigure(_points.First(), FigureBegin.Filled);
for (int i = 1; i < _points.Count && i < _framePoint; i++)
{
geometrySink.AddLine(_points[i]);
}
geometrySink.EndFigure(FigureEnd.Open);
}
geometrySink.Close();
// target.DrawGeometry(pathGeometry, brush);
target.DrawGeometry(new GeometryNode().PathGeometry, brush);
// important. turn pathGeometry into nodes
// pathGeometry.Combine
pathGeometry.Dispose();
brush.Dispose();
_frameDelayCounter++;
if (_frameDelayCounter >= FrameDelay)
{
_framePoint++;
_frameDelayCounter = 0;
}
}
/// <summary>
/// Draws a Polygon.
/// </summary>
/// <param name="pen">The Pen.</param>
/// <param name="polygon">The Polygon.</param>
public void DrawPolygon(Pen pen, Polygon polygon)
{
var dxPen = pen.Instance as DirectXPen;
if (dxPen == null)
{
throw new ArgumentException("DirectX10 expects a DirectXPen as resource.");
}
var geometry = new PathGeometry(DirectXHelper.Direct2DFactory);
using (GeometrySink sink = geometry.Open())
{
sink.BeginFigure(DirectXHelper.ConvertVector(polygon.Points[0]), FigureBegin.Hollow);
for (int i = 1; i < polygon.Points.Length; i++)
{
sink.AddLine(DirectXHelper.ConvertVector(polygon.Points[i]));
}
sink.EndFigure(FigureEnd.Closed);
sink.Close();
_renderTarget.DrawGeometry(geometry, dxPen.GetPen(), dxPen.Width);
}
geometry.Dispose();
}
private void RenderingDrawMultiLine(List <float[]> points, int[] color, int thickness, bool drawWorldMap)
{
RawVector2[] pts = new RawVector2[points.Count + 1];
for (int i = 0; i < points.Count; i++)
{
int[] screen;
Helpers.ViewTransform.ToScreen.WorldToScreen(points[i], out screen, drawWorldMap);
pts[i] = new RawVector2(screen[0], screen[1]);
}
pts[pts.Length - 1] = pts[0];
pathGeometry = new PathGeometry(factory);
geometrySink = pathGeometry.Open();
geometrySink.BeginFigure(pts[0], new FigureBegin());
geometrySink.AddLines(pts);
geometrySink.EndFigure(new FigureEnd());
geometrySink.Close();
ChangeColor(color);
device.DrawGeometry(pathGeometry, solidColorBrush);
pathGeometry.Dispose();
geometrySink.Dispose();
}
public Result DrawGlyphRun(object clientDrawingContext, float baselineOriginX, float baselineOriginY, MeasuringMode measuringMode, GlyphRun glyphRun, GlyphRunDescription glyphRunDescription, ComObject clientDrawingEffect)
{
var pathGeometry = new PathGeometry(_d2DFactory);
var geometrySink = pathGeometry.Open();
var fontFace = glyphRun.FontFace;
if (glyphRun.Indices.Length > 0)
{
fontFace.GetGlyphRunOutline(glyphRun.FontSize, glyphRun.Indices, glyphRun.Advances, glyphRun.Offsets, glyphRun.IsSideways, glyphRun.BidiLevel % 2 != 0, geometrySink);
}
geometrySink.Close();
geometrySink.Dispose();
fontFace.Dispose();
var matrix = new Matrix3x2()
{
M11 = 1,
M12 = 0,
M21 = 0,
M22 = 1,
M31 = baselineOriginX,
M32 = baselineOriginY
};
var transformedGeometry = new TransformedGeometry(_d2DFactory, pathGeometry, matrix);
_renderTarget.DrawGeometry(transformedGeometry, PenBrush, PenWidth, PenStyle);
_renderTarget.FillGeometry(transformedGeometry, FontBrush);
pathGeometry.Dispose();
transformedGeometry.Dispose();
return(SharpDX.Result.Ok);
}
/// <summary>
/// Draw line with the data point collection.
/// </summary>
/// <param name="points"></param>
/// <param name="xAxesCenterHeight"></param>
/// <param name="yAxesCenterWidth"></param>
/// <param name="HeightRate"></param>
/// <param name="WidthRate"></param>
/// <param name="xAxesMaxValue"></param>
/// <param name="color"></param>
/// <param name="autoShift"></param>
/// <param name="keepInRightOfYAxis"></param>
public System.Drawing.Point Draw(int layerIndex, Charting.Base.DataPointCollection points, float xAxesCenterHeight, float yAxesCenterWidth, float HeightRate, float WidthRate, float xAxesMaxValue, System.Drawing.Color color, float opacity, bool autoShift = true, bool keepInRightOfYAxis = false)
{
this.opacity = opacity;
device.layers[layerIndex].AntialiasMode = AntialiasMode.PerPrimitive;
if (curentColor != color)
{
SetLineColor(color, opacity);
}
SharpDX.Vector2[] tmpPointArray;
float MinX = 0;
float tmpYAxesCenterWidth = yAxesCenterWidth;
tmpPointArray = DrawingBase.Convertor.convertDataPointToVector2Array(points, HeightRate, WidthRate, out MinX);
if (tmpPointArray.Length > 1)
{
if (autoShift)
{
if (points.GetLast().XValue > xAxesMaxValue)
{
tmpYAxesCenterWidth = -((float)points.GetLast().XValue - xAxesMaxValue) * WidthRate + yAxesCenterWidth;
}
else
{
tmpYAxesCenterWidth = -tmpPointArray[0].X + yAxesCenterWidth;
}
}
if (keepInRightOfYAxis)
{
if (MinX < 0)
{
tmpYAxesCenterWidth = tmpYAxesCenterWidth - MinX;
}
}
var linePath = new PathGeometry(device.factory);
using (var sink = linePath.Open())
{
sink.BeginFigure(tmpPointArray[0], FigureBegin.Hollow);
sink.AddLines(tmpPointArray);
sink.EndFigure(FigureEnd.Open);
sink.Close();
}
if (device.layers[layerIndex] != null)
{
device.layers[layerIndex].Transform = Matrix.Translation(tmpYAxesCenterWidth, xAxesCenterHeight, 0);
if (pattern != Charting.Base.LineDrawPattern.SOLID)
{
device.layers[layerIndex].DrawGeometry(linePath, brush, Width, strokeStyle);
}
else
{
device.layers[layerIndex].DrawGeometry(linePath, brush, Width);
}
device.layers[layerIndex].Transform = Matrix.Identity;
}
linePath.Dispose();
}
return(new System.Drawing.Point((int)tmpYAxesCenterWidth, (int)xAxesCenterHeight));
}
public override void DrawDashPolygon(PointF[] pts)
{
if (pts.Length == 0)
{
return;
}
PathGeometry geo = new PathGeometry(factory);
var sink = geo.Open();
sink.BeginFigure(pts[0].ToVector(), FigureBegin.Filled);
for (int i = 0; i < pts.Length; i++)
{
sink.AddLine(pts[i].ToVector());
}
sink.EndFigure(FigureEnd.Open);
sink.Close();
StrokeStyle style = new StrokeStyle(factory, new StrokeStyleProperties()
{
DashStyle = DashStyle.Dash
});
renderTarget.DrawGeometry(geo, brush_gray, 4, style);
renderTarget.DrawLine(pts[0].ToVector(), pts[pts.Length - 1].ToVector(), brush_gray, 2, style);
style.Dispose();
sink.Dispose();
geo.Dispose();
}
private static void DrawRestDotPart(RenderTarget renderTarget, RawVector2 pos, Color color)
{
PointF[] pathPoints;
using (GraphicsPath path = new GraphicsPath())
{
path.AddBezier(pos.X, pos.Y + 3f, pos.X - 2f, pos.Y + 6f, pos.X - 8f, pos.Y + 8f, pos.X - 12f, pos.Y + 2f);
path.AddBezier((float)(pos.X - 12f), (float)(pos.Y + 2f), (float)(pos.X - 8f), (float)(pos.Y + 6.5f), (float)(pos.X - 2f), (float)(pos.Y + 5f), (float)(pos.X + 1f), (float)(pos.Y - 1f));
path.Flatten();
pathPoints = path.PathPoints;
path.Dispose();
}
using (SharpDX.Direct2D1.Factory factory = renderTarget.Factory)
{
PathGeometry geometry = new PathGeometry(factory);
if (pathPoints.Length > 1)
{
GeometrySink sink = geometry.Open();
sink.SetSegmentFlags(PathSegment.ForceRoundLineJoin);
sink.BeginFigure(new RawVector2(pathPoints[0].X, pathPoints[0].Y), FigureBegin.Filled);
for (int i = 1; i < pathPoints.Length; i++)
{
sink.AddLine(new RawVector2(pathPoints[i].X, pathPoints[i].Y));
}
sink.EndFigure(FigureEnd.Closed);
sink.Close();
sink.Dispose();
}
SolidColorBrush brush = new SolidColorBrush(renderTarget, color.ToRawColor4(1f));
renderTarget.FillGeometry(geometry, brush);
brush.Dispose();
geometry.Dispose();
}
renderTarget.FillCircle(new RawVector2(pos.X - 8f, pos.Y + 2f), 3f, color);
}
public void BorderedLine(float start_x, float start_y, float end_x, float end_y, float stroke, Direct2DBrush brush, Direct2DBrush borderBrush)
{
var geometry = new PathGeometry(_factory);
var sink = geometry.Open();
float half = stroke / 2.0f;
float quarter = half / 2.0f;
sink.BeginFigure(new RawVector2(start_x, start_y - half), FigureBegin.Filled);
sink.AddLine(new RawVector2(end_x, end_y - half));
sink.AddLine(new RawVector2(end_x, end_y + half));
sink.AddLine(new RawVector2(start_x, start_y + half));
sink.EndFigure(FigureEnd.Closed);
sink.Close();
_device.DrawGeometry(geometry, borderBrush, half);
_device.FillGeometry(geometry, brush);
sink.Dispose();
geometry.Dispose();
}
public void DrawShip(RenderTarget D2DRT, SolidColorBrush scb, Factory d2dFactory)
{
PathGeometry shape = new PathGeometry(d2dFactory);
GeometrySink sink = shape.Open();
//Ship Front
sink.BeginFigure(new Vector2((float)X + direction.X * 20, (float)Y - direction.Y * 20), FigureBegin.Hollow);
//Calculating Ship Right Wing by rotating unit vector 90 degrees
float rwX = (float)(direction.X * 0 - direction.Y * -1);
float rwY = (float)(direction.X * 1 + direction.Y * 0);
sink.AddLine(new Vector2(X + rwX * 7, Y + rwY * 7));
//Calculating Ship Left Wing by rotating unit vector 270 degrees
float lwX = (float)(direction.X * 0 - direction.Y * 1);
float lwY = (float)(direction.X * -1 + direction.Y * 0);
sink.AddLine(new Vector2(X + lwX * 7, Y - rwY * 7));
sink.EndFigure(FigureEnd.Closed);
sink.Close();
D2DRT.DrawGeometry(shape, scb, 1f);
//draw a line that is 10 times the length of the unit vector ship.direction
D2DRT.DrawLine(new Vector2(X, Y), new Vector2(X + direction.X * 10, Y - direction.Y * 10), scb);
edgePoints = new List <Vector2>();
edgePoints.Add(new Vector2((float)X + direction.X * 20, (float)(Y - direction.Y * 20)));
edgePoints.Add(new Vector2(X + lwX * 7, Y - rwY * 7));
edgePoints.Add(new Vector2(X + lwX * 7, Y - rwY * 7));
shape.Dispose();
sink.Dispose();
}
public void DrawBox2D(float x, float y, float width, float height, float stroke, Direct2DColor interiorColor, Direct2DColor color)
{
var geometry = new PathGeometry(_factory);
var sink = geometry.Open();
sink.BeginFigure(new RawVector2(x, y), FigureBegin.Filled);
sink.AddLine(new RawVector2(x + width, y));
sink.AddLine(new RawVector2(x + width, y + height));
sink.AddLine(new RawVector2(x, y + height));
sink.EndFigure(FigureEnd.Closed);
sink.Close();
_sharedBrush.Color = color;
_device.DrawGeometry(geometry, _sharedBrush, stroke);
_sharedBrush.Color = interiorColor;
_device.FillGeometry(geometry, _sharedBrush);
sink.Dispose();
geometry.Dispose();
}
public override Result DrawStrikethrough(object clientDrawingContext, float baselineOriginX, float baselineOriginY, ref Strikethrough strikethrough, ComObject clientDrawingEffect)
{
PathGeometry pg = new PathGeometry(this.factory);
GeometrySink sink = pg.Open();
Vector2 topLeft = new Vector2(0.0f, strikethrough.Offset);
sink.BeginFigure(topLeft, FigureBegin.Filled);
topLeft.X += strikethrough.Width;
sink.AddLine(topLeft);
topLeft.Y += strikethrough.Thickness;
sink.AddLine(topLeft);
topLeft.X -= strikethrough.Width;
sink.AddLine(topLeft);
sink.EndFigure(FigureEnd.Closed);
sink.Close();
TransformedGeometry tg = new TransformedGeometry(this.factory, pg, Matrix3x2.Translation(baselineOriginX, baselineOriginY) * Matrix3x2.Scaling(1.0f, -1.0f));
pg.Dispose();
sink.Dispose();
this.AddGeometry(tg);
return(Result.Ok);
}
public static void FillSector(this RenderTarget renderTarget, RawVector2 pos, float radius, Color color, float angleStart, float angleEnd)
{
PointF[] pathPoints;
using (GraphicsPath path = new GraphicsPath())
{
radius *= 2f;
path.AddPie(pos.X - (radius / 2f), pos.Y - (radius / 2f), radius, radius, angleStart, angleEnd);
path.Flatten();
pathPoints = path.PathPoints;
path.Dispose();
}
using (SharpDX.Direct2D1.Factory factory = renderTarget.Factory)
{
PathGeometry geometry = new PathGeometry(factory);
if (pathPoints.Length > 1)
{
GeometrySink sink = geometry.Open();
sink.SetSegmentFlags(PathSegment.ForceRoundLineJoin);
sink.BeginFigure(new RawVector2(pathPoints[0].X, pathPoints[0].Y), FigureBegin.Filled);
for (int i = 1; i < pathPoints.Length; i++)
{
sink.AddLine(new RawVector2(pathPoints[i].X, pathPoints[i].Y));
}
sink.EndFigure(FigureEnd.Closed);
sink.Close();
sink.Dispose();
}
SolidColorBrush brush = new SolidColorBrush(renderTarget, color.ToRawColor4(1f));
renderTarget.FillGeometry(geometry, brush);
brush.Dispose();
geometry.Dispose();
}
}
public override void Draw(RenderTarget target)
{
if (this.points.Count >= 4)
{
SolidColorBrush curveBrush = new SolidColorBrush(target, this.LineColor);
PathGeometry geometry = new PathGeometry(target.Factory);
GeometrySink gs = geometry.Open();
gs.BeginFigure(this.points[0], FigureBegin.Filled);
for (int i = 0; i < this.points.Count - 3; i += 2)
{
float a = 0;
float b = 1;
float h = (b - a) / this.resolution;
float t = a;
RawVector2 P0, P1;
P0 = MathHelper.Interpolate(t, this.points[i], this.points[i + 1], this.points[i + 2], this.points[i + 3]);
while (t < b)
{
t += h;
P1 = MathHelper.Interpolate(t, this.points[i], this.points[i + 1], this.points[i + 2], this.points[i + 3]);
// target.DrawLine(P0, P1, curveBrush);
gs.AddLine(P0);
gs.AddLine(P1);
P0 = P1;
}
}
if (this.Closed)
{
this.Close(target, gs);
gs.EndFigure(FigureEnd.Closed);
gs.Close();
if (this.Filled)
{
SolidColorBrush fillBrush = new SolidColorBrush(target, this.FillColor);
target.FillGeometry(geometry, fillBrush);
fillBrush.Dispose();
}
}
else
{
gs.EndFigure(FigureEnd.Open);
gs.Close();
}
target.DrawGeometry(geometry, curveBrush, this.LineThickness);
gs.Dispose();
geometry.Dispose();
curveBrush.Dispose();
}
base.Draw(target);
}
protected override void OnCleanUpDeviceIndependentResources()
{
base.OnCleanUpDeviceIndependentResources();
_leftMountainGeometry.Dispose();
_rightMountainGeometry.Dispose();
_sunGeometry.Dispose();
_riverGeometry.Dispose();
}
private static void DrawTie(this RenderTarget renderTarget, SharpDX.DirectWrite.Factory writeFactory, RawVector2 startPos, RawVector2 endPos, Color color, bool flipVertical = false, bool isTriplet = false)
{
PointF[] pathPoints;
RawVector2 vector;
RawVector2 vector2;
using (GraphicsPath path = new GraphicsPath())
{
float num = 45f;
float num2 = 0.3f;
float num3 = startPos.GetDistanceByRawVector2(endPos).Clamp(64f, 256f);
float num4 = startPos.GetAngleByRawVector2(endPos);
float num5 = endPos.GetAngleByRawVector2(startPos);
if (flipVertical)
{
vector = startPos.GetRawVector2ByPolarCoordinates(num4 + num, num3 * num2);
vector2 = endPos.GetRawVector2ByPolarCoordinates(num5 - num, num3 * num2);
path.AddBezier(startPos.X, startPos.Y, vector.X, vector.Y, vector2.X, vector2.Y, endPos.X, endPos.Y);
path.AddBezier(endPos.X, endPos.Y + 1f, vector2.X, vector2.Y + 2f, vector.X, vector.Y + 2f, startPos.X, startPos.Y + 1f);
}
else
{
vector = startPos.GetRawVector2ByPolarCoordinates(num4 - num, num3 * num2);
vector2 = endPos.GetRawVector2ByPolarCoordinates(num5 + num, num3 * num2);
path.AddBezier(startPos.X, startPos.Y, vector.X, vector.Y, vector2.X, vector2.Y, endPos.X, endPos.Y);
path.AddBezier(endPos.X, endPos.Y - 1f, vector2.X, vector2.Y - 2f, vector.X, vector.Y - 2f, startPos.X, startPos.Y - 1f);
}
path.Flatten();
pathPoints = path.PathPoints;
path.Dispose();
}
using (SharpDX.Direct2D1.Factory factory = renderTarget.Factory)
{
PathGeometry geometry = new PathGeometry(factory);
if (pathPoints.Length > 1)
{
GeometrySink sink = geometry.Open();
sink.SetSegmentFlags(PathSegment.ForceRoundLineJoin);
sink.BeginFigure(new RawVector2(pathPoints[0].X, pathPoints[0].Y), FigureBegin.Filled);
for (int i = 1; i < pathPoints.Length; i++)
{
sink.AddLine(new RawVector2(pathPoints[i].X, pathPoints[i].Y));
}
sink.EndFigure(FigureEnd.Closed);
sink.Close();
sink.Dispose();
}
SolidColorBrush brush = new SolidColorBrush(renderTarget, color.ToRawColor4(1f));
renderTarget.FillGeometry(geometry, brush);
brush.Dispose();
geometry.Dispose();
if (isTriplet)
{
RawVector2 pos = new RawVector2(vector.X + ((vector2.X - vector.X) / 2f), vector.Y + ((vector2.Y - vector.Y) / 2f));
renderTarget.DrawTextLayout(writeFactory, "3", pos, "Consolas", 16f, Color.FromArgb((int)(color.A * 0.75f), color), TextAlignment.Center, ParagraphAlignment.Center, SharpDX.DirectWrite.FontStyle.Normal, FontWeight.ExtraBlack);
}
}
}
/// <summary>
/// Disposes of resources</summary>
/// <param name="disposing">True to release both managed and unmanaged resources;
/// false to release only unmanaged resources</param>
protected override void Dispose(bool disposing)
{
if (disposing && m_geometry != null)
{
m_geometry.Dispose();
m_geometry = null;
}
base.Dispose(disposing);
}
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
blue.Dispose();
red.Dispose();
brush.Dispose();
sink.Dispose();
path.Dispose();
renderTarget.Dispose();
factory.Dispose();
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
GeometrySink sink = Interlocked.Exchange(ref _sink, null);
if (sink != null)
{
sink.Dispose();
PathGeometry.Dispose();
}
}
public Result DrawGlyphRun(object clientDrawingContext, float baselineOriginX, float baselineOriginY, MeasuringMode measuringMode, GlyphRun glyphRun, GlyphRunDescription glyphRunDescription, ComObject clientDrawingEffect)
{
if (clientDrawingEffect != null && clientDrawingEffect is SolidColorBrush)
{
SolidColorBrush brushx = clientDrawingEffect as SolidColorBrush;
_renderTarget.DrawGlyphRun(new Vector2(baselineOriginX, baselineOriginY), glyphRun, brushx, measuringMode);
return(Result.Ok);
}
var pathGeometry = new PathGeometry(_d2DFactory);
var geometrySink = pathGeometry.Open();
var fontFace = glyphRun.FontFace;
if (glyphRun.Indices.Length > 0)
{
fontFace.GetGlyphRunOutline(glyphRun.FontSize, glyphRun.Indices, glyphRun.Advances, glyphRun.Offsets, glyphRun.IsSideways, glyphRun.BidiLevel % 2 != 0, geometrySink);
}
geometrySink.Close();
geometrySink.Dispose();
fontFace.Dispose();
var matrix = new Matrix3x2()
{
M11 = 1,
M12 = 0,
M21 = 0,
M22 = 1,
M31 = baselineOriginX,
M32 = baselineOriginY
};
var transformedGeometry = new TransformedGeometry(_d2DFactory, pathGeometry, matrix);
var brushColor = (Color4)Color.Black;
SolidColorBrush brush = null;
if (clientDrawingEffect != null && clientDrawingEffect is ColorDrawingEffect)
{
brushColor = (clientDrawingEffect as ColorDrawingEffect).Color;
}
brush = new SolidColorBrush(_renderTarget, brushColor);
// _renderTarget.DrawGeometry(transformedGeometry, brush);
_renderTarget.FillGeometry(transformedGeometry, brush);
pathGeometry.Dispose();
transformedGeometry.Dispose();
brush.Dispose();
return(SharpDX.Result.Ok);
}
protected override void OnCleanUpDeviceIndependentResources()
{
base.OnCleanUpDeviceIndependentResources();
_strokeStyle.Dispose();
_textFormat.Dispose();
_circleGeometry1.Dispose();
_circleGeometry2.Dispose();
_geometryUnion.Dispose();
_geometryIntersect.Dispose();
_geometryXor.Dispose();
_geometryExclude.Dispose();
}
public static void DrawBezierLine(this RenderTarget renderTarget, PointF[] points, Color color, float strokeWidth, StrokeStyle strokeStyle, bool disposeStrokeStyle = true)
{
if (points.Length >= 2)
{
PointF[] pathPoints;
int num;
using (GraphicsPath path = new GraphicsPath())
{
List <PointF> list = new List <PointF> {
points.First <PointF>()
};
for (num = 1; num < points.Length; num++)
{
PointF tf;
PointF tf2;
GetBezierCtrlPoint(points, num - 1, 0.15f, 0.15f, out tf, out tf2);
list.Add(tf);
list.Add(tf2);
list.Add(points[num]);
}
path.AddBeziers(list.ToArray());
path.Flatten();
pathPoints = path.PathPoints;
path.Dispose();
}
using (SharpDX.Direct2D1.Factory factory = renderTarget.Factory)
{
PathGeometry geometry = new PathGeometry(factory);
if (pathPoints.Length > 1)
{
GeometrySink sink = geometry.Open();
sink.SetSegmentFlags(PathSegment.ForceRoundLineJoin);
sink.BeginFigure(new RawVector2(pathPoints[0].X, pathPoints[0].Y), FigureBegin.Filled);
for (num = 1; num < pathPoints.Length; num++)
{
sink.AddLine(new RawVector2(pathPoints[num].X, pathPoints[num].Y));
}
sink.EndFigure(FigureEnd.Open);
sink.Close();
sink.Dispose();
}
SolidColorBrush brush = new SolidColorBrush(renderTarget, color.ToRawColor4(1f));
renderTarget.DrawGeometry(geometry, brush, strokeWidth, strokeStyle);
brush.Dispose();
geometry.Dispose();
}
if (disposeStrokeStyle && (strokeStyle != null))
{
strokeStyle.Dispose();
}
}
}
public override void Draw()
{
if (isMouseDown && Math.Abs(beginAngle - dragAngle) > sweepAngleMinimum)
{
Pie = displayer.Factory.CreatePathGeometry(); //扇形区域
//开始合成扇形
GeometrySink gs = Pie.Open();
gs.BeginFigure(displayer.coordinateSystem.OriginalPoint, FigureBegin.Filled);
//添加第一条线
//float angle1 = CoordinateSystem.AngleToNorth(displayer.coordinateSystem.OriginalPoint, beginLinePoint);
//angle1 -= 30;
//if (angle1 < 0)
// angle1 += 360;
//Point2F p = displayer.coordinateSystem.CalIntersectionPoint(angle1);
//gs.AddLine(p);
gs.AddLine(beginLinePoint); //原始代码
//判断起始角度和结束角度
float begin = Tools.FindSmallArcBeginAngle(beginAngle, dragAngle);
float end = Tools.FindSmallArcEndAngle(beginAngle, dragAngle);
//判断上行扫过的方向，如果起始角度是鼠标点击的位置则扇形是顺时针扫过
//如果起始角度是鼠标拖动位置，则扇形是逆时针扫过
SweepDirection sd;
sd = Tools.FloatEquals(begin, beginAngle) ? SweepDirection.Clockwise : SweepDirection.Counterclockwise;
//扇形的X轴Y轴半径是矩形框width的一半
SizeF size = new SizeF(displayer.coordinateSystem.CoordinateArea.Width / 2, displayer.coordinateSystem.CoordinateArea.Height / 2);
//添加弧线
ArcSegment arc = new ArcSegment(dragLinePoint, size, 0, sd, ArcSize.Small);
gs.AddArc(arc);
//添加第二条线
gs.AddLine(displayer.coordinateSystem.OriginalPoint);
gs.EndFigure(FigureEnd.Closed);
gs.Close();
//绘制区域
displayer.Canvas.FillGeometry(Pie, antennaRangeAreaBrush);
displayer.Canvas.DrawGeometry(Pie, antennaRangeAreaBrush, 3);
//释放资源
gs.Dispose();
Pie.Dispose();
}
}
public override void Draw()
{
if (!isMouseDown)
{
return;
}
var gs = CreateSectionSweepGeometry();
//绘制区域
DrawSectionSweepGeometry();
//释放资源
gs.Dispose();
_pie.Dispose();
}
public override void Draw(RenderTarget target)
{
SolidColorBrush polyBrush = new SolidColorBrush(target, this.LineColor);
PathGeometry geometry = new PathGeometry(target.Factory);
GeometrySink gs = geometry.Open();
gs.BeginFigure(this.points[0], FigureBegin.Filled);
for (int i = 0; i < this.PointCount - 1; i++)
{
gs.AddLine(new RawVector2()
{
X = this.points[i].X, Y = this.points[i].Y
});
gs.AddLine(new RawVector2()
{
X = this.points[i + 1].X, Y = this.points[i + 1].Y
});
}
if (this.Closed)
{
gs.EndFigure(FigureEnd.Closed);
}
else
{
gs.EndFigure(FigureEnd.Open);
}
gs.Close();
target.DrawGeometry(geometry, polyBrush);
if (this.Filled)
{
SolidColorBrush fillBrush = new SolidColorBrush(target, this.FillColor);
target.FillGeometry(geometry, fillBrush);
fillBrush.Dispose();
}
gs.Dispose();
geometry.Dispose();
polyBrush.Dispose();
base.Draw(target);
}
public void FillTriangle(float a_x, float a_y, float b_x, float b_y, float c_x, float c_y, Direct2DBrush brush)
{
var geometry = new PathGeometry(_factory);
var sink = geometry.Open();
sink.BeginFigure(new RawVector2(a_x, a_y), FigureBegin.Filled);
sink.AddLine(new RawVector2(b_x, b_y));
sink.AddLine(new RawVector2(c_x, c_y));
sink.EndFigure(FigureEnd.Closed);
sink.Close();
_device.FillGeometry(geometry, brush);
sink.Dispose();
geometry.Dispose();
}
public static void DrawArrow(this RenderTarget target, SolidColorBrush brush, RawVector2 V0, RawVector2 V1, float alpha, float size)
{
target.DrawLine(V0, V1, brush);
float distance = Distance(V0, V1);
RawVector2 pH = new RawVector2()
{
X = (size * V0.X + (distance - size) * V1.X) / distance, Y = (size * V0.Y + (distance - size) * V1.Y) / distance
};
RawVector2[] triangle = new RawVector2[3];
triangle[0] = V1;
float beta = (float)Math.Atan2(V1.Y - V0.Y, V1.X - V0.X);
float d = Distance(V1, pH) * (float)Math.Tan(alpha * Math.PI / 360);
float angle1 = (float)(beta + Math.PI / 2);
float angle2 = (float)(beta - Math.PI / 2);
triangle[1] = new RawVector2()
{
X = pH.X + d * (float)Math.Cos(angle1), Y = pH.Y + d * (float)Math.Sin(angle1)
};
triangle[2] = new RawVector2()
{
X = pH.X + d * (float)Math.Cos(angle2), Y = pH.Y + d * (float)Math.Sin(angle2)
};
PathGeometry polygonGeometry = new PathGeometry(target.Factory);
GeometrySink gs = polygonGeometry.Open();
gs.BeginFigure(triangle[0], FigureBegin.Filled);
gs.AddLines(new RawVector2[]
{
triangle[1],
triangle[2]
});
gs.EndFigure(FigureEnd.Closed);
gs.Close();
target.FillGeometry(polygonGeometry, brush);
gs.Dispose();
polygonGeometry.Dispose();
}
/// <summary>
/// Releases all resources used by this Geometry.
/// </summary>
/// <param name="disposing">A Boolean value indicating whether this is called from the destructor.</param>
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
try
{
if (IsOpen)
{
_sink.Close();
}
_sink.Dispose();
_geometry.Dispose();
}
catch { }
disposedValue = true;
}
}
public Result DrawGlyphRun(object clientDrawingContext, float baselineOriginX, float baselineOriginY, MeasuringMode measuringMode, GlyphRun glyphRun, GlyphRunDescription glyphRunDescription, ComObject clientDrawingEffect)
{
var pathGeometry = new PathGeometry(_d2DFactory);
var geometrySink = pathGeometry.Open();
float[] advances;
GlyphOffset[] offsets;
var indecies = glyphRun.ToArrays(out advances, out offsets);
var result = glyphRun.FontFace.GetGlyphRunOutline(glyphRun.FontSize, indecies, advances, offsets, glyphRun.IsSideways, glyphRun.BidiLevel % 2 != 0, geometrySink);
geometrySink.Close();
var matrix = new Matrix3x2()
{
M11 = 1,
M12 = 0,
M21 = 0,
M22 = 1,
M31 = baselineOriginX,
M32 = baselineOriginY
};
var transformedGeometry = new TransformedGeometry(_d2DFactory, pathGeometry, matrix);
var brushColor = new Color4(1, 0, 0, 0);
if (clientDrawingEffect != null && clientDrawingEffect is ColorDrawingEffect)
{
brushColor = (clientDrawingEffect as ColorDrawingEffect).Color;
}
var brush = new SolidColorBrush(_renderTarget, brushColor);
_renderTarget.DrawGeometry(transformedGeometry, brush);
_renderTarget.FillGeometry(transformedGeometry, brush);
pathGeometry.Dispose();
transformedGeometry.Dispose();
brush.Dispose();
return(SharpDX.Result.Ok);
}
/// <summary>
/// Unload content and cleanup unmanaged resources.
/// </summary>
public override void UnloadContent()
{
base.UnloadContent();
if (_slice != null)
{
_slice.Dispose();
}
_slice = null;
var legendItems = _strings.Values.ToList();
_strings.Clear();
foreach (var legendItem in legendItems)
{
legendItem.Dispose();
}
legendItems.Clear();
_legendFont = null;
}
/// <summary>
/// Fills a Polygon.
/// </summary>
/// <param name="color">The Color.</param>
/// <param name="polygon">The Polygon.</param>
public void FillPolygon(Color color, Polygon polygon)
{
var geometry = new PathGeometry(DirectXHelper.Direct2DFactory);
using (GeometrySink sink = geometry.Open())
{
sink.BeginFigure(DirectXHelper.ConvertVector(polygon.Points[0]), FigureBegin.Filled);
for (int i = 1; i < polygon.Points.Length; i++)
sink.AddLine(DirectXHelper.ConvertVector(polygon.Points[i]));
sink.EndFigure(FigureEnd.Closed);
sink.Close();
_renderTarget.FillGeometry(geometry,
new SolidColorBrush(DirectXHelper.RenderTarget, DirectXHelper.ConvertColor(color)));
}
geometry.Dispose();
}
/// <summary>
/// Draws a Polygon.
/// </summary>
/// <param name="pen">The Pen.</param>
/// <param name="polygon">The Polygon.</param>
public void DrawPolygon(Pen pen, Polygon polygon)
{
var dxPen = pen.Instance as DirectXPen;
if (dxPen == null) throw new ArgumentException("DirectX10 expects a DirectXPen as resource.");
var geometry = new PathGeometry(DirectXHelper.Direct2DFactory);
using (GeometrySink sink = geometry.Open())
{
sink.BeginFigure(DirectXHelper.ConvertVector(polygon.Points[0]), FigureBegin.Hollow);
for (int i = 1; i < polygon.Points.Length; i++)
sink.AddLine(DirectXHelper.ConvertVector(polygon.Points[i]));
sink.EndFigure(FigureEnd.Closed);
sink.Close();
_renderTarget.DrawGeometry(geometry, dxPen.GetPen(), dxPen.Width);
}
geometry.Dispose();
}
