public static void AddEllipseGeometry(
this D2D.GeometrySink sink, Jupiter.Media.EllipseGeometry ellipseGeometry)
{
// Start the ellipse at 9 o'clock.
sink.BeginFigure(
new Vector2(
(float)(ellipseGeometry.Center.X - ellipseGeometry.RadiusX),
(float)(ellipseGeometry.Center.Y)),
D2D.FigureBegin.Filled);
// Do almost full ellipse in one arc (there is .00001 pixel size missing)
sink.AddArc(
new D2D.ArcSegment
{
Point = new Vector2(
(float)(ellipseGeometry.Center.X - ellipseGeometry.RadiusX),
(float)(ellipseGeometry.Center.Y + 0.00001)),
Size = new Size2F(
(float)(ellipseGeometry.RadiusX * 2),
(float)(ellipseGeometry.RadiusY * 2)),
RotationAngle = 0,
SweepDirection = D2D.SweepDirection.Clockwise,
ArcSize = D2D.ArcSize.Large
});
// Close the ellipse
sink.EndFigure(D2D.FigureEnd.Closed);
}
public override void Create(D2D.GeometrySink sink)
{
sink.AddArc(new D2D.ArcSegment()
{
ArcSize = ArcSize, Point = Point, RotationAngle = Rotation, Size = Size, SweepDirection = SweepDirection
});
}
public void ArcTo(Location point, Size size, double rotationAngle, bool isLargeArc)
{
_sink.AddArc(new D2D.ArcSegment
{
Point = point.ToD2D(),
Size = size.ToD2D(),
RotationAngle = (float)rotationAngle,
ArcSize = isLargeArc ? D2D.ArcSize.Large : D2D.ArcSize.Small,
SweepDirection = D2D.SweepDirection.Clockwise,
});
}
public void AddArc(float width, float height, float angleDegrees, bool isLargeArc, bool sweepDirection, Vector2 endPoint)
{
geometrySink.AddArc(new ArcSegment()
{
Size = new Size2F(width, height),
RotationAngle = angleDegrees,
ArcSize = isLargeArc ? ArcSize.Large : ArcSize.Small,
SweepDirection = sweepDirection ? SweepDirection.Clockwise : SweepDirection.CounterClockwise,
Point = endPoint
});
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Обновление данных арки
/// </summary>
//---------------------------------------------------------------------------------------------------------
public override void Update()
{
XDisposer.SafeDispose(ref mD2DGeometry);
mD2DGeometry = new Direct2D.PathGeometry(XDirect2DManager.D2DFactory);
mD2DGeometrySink = mD2DGeometry.Open();
mD2DGeometrySink.BeginFigure(mStartPoint.ToRawVector2(), mIsFilled ? Direct2D.FigureBegin.Filled : Direct2D.FigureBegin.Hollow);
Direct2D.ArcSegment arc_segment = new Direct2D.ArcSegment();
arc_segment.ArcSize = mIsLargeArc ? Direct2D.ArcSize.Large : Direct2D.ArcSize.Small;
arc_segment.Point = mEndPoint.ToRawVector2();
arc_segment.RotationAngle = mRotationAngle;
arc_segment.Size = new SharpDX.Size2F(mRadiusX, mRadiusY);
arc_segment.SweepDirection = mIsClockwiseDirection ? Direct2D.SweepDirection.Clockwise : Direct2D.SweepDirection.CounterClockwise;
mD2DGeometrySink.AddArc(arc_segment);
mD2DGeometrySink.EndFigure(mIsClosed ? Direct2D.FigureEnd.Closed : Direct2D.FigureEnd.Open);
mD2DGeometrySink.Close();
XDisposer.SafeDispose(ref mD2DGeometrySink);
mBoundsRect = mD2DGeometry.GetWidenedBounds(2).ToRect();
}
public static void AddPathFigureSegment(
this D2D.GeometrySink sink, Jupiter.Media.PathSegment segment)
{
var bezierSegment = segment as BezierSegment;
if (bezierSegment != null)
{
sink.AddBezier(
new D2D.BezierSegment
{
Point1 = bezierSegment.Point1.ToSharpDX(),
Point2 = bezierSegment.Point2.ToSharpDX(),
Point3 = bezierSegment.Point3.ToSharpDX()
});
return;
}
var lineSegment = segment as LineSegment;
if (lineSegment != null)
{
sink.AddLine(
lineSegment.Point.ToSharpDX());
return;
}
var polyBezierSegment = segment as PolyBezierSegment;
if (polyBezierSegment != null)
{
var beziers = new D2D.BezierSegment[polyBezierSegment.Points.Count / 3];
for (int i = 0; i < beziers.Length; i++)
{
beziers[i].Point1 = polyBezierSegment.Points[i * 3].ToSharpDX();
beziers[i].Point2 = polyBezierSegment.Points[i * 3 + 1].ToSharpDX();
beziers[i].Point3 = polyBezierSegment.Points[i * 3 + 2].ToSharpDX();
}
sink.AddBeziers(beziers);
return;
}
var polyLineSegment = segment as PolyLineSegment;
if (polyLineSegment != null)
{
var lines = new SharpDX.Vector2[polyLineSegment.Points.Count];
for (int i = 0; i < lines.Length; i++)
{
lines[i] = polyLineSegment.Points[i].ToSharpDX();
}
sink.AddLines(lines);
return;
}
var quadraticBezierSegment = segment as QuadraticBezierSegment;
if (quadraticBezierSegment != null)
{
sink.AddQuadraticBezier(
new D2D.QuadraticBezierSegment
{
Point1 = quadraticBezierSegment.Point1.ToSharpDX(),
Point2 = quadraticBezierSegment.Point2.ToSharpDX()
});
return;
}
var polyQuadraticBezierSegment = segment as PolyQuadraticBezierSegment;
if (polyQuadraticBezierSegment != null)
{
var quadraticBeziers = new D2D.QuadraticBezierSegment[polyBezierSegment.Points.Count / 2];
for (int i = 0; i < quadraticBeziers.Length; i++)
{
quadraticBeziers[i].Point1 = polyBezierSegment.Points[i * 2].ToSharpDX();
quadraticBeziers[i].Point2 = polyBezierSegment.Points[i * 2 + 1].ToSharpDX();
}
sink.AddQuadraticBeziers(quadraticBeziers);
return;
}
var arcSegment = segment as ArcSegment;
if (arcSegment != null)
{
sink.AddArc(
new D2D.ArcSegment
{
Point = arcSegment.Point.ToSharpDX(),
Size = arcSegment.Size.ToSharpDX(),
RotationAngle = (float)arcSegment.RotationAngle,
SweepDirection = arcSegment.SweepDirection.ToSharpDX(),
ArcSize = arcSegment.IsLargeArc ? D2D.ArcSize.Large : D2D.ArcSize.Small
});
return;
}
}
//---------------------------------------------------------------------------------------------------------
/// <summary>
/// Обновление данных геометрии
/// </summary>
//---------------------------------------------------------------------------------------------------------
public override void Update()
{
XDisposer.SafeDispose(ref mD2DGeometry);
mD2DGeometry = new Direct2D.PathGeometry(XDirect2DManager.D2DFactory);
mD2DGeometrySink = mD2DGeometry.Open();
CCadSegment current_figure = mSegments[0];
mD2DGeometrySink.BeginFigure(current_figure.BasePoint.ToRawVector2(), current_figure.IsFilled ? Direct2D.FigureBegin.Filled :
Direct2D.FigureBegin.Hollow);
Int32 current_new_figure = 0;
for (Int32 i = 0; i < mSegments.Count; i++)
{
CCadSegment current_segment = mSegments[i];
// Если новая фигура
if (current_segment.IsNewFigure && current_new_figure != i)
{
// Закрывает текущую фигуру
mD2DGeometrySink.EndFigure(current_figure.IsClosed ? Direct2D.FigureEnd.Closed : Direct2D.FigureEnd.Open);
// Открываем новую фигуру
mD2DGeometrySink.BeginFigure(current_segment.BasePoint.ToRawVector2(),
current_segment.IsFilled ? Direct2D.FigureBegin.Filled : Direct2D.FigureBegin.Hollow);
current_figure = current_segment;
current_new_figure = i;
}
switch (current_segment.SegmentType)
{
case TCadSegmentType.Points:
{
CCadSegmentPoints points = current_segment as CCadSegmentPoints;
mD2DGeometrySink.AddLines(points.Points.ConvertToDirect2DRawVectors());
}
break;
case TCadSegmentType.Line:
{
CCadSegmentLine line = current_segment as CCadSegmentLine;
mD2DGeometrySink.AddLine(line.EndPoint.ToRawVector2());
}
break;
case TCadSegmentType.Arc:
{
CCadSegmentArc arc = current_segment as CCadSegmentArc;
Direct2D.ArcSegment arc_segment = new Direct2D.ArcSegment();
arc_segment.ArcSize = arc.mIsLargeArc ? Direct2D.ArcSize.Large : Direct2D.ArcSize.Small;
arc_segment.Point = arc.mEndPoint.ToRawVector2();
arc_segment.RotationAngle = arc.mRotationAngle;
arc_segment.Size = new Size2F(arc.mRadiusX, arc.mRadiusY);
arc_segment.SweepDirection = arc.mIsClockwiseDirection ? Direct2D.SweepDirection.Clockwise : Direct2D.SweepDirection.CounterClockwise;
mD2DGeometrySink.AddArc(arc_segment);
}
break;
case TCadSegmentType.Bezier:
break;
default:
break;
}
}
// Закрывает текущую фигуру
mD2DGeometrySink.EndFigure(current_figure.IsClosed ? Direct2D.FigureEnd.Closed : Direct2D.FigureEnd.Open);
mD2DGeometrySink.Close();
XDisposer.SafeDispose(ref mD2DGeometrySink);
mBoundsRect = mD2DGeometry.GetWidenedBounds(2).ToRect();
}
