/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="text"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Test2d.XText text, double dx, double dy, ImmutableArray<Test2d.ShapeProperty> db, Test2d.Record r)
{
var _gfx = gfx as XGraphics;
var tbind = text.BindToTextProperty(db, r);
if (string.IsNullOrEmpty(tbind))
return;
var options = new XPdfFontOptions(PdfFontEncoding.Unicode);
var fontStyle = XFontStyle.Regular;
if (text.Style.TextStyle.FontStyle.HasFlag(Test2d.FontStyle.Bold))
{
fontStyle |= XFontStyle.Bold;
}
if (text.Style.TextStyle.FontStyle.HasFlag(Test2d.FontStyle.Italic))
{
fontStyle |= XFontStyle.Italic;
}
if (text.Style.TextStyle.FontStyle.HasFlag(Test2d.FontStyle.Underline))
{
fontStyle |= XFontStyle.Underline;
}
if (text.Style.TextStyle.FontStyle.HasFlag(Test2d.FontStyle.Strikeout))
{
fontStyle |= XFontStyle.Strikeout;
}
var font = new XFont(
text.Style.TextStyle.FontName,
_scaleToPage(text.Style.TextStyle.FontSize),
fontStyle,
options);
var rect = Test2d.Rect2.Create(
text.TopLeft,
text.BottomRight,
dx, dy);
var srect = new XRect(
_scaleToPage(rect.X),
_scaleToPage(rect.Y),
_scaleToPage(rect.Width),
_scaleToPage(rect.Height));
var format = new XStringFormat();
switch (text.Style.TextStyle.TextHAlignment)
{
case Test2d.TextHAlignment.Left:
format.Alignment = XStringAlignment.Near;
break;
case Test2d.TextHAlignment.Center:
format.Alignment = XStringAlignment.Center;
break;
case Test2d.TextHAlignment.Right:
format.Alignment = XStringAlignment.Far;
break;
}
switch (text.Style.TextStyle.TextVAlignment)
{
case Test2d.TextVAlignment.Top:
format.LineAlignment = XLineAlignment.Near;
break;
case Test2d.TextVAlignment.Center:
format.LineAlignment = XLineAlignment.Center;
break;
case Test2d.TextVAlignment.Bottom:
format.LineAlignment = XLineAlignment.Far;
break;
}
_gfx.DrawString(
tbind,
font,
ToXSolidBrush(text.Style.Stroke),
srect,
format);
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="container"></param>
private void Add(DxfDocument doc, Test2d.Container container)
{
_pageWidth = container.Width;
_pageHeight = container.Height;
if (container.Template != null)
{
Draw(doc, container.Template, container.Properties, null);
}
Draw(doc, container, container.Properties, null);
}
private void CreateHatchBoundsAndEntitiess(Test2d.XPathGeometry pg, double dx, double dy, out ICollection<HatchBoundaryPath> bounds, out ICollection<EntityObject> entities)
{
bounds = new List<HatchBoundaryPath>();
entities = new List<EntityObject>();
// TODO: FillMode = pg.FillRule == Test2d.XFillRule.EvenOdd ? FillMode.Alternate : FillMode.Winding;
foreach (var pf in pg.Figures)
{
var edges = new List<EntityObject>();
var startPoint = pf.StartPoint;
foreach (var segment in pf.Segments)
{
if (segment is Test2d.XArcSegment)
{
throw new NotSupportedException("Not supported segment type: " + segment.GetType());
//var arcSegment = segment as Test2d.XArcSegment;
// TODO: Convert WPF/SVG elliptical arc segment format to DXF ellipse arc.
//startPoint = arcSegment.Point;
}
else if (segment is Test2d.XBezierSegment)
{
var bezierSegment = segment as Test2d.XBezierSegment;
var dxfSpline = CreateCubicSpline(
startPoint.X + dx,
startPoint.Y + dy,
bezierSegment.Point1.X + dx,
bezierSegment.Point1.Y + dy,
bezierSegment.Point2.X + dx,
bezierSegment.Point2.Y + dy,
bezierSegment.Point3.X + dx,
bezierSegment.Point3.Y + dy);
edges.Add(dxfSpline);
entities.Add((Spline)dxfSpline.Clone());
startPoint = bezierSegment.Point3;
}
else if (segment is Test2d.XLineSegment)
{
var lineSegment = segment as Test2d.XLineSegment;
var dxfLine = CreateLine(
startPoint.X + dx,
startPoint.Y + dy,
lineSegment.Point.X + dx,
lineSegment.Point.Y + dy);
edges.Add(dxfLine);
entities.Add((Line)dxfLine.Clone());
startPoint = lineSegment.Point;
}
else if (segment is Test2d.XPolyBezierSegment)
{
var polyBezierSegment = segment as Test2d.XPolyBezierSegment;
if (polyBezierSegment.Points.Count >= 3)
{
var dxfSpline = CreateCubicSpline(
startPoint.X + dx,
startPoint.Y + dy,
polyBezierSegment.Points[0].X + dx,
polyBezierSegment.Points[0].Y + dy,
polyBezierSegment.Points[1].X + dx,
polyBezierSegment.Points[1].Y + dy,
polyBezierSegment.Points[2].X + dx,
polyBezierSegment.Points[2].Y + dy);
edges.Add(dxfSpline);
entities.Add((Spline)dxfSpline.Clone());
}
if (polyBezierSegment.Points.Count > 3
&& polyBezierSegment.Points.Count % 3 == 0)
{
for (int i = 3; i < polyBezierSegment.Points.Count; i += 3)
{
var dxfSpline = CreateCubicSpline(
polyBezierSegment.Points[i - 1].X + dx,
polyBezierSegment.Points[i - 1].Y + dy,
polyBezierSegment.Points[i].X + dx,
polyBezierSegment.Points[i].Y + dy,
polyBezierSegment.Points[i + 1].X + dx,
polyBezierSegment.Points[i + 1].Y + dy,
polyBezierSegment.Points[i + 2].X + dx,
polyBezierSegment.Points[i + 2].Y + dy);
edges.Add(dxfSpline);
entities.Add((Spline)dxfSpline.Clone());
}
}
startPoint = polyBezierSegment.Points.Last();
}
else if (segment is Test2d.XPolyLineSegment)
{
var polyLineSegment = segment as Test2d.XPolyLineSegment;
if (polyLineSegment.Points.Count >= 1)
{
var dxfLine = CreateLine(
startPoint.X + dx,
startPoint.Y + dy,
polyLineSegment.Points[0].X + dx,
polyLineSegment.Points[0].Y + dy);
edges.Add(dxfLine);
entities.Add((Line)dxfLine.Clone());
}
if (polyLineSegment.Points.Count > 1)
{
for (int i = 1; i < polyLineSegment.Points.Count; i++)
{
var dxfLine = CreateLine(
polyLineSegment.Points[i - 1].X + dx,
polyLineSegment.Points[i - 1].Y + dy,
polyLineSegment.Points[i].X + dx,
polyLineSegment.Points[i].Y + dy);
edges.Add(dxfLine);
entities.Add((Line)dxfLine.Clone());
}
}
startPoint = polyLineSegment.Points.Last();
}
else if (segment is Test2d.XPolyQuadraticBezierSegment)
{
var polyQuadraticSegment = segment as Test2d.XPolyQuadraticBezierSegment;
if (polyQuadraticSegment.Points.Count >= 2)
{
var dxfSpline = CreateQuadraticSpline(
startPoint.X + dx,
startPoint.Y + dy,
polyQuadraticSegment.Points[0].X + dx,
polyQuadraticSegment.Points[0].Y + dy,
polyQuadraticSegment.Points[1].X + dx,
polyQuadraticSegment.Points[1].Y + dy);
edges.Add(dxfSpline);
entities.Add((Spline)dxfSpline.Clone());
}
if (polyQuadraticSegment.Points.Count > 2
&& polyQuadraticSegment.Points.Count % 2 == 0)
{
for (int i = 3; i < polyQuadraticSegment.Points.Count; i += 3)
{
var dxfSpline = CreateQuadraticSpline(
polyQuadraticSegment.Points[i - 1].X + dx,
polyQuadraticSegment.Points[i - 1].Y + dy,
polyQuadraticSegment.Points[i].X + dx,
polyQuadraticSegment.Points[i].Y + dy,
polyQuadraticSegment.Points[i + 1].X + dx,
polyQuadraticSegment.Points[i + 1].Y + dy);
edges.Add(dxfSpline);
entities.Add((Spline)dxfSpline.Clone());
}
}
startPoint = polyQuadraticSegment.Points.Last();
}
else if (segment is Test2d.XQuadraticBezierSegment)
{
var qbezierSegment = segment as Test2d.XQuadraticBezierSegment;
var dxfSpline = CreateQuadraticSpline(
startPoint.X + dx,
startPoint.Y + dy,
qbezierSegment.Point1.X + dx,
qbezierSegment.Point1.Y + dy,
qbezierSegment.Point2.X + dx,
qbezierSegment.Point2.Y + dy);
edges.Add(dxfSpline);
entities.Add((Spline)dxfSpline.Clone());
startPoint = qbezierSegment.Point2;
}
else
{
throw new NotSupportedException("Not supported segment type: " + segment.GetType());
}
}
// TODO: Add support for pf.IsClosed
var path = new HatchBoundaryPath(edges);
bounds.Add(path);
}
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="path"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Test2d.XPath path, double dx, double dy, ImmutableArray<Test2d.ShapeProperty> db, Test2d.Record r)
{
if (!path.IsStroked && !path.IsFilled)
return;
var _doc = doc as DxfDocument;
var style = path.Style;
ICollection<HatchBoundaryPath> bounds;
ICollection<EntityObject> entities;
CreateHatchBoundsAndEntitiess(path.Geometry, dx, dy, out bounds, out entities);
if (entities == null || bounds == null)
return;
if (path.IsFilled)
{
var fill = GetColor(style.Fill);
var fillTransparency = GetTransparency(style.Fill);
var hatch = new Hatch(HatchPattern.Solid, bounds, false);
hatch.Layer = _currentLayer;
hatch.Color = fill;
hatch.Transparency.Value = fillTransparency;
_doc.AddEntity(hatch);
}
if (path.IsStroked)
{
// TODO: Add support for Closed paths.
var stroke = GetColor(style.Stroke);
var strokeTansparency = GetTransparency(style.Stroke);
var lineweight = ThicknessToLineweight(style.Thickness);
foreach (var entity in entities)
{
entity.Layer = _currentLayer;
entity.Color = stroke;
entity.Transparency.Value = strokeTansparency;
entity.Lineweight.Value = lineweight;
_doc.AddEntity(entity);
}
}
}
private static AciColor GetColor(Test2d.ArgbColor color)
{
return new AciColor(color.R, color.G, color.B);
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="arc"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Test2d.XArc arc, double dx, double dy, ImmutableArray<Test2d.ShapeProperty> db, Test2d.Record r)
{
var _doc = doc as DxfDocument;
var style = arc.Style;
var dxfEllipse = CreateEllipticalArc(arc, dx, dy);
if (arc.IsFilled)
{
var fill = GetColor(style.Fill);
var fillTransparency = GetTransparency(style.Fill);
// TODO: The netDxf does not create hatch for Ellipse with end angle equal to 360.
var bounds =
new List<HatchBoundaryPath>
{
new HatchBoundaryPath(
new List<EntityObject>
{
(Ellipse)dxfEllipse.Clone()
})
};
var hatch = new Hatch(HatchPattern.Solid, bounds, false);
hatch.Layer = _currentLayer;
hatch.Color = fill;
hatch.Transparency.Value = fillTransparency;
_doc.AddEntity(hatch);
}
if (arc.IsStroked)
{
var stroke = GetColor(style.Stroke);
var strokeTansparency = GetTransparency(style.Stroke);
var lineweight = ThicknessToLineweight(style.Thickness);
dxfEllipse.Layer = _currentLayer;
dxfEllipse.Color = stroke;
dxfEllipse.Transparency.Value = strokeTansparency;
dxfEllipse.Lineweight.Value = lineweight;
_doc.AddEntity(dxfEllipse);
}
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="text"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Test2d.XText text, double dx, double dy, ImmutableArray<Test2d.ShapeProperty> db, Test2d.Record r)
{
var _doc = doc as DxfDocument;
var tbind = text.BindToTextProperty(db, r);
if (string.IsNullOrEmpty(tbind))
return;
var style = text.Style;
var stroke = GetColor(style.Stroke);
var strokeTansparency = GetTransparency(style.Stroke);
var attachmentPoint = default(MTextAttachmentPoint);
double x, y;
var rect = Test2d.Rect2.Create(text.TopLeft, text.BottomRight, dx, dy);
switch (text.Style.TextStyle.TextHAlignment)
{
default:
case Test2d.TextHAlignment.Left:
x = rect.X;
break;
case Test2d.TextHAlignment.Center:
x = rect.X + rect.Width / 2.0;
break;
case Test2d.TextHAlignment.Right:
x = rect.X + rect.Width;
break;
}
switch (text.Style.TextStyle.TextVAlignment)
{
default:
case Test2d.TextVAlignment.Top:
y = rect.Y;
break;
case Test2d.TextVAlignment.Center:
y = rect.Y + rect.Height / 2.0;
break;
case Test2d.TextVAlignment.Bottom:
y = rect.Y + rect.Height;
break;
}
switch (text.Style.TextStyle.TextVAlignment)
{
default:
case Test2d.TextVAlignment.Top:
switch (text.Style.TextStyle.TextHAlignment)
{
default:
case Test2d.TextHAlignment.Left:
attachmentPoint = MTextAttachmentPoint.TopLeft;
break;
case Test2d.TextHAlignment.Center:
attachmentPoint = MTextAttachmentPoint.TopCenter;
break;
case Test2d.TextHAlignment.Right:
attachmentPoint = MTextAttachmentPoint.TopRight;
break;
}
break;
case Test2d.TextVAlignment.Center:
switch (text.Style.TextStyle.TextHAlignment)
{
default:
case Test2d.TextHAlignment.Left:
attachmentPoint = MTextAttachmentPoint.MiddleLeft;
break;
case Test2d.TextHAlignment.Center:
attachmentPoint = MTextAttachmentPoint.MiddleCenter;
break;
case Test2d.TextHAlignment.Right:
attachmentPoint = MTextAttachmentPoint.MiddleRight;
break;
}
break;
case Test2d.TextVAlignment.Bottom:
switch (text.Style.TextStyle.TextHAlignment)
{
default:
case Test2d.TextHAlignment.Left:
attachmentPoint = MTextAttachmentPoint.BottomLeft;
break;
case Test2d.TextHAlignment.Center:
attachmentPoint = MTextAttachmentPoint.BottomCenter;
break;
case Test2d.TextHAlignment.Right:
attachmentPoint = MTextAttachmentPoint.BottomRight;
break;
}
break;
}
var ts = new TextStyle(style.TextStyle.FontName, style.TextStyle.FontFile);
var dxfMText = new MText(
new Vector3(ToDxfX(x), ToDxfY(y), 0),
text.Style.TextStyle.FontSize * 72.0 / 96.0,
rect.Width,
ts);
dxfMText.AttachmentPoint = attachmentPoint;
var fs = text.Style.TextStyle.FontStyle;
var options = new MTextFormattingOptions(dxfMText.Style);
options.Bold = fs.Flags.HasFlag(Test2d.FontStyleFlags.Bold);
options.Italic = fs.Flags.HasFlag(Test2d.FontStyleFlags.Italic);
options.Underline = fs.Flags.HasFlag(Test2d.FontStyleFlags.Underline);
options.StrikeThrough = fs.Flags.HasFlag(Test2d.FontStyleFlags.Strikeout);
options.Aligment = MTextFormattingOptions.TextAligment.Default;
options.Color = null;
dxfMText.Write(tbind, options);
dxfMText.Layer = _currentLayer;
dxfMText.Transparency.Value = strokeTansparency;
dxfMText.Color = stroke;
_doc.AddEntity(dxfMText);
}
/// <summary>
///
/// </summary>
/// <param name="style"></param>
/// <param name="scale"></param>
/// <returns></returns>
private static XPen ToXPen(Test2d.BaseStyle style, Func<double, double> scale)
{
var pen = new XPen(ToXColor(style.Stroke), XUnit.FromPresentation(style.Thickness));
switch (style.LineCap)
{
case Test2d.LineCap.Flat:
pen.LineCap = XLineCap.Flat;
break;
case Test2d.LineCap.Square:
pen.LineCap = XLineCap.Square;
break;
case Test2d.LineCap.Round:
pen.LineCap = XLineCap.Round;
break;
}
if (style.Dashes != null)
{
// TODO: Convert to correct dash values.
pen.DashPattern = style.Dashes;
}
pen.DashOffset = style.DashOffset;
return pen;
}
/// <summary>
///
/// </summary>
/// <param name="g"></param>
/// <param name="c"></param>
/// <param name="width"></param>
/// <param name="height"></param>
private void DrawBackground(Graphics g, Test2d.ArgbColor c, double width, double height)
{
var color = Color.FromArgb(c.R, c.G, c.B, c.A);
var brush = new SolidBrush(color);
var rect = Test2d.Rect2.Create(0, 0, width, height);
g.FillRectangle(
brush,
(float)rect.X,
(float)rect.Y,
(float)rect.Width,
(float)rect.Height);
brush.Dispose();
}
/// <summary>
///
/// </summary>
/// <param name="path"></param>
/// <param name="project"></param>
public void Save(string path, Test2d.Project project)
{
using (var pdf = new PdfDocument())
{
var projectOutline = default(PdfOutline);
foreach (var document in project.Documents)
{
var documentOutline = default(PdfOutline);
foreach (var container in document.Containers)
{
var page = Add(pdf, container);
if (projectOutline == null)
{
projectOutline = pdf.Outlines.Add(
project.Name,
page,
true,
PdfOutlineStyle.Regular,
XColors.Black);
}
if (documentOutline == null)
{
documentOutline = projectOutline.Outlines.Add(
document.Name,
page,
true,
PdfOutlineStyle.Regular,
XColors.Black);
}
documentOutline.Outlines.Add(
container.Name,
page,
true,
PdfOutlineStyle.Regular,
XColors.Black);
}
}
pdf.Save(path);
ClearCache(isZooming: false);
}
}
/// <summary>
///
/// </summary>
/// <param name="color"></param>
/// <returns></returns>
private static XColor ToXColor(Test2d.ArgbColor color)
{
return XColor.FromArgb(
color.A,
color.R,
color.G,
color.B);
}
/// <summary>
///
/// </summary>
/// <param name="path"></param>
/// <param name="container"></param>
public void Save(string path, Test2d.Container container)
{
using (var pdf = new PdfDocument())
{
Add(pdf, container);
pdf.Save(path);
}
}
/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="path"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Test2d.XPath path, double dx, double dy, ImmutableArray<Test2d.ShapeProperty> db, Test2d.Record r)
{
var _gfx = gfx as XGraphics;
var gp = path.Geometry.ToXGraphicsPath(dx, dy, _scaleToPage);
if (path.IsFilled && path.IsStroked)
{
_gfx.DrawPath(
ToXPen(path.Style, _scaleToPage),
ToXSolidBrush(path.Style.Fill),
gp);
}
else if (path.IsFilled && !path.IsStroked)
{
_gfx.DrawPath(
ToXSolidBrush(path.Style.Fill),
gp);
}
else if (!path.IsFilled && path.IsStroked)
{
_gfx.DrawPath(
ToXPen(path.Style, _scaleToPage),
gp);
}
}
/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="image"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Test2d.XImage image, double dx, double dy, ImmutableArray<Test2d.ShapeProperty> db, Test2d.Record r)
{
var _gfx = gfx as XGraphics;
var rect = Test2d.Rect2.Create(
image.TopLeft,
image.BottomRight,
dx, dy);
var srect = new XRect(
_scaleToPage(rect.X),
_scaleToPage(rect.Y),
_scaleToPage(rect.Width),
_scaleToPage(rect.Height));
if (image.IsStroked && image.IsFilled)
{
_gfx.DrawRectangle(
ToXPen(image.Style, _scaleToPage),
ToXSolidBrush(image.Style.Fill),
srect);
}
else if (image.IsStroked && !image.IsFilled)
{
_gfx.DrawRectangle(
ToXPen(image.Style, _scaleToPage),
srect);
}
else if (!image.IsStroked && image.IsFilled)
{
_gfx.DrawRectangle(
ToXSolidBrush(image.Style.Fill),
srect);
}
if (_enableImageCache
&& _biCache.ContainsKey(image.Path))
{
_gfx.DrawImage(_biCache[image.Path], srect);
}
else
{
if (_state.ImageCache == null || string.IsNullOrEmpty(image.Path))
return;
var bytes = _state.ImageCache.GetImage(image.Path);
if (bytes != null)
{
var ms = new System.IO.MemoryStream(bytes);
#if WPF
var bs = new BitmapImage();
bs.BeginInit();
bs.StreamSource = ms;
bs.EndInit();
bs.Freeze();
var bi = XImage.FromBitmapSource(bs);
#else
var bi = XImage.FromStream(ms);
#endif
if (_enableImageCache)
_biCache[image.Path] = bi;
_gfx.DrawImage(bi, srect);
if (!_enableImageCache)
bi.Dispose();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="rectangle"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Test2d.XRectangle rectangle, double dx, double dy, ImmutableArray<Test2d.ShapeProperty> db, Test2d.Record r)
{
if (!rectangle.IsStroked && !rectangle.IsFilled && !rectangle.IsGrid)
return;
var _doc = doc as DxfDocument;
var style = rectangle.Style;
var rect = Test2d.Rect2.Create(rectangle.TopLeft, rectangle.BottomRight, dx, dy);
DrawRectangleInternal(_doc, _currentLayer, rectangle.IsFilled, rectangle.IsStroked, style, ref rect);
if (rectangle.IsGrid)
{
DrawGridInternal(
_doc,
_currentLayer,
style,
rectangle.OffsetX, rectangle.OffsetY,
rectangle.CellWidth, rectangle.CellHeight,
ref rect);
}
}
private void DrawBackground(CanvasDrawingSession ds, T2d.ArgbColor c, double width, double height)
{
var color = Color.FromArgb(c.A, c.R, c.G, c.B);
var rect = T2d.Rect2.Create(0, 0, width, height);
ds.FillRectangle(
(float)rect.X,
(float)rect.Y,
(float)rect.Width,
(float)rect.Height,
color);
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="ellipse"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Test2d.XEllipse ellipse, double dx, double dy, ImmutableArray<Test2d.ShapeProperty> db, Test2d.Record r)
{
if (!ellipse.IsStroked && !ellipse.IsFilled)
return;
var _doc = doc as DxfDocument;
var style = ellipse.Style;
var rect = Test2d.Rect2.Create(ellipse.TopLeft, ellipse.BottomRight, dx, dy);
DrawEllipseInternal(_doc, _currentLayer, ellipse.IsFilled, ellipse.IsStroked, style, ref rect);
}
private async Task CacheImages(T2d.Project project)
{
var images = T2d.Editor.GetAllShapes<T2d.XImage>(project);
if (images != null)
{
foreach (var image in images)
{
await CacheImage(image.Path);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="qbezier"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Test2d.XQBezier qbezier, double dx, double dy, ImmutableArray<Test2d.ShapeProperty> db, Test2d.Record r)
{
if (!qbezier.IsStroked && !qbezier.IsFilled)
return;
var _doc = doc as DxfDocument;
var style = qbezier.Style;
var dxfSpline = CreateQuadraticSpline(
qbezier.Point1.X + dx,
qbezier.Point1.Y + dy,
qbezier.Point2.X + dx,
qbezier.Point2.Y + dy,
qbezier.Point3.X + dx,
qbezier.Point3.Y + dy);
if (qbezier.IsFilled)
{
var fill = GetColor(style.Fill);
var fillTransparency = GetTransparency(style.Fill);
var bounds =
new List<HatchBoundaryPath>
{
new HatchBoundaryPath(
new List<EntityObject>
{
(Spline)dxfSpline.Clone()
})
};
var hatch = new Hatch(HatchPattern.Solid, bounds, false);
hatch.Layer = _currentLayer;
hatch.Color = fill;
hatch.Transparency.Value = fillTransparency;
_doc.AddEntity(hatch);
}
if (qbezier.IsStroked)
{
var stroke = GetColor(style.Stroke);
var strokeTansparency = GetTransparency(style.Stroke);
var lineweight = ThicknessToLineweight(style.Thickness);
dxfSpline.Layer = _currentLayer;
dxfSpline.Color = stroke;
dxfSpline.Transparency.Value = strokeTansparency;
dxfSpline.Lineweight.Value = lineweight;
_doc.AddEntity(dxfSpline);
}
}
private void DrawGridInternal(DxfDocument doc, Layer layer, Test2d.ShapeStyle style, double offsetX, double offsetY, double cellWidth, double cellHeight, ref Test2d.Rect2 rect)
{
var stroke = GetColor(style.Stroke);
var strokeTansparency = GetTransparency(style.Stroke);
var lineweight = ThicknessToLineweight(style.Thickness);
double ox = rect.X;
double oy = rect.Y;
double sx = ox + offsetX;
double sy = oy + offsetY;
double ex = ox + rect.Width;
double ey = oy + rect.Height;
for (double gx = sx; gx < ex; gx += cellWidth)
{
var dxfLine = CreateLine(gx, oy, gx, ey);
dxfLine.Layer = layer;
dxfLine.Color = stroke;
dxfLine.Transparency.Value = strokeTansparency;
dxfLine.Lineweight.Value = lineweight;
doc.AddEntity(dxfLine);
}
for (double gy = sy; gy < ey; gy += cellHeight)
{
var dxfLine = CreateLine(ox, gy, ex, gy);
dxfLine.Layer = layer;
dxfLine.Color = stroke;
dxfLine.Transparency.Value = strokeTansparency;
dxfLine.Lineweight.Value = lineweight;
doc.AddEntity(dxfLine);
}
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="image"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Test2d.XImage image, double dx, double dy, ImmutableArray<Test2d.ShapeProperty> db, Test2d.Record r)
{
var _doc = doc as DxfDocument;
var bytes = _state.ImageCache.GetImage(image.Path);
if (bytes != null)
{
var rect = Test2d.Rect2.Create(image.TopLeft, image.BottomRight, dx, dy);
if (_enableImageCache
&& _biCache.ContainsKey(image.Path))
{
var dxfImageDefinition = _biCache[image.Path];
var dxfImage = new Image(
dxfImageDefinition,
new Vector3(ToDxfX(rect.X), ToDxfY(rect.Y + rect.Height), 0),
rect.Width,
rect.Height);
_doc.AddEntity(dxfImage);
}
else
{
if (_state.ImageCache == null || string.IsNullOrEmpty(image.Path))
return;
var path = System.IO.Path.Combine(_outputPath, System.IO.Path.GetFileName(image.Path));
System.IO.File.WriteAllBytes(path, bytes);
var dxfImageDefinition = new ImageDef(path);
if (_enableImageCache)
_biCache[image.Path] = dxfImageDefinition;
var dxfImage = new Image(
dxfImageDefinition,
new Vector3(ToDxfX(rect.X), ToDxfY(rect.Y + rect.Height), 0),
rect.Width,
rect.Height);
_doc.AddEntity(dxfImage);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="container"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Test2d.Container container, ImmutableArray<Test2d.ShapeProperty> db, Test2d.Record r)
{
var _doc = doc as DxfDocument;
foreach (var layer in container.Layers)
{
var dxfLayer = new Layer(layer.Name)
{
IsVisible = layer.IsVisible
};
_doc.Layers.Add(dxfLayer);
_currentLayer = dxfLayer;
Draw(doc, layer, db, r);
}
}
/// <summary>
///
/// </summary>
/// <param name="path"></param>
/// <param name="container"></param>
public void Save(string path, Test2d.Container container)
{
_outputPath = System.IO.Path.GetDirectoryName(path);
var doc = new DxfDocument(DxfVersion.AutoCad2010);
Add(doc, container);
doc.Save(path);
ClearCache(isZooming: false);
}
private void DrawRectangleInternal(DxfDocument doc, Layer layer, bool isFilled, bool isStroked, Test2d.BaseStyle style, ref Test2d.Rect2 rect)
{
double x = rect.X;
double y = rect.Y;
double w = rect.Width;
double h = rect.Height;
var dxfLine1 = CreateLine(x, y, x + w, y);
var dxfLine2 = CreateLine(x + w, y, x + w, y + h);
var dxfLine3 = CreateLine(x + w, y + h, x, y + h);
var dxfLine4 = CreateLine(x, y + h, x, y);
if (isFilled)
{
var fill = GetColor(style.Fill);
var fillTransparency = GetTransparency(style.Fill);
var bounds =
new List<HatchBoundaryPath>
{
new HatchBoundaryPath(
new List<EntityObject>
{
(Line)dxfLine1.Clone(),
(Line)dxfLine2.Clone(),
(Line)dxfLine3.Clone(),
(Line)dxfLine4.Clone()
})
};
var hatch = new Hatch(HatchPattern.Solid, bounds, false);
hatch.Layer = layer;
hatch.Color = fill;
hatch.Transparency.Value = fillTransparency;
doc.AddEntity(hatch);
}
if (isStroked)
{
var stroke = GetColor(style.Stroke);
var strokeTansparency = GetTransparency(style.Stroke);
var lineweight = ThicknessToLineweight(style.Thickness);
dxfLine1.Layer = layer;
dxfLine1.Color = stroke;
dxfLine1.Transparency.Value = strokeTansparency;
dxfLine1.Lineweight.Value = lineweight;
dxfLine2.Layer = layer;
dxfLine2.Color = stroke;
dxfLine2.Transparency.Value = strokeTansparency;
dxfLine2.Lineweight.Value = lineweight;
dxfLine3.Layer = layer;
dxfLine3.Color = stroke;
dxfLine3.Transparency.Value = strokeTansparency;
dxfLine3.Lineweight.Value = lineweight;
dxfLine4.Layer = layer;
dxfLine4.Color = stroke;
dxfLine4.Transparency.Value = strokeTansparency;
dxfLine4.Lineweight.Value = lineweight;
doc.AddEntity(dxfLine1);
doc.AddEntity(dxfLine2);
doc.AddEntity(dxfLine3);
doc.AddEntity(dxfLine4);
}
}
private static short GetTransparency(Test2d.ArgbColor color)
{
return (short)(90.0 - color.A * 90.0 / 255.0);
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="layer"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Test2d.Layer layer, ImmutableArray<Test2d.ShapeProperty> db, Test2d.Record r)
{
var _doc = doc as DxfDocument;
foreach (var shape in layer.Shapes)
{
if (shape.State.Flags.HasFlag(_state.DrawShapeState.Flags))
{
shape.Draw(_doc, this, 0, 0, db, r);
}
}
}
private Ellipse CreateEllipticalArc(Test2d.XArc arc, double dx, double dy)
{
var a = Test2d.GdiArc.FromXArc(arc, dx, dy);
double _cx = ToDxfX(a.X + a.Width / 2.0);
double _cy = ToDxfY(a.Y + a.Height / 2.0);
double minor = Math.Min(a.Height, a.Width);
double major = Math.Max(a.Height, a.Width);
double startAngle = -a.EndAngle;
double endAngle = -a.StartAngle;
double rotation = 0;
if (a.Height > a.Width)
{
startAngle += 90;
endAngle += 90;
rotation = -90;
}
return new Ellipse()
{
Center = new Vector3(_cx, _cy, 0),
MajorAxis = major,
MinorAxis = minor,
StartAngle = startAngle,
EndAngle = endAngle,
Rotation = rotation
};
}
/// <summary>
///
/// </summary>
/// <param name="doc"></param>
/// <param name="line"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object doc, Test2d.XLine line, double dx, double dy, ImmutableArray<Test2d.ShapeProperty> db, Test2d.Record r)
{
if (!line.IsStroked)
return;
var _doc = doc as DxfDocument;
var style = line.Style;
var stroke = GetColor(style.Stroke);
var strokeTansparency = GetTransparency(style.Stroke);
var lineweight = ThicknessToLineweight(style.Thickness);
double _x1 = line.Start.X + dx;
double _y1 = line.Start.Y + dy;
double _x2 = line.End.X + dx;
double _y2 = line.End.Y + dy;
Test2d.XLine.SetMaxLength(line, ref _x1, ref _y1, ref _x2, ref _y2);
var dxfLine = CreateLine(_x1, _y1, _x2, _y2);
// TODO: Draw line start arrow.
// TODO: Draw line end arrow.
dxfLine.Layer = _currentLayer;
dxfLine.Color = stroke;
dxfLine.Transparency.Value = strokeTansparency;
dxfLine.Lineweight.Value = lineweight;
_doc.AddEntity(dxfLine);
}
private void DrawEllipseInternal(DxfDocument doc, Layer layer, bool isFilled, bool isStroked, Test2d.BaseStyle style, ref Test2d.Rect2 rect)
{
var dxfEllipse = CreateEllipse(rect.X, rect.Y, rect.Width, rect.Height);
if (isFilled)
{
var fill = GetColor(style.Fill);
var fillTransparency = GetTransparency(style.Fill);
// TODO: The netDxf does not create hatch for Ellipse with end angle equal to 360.
var bounds =
new List<HatchBoundaryPath>
{
new HatchBoundaryPath(
new List<EntityObject>
{
(Ellipse)dxfEllipse.Clone()
})
};
var hatch = new Hatch(HatchPattern.Solid, bounds, false);
hatch.Layer = layer;
hatch.Color = fill;
hatch.Transparency.Value = fillTransparency;
doc.AddEntity(hatch);
}
if (isStroked)
{
var stroke = GetColor(style.Stroke);
var strokeTansparency = GetTransparency(style.Stroke);
var lineweight = ThicknessToLineweight(style.Thickness);
dxfEllipse.Layer = layer;
dxfEllipse.Color = stroke;
dxfEllipse.Transparency.Value = strokeTansparency;
dxfEllipse.Lineweight.Value = lineweight;
doc.AddEntity(dxfEllipse);
}
}
/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="qbezier"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Test2d.XQBezier qbezier, double dx, double dy, ImmutableArray<Test2d.ShapeProperty> db, Test2d.Record r)
{
var _gfx = gfx as XGraphics;
double x1 = qbezier.Point1.X;
double y1 = qbezier.Point1.Y;
double x2 = qbezier.Point1.X + (2.0 * (qbezier.Point2.X - qbezier.Point1.X)) / 3.0;
double y2 = qbezier.Point1.Y + (2.0 * (qbezier.Point2.Y - qbezier.Point1.Y)) / 3.0;
double x3 = x2 + (qbezier.Point3.X - qbezier.Point1.X) / 3.0;
double y3 = y2 + (qbezier.Point3.Y - qbezier.Point1.Y) / 3.0;
double x4 = qbezier.Point3.X;
double y4 = qbezier.Point3.Y;
if (qbezier.IsFilled)
{
var path = new XGraphicsPath();
path.AddBezier(
_scaleToPage(x1 + dx),
_scaleToPage(y1 + dy),
_scaleToPage(x2 + dx),
_scaleToPage(y2 + dy),
_scaleToPage(x3 + dx),
_scaleToPage(y3 + dy),
_scaleToPage(x4 + dx),
_scaleToPage(y4 + dy));
if (qbezier.IsStroked)
{
_gfx.DrawPath(
ToXPen(qbezier.Style, _scaleToPage),
ToXSolidBrush(qbezier.Style.Fill),
path);
}
else
{
_gfx.DrawPath(
ToXSolidBrush(qbezier.Style.Fill),
path);
}
}
else
{
if (qbezier.IsStroked)
{
_gfx.DrawBezier(
ToXPen(qbezier.Style, _scaleToPage),
_scaleToPage(x1 + dx),
_scaleToPage(y1 + dy),
_scaleToPage(x2 + dx),
_scaleToPage(y2 + dy),
_scaleToPage(x3 + dx),
_scaleToPage(y3 + dy),
_scaleToPage(x4 + dx),
_scaleToPage(y4 + dy));
}
}
}